java jackson 泛型_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);

}