最近在用jackson反序列化泛型参数遇到了点问题，下面的博客地址是我搜到的解决方案
感谢思路，特奉上循环版本，有兴趣的同学可评论交流
/**
* 获取泛型参数循环版
* 思路： 依赖栈结构先进后出的特性实现
* 1，遍历泛型引用(树的遍历)，并将所有type存储到栈中
* 2，按顺序出栈，简单类型直接生成javaType，并缓存
* 3，泛型类型从缓存中获取依赖的javaType生成，并将自身放入缓存以供栈底的依赖类型获取javaType
* 4，出栈结束，栈底最后一个元素就是参数需要的类型
* @param type
* @return
*/
public static JavaTypejavaType(Type type) {
//数据存储栈
Stack typeStack =new Stack<>();
//数据遍历栈
Stack parameterizedTypes =new Stack<>();
typeStack.push(type);
if (typeinstanceof ParameterizedType) {
parameterizedTypes.push((ParameterizedType) type);
}
while (!parameterizedTypes.empty()) {
ParameterizedType parameterizedType = parameterizedTypes.pop();
Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
for (int i =0; i < actualTypeArguments.length; i++) {
if (actualTypeArguments[i]instanceof ParameterizedType) {
parameterizedTypes.push((ParameterizedType) actualTypeArguments[i]);
}
typeStack.push(actualTypeArguments[i]);
}
}
Map cache =new HashMap<>();
ParameterizedType parameterizedType =null;
while (!typeStack.empty()) {
while (!typeStack.empty()) {
Type pop = typeStack.pop();
if (popinstanceof ParameterizedType) {
parameterizedType = (ParameterizedType) pop;
break;
}else {
if(popinstanceof Class){
JavaType javaType = TypeFactory.defaultInstance().constructParametricType((Class) pop, new JavaType[0]);
cache.put(pop, javaType);
}
}
}
if (parameterizedType !=null) {
Type[] typeArguments = parameterizedType.getActualTypeArguments();
Class rowClass = (Class) parameterizedType.getRawType();
JavaType[] javaTypes =new JavaType[typeArguments.length];
for (int i =0; i < typeArguments.length; i++) {
JavaType javaType = cache.get(typeArguments[i]);
if (javaType ==null) {//兼容泛型
javaType = TypeFactory.defaultInstance().constructParametricType(Object.class, new JavaType[0]);
}
javaTypes[i] = javaType;
}
JavaType javaType = TypeFactory.defaultInstance().constructParametricType(rowClass, javaTypes);
cache.put(parameterizedType, javaType);
}
}
return cache.get(type);
}
