Method method = ((MethodSignature) pjp.getSignature()).getMethod();
Object[] args = pjp.getArgs();
//根據方法註解和引數獲取快取的key， 
String key = GenerateKeyUtil.getCacheKey(method, args); 

String cacheJson = redisTemplate.opsForValue().get(key);

 Class<?> returnType = method.getReturnType();

 return objctMapper.readValue(cacheJson,returnType);

如果method的返回型別是List<User>,上面的方法method.getReturnType() 的返回值只是Class<java.util.List>，所以反序列化的結果是ArrayList<HashMap>型別的，而並不是List<User>型別。另外，上面為了簡化程式碼沒有判斷快取是否有值，和沒有快取執行目標方法的並新增快取的程式碼。

後來看了一下jackson的程式碼註釋，使用下列方法可以通用的解析json資料為帶泛型的結果；

Method method = ((MethodSignature) pjp.getSignature()).getMethod();

 Object[] args = pjp.getArgs();
//根據方法註解和引數獲取快取的key，
 String key = GenerateKeyUtil.getCacheKey(method, args);
//獲取redis快取的值,
 String cacheJson = redisTemplate.opsForValue().get(key);    
 //帶有泛型資訊
 Type genericReturnType = method.getGenericReturnType(); 
 //獲取返回類的繫結資訊    
JavaType javaType = JsonUtil.getJavaType(genericReturnType);   
 
return objectMapper.readValue(cacheJson,javaType);

下面是JsonUtil.getJavaType(Type type)的程式碼

 public static JavaType getJavaType(Type type) {
        //判斷是否帶有泛型
        if (type instanceof ParameterizedType) {
            Type[] actualTypeArguments = ((ParameterizedType) type).getActualTypeArguments();
            //獲取泛型型別
            Class rowClass = (Class) ((ParameterizedType) type).getRawType();
            
            JavaType[] javaTypes = new JavaType[actualTypeArguments.length];
            
            for (int i = 0; i < actualTypeArguments.length; i++) {
                //泛型也可能帶有泛型，遞迴獲取
                javaTypes[i] = getJavaType(actualTypeArguments[i]);
            }
            return TypeFactory.defaultInstance().constructParametricType(rowClass, javaTypes);
        } else {
            //簡單型別直接用該類構建JavaType
            Class cla = (Class) type;
            return TypeFactory.defaultInstance().constructParametricType(cla, new JavaType[0]);
        }
    }
 

上面的方法經過測試可以解析任意層數，但是是遞迴實現，搞了半天沒搞出來迴圈方式實現。

有迴圈實現的求評論個連結或則程式碼。。。

另外把TypeFactory.constructParametricType()的原始碼註釋貼下面

 /**
     * Factory method for constructing {@link JavaType} that
     * represents a parameterized type. For example, to represent
     * type <code>List<Set<Integer>></code>, you could
     * call
     *<pre>
     *  JavaType inner = TypeFactory.constructParametricType(Set.class, Set.class, Integer.class);
     *  return TypeFactory.constructParametricType(ArrayList.class, List.class, inner);
     *</pre>
     *<p>
     * The reason for first two arguments to be separate is that parameterization may
     * apply to a super-type. For example, if generic type was instead to be
     * constructed for <code>ArrayList<Integer></code>, the usual call would be:
     *<pre>
     *  TypeFactory.constructParametricType(ArrayList.class, List.class, Integer.class);
     *</pre>
     * since parameterization is applied to {@link java.util.List}.
     * In most cases distinction does not matter, but there are types where it does;
     * one such example is parameterization of types that implement {@link java.util.Iterator}.
     *<p>
     * NOTE: type modifiers are NOT called on constructed type.
     * 
     * @param rawType Actual type-erased type
     * @param parameterTypes Type parameters to apply
     * 
     * @since 2.5 NOTE: was briefly deprecated for 2.6
     */