Retrofit源码解析

square公司开源了一系列的优秀库，比如Retrofit,OkHttp,Picasso等，
前面简单分析了Picasso的源码，这里来分析下Retrofit的使用：

一、gradle添加依赖

compile 'com.squareup.okhttp:okhttp:2.4.0'
compile 'com.squareup.okhttp:okhttp-urlconnection:2.4.0'
compile 'com.squareup.okio:okio:1.5.0'
compile 'com.google.code.gson:gson:2.2.4'

compile 'com.squareup.retrofit:retrofit:2.0.0-beta2'
compile 'com.squareup.retrofit:adapter-rxjava:2.0.0-beta2'
compile 'com.squareup.retrofit:converter-gson:2.0.0-beta2'

compile 'io.reactivex:rxandroid:1.1.0'
compile 'io.reactivex:rxjava:1.1.0'

盗两张网上的图：
下面是从创建Retrofit出发，具体的使用流程；Retrofit最终的请求操作都是交由okHttp去执行的，执行的结果返回Response，再根据转换器进行解析成相对应的返回类型T;
Retrofit中使用了动态代理，方便了使用；通过retrofit.create返回的其实是个动态代理类，所有具体的处理逻辑交由MethodHandler进行处理；

下面是Retrofit系统中的整个类图，有点像外观模式，Retrofit持有所有子系统的引用；Retrofit比较重要的是两个Factory，一个使用来生成CallAdapter的CallAdapterFactory；一个是用来转换结果的ConvertFactory；这两个都可以用户自己进行添加。
在自定义的Service中，每一个method对应一个MethodHandler,MethodHandler持有retrofit，前面两个Factory以及生成Request的RequestFactory；在okHttp中，Request需要自己进行定义创建，而Retrofit简化了这个操作，进行了相应的封装，使用注解的方式来定义Request的相关参数信息；注解信息的解析则在RequestFactory中完成，通过RequestFactoryParser对注解信息进行简单解析，RequestBuilderAction是解析method中参数中的注解如@Path这些产生的中间产物，最终通过RequestBuilder来具体产生一个Request，RequestBuilder中持有okHttp中的Request.Builder类的引用，其创建Request过程其实都是交给okHttp来操作的；
生成的Request最终封装成为一个OkHttpCall，OkHttpCall则可以看做是对okHttp中Call的通过，它的enqueue等网络请求操作都是委托个给okHttp来操作的；同时对okHttp的返回Response进行解析，使用convertFactory，将其解析为用户所期望的返回类型；

二、使用

（一）使用Call形式

1、定义请求接口：

public interface RetrofirHttpService {
    @GET("{user}")
    Call getData(@Path("user") String user);
}
注：UserInfo是自己定义的解析类：
public class UserInfo {
    String username;
    String password;
}

2、使用GET获取信息：

// 原始的CallBack方式
private void getUseCall() {
    // 添加拦截器
    OkHttpClient client = new OkHttpClient();
    client.interceptors().add(new LoggingInterceptor());

    Retrofit retrofit = new Retrofit.Builder()
            .baseUrl("http://115.156.187.146/TransferServer/")
            .client(client)                                     // 添加okHttp
            .addConverterFactory(GsonConverterFactory.create()) // GSON进行转换
            .build();
    RetrofirHttpService apiStores = retrofit.create(RetrofirHttpService.class);
    Call call = apiStores.getData("ServerMain.php");

    // 异步调用
    call.enqueue(new Callback() {
        @Override
        public void onResponse(Response response, Retrofit retrofit) {
            UserInfo data = response.body();
            LogUtils.i("Call Result:" + data.m);
        }

        @Override
        public void onFailure(Throwable t) {
            LogUtils.e(t.toString());
        }
    });
}

（二）使用RxJava形式

1、定义请求接口

public interface RxHttpService {
    @GET("{path}")
    Observable getData(@Path("path") String path);
}

2、具体使用

// 使用RxJava方式
private void getUseRxJava() {
    // 添加拦截器
    OkHttpClient client = new OkHttpClient();
    client.interceptors().add(new LoggingInterceptor());

    Retrofit retrofit = new Retrofit.Builder()
            .baseUrl("http://115.156.187.146/TransferServer/")
            .client(client)  // 添加okHttp
            .addConverterFactory(GsonConverterFactory.create()) // GSON进行转换
            .addCallAdapterFactory(RxJavaCallAdapterFactory.create())
            .build();

    RxHttpService apiStores = retrofit.create(RxHttpService.class);
    Observable observable = apiStores.getData("ServerMain.php");
    observable.subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(new Observer() {
                @Override
                public void onNext(UserInfo user) {
                    LogUtils.i("Call Result:" + user.m);
                }

                @Override
                public void onCompleted() {
                }

                @Override
                public void onError(Throwable error) {
                    LogUtils.e(error.toString());
                }
            });
}

三、源码分析：

（一）先来看创建动态代理类的过程：

RxHttpService apiStores = retrofit.create(RxHttpService.class);

动态代理的知识具体见《 设计模式汇总：结构型模型（上）》中的代理模式中的解释。

1）Retrofit#create:

/** Create an implementation of the API defined by the {@code service} interface. */
@SuppressWarnings("unchecked") // Single-interface proxy creation guarded by parameter safety.
public  T create(final Class service) {
    Utils.validateServiceInterface(service);
    if (validateEagerly) {
        eagerlyValidateMethods(service);
    }
    return (T) Proxy.newProxyInstance(service.getClassLoader(), new Class[]{service},
            new InvocationHandler() {
                private final Platform platform = Platform.get();

                @Override
                public Object invoke(Object proxy, Method method, Object... args)
                        throws Throwable {
                    // If the method is a method from Object then defer to normal invocation.
                    if (method.getDeclaringClass() == Object.class) {
                        return method.invoke(this, args);
                    }
                    if (platform.isDefaultMethod(method)) {
                        return platform.invokeDefaultMethod(method, service, proxy, args);
                    }
                    return loadMethodHandler(method).invoke(args);
                }
            });
}

标准的动态代理创建过程；
来看代理类和委托类之间的中间InvocationHandler类的invoke函数具体执行逻辑；
loadMethodHandler(method).invoke(args);

2）Retrofit#loadMethodHandler:

private final Map<Method, MethodHandler> methodHandlerCache = new LinkedHashMap<>();

MethodHandler loadMethodHandler(Method method) {
    MethodHandler handler;
    synchronized (methodHandlerCache) {
        handler = methodHandlerCache.get(method);
        if (handler == null) {
            handler = MethodHandler.create(this, method);
            methodHandlerCache.put(method, handler);
        }
    }
    return handler;
}

Retrofit维护了一个method对应的Map，这里将method都封装成一个MethodHandler类（可以当作是委托类）；调用代理类，其实就是调用MethodHandler的invoke;所以具体的实现逻辑都在MethodHandler中；

（二）MethodHanlder

1）MethodHandler类：

final class MethodHandler {
    // MethodHandler持有一个retrofit对象
    private final Retrofit retrofit;
    // 类似于Volley中的 Request ，包含了HTTP请求的Url、Header信息，MediaType、Method以及RequestAction数组
    private final RequestFactory requestFactory;
    // HTTP请求返回数据的类型
    private final CallAdapter callAdapter;
    // 对返回数据进行转换的类型转换器
    private final Converter responseConverter;

    private MethodHandler(Retrofit retrofit, RequestFactory requestFactory,
                          CallAdapter callAdapter, Converter responseConverter) {
        this.retrofit = retrofit;
        this.requestFactory = requestFactory;
        this.callAdapter = callAdapter;
        this.responseConverter = responseConverter;
    }

    // 每一次请求的最终具体调用的函数
    Object invoke(Object... args) {
        // 可以发现最终是调用callAdapter的adapt函数
        // 并且将相应的请求事务封装成一个OkHttpCall类进行处理
        return callAdapter.adapt(new OkHttpCall<>(retrofit, requestFactory, responseConverter, args));
    }

    // 调用该静态类创建一个MethodHandler实例
    @SuppressWarnings("unchecked")
    static MethodHandler create(Retrofit retrofit, Method method) {
        // 创建CallAdapter
        CallAdapter