Java如何通過反射獲取泛型的真實類型？

一、背景

在Android項目中想封裝retrofit提供get、post等公共的方法，如：

返回的統(tǒng)一數(shù)據(jù)格式：

{
    "errCode":0,
  "errMsg":"ok",
  "data":...
}

data中的可能是以下情況：

  • 基本數(shù)據(jù)類型的數(shù)據(jù)，如：true、1、字符串等
  • json對象，如{"key1":"value"}
  • json數(shù)組，如[{"key1":"value1"},{"key2":"value2"}]

這時候data的類型就不好確定了，在傳統(tǒng)的Retrofit方式使用時，可能是以下用法：

interface ApiService {
  @GET
  Observable<ResponseEntity<String>> getxxx1(...)
  
  @GET
  Observable<ResponseEntity<JsonClass>> getxxx2(...)

  @GET
  Observable<ResponseEntity<List<JsonClass>> getxxx3(...)
}

class JsonClass {}
class ResponseEntity<T>{
  public int errCode;
  public String errMsg;
  public T data;
}

通過傳入具體的ResponseEntity中的泛型類，這樣Retrofit中就能通過GsonConverterFactory進行類型轉(zhuǎn)換，但是這種就會存在以下的問題：??

  1. 不能對返回的ResponseEntity的錯誤碼進行統(tǒng)一處理

    比如我們的業(yè)務中定義了一些固定的錯誤碼，如errCode=0表示正常返回數(shù)據(jù)，errCode=1001表示token過期需要跳轉(zhuǎn)到登錄頁面重新登錄，errCode>xxx時需要彈toast提示等，這些如果不統(tǒng)一處理就需要在每個調(diào)用接口的onSuccess方法中做一下判斷。

  2. 將整個返回的數(shù)據(jù)都暴露給了業(yè)務，但業(yè)務只關(guān)心的是 T 所代表的數(shù)據(jù)

    對于框架來說應該是給業(yè)務提供自己需要的數(shù)據(jù)就OK了，一些底層的判斷還是能不給暴漏給業(yè)務就盡量不暴漏給業(yè)務

  3. 對于組件化的項目中存在多個ApiService

    在這些年的面試過程中，發(fā)現(xiàn)有些面試者在組件化的項目中，每個組件中都存在一個ApiService，每個ApiService都承擔著不同的業(yè)務module的業(yè)務接口數(shù)據(jù)請求，由于Java并不支持類別分類（即同一個類可以分散到不同的文件中，iOS中是Category，類似kotlin里面的擴展函數(shù)），所以會導致項目中有多個 Retrofit 實例

基于以上原因，我才想在我們的項目中對Retrofit做進一步封裝，來避免上述問題

首先我嘗試這么寫：

interface ApiService {
  @GET
  <T> Observable<ResponseEntity<T> get(Map<String,String> params)
    
  @POST
  <T> Observable<ResponseEntity<T>> post(Map<String,String> params)
}

會報錯?com.google.gson.internal.LinkedTreeMap cannot be cast to xxx，究其主要原因是Java中存在泛型擦除，這就導致在GsonConverterFactory中進行轉(zhuǎn)換時找不到 T 的真實類型，在編譯后 ResponseEntity<T>可以想象成ResponseEntity<Object>，這就引申出本篇文章的主題

二、Gson反序列化泛型數(shù)據(jù)的方法

如何將json字符串轉(zhuǎn)換成帶泛型的數(shù)據(jù)結(jié)構(gòu)

class ResponseData<T>{
    private int errCode;
    private String errMsg;
    private T data;
        
    // .... 省略get set
}
class Result{
    private String name;

    // .... 省略get set
}

public static void main(String[] args) {
  Gson gson = new Gson();
  String r1Str = "{\"errCode\":0,\"errMsg\":\"ok\",\"data\":{\"name\":\"result1\"}}";

  ResponseData<Result> responseData = gson.fromJson(r1Str, ResponseData.class);
  System.out.println(responseData.getData().getName());
}

報錯?：com.google.gson.internal.LinkedTreeMap cannot be cast to Result，這里就是因為有泛型擦除的問題，在代碼里不能寫ResponseData<Result>.class，所以轉(zhuǎn)換過程中并不知道 T 的真實類型是什么，換一種方式：

public static void main(String[] args) {
  Gson gson = new Gson();
  String r1Str = "{\"errCode\":0,\"errMsg\":\"ok\",\"data\":{\"name\":\"result1\"}}";

    ResponseData<Result> responseData = gson.fromJson(r1Str,new TypeToken<ResponseData<Result>>(){}.getType());
  System.out.println(responseData.getData().getName());
}

使用 TypeToken 來做獲取 T 的真實類型，那么TypeToken是如何實現(xiàn)的呢，下面我們來看看源碼

protected TypeToken() {
  this.type = getSuperclassTypeParameter(this.getClass());
  this.rawType = Types.getRawType(this.type);
  this.hashCode = this.type.hashCode();
}

static Type getSuperclassTypeParameter(Class<?> subclass) {
  // getGenericSuperclass的作用： 返回此 Class 所表示的實體（類、接口、基本類型或 void）的直接超類的 Type。
  Type superclass = subclass.getGenericSuperclass();
  if (superclass instanceof Class) {
    throw new RuntimeException("Missing type parameter.");
  } else {
    // ParameterizedType的作用：獲得元數(shù)據(jù)中泛型簽名類型(泛型真實類型) 
    ParameterizedType parameterized = (ParameterizedType)superclass;
    // getActualTypeArguments的作用：獲得真實類型參數(shù)
    return Types.canonicalize(parameterized.getActualTypeArguments()[0]);
  }
}

public final Type getType() {
  return this.type;
}

這里核心是使用了getGenericSuperclass和ParameterizedType，下面一小節(jié)我們就詳細了解下反射技術(shù)中的這幾個api類的作用，了解是如何通過它去獲取泛型的真實類型的。

這里還有一個細節(jié)需要注意的：

?? new TypeToken<ResponseData<Result>>(){} 實例化之后為什么需要加 {} ？

TypeToken 的構(gòu)造函數(shù)是protected的，表示本包以及子類可以使用，加一個 {} 就相當于繼承了這個類，相當于：

class TypeToken$0 extends TypeToken<ResponseData<Result>>{}
TypeToken<ResponseData<Result>> sToken = new TypeToken$0();

三、如何通過反射獲取泛型的真實類型？

當我們對一個泛型類進行反射時，需要到泛型中的真實數(shù)據(jù)類型，來完成如json反序列化的操作。此時需要通過 Type 體系來完成。 Type 接口包含了一個實現(xiàn)類(Class)和四個實現(xiàn)接口，他們分別是:

  • TypeVariable

    泛型類型變量。可以獲得泛型上下限等信息;

  • ParameterizedType

    具體的泛型類型，可以獲得元數(shù)據(jù)中泛型簽名類型(泛型真實類型)

  • GenericArrayType

    當需要描述的類型是泛型類的數(shù)組時，比如List[],Map[]，此接口會作為Type的實現(xiàn)。

  • WildcardType

    通配符泛型，獲得上下限信息;

3.1、TypeVariable
 public class TestType <K extends Comparable & Serializable, V> {
    K key;
    V value;
    public static void main(String[] args) throws Exception {
            // 獲取字段的類型
            Field fk = TestType.class.getDeclaredField("key"); 
      Field fv = TestType.class.getDeclaredField("value");
      // getGenericType
            TypeVariable keyType = (TypeVariable)fk.getGenericType(); 
      TypeVariable valueType = (TypeVariable)fv.getGenericType(); 
      // getName 方法
            System.out.println(keyType.getName()); 
      System.out.println(valueType.getName());
            // getGenericDeclaration 方法 
      System.out.println(keyType.getGenericDeclaration());
      System.out.println(valueType.getGenericDeclaration()); 
      // getBounds 方法
      System.out.println("K 的上界:");
            for (Type type : keyType.getBounds()) {
                System.out.println(type);
            }
            System.out.println("V 的上界:");
            for (Type type : valueType.getBounds()) {
                System.out.println(type); }
            }
 }
3.2、ParameterizedType
 
public class TestType {
    Map<String, String> map;
        public static void main(String[] args) throws Exception {
            Field f = TestType.class.getDeclaredField("map"); 
      System.out.println(f.getGenericType()); // java.util.Map<java.lang.String,java.lang.String>
            ParameterizedType pType = (ParameterizedType) f.getGenericType(); 
      System.out.println(pType.getRawType()); // interface java.util.Map 
      for (Type type : pType.getActualTypeArguments()) {
                System.out.println(type); // 打印兩遍: class java.lang.String
        }
    }
}
3.3、GenericArrayType
 public class TestType<T> {
    List<String>[] lists;
        public static void main(String[] args) throws Exception {
            Field f = TestType.class.getDeclaredField("lists");
            GenericArrayType genericType = (GenericArrayType) f.getGenericType();
      System.out.println(genericType.getGenericComponentType());
        } 
 }
3.4、WildcardType
public class TestType {
    private List<? extends Number> a; // 上限 
  private List<? super String> b; //下限
    public static void main(String[] args) throws Exception { 
    Field fieldA = TestType.class.getDeclaredField("a"); 
    Field fieldB = TestType.class.getDeclaredField("b"); 
    // 先拿到范型類型
        ParameterizedType pTypeA = (ParameterizedType) fieldA.getGenericType(); 
    ParameterizedType pTypeB = (ParameterizedType) fieldB.getGenericType(); 
    // 再從范型里拿到通配符類型
        WildcardType wTypeA = (WildcardType) pTypeA.getActualTypeArguments()[0];
    WildcardType wTypeB = (WildcardType) pTypeB.getActualTypeArguments()[0]; 
    // 方法測試
        System.out.println(wTypeA.getUpperBounds()[0]); // class java.lang.Number
    System.out.println(wTypeB.getLowerBounds()[0]); // class java.lang.String 
    // 看看通配符類型到底是什么, 打印結(jié)果為: ? extends java.lang.Number
    System.out.println(wTypeA); 
  }
}

從上面四個類可以看出，要獲取泛型的真實類型需要用到ParameterizedType，通過 getActualTypeArguments 獲取。

我們了解了這些API之后，那如何自己實現(xiàn)一個獲取泛型類型的方法呢，下一小節(jié)我們就來看看

四、自定義TypeToken

public class MyTypeToken<T> {
  final Type type;
  protected MyTypeToken() {
    this.type = getSuperclassTypeParameter(this.getClass());
  }

  static Type getSuperclassTypeParameter(Class<?> subclass) {
    Type superclass = subclass.getGenericSuperclass();
    if (superclass instanceof Class) {
      throw new RuntimeException("Missing type parameter.");
    } else {
      ParameterizedType parameterized = (ParameterizedType)superclass;
      return parameterized.getActualTypeArguments()[0];
    }
  }

  public Type getType() {
    return type;
  }
}

使用方式：

String r1Str = "{\"errCode\":0,\"errMsg\":\"ok\",\"data\":{\"name\":\"result1\"}}";
System.out.println(r1Str);
ResponseData<Result> responseData = gson.fromJson(r1Str,new MyTypeToken<ResponseData<Result>>(){}.getType());
System.out.println(responseData.getData().getName());

這里需要注意的是??new MyTypeToken<ResponseData<Result>>(){} 這里是帶有 {}的。

?著作權(quán)歸作者所有,轉(zhuǎn)載或內(nèi)容合作請聯(lián)系作者
【社區(qū)內(nèi)容提示】社區(qū)部分內(nèi)容疑似由AI輔助生成，瀏覽時請結(jié)合常識與多方信息審慎甄別。
平臺聲明：文章內(nèi)容（如有圖片或視頻亦包括在內(nèi)）由作者上傳并發(fā)布，文章內(nèi)容僅代表作者本人觀點，簡書系信息發(fā)布平臺，僅提供信息存儲服務。

相關(guān)閱讀更多精彩內(nèi)容

友情鏈接更多精彩內(nèi)容