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&lt;Collection&lt;Foo&gt;&gt;(){}.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

----------------------------------------------多做多解決多總結-----------------------------------