手把手實現一個mini-Retrofit框架

前文

本篇文章將採用循序漸進的編碼方式，從零開始實現一個Retorift框架;在實現過程中不斷提出問題並分析實現,最終開發出一個mini版的Retrofit框架

演示一個使用OkHttp的項目Demo

爲了更好的演示框架的實現過程，這裏我先創建了一個簡單的Demo項目

這個Demo項目中主要包含3個部分

Json數據對應JavaEntity類
項目中包裝網絡請求回調的Callback
一個包含項目所有網絡接口請求的管理類RestService

JavaBean

@Data
@ToString
public class BaseResponse<T> {
    private boolean error;
    private T results;
}

package com.knight.sample.entity;

import java.util.List;
import java.util.Map;

public class XianduResponse extends BaseResponse<List<GankEntity>> {
}

NetCallback

package com.knight.sample;

import java.io.IOException;

/**
 * 項目封裝的統一網絡請求的回調
 * @param <T>
 */
public interface NetCallback<T> {
    void onFailure(Exception e);

    void onSuccess(T data);
}

NetWorkService

package com.knight.sample;

import android.util.Log;

import com.google.gson.Gson;
import com.google.gson.stream.JsonReader;

import java.io.IOException;

import okhttp3.Call;
import okhttp3.Callback;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;

public class RestService {
    private static OkHttpClient okHttpClient;
    public static void init() {
        okHttpClient = new OkHttpClient.Builder()
                .build();
    }

    public static<T>  void todayGank(Class<T> responseClazz,NetCallback<T> callback) {
        Request request = new Request.Builder().url("http://gank.io/api/today")
                .get()
                .build();
        okHttpClient.newCall(request).enqueue(new WrapOkHttpCallback<>(responseClazz,callback));
    }

    public static<T>  void xianduGank(int count, int page,Class<T> responseClazz,NetCallback<T> callback) {
        Request request = new Request.Builder()
                .url("http://gank.io/api/xiandu/data/id/appinn/count/" + count + "/page/" + page)
                .get().build();
        okHttpClient.newCall(request).enqueue(new WrapperOkHttpCallback<>(responseClazz,callback));
    }

    static class WrapOkHttpCallback<T> implements Callback {
        private static Gson gson = new Gson();
        private Class<T> clazz;
        private NetCallback<T> callback;

        public WrapOkHttpCallback(Class<T> responseClazz, NetCallback<T> netCallback) {
            this.clazz = responseClazz;
            this.callback = netCallback;
        }

        @Override
        public void onFailure(Call call, IOException e) {
            Log.e("WrapperOkHttpCallback", "onFailure");
            e.printStackTrace();
            callback.onFailure(e);
        }

        @Override
        public void onResponse(Call call, Response response) throws IOException {
            JsonReader jsonReader = gson.newJsonReader(response.body().charStream());
            T entity = gson.getAdapter(clazz).read(jsonReader);
            Log.d("response", entity.toString());
            callback.onSuccess(entity);

        }
    }

}

在NetworkService類中，我們目前定義了2個Http 請求 todayGank 和 xianduGank ，目前兩個請求方式都是 Get 其中 xianduGank 需要傳入 count 及 page參數分別表示每頁數據的數據以及請求的頁碼，除此之外這兩個網絡請求都需要傳入一個Class對象表示響應的Json數據對應的Model，以便在內部使用Gson來解析，以及網絡請求的異步回調 NetCallback

我們不直接使用OkHttp提供的Callback ，而是在內部簡單的做了封裝，轉換成項目自己的NetCallback，因爲對項目的開發人員來說，能夠在Callback接口的success回調中直接得到響應的Json數據對應的JavaBean會更優化一些。

本次提交詳細代碼見

思考項目現狀

上文模擬的代碼只是一個簡單的例子，也許存在其他更好的封裝方式，但這並不是我們這篇文章想要討論的重點。讓我們先回到示例中RestService類中的代碼部分,看下目前網絡請求的寫法；

因爲我們項目中已經有了OKHttp這個網絡庫了，有關Http具體的連接及通信的髒話、累活都可以交給它來處理，那麼對於項目開發者，我們只需要關係並配置以下Http請求部分

請求的url 地址
請求的方式 (GET、POST、PUT…)
請求內容體

我們知道JAVA的註解有以下特性

註解可以使用在方法上
Retention爲RUNTIME的註解可以在虛擬機運行時也獲取到註解上的信息
Java的動態代理可以在運行時生成原接口類型的代理實現類對象並hook方法的調用

每一個網絡接口調用請求的url地址和請求方式都是唯一的 ,那麼對於一個簡單的網絡請求我們能不能使用註解 + 動態代理 來簡化這一過程，改爲聲明式的編程方式來實現網絡調用，比如就像這樣

/**
 * Created by zhuoxiuwu
 * on 2019/4/25
 * email [email protected]
 */
public interface NetRestService {

    @GET("http://gank.io/api/today")
    public Call todayGank();
}

在我們的構思中，可以在接口的抽象方法上添加了註解 @GET 表示這是一個Http GET請求的調用

註解中GET帶的默認參數表示GET請求的地址。聲明這個方法後，運行時我們通過Java動態代理技術解析這個方法上的註解的信息，內部通過調用OKHttp的相關方法生成一個 Call對象

有了大概思路了,我們接下來先簡單的實現一個小例子來驗證我們的想法是否可行

編碼實現

3.1 簡單實現一個支持GET、POST請求的Retrofit

新建一個註解類@GET

package retrofit2.http;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;


/**
 * Created by zhuoxiuwu
 * on 2019/4/25
 * email [email protected]
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface GET {
    //註解中 方法名寫成value 這樣的話，在使用註解傳入參數時就不用帶key了，它會作爲一個默認的調用
    String value();
}

新建一個處理Http接口類的動態代理的類Retrofit，我們實際網絡請求的調用是依賴OKHttp,所以我們要求構造函數傳入OkHttp對象

目前Retrofit 類只有一個方法public T createService(final Class service) 它接收一個抽象類，並生成該抽象類的代理實現。

package retrofit2;



import java.lang.annotation.Annotation;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

import okhttp3.OkHttpClient;
import okhttp3.Request;
import retrofit2.http.GET;

public class Retrofit {

    private OkHttpClient mOkHttpClient;

    public Retrofit(OkHttpClient mOkHttpClient) {
        this.mOkHttpClient = mOkHttpClient;
    }

    @SuppressWarnings("unchecked")
    public <T> T createService(final Class<T> service) {
        return (T) Proxy.newProxyInstance(service.getClassLoader(), new Class<?>[]{service},
                new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method,
                                         Object[] args) throws Throwable {
                        //獲取方法所有的註解
                        final Annotation[] annotations = method.getAnnotations();
                        for (int i = 0; i < annotations.length; i++) {
                            if (annotations[i] instanceof GET) { //如果註解是GET類型

                                final GET annotation = (GET) annotations[i];
                                final String url = annotation.value();
                                final Request request = new Request.Builder()
                                        .url(url)
                                        .get().build();
                                return mOkHttpClient.newCall(request);
                            }
                        }
                        return null;
                    }
                });
    }
}

因爲我們主要的目標是爲了驗證這個方案的可行性，因此createService方法內部的邏輯很簡單

1.獲取方法上的所有註解

 //獲取方法所有的註解
                        final Annotation[] annotations = method.getAnnotations();

2.判斷如果存在@GET註解則獲取註解內的值作爲請求的地址

if (annotations[i] instanceof GET) { //如果註解是GET類型

    final GET annotation = (GET) annotations[i];
    final String url = annotation.value();

3.根據url構造GET請求的Request對象，並作爲參數調用OkHttpClient的newCall方法生成Call對象作爲該方法調用的返回值

 final Request request = new Request.Builder()
                                        .url(url)
                                        .get().build();
                                return mOkHttpClient.newCall(request);

以上完成了一個對@GET註解申明的Http請求的動態代理封裝，下面我們在自己的項目中驗證一下

3.2在項目中驗證

1.創建一個接口類,並添加一個方法，方法的返回類型爲Call，方法是添加了@GET註解

package com.knight.sample;

import okhttp3.Call;
import retrofit2.http.GET;

/**
 * Created by zhuoxiuwu
 * on 2019/4/25
 * email [email protected]
 */
public interface NetRestService {

    @GET("http://gank.io/api/today")
    public Call todayGank();
}

2.在項目中添加測試方法並調用

private void getToDayGankByRetrofit() {
        final Retrofit retrofit = new Retrofit(new OkHttpClient());
        retrofit.createService(NetRestService.class).todayGank().enqueue(new Callback() {
            @Override
            public void onFailure(Call call, IOException e) {

            }

            @Override
            public void onResponse(Call call, Response response) throws IOException {
                JsonReader jsonReader = gson.newJsonReader(response.body().charStream());
                TodayGankResponse todayGankResponse = gson.getAdapter(TodayGankResponse.class).read(jsonReader);
                showHttpResult(todayGankResponse.toString());
                 Log.d("RetrofitTest","調用成功,結果爲"+todayGankResponse.toString());
            }
        });
    }

運行之後,方法調用成功並得到了響應結果

 D/RetrofitTest: 調用成功,結果爲BaseResponse(error=false, results={Android=[GankEntity(url=https://github.com/iqiyi/Neptune, desc=適用於Android的靈活，強大且輕量級的插件框架...

通過簡單的一個實現,我們成功驗證了使用註解加動態代理的方式實現一個聲明式的網絡請求框架是可行的，那麼後續我們需要繼續完善這個項目，提供對更多請求方式以及參數的支持

對於其他請求方式的支持，我們可以添加更多的表示請求方式的註解,當用戶設置了不同的註解，在內部我們使用OKHttp調用相應的方法。Http的請求方式大概如下

@DELETE
@GET
@HEAD
@PATCH
@POST
@PUT
@OPTIONS

本次提交見git

3.3繼續實現POST註解

爲了加深理解，我們繼續簡單的實現一個POST請求，並支持傳入一個參數對象，作爲POST請求的JSON數據

首先我們添加一個POST註解


@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface POST {
    String value();
}

package retrofit2;


import com.google.gson.Gson;

import java.lang.annotation.Annotation;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.Type;

import okhttp3.Call;
import okhttp3.MediaType;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.RequestBody;
import retrofit2.http.GET;
import retrofit2.http.POST;

public class Retrofit {

    private OkHttpClient mOkHttpClient;

    public Retrofit(OkHttpClient mOkHttpClient) {
        this.mOkHttpClient = mOkHttpClient;
    }

    @SuppressWarnings("unchecked")
    public <T> T createService(final Class<T> service) {
        return (T) Proxy.newProxyInstance(service.getClassLoader(), new Class<?>[]{service},
                new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method,
                                         Object[] args) throws Throwable {
                        //獲取方法所有的註解
                        final Annotation[] annotations = method.getAnnotations();

                        for (int i = 0; i < annotations.length; i++) {
                            if (annotations[i] instanceof GET) { //如果註解是GET類型
                                final GET annotation = (GET) annotations[i];
                                return parseGet(annotation.value(), method, args);
                            } else if (annotations[i] instanceof POST) {
                                final POST annotation = (POST) annotations[i];
                                return parsePost(annotation.value(), method, args);
                            }
                        }
                        return null;
                    }
                });
    }


    private Call parseGet(String url, Method method, Object args[]) {
        final Request request = new Request.Builder()
                .url(url)
                .get().build();
        return mOkHttpClient.newCall(request);
    }

    private Gson gson = new Gson();
    private static final MediaType MEDIA_TYPE = MediaType.get("application/json; charset=UTF-8");

    private Call parsePost(String url, Method method, Object args[]) {
        final Type[] genericParameterTypes = method.getGenericParameterTypes();
        if (genericParameterTypes.length > 0) {
            final Class<?> clazz = Utils.getRawType(genericParameterTypes[0]);
            final String jsonBody = gson.toJson(args[0], clazz);
            final Request request = new Request.Builder()
                    .url(url)
                    .post(RequestBody.create(MEDIA_TYPE, jsonBody))
                    .build();
            return mOkHttpClient.newCall(request);
        }
        return null;
    }


}

在 paresePost方法中我們首先通過Method的getGenericParameterTypes方法獲取所有參數的Type類型，並且通過Type類獲得參數的原始Class類型，之後就可以使用Gson轉換成對應的Json對象了。

點擊查看本次git提交的詳細代碼

3.4 實現ConverterFactory 解耦Json轉換

在上面的例子中，我們直接在框架Retrofit中使用了Gson庫做Json轉換；但作爲一個框架，我們不希望這個框架直接強耦合一個Json轉換庫，這部分可以交由開發者根據具體的項目技術選型自由選擇；因此我們可以對這部分做下抽象封裝，提取成一個負責Json轉換的接口, 讓應用層傳入該接口的具體實現.

package retrofit2;

import java.lang.reflect.Type;

import javax.annotation.Nullable;

import okhttp3.RequestBody;

/**
 * Created by zhuoxiuwu
 * on 2019/4/25
 * email [email protected]
 */
public interface Converter<F, T> {
    @Nullable
    T convert(F value);

    abstract class Factory {
        public @Nullable
        Converter<?, RequestBody> requestBodyConverter(Type type) {
            return null;
        }

    }
}

應用層需要傳入一個ConverterFactory,該工廠類負責根據傳入的Type類型，返回一個能夠將該Type類型的對象轉換成RequestBody的Converter

我們對Retrofit的構造函數以及paresePost方法做下修改，要求構造函數中傳入一個ConverterFactory的實現，並在paresePost方法中使用這個ConverterFactory來做Java對象到ReqeustBody的轉換

public class Retrofit {

    private OkHttpClient mOkHttpClient;

    private Converter.Factory mConverterFactory;

    public Retrofit(OkHttpClient mOkHttpClient, Converter.Factory mConverterFactory) {
        this.mOkHttpClient = mOkHttpClient;
        this.mConverterFactory = mConverterFactory;
    }
    //..省略部分代碼
    
    private Call parsePost(String url, Method method, Object args[]) {
        final Type[] genericParameterTypes = method.getGenericParameterTypes();
        if (genericParameterTypes.length > 0) {
            //直接調用得到RequestBody
            final RequestBody requestBody = requestBodyConverter(genericParameterTypes[0]).convert(args[0]);
            final Request request = new Request.Builder()
                    .url(url)
                    .post(requestBody)
                    .build();
            return mOkHttpClient.newCall(request);
        }
        return null;
    }


    public <T> Converter<T, RequestBody> requestBodyConverter(Type type) {
        return (Converter<T, RequestBody>) mConverterFactory.requestBodyConverter(type);
    }

在應用層，我們實現並傳入一個Gson的ConvertFactory的實現

package com.knight.sample;

import com.google.gson.Gson;
import com.google.gson.TypeAdapter;
import com.google.gson.reflect.TypeToken;
import com.google.gson.stream.JsonWriter;

import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.Writer;
import java.lang.reflect.Type;
import java.nio.charset.Charset;

import okhttp3.MediaType;
import okhttp3.RequestBody;
import okio.Buffer;
import retrofit2.Converter;

/**
 * Created by zhuoxiuwu
 * on 2019/4/25
 * email [email protected]
 */
public class GsonConverterFactory extends Converter.Factory {
    public static GsonConverterFactory create() {
        return create(new Gson());
    }

    public static GsonConverterFactory create(Gson gson) {
        if (gson == null) throw new NullPointerException("gson == null");
        return new GsonConverterFactory(gson);
    }

    private final Gson gson;

    private GsonConverterFactory(Gson gson) {
        this.gson = gson;
    }

    @Override
    public Converter<?, RequestBody> requestBodyConverter(Type type) {
        //通過Type 轉換成Gson的TypeAdapter
        //具體類型的json轉換依賴於這個TypeAdapter
        TypeAdapter<?> adapter = gson.getAdapter(TypeToken.get(type));
        return new GsonRequestBodyConverter<>(gson, adapter);

    }


    final static class GsonRequestBodyConverter<T> implements Converter<T, RequestBody> {
        private static final MediaType MEDIA_TYPE = MediaType.get("application/json; charset=UTF-8");
        private static final Charset UTF_8 = Charset.forName("UTF-8");

        private final Gson gson;
        private final TypeAdapter<T> adapter;

        GsonRequestBodyConverter(Gson gson, TypeAdapter<T> adapter) {
            this.gson = gson;
            this.adapter = adapter;
        }

        @Override
        public RequestBody convert(T value) {
            Buffer buffer = new Buffer();
            Writer writer = new OutputStreamWriter(buffer.outputStream(), UTF_8);
            JsonWriter jsonWriter = null;
            try {
                jsonWriter = gson.newJsonWriter(writer);
                adapter.write(jsonWriter, value);
                jsonWriter.close();
                return RequestBody.create(MEDIA_TYPE, buffer.readByteString());
            } catch (IOException e) {
                e.printStackTrace();
                return null;
            }

        }
    }

}

點擊查看本次git提交的詳細代碼

3.5 實現CallAdapter 支持方法返回類型

繼續回到Http請求的聲明中，目前我們方法所支持的返回類型都是OKHttp的Call對象,而Call對象從使用上來說,目前還是有些繁瑣,原生的Call對象返回的是ResponseBody還需要開發者自己處理並做轉換。

public interface NetRestService {

    @GET("http://gank.io/api/today")
    public Call todayGank();
}

也許我們希望這個方法可以這樣定義

public interface NetRestService {

    @GET("http://gank.io/api/today")
    public TodayGankResponse todayGank();
}

也許我們可以在框架內部通過判斷方法的返回類型是不是Call對象,如果不是,就在框架內部直接同步調用網絡請求得到響應的Json內容後直接轉換成JavaBean對象作爲方法的返回值。但是這個設想存在這樣幾個問題

要實現直接返回Http結果則方法調用是同步調用,如果在主線程做IO請求肯定是不合理的
如果內部IO異常了,或者JSON轉換失敗了方法返回的是什麼呢？爲null嗎？

因此更合理的一種方式，我們希望接口方法返回的是一個支持異步回調的對象;

比如我們的項目自己新增了一個支持異步調用的NetCall抽象接口

/**
 * Created by zhuoxiuwu
 * on 2019/4/26
 * email [email protected]
 */
public interface NetCall<T> {
    public void execute(NetCallback<T> netCallback);
}

我們希望我們的方法可以這樣申明

public interface NetRestService {

    @GET("http://gank.io/api/today")
    public NetCall<TodayGankResponse> todayGank();
}

這樣的話在應用層我們調用的時候就可以像這樣使用

        retrofit.createService(NetRestService.class).todayGank()
                .execute(new NetCallback<TodayGankResponse>() {
                    @Override
                    public void onFailure(Exception e) {

                    }

                    @Override
                    public void onSuccess(TodayGankResponse data) {
                        Log.d("RetrofitTest","調用成功,結果爲"+data.toString());
                        showHttpResult(data.toString());
                    }
                });

那麼具體要怎麼實現呢，同樣我們可以把這個構思做一個抽象並封裝起來，讓Retrofit框架支持對方法返回類型的自定義適配；和Converter接口一樣的思路，我們在框架可以定義一個 CallAdapter接口,讓應用層來具體實現並傳入

package retrofit2;

import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;

import okhttp3.Call;

/**
 * Created by zhuoxiuwu
 * on 2019/4/26
 * email [email protected]
 */
public interface CallAdapter<T> {

    T adapt(Call call);


    abstract class Factory {

        public abstract CallAdapter<?> get(Type returnType,Retrofit retrofit);

        /**
         * 這是一個框架提供給開發者的util方法
         * 用於獲取類型的泛型上的類型
         * 比如 Call<Response> 則 第0個泛型是Response.class
         */
        protected static Type getParameterUpperBound(int index, ParameterizedType type) {
            return Utils.getParameterUpperBound(index, type);
        }

        /**
         * 獲取Type對應的Class
         * @param type
         * @return
         */
        protected static Class<?> getRawType(Type type) {
            return Utils.getRawType(type);
        }
    }
}

在應用層我們可以實現一個NetCallAdapter，支持Call對象到 NetCall對象的轉換

package com.knight.sample;

import java.io.IOException;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;

import okhttp3.Call;
import okhttp3.Callback;
import okhttp3.Response;
import retrofit2.CallAdapter;
import retrofit2.Retrofit;

/**
 * Created by zhuoxiuwu
 * on 2019/4/26
 * email [email protected]
 */
package com.knight.sample;

import java.io.IOException;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;

import okhttp3.Call;
import okhttp3.Callback;
import okhttp3.Response;
import retrofit2.CallAdapter;
import retrofit2.Retrofit;

/**
 * Created by zhuoxiuwu
 * on 2019/4/26
 * email [email protected]
 */
public class NetCallAdapterFactory extends CallAdapter.Factory {

    /**
     * returnType參數 和 retroift參數 由底層框架傳遞給開發者
     * @param returnType
     * @param retrofit
     * @return
     */
    @Override
    public CallAdapter<?> get(final Type returnType, final Retrofit retrofit) {
        //判斷返回類型是否是 NetCall
        if (getRawType(returnType) != NetCall.class) {
            return null;
        }
        //要求開發者方法的返回類型必須寫成 NetCall<T> 或者NetCall<? extends Foo> 的形式,泛型內的類型就是Json數據對應的Class
        if (!(returnType instanceof ParameterizedType)) {
            throw new IllegalStateException(
                    "NetCall return type must be parameterized as NetCall<Foo> or NetCall<? extends Foo>");
        }
        final Type innerType = getParameterUpperBound(0, (ParameterizedType) returnType);
        
        return new CallAdapter<NetCall>() {

            @Override
            public NetCall adapt(final Call call) {

                return new NetCall() {
                    @Override
                    public void execute(final NetCallback netCallback) {
                        call.enqueue(new Callback() {
                            @Override
                            public void onFailure(Call call, IOException e) {
                                netCallback.onFailure(e);
                            }

                            @Override
                            public void onResponse(Call call, Response response) throws IOException {
                                //由retrofit 提供 ResponseBody 到 某個Type Class的轉換
                                final Object value = retrofit.responseBodyTConverter(innerType).convert(response.body());
                                netCallback.onSuccess(value);
                            }
                        });
                    }
                };
            }
        };
    }
}

在Retrofit類中，我們添加了判斷方法返回類型的邏輯，如果發現方法的返回類型不是Call類型，則使用CallAdapter做轉換

package retrofit2;


import com.google.gson.Gson;

import java.lang.annotation.Annotation;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.Type;

import okhttp3.Call;
import okhttp3.MediaType;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.RequestBody;
import okhttp3.ResponseBody;
import retrofit2.http.GET;
import retrofit2.http.POST;

public class Retrofit {

    private OkHttpClient mOkHttpClient;

    private Converter.Factory mConverterFactory;

    private CallAdapter.Factory mCallAdapterFactory;

    public Retrofit(OkHttpClient mOkHttpClient, Converter.Factory mConverterFactory, CallAdapter.Factory callAdapterFactory) {
        this.mOkHttpClient = mOkHttpClient;
        this.mConverterFactory = mConverterFactory;
        this.mCallAdapterFactory = callAdapterFactory;
    }

    @SuppressWarnings("unchecked")
    public <T> T createService(final Class<T> service) {
        return (T) Proxy.newProxyInstance(service.getClassLoader(), new Class<?>[]{service},
                new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method,
                                         Object[] args) throws Throwable {
                        //獲取方法所有的註解
                        final Annotation[] annotations = method.getAnnotations();
                        final Type returnType = method.getGenericReturnType();
                        for (int i = 0; i < annotations.length; i++) {
                            if (annotations[i] instanceof GET) { //如果註解是GET類型
                                final GET annotation = (GET) annotations[i];
                                return parseGet(annotation.value(), method, args);
                            } else if (annotations[i] instanceof POST) {
                                final POST annotation = (POST) annotations[i];
                                return parsePost(annotation.value(), method, args);
                            }
                        }
                        return null;
                    }
                });
    }


    private Object parseGet(String url, Method method, Object args[]) {
        final Request request = new Request.Builder()
                .url(url)
                .get().build();

        final Call call = mOkHttpClient.newCall(request);


        return adaptCall(method, call);
    }


    private Object parsePost(String url, Method method, Object args[]) {
        final Type[] genericParameterTypes = method.getGenericParameterTypes();
        if (genericParameterTypes.length > 0) {
            final RequestBody requestBody = requestBodyConverter(genericParameterTypes[0]).convert(args[0]);
            final Request request = new Request.Builder()
                    .url(url)
                    .post(requestBody)
                    .build();
            final Call call = mOkHttpClient.newCall(request);

            return adaptCall(method, call);

        }
        return null;
    }

    /**
     * 負責 任意Java類型到 RequestBody的轉換
     * @param type
     * @param <T>
     * @return
     */
    public <T> Converter<T, RequestBody> requestBodyConverter(Type type) {
        return (Converter<T, RequestBody>) mConverterFactory.requestBodyConverter(type);
    }

    /**
     * 負責ResponseBody到Type類型的轉換
     * @param type
     * @param <T>
     * @return
     */
    public <T> Converter<ResponseBody,T> responseBodyTConverter(Type type){
        return (Converter<ResponseBody, T>) mConverterFactory.responseBodyConverter(type);
    }


    /**
     * 獲取方法的返回類型，並使用CallAdapter做類型轉換
     * @param method
     * @param call
     * @return
     */
    private Object adaptCall(Method method, Call call) {
        final Type returnType = method.getGenericReturnType();
        if (Utils.getRawType(returnType) != Call.class) {
            final CallAdapter<?> callAdapter = mCallAdapterFactory.get(returnType,this);
            return callAdapter.adapt(call);
        } else {
            return call;
        }
    }

}

框架的後續實現及優化

到目前爲止我們已經實現了一個簡單的retrofit框架，也許代碼不夠精簡，邊界處理沒有十分嚴謹，但已經初具雛形。我們可以繼續思考現有項目的不足添加更多的支持。

比如在網絡請求方面目前只支持GET、POST，那麼我們後續需要添加更多請求方式的支持

在Retrofit對象的構造上，目前我們的構造函數傳入了3個對象，如果後續有更多的參數需要配置化，那麼我們可以使用 Builder設計模式來構建Retrofit

在CallAdapter的設計上，我們目前只支持傳入一個CallAdapterFactory，因此方法的返回類型除了原生的Call對象外只支持應用開發者新增一個。實際上,這不太合理，因此這部分我們可以支持開發者傳入一個列表，在內部我們迭代這個List ，遍歷過程中調用CallAdapter<?> get(Type returnType,Retrofit retrofit);,如果這個Factory返回了null，則說明它對該類型不支持，則繼續調用下個CallFactory 直到找到合適的


    abstract class Factory {
        //如果返回了null 則該Factory不支持該returnType的轉換
        public abstract CallAdapter<?> get(Type returnType,Retrofit retrofit);
    }

在框架的性能優化上，目前我們每次調用 createService(final Class service) 都是返回一個新的代理類，其實我們可以建立一個 Service類類型到該類型代理對象的Map緩存，如果發現緩存池有則直接複用該對象。更進一步的思考，我們是否可以以Method方法爲緯度,每次調用一個抽象方法時我們解析該方法上的註解生成一個自己的ServiceMethod類對象並加到緩存池中，下次調用同樣的方法時，我們就不需要解析註解了，而是直接使用內部的ServiceMethod

static <ResponseT, ReturnT> HttpServiceMethod<ResponseT, ReturnT> parseAnnotations(
            Retrofit retrofit, Method method){

        //...解析method並生成一個HttpServiceMethod對象
        return null;
    }

    //框架內部表示一個Http方法調用的類
    class HttpServiceMethod<ResponseT, ReturnT>{
        //arguments
        //解析方法及註解並把信息保存下來，同樣的方法就不需要二次解析了


        //args爲方法的參數，每次方法調用時只需要處理不同的參數
        //具體是POST 方法還是GET方法， callAdapter具體使用哪一個 都已經確定下來了
        final  ReturnT invoke(Object[] args) {
            return null;
        }
    }

以上提出的一些優化點，大家可以自己先思考實現並重新閱讀寫Retrofit源碼來加深自己的理解。從整個思考流程及實現上來看Retrofit的實現並不複雜，但是從實現一個簡單可用的網絡封裝庫到實現一個拓展性強、職責分離的框架，中間的過程還是有很多細節的,如果你看完了這篇文章可以再抽1個小時左右的時間重新看下Retorift框架的源碼相信從中還會有更多的收穫.

歡迎關注我的微信公衆號獲取更多技術文章

手把手實現一個mini-Retrofit框架

前文

演示一個使用OkHttp的項目Demo

JavaBean

NetCallback

NetWorkService

思考項目現狀

編碼實現

3.1 簡單實現一個支持GET、POST請求的Retrofit

3.2在項目中驗證

3.3繼續實現POST註解

3.4 實現ConverterFactory 解耦Json轉換

3.5 實現CallAdapter 支持方法返回類型

框架的後續實現及優化

測試人員都是畫畫大神，讓我看看誰還不會用代碼圖？

Object.values()對象遍歷

手把手實現一個mini-Retrofit框架

進程與線程併發與並行

TCP 協議的握手連接

Okio組件源碼分析

【數據加解密】CRC檢驗算法的原理及實現

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結