This utility library helps to determine real types for generics, arrays, wildcards and other complex types on runtime. Receiving type for generics can be a problem because of Java doesn't store information about generic type parameters on runtime so this library helps to solve this problem.
To add library to your project perform next steps:
Add the following dependency to your pom.xml:
<dependency>
<groupId>com.github.vladislavsevruk</groupId>
<artifactId>type-resolver</artifactId>
<version>1.0.3</version>
</dependency>Add the following dependency to your build.gradle:
implementation 'com.github.vladislavsevruk:type-resolver:1.0.3'TypeMeta represents metadata about type
parameter(s) for generics and arrays.
Examples of resulted TypeMeta structure for different cases:
- List<? extends Number>:
{ type: List, wildcard: false, genericTypes: [
{ type: Number, wildcard: true, genericTypes:[] }
] }- long[]:
{ type: long[], wildcard: false, genericTypes: [
{ type: long, wildcard: false, genericTypes:[] }
] }- Map<String, Integer>[]:
{ type: Map[], wildcard: false, genericTypes: [
{ type: Map, wildcard: false, genericTypes: [
{ type: String, wildcard: false, genericTypes:[] },
{ type: Integer, wildcard: false, genericTypes:[] }
] }
] }TypeProvider provides easy to use method for generating TypeMeta for generics.
- With TypeProvider:
TypeMeta<?> typeMeta = new TypeProvider<Map<String, List<Integer>>>() {}.getTypeMeta();- Without TypeProvider:
TypeMeta<?> innerTypeMeta1 = new TypeMeta<>(String.class);
TypeMeta<?> deepInnerTypeMeta = new TypeMeta<>(Integer.class);
TypeMeta<?>[] deepInnerTypeMetas = new TypeMeta<?>[] { deepInnerTypeMeta };
TypeMeta<?> innerTypeMeta2 = new TypeMeta<>(List.class, deepInnerTypeMetas);
TypeMeta<?>[] innerTypeMetas = new TypeMeta<?>[] { innerTypeMeta1, innerTypeMeta2 };
TypeMeta<Map> typeMeta = new TypeMeta<>(Map.class, innerTypeMetas);FieldTypeResolver can be used to determine TypeMeta for field of provided class. Library has default implementation of this interface.
ExecutableTypeResolver can be used to determine TypeMeta for return and argument types of provided method. Library has default implementation of this interface.
Let's assume that we have following generic class:
public class Cake<T> {
private List<String> ingredients;
private T filling;
}and we need to determine its fields type. We can use FieldTypeMetaResolver for this purpose:
FieldTypeResolver<TypeMeta<?>> fieldTypeResolver = new FieldTypeMetaResolver();
// get class field to determine its type
Field fieldToResolve = Cake.class.getDeclaredField("ingredients");
TypeMeta<?> fieldTypeMeta = fieldTypeResolver.resolveField(Cake.class, fieldToResolve);Resulted TypeMeta will have following structure:
{ type: List, wildcard: false, genericTypes: [
{ type: String, wildcard: false, genericTypes:[] }
] }If we need to determine type of field that use generic parameter(s) we may use subclass of TypeProvider:
FieldTypeResolver<TypeMeta<?>> fieldTypeResolver = new FieldTypeMetaResolver();
// get class field to determine its type
Field fieldToResolve = Cake.class.getDeclaredField("filling");
// create type provider with generic class where field declared
// we use String as Cake's type parameter for this example
TypeProvider<?> typeProvider = new TypeProvider<Cake<String>>() {};
TypeMeta<?> fieldTypeMeta = fieldTypeResolver.resolveField(typeProvider, fieldToResolve);And as a result TypeMeta will have following structure:
{ type: String, wildcard: false, genericTypes:[] }Let's assume that our generic class have following methods:
public class Cake<T> {
...
public List<String> getIngredients() {
...
}
public void setFilling(T filling) {
...
}
}To determine their argument or return types we can use ExecutableTypeMetaResolver:
ExecutableTypeResolver<TypeMeta<?>> executableTypeResolver = new ExecutableTypeMetaResolver();
// get method to determine its return and argument types
Method methodToResolve = Cake.class.getDeclaredMethod("getIngredients");
TypeMeta<?> methodReturnTypeMeta = executableTypeResolver.getReturnType(Cake.class, methodToResolve);
List<TypeMeta<?>> methodArgumentsTypeMetaList = executableTypeResolver
.getParameterTypes(Cake.class, methodToResolve);Resulted TypeMeta items will have following structures:
- Return type (methodReturnTypeMeta):
{ type: List, wildcard: false, genericTypes: [
{ type: String, wildcard: false, genericTypes:[] }
] }- Argument types (methodArgumentsTypeMetaList):
[]If we need to determine types of method that uses generic parameters we may use subclass of TypeProvider:
ExecutableTypeResolver<TypeMeta<?>> executableTypeResolver = new ExecutableTypeMetaResolver();
// get method to determine its return and argument types
Method methodToResolve = Cake.class.getDeclaredMethod("setFilling", Object.class);
// create type provider with generic class where field declared
// we use String as Cake's type parameter for this example
TypeProvider<?> typeProvider = new TypeProvider<Cake<String>>() {};
TypeMeta<?> methodReturnTypeMeta = executableTypeResolver.getReturnType(typeProvider, methodToResolve);
List<TypeMeta<?>> methodArgumentsTypeMetaList = executableTypeResolver
.getParameterTypes(typeProvider, methodToResolve);And as a result TypeMeta items will have following structure:
- Return type (methodReturnTypeMeta):
{ type: void, wildcard: false, genericTypes: [] }- Argument types (methodArgumentsTypeMetaList):
[{ type: String, wildcard: false, genericTypes:[] }]This project is licensed under the MIT License, you can read the full text here.
React
Typescript
Django
Laravel
Facebook
Microsoft
Google
Alibaba
D3
Tencent