一仆救、背景

在Android項(xiàng)目中想封裝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進(jìn)行類型轉(zhuǎn)換叠聋，但是這種就會存在以下的問題：??

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

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

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

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

3. 對于組件化的項(xiàng)目中存在多個ApiService

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

基于以上原因，我才想在我們的項(xiàng)目中對Retrofit做進(jìn)一步封裝雪猪，來避免上述問題

首先我嘗試這么寫：

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中存在泛型擦除，這就導(dǎo)致在GsonConverterFactory中進(jìn)行轉(zhuǎn)換時找不到 T 的真實(shí)類型只恨，在編譯后 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官觅，這里就是因?yàn)橛蟹盒筒脸膯栴}纵菌，在代碼里不能寫ResponseData<Result>.class，所以轉(zhuǎn)換過程中并不知道 T 的真實(shí)類型是什么缰猴，換一種方式：

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 的真實(shí)類型产艾，那么TypeToken是如何實(shí)現(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 所表示的實(shí)體（類滑绒、接口闷堡、基本類型或 void）的直接超類的 Type。
  Type superclass = subclass.getGenericSuperclass();
  if (superclass instanceof Class) {
    throw new RuntimeException("Missing type parameter.");
  } else {
    // ParameterizedType的作用：獲得元數(shù)據(jù)中泛型簽名類型(泛型真實(shí)類型) 
    ParameterizedType parameterized = (ParameterizedType)superclass;
    // getActualTypeArguments的作用：獲得真實(shí)類型參數(shù)
    return Types.canonicalize(parameterized.getActualTypeArguments()[0]);
  }
}

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

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

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

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

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

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

三软舌、如何通過反射獲取泛型的真實(shí)類型？

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

• TypeVariable

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

• ParameterizedType

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

• GenericArrayType

  當(dāng)需要描述的類型是泛型類的數(shù)組時不跟，比如List[],Map[]，此接口會作為Type的實(shí)現(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); 
  }
}

從上面四個類可以看出米诉，要獲取泛型的真實(shí)類型需要用到ParameterizedType，通過 getActualTypeArguments 獲取篷帅。

我們了解了這些API之后史侣，那如何自己實(shí)現(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>>(){} 這里是帶有 {}的惊橱。