Original link: https://muyig.github.io/blog/2020/01/10/TypeReference/
String userString = "[{\"userId\":\"111\",\"userName\":\"Tom\"},{\"userId\":\"222\",\"userName\":\"Jerry\"}]";
List<UserInfo> input = new ArrayList<>();
List<UserInfo> userInfoList = JSON.parseObject(userString, input.getClass());
java.lang.ClassCastException: com.alibaba.fastjson.JSONObject cannot be cast to com.vdian.dagon.core.user.UserInfo
List<UserInfo> userInfoList = JSON.parseObject(userString, new TypeReference<List<UserInfo>>() {
});
@SuppressWarnings("unchecked")
public static <T> T parseObject(String text, TypeReference<T> type, Feature... features) {
return (T) parseObject(text, type.type, ParserConfig.global, DEFAULT_PARSER_FEATURE, features);
}
new Runnable() {
@Override
public void run() {
// ...
}
};
new AbstractList<String>() {
@Override
public int size() {
return 0;
}
@Override
public String get(int index) {
return null;
}
};
new ArrayList<String>() {
// 因为父类非抽象，因此不需要实现任何方法（当然如果想重写也是可以的）
};
public class TypeReference<T> {
protected final Type type;
/**
* Constructs a new type literal. Derives represented class from type
* parameter.
*
* <p>Clients create an empty anonymous subclass. Doing so embeds the type
* parameter in the anonymous class's type hierarchy so we can reconstitute it
* at runtime despite erasure.
*/
protected TypeReference(){
// 1. 获取当前类的父类的类型定义，由于我们采用了创建匿名子类的方式，所以这里拿到的就是 TypeReference的类型定义。
Type superClass = getClass().getGenericSuperclass();
// 2.强转为ParameterizedType，获取到泛型参数数组。
Type type = ((ParameterizedType) superClass).getActualTypeArguments()[0];
// 省略缓存逻辑
this.type = cachedType;
}
// 其他方法
}
public class ReflectionTest {
static class SubArrayList1<E> extends ArrayList<E> {
}
static class SubArrayList2 extends ArrayList<String> {
}
private static void printSuperclass(Class<?> c) {
Type superclass = c.getGenericSuperclass();
ParameterizedType parameterizedType = (ParameterizedType) superclass;
System.out.println("superclass:" + parameterizedType.getTypeName());
}
public static void main(String[] args) {
SubArrayList1<String> subArrayList1 = new SubArrayList1<>();
printSuperclass(subArrayList1.getClass());
SubArrayList2 subArrayList2 = new SubArrayList2();
printSuperclass(subArrayList2.getClass());
printSuperclass(new ArrayList<String>() {
}.getClass());
}
}
superclass:java.util.ArrayList<E>
superclass:java.util.ArrayList<java.lang.String>
superclass:java.util.ArrayList<java.lang.String>
ReflectionTest.class :
没找到
ReflectionTest\$1.class :
Signature: #13 // Ljava/util/ArrayList<Ljava/lang/String;>;
ReflectionTest\$SubArrayList1.class :
Signature: #16 // <E:Ljava/lang/Object;>Ljava/util/ArrayList<TE;>;
ReflectionTest\$SubArrayList2.class :
Signature: #14 // Ljava/util/ArrayList<Ljava/lang/String;>;
public class ReflectionTest {
class TestInterface implements Callable<String>, Comparable<Integer> {
@Override
public String call() {
return null;
}
@Override
public int compareTo(Integer o) {
return 0;
}
}
private static void printInterfaces(Class<?> c) {
Type[] types = c.getGenericInterfaces();
for (Type type : types) {
ParameterizedType parameterizedType = (ParameterizedType) type;
System.out.println(parameterizedType.getTypeName());
}
}
public static void main(String[] args) {
printInterfaces(TestInterface.class);
}
}
java.util.concurrent.Callable<java.lang.String>
java.lang.Comparable<java.lang.Integer>
ReflectionTest\$TestInterface.class :
Signature: #32 // Ljava/lang/Object;Ljava/util/concurrent/Callable<Ljava/lang/String;>;Ljava/lang/Comparable<Ljava/lang/Integer;>;
public class BaseGeneric<T> {
private T data;
public T getData() {
return data;
}
public void setData(T data) {
this.data = data;
}
public BaseGeneric(T data) {
this.data = data;
}
public BaseGeneric() {
}
public static void main(String[] args) {
new BaseGeneric<String>() {
};
}
}
BaseGeneric.class
Signature: #31 // <T:Ljava/lang/Object;>Ljava/lang/Object;
BaseGeneric$1.class
Signature: #13 // Lcom/sunshinevvv/thinkinginjava/generics/BaseGeneric<Ljava/lang/String;>;
