Java反射--基于ParameterizedType实现泛型类，参数化类型

一、引子：

项目中使用Gson的反序列化将json转化成具体的对象，具体方法是：

package com.google.gson;下的反序列化方法

 public <T> T fromJson(String json, Type typeOfT) throws JsonSyntaxException{
   ......
 }

参数<T> ：the type of the desired object

参数json：要被反序列化的json数据；

参数typeOfT：指定的通用类型的src。可以通过 Type typeOfT = new TypeToken<Collection<Foo>>(){}.getType();获得；

边对象：使用了泛型类

 public class CtiEdgeT<T,V> {
     private String id;
     //顶点
     private T inVertex;
     //对应点
     private V outVertex;
    ......
 }

最开始考虑使用具体的model作为参数，例如CtiEdgeT<DomainVertex,IpVertex> 具体类型（DomainVertex，IpVertex）做为参数，通过gson反序列化获得具体类型的CtiEdgeT<SampleVertex,IpVertex>对象，例如：

  private boolean saveEdgeToGraph(String msg, String inType, String outType) {
         boolean flag = false;
         switch (inType){
             case Constant.SAMPLE_LABEL:{
                 switch (outType){
                     case Constant.IP_LABEL:{
                         Type type = new TypeToken<CtiEdgeT<SampleVertex,IpVertex>>() {
                         }.getType();
                         CtiEdgeT<SampleVertex,IpVertex> edge =  JsonUtil.getJson().fromJson(msg, type);
                         flag = this.doSaveEdgeToGraph(inType,outType,edge.getInVertex(),edge.getOutVertex(),edge);
                         break;
                     }
                     case Constant.DOMAIN_LABEL:{
                         Type type = new TypeToken<CtiEdgeT<SampleVertex,DomainVertex>>() {
                         }.getType();
                         CtiEdgeT<SampleVertex,DomainVertex> edge =  JsonUtil.getJson().fromJson(msg, type);
                         flag = this.doSaveEdgeToGraph(inType,outType,edge.getInVertex(),edge.getOutVertex(),edge);
                         break;
                     }
                     。。。。。。
                 }
             }
         }
     }

本项目中就有20+种数据，即20+个model，这样做导致的结果就是如果有很多不同的边CtiEdgeT<T,V>，将会写大量的冗余代码。

二、解决方案：

可以通过 ParameterizedType 这个接口实现泛型类，参数化类型，参考这篇文章： https://www.jianshu.com/p/b1ad2f1d3e3e

具体实现如下：

EdgeParameterTypeImpl：

 import java.lang.reflect.ParameterizedType;
 import java.lang.reflect.Type;
 
 public class EdgeParameterTypeImpl implements ParameterizedType {
 
     //边
     private Class ctiEdgeT ;
     //顶点
     private Class inVertex ;
     //对应点
     private Class outVertex ;
 
     public EdgeParameterTypeImpl(Class ctiEdgeT,Class inVertex,Class outVertex) {
         this.ctiEdgeT = ctiEdgeT ;
         this.inVertex = inVertex ;
         this.outVertex = outVertex ;
     }
 
     @Override
     public Type[] getActualTypeArguments() {
         return new Type[]{inVertex,outVertex};
     }
 
     @Override
     public Type getRawType() {
         return ctiEdgeT;
     }
 
     @Override
     public Type getOwnerType() {
         return null;
     }
 
 }

 边 CtiEdgeT<T,V>：

 public class CtiEdgeT<T,V> {
     private String id;
     //顶点
     private T inVertex;
     //对应点
     private V outVertex;
 
     public String getId() {
         return id;
     }
 
     public void setId(String id) {
         this.id = id;
     }
 
     public T getInVertex() {
         return inVertex;
     }
 
     public void setInVertex(T inVertex) {
         this.inVertex = inVertex;
     }
 
     public V getOutVertex() {
         return outVertex;
     }
 
     public void setOutVertex(V outVertex) {
         this.outVertex = outVertex;
     }
 }

通过参数化泛型解决，传入的具体model类作为参数，反序列化得到具体的边

 private boolean saveEdgeToGraph(String msg, String inType, String outType) {
         boolean flag = false;
         Class<?> inVertex = Constant.vertexClassMap.get(inType); //inType : SAMPLE_LABEL
         Class<?> outVertex = Constant.vertexClassMap.get(outType); //outType : IP_LABEL
         EdgeParameterTypeImpl type = new EdgeParameterTypeImpl(CtiEdgeT.class, inVertex, outVertex);
         @SuppressWarnings("rawtypes")
         CtiEdgeT edge =  JsonUtil.getJson().fromJson(msg,type);
         flag = this.doSaveEdgeToGraph(inType,outType,edge.getInVertex(),edge.getOutVertex(),edge);
         return flag;
     }

从vertexClassMap中取对应的具体model

 public class Constant {
     @SuppressWarnings("rawtypes")
     public static Map<String,Class> vertexClassMap = new HashMap<String,Class>();
 
     static{
         try {
             vertexClassMap.put(SAMPLE_LABEL,SampleVertex.class);
             vertexClassMap.put(IP_LABEL,IpVertex.class);
             vertexClassMap.put(DOMAIN_LABEL,DomainVertex.class);
             。。。。。。
             }
         }
     }

通过追踪代码：CtiEdgeT edge = JsonUtil.getJson().fromJson(msg,type);可以发现type的源码

   TypeToken(Type type) {
     this.type = $Gson$Types.canonicalize($Gson$Preconditions.checkNotNull(type));
     this.rawType = (Class<? super T>) $Gson$Types.getRawType(this.type);
     this.hashCode = this.type.hashCode();
   }

   public static Type canonicalize(Type type) {
     if (type instanceof Class) {
       Class<?> c = (Class<?>) type;
       return c.isArray() ? new GenericArrayTypeImpl(canonicalize(c.getComponentType())) : c;
 
     } else if (type instanceof ParameterizedType) {
       ParameterizedType p = (ParameterizedType) type;
       return new ParameterizedTypeImpl(p.getOwnerType(),
           p.getRawType(), p.getActualTypeArguments());
 
     }
     ......
   }

上面标红的代码会执行具体model的实现类的方法，得到具体的类型。

三、拓展点：

关于ParameterizedType 的解析可以参考这篇文章： https://blog.csdn.net/a327369238/article/details/52622331

 public class ParameterTest {
     public static void main(String[] args) {
         Method method = null;
         try {
             //这里的第二个参数，和getRawType()意义类似
             method = new ParameterTest().getClass().getMethod("test", HashMap.class);
         } catch (NoSuchMethodException e) {
             e.printStackTrace();
         }
         Type[] types = method.getGenericParameterTypes();
         ParameterizedType ptype = (ParameterizedType) types[0];
         Type rawType = ptype.getRawType();
         System.out.println("最外层<>前面那个类型 rawType："+rawType);
         Type type = ptype.getActualTypeArguments()[0];
         Type type1 = ptype.getActualTypeArguments()[1];
         System.out.println("泛型 type："+type);
         System.out.println("泛型 type1："+type1);
         Type ownerType = ptype.getOwnerType();
         System.out.println("ownerType："+ownerType);
         //type是Type类型，但直接输出的不是具体Type的五种子类型，
        //而是这五种子类型以及WildcardType具体表现形式
         System.out.println("泛型 type name："+type.getClass().getName());
     }
     public void test(HashMap<String,Integer> a){
     }
 }

结果：

 最外层<>前面那个类型 rawType：class java.util.HashMap
 泛型 type：class java.lang.String
 泛型 type1：class java.lang.Integer
 ownerType：null
 泛型 type name：java.lang.Class

因此 EdgeParameterTypeImpl 中的

public Type getRawType() { return ctiEdgeT;} 得到边ctiEdgeT，而边 CtiEdgeT<T,V> 是参数是泛型，

public Type[] getActualTypeArguments() { return new Type[]{inVertex,outVertex};} 得到参数 inVertex,outVertex

----------------------------------------------多做多解决多总结-----------------------------------