Retrofit源码分析

通过一次网络请求，来分析Retrofit源码

Retrofit第三方开源库，最近在很多地方都看到有人在使用。用了之后，感觉这是一个很简洁，代码维护成本较低的开源库。

Retrofit一般会依赖OkHttp这个库，它访问网络依赖OkHttpClient，通常情况下都是：Retrofit + OkHttp一起使用的。

Retrofit也支持RxJava作为适配器工厂，Retrofit + OkHttp + RxJava 的组合也是很多开发者喜欢的。

在这里，通过Retrofit来请求一次网络，一步一步分析Retrofit内部原理与源码。

---

    compile "com.squareup.retrofit2:retrofit:2.0.2"
    compile "com.squareup.retrofit2:converter-gson:2.0.2"
    compile 'com.squareup.okhttp3:okhttp:3.2.0'

简单来说，Retrofit通过：注解 + 反射 + 动态代理。面向对象的形式来处理一次网络请求。

Retrofit让请求网络的代码变得简洁起来了，维护成本也低很多。

Retrofit让开发者只关心两个问题：

1，请求网络接口类的定义。

2，解析服务器传递过来的json生成Java Bean。

---

下面就从使用方式上来分析Retrofit的源码。

例如，让Retrofit来完成这样的一次网络请求，将服务器传递过来的json转化成Java Bean。

Get请求：

    https://api.douban.com/v2/fm/app_channels

1，首先，生成请求网络接口类。

    public interface AppChannelsApi {

        @GET("v2/fm/app_channels")
        Call<AppChannels> getAppCannels();
    }

2，分析服务器传递过来的json生成Java Bean。

    public class AppChannels {

        private List<GroupsBean> groups;

        ...

3，声明HostUrl。

    public class HostUrl {

        public static final String HOST = "https://api.douban.com/";
    }

4，创建OkHttpClient。

    public class HttpClient {

        private static OkHttpClient mOkHttpClient = new OkHttpClient.Builder().build();

        public static OkHttpClient get() {
            return mOkHttpClient;
        }
    }

5，生成Retrofit对象，通过Retrofit对象获取到接口的实现类。

    public class AppChannelsClient {

        private static AppChannelsApi api;

        public static AppChannelsApi get() {
            if (api == null) {
                synchronized (AppChannelsClient.class) {
                    if (null == api) {
                        Retrofit retrofit = new Retrofit.Builder()
                                .baseUrl(HostUrl.HOST)
                                .client(HttpClient.get())
                                .addConverterFactory(GsonConverterFactory.create())
                                .build();
                        api = retrofit.create(AppChannelsApi.class);
                    }
                }
            }
            return api;
        }
    }

6，使用Retrofit请求网络。

    Call<AppChannels> call = AppChannelsClient.get().getAppCannels();
    call.enqueue(new MyCallBack<AppChannels>() {
        @Override
        public void onSuccess(AppChannels data) {
            Log.i(TAG, "size:" + data.getGroups().size() + "  " + data.toString());
            mTextView.setText(data.toString());
        }

        @Override
        public void onFailure(Call<AppChannels> call, Throwable t) {

        }
    });

7，创建自己的CallBack，简化回调参数。

    public abstract class MyCallBack<T> implements Callback<T> {
        @Override
        public void onResponse(Call<T> call, Response<T> response) {
            T data = response.body();
            if (data != null) {
                onSuccess(data);
            } else {
                onFailure(call, null);
            }
        }

        abstract public void onSuccess(T data);
    }

使用Retrofit请求网络就是这么简单，开发者只需要把注意力放在请求网络的接口类和服务器返回的Java Bean就行了。

---

现在开始分析源码：

    public interface AppChannelsApi {

        @GET("v2/fm/app_channels")
        Call<AppChannels> getAppCannels();
    }

可以看到使用了接口，以注解的方式设置网络请求方式，请求参数信息。

可以看得出，Retrofit想动态的获取到注解，请求参数信息，只能通过反射的方式拿到了。

下面分析Retrofit是怎么初始化，怎么拿到这些注解信息的：

    public class AppChannelsClient {

        private static AppChannelsApi api;

        public static AppChannelsApi get() {
            if (api == null) {
                synchronized (AppChannelsClient.class) {
                    if (null == api) {
                        Retrofit retrofit = new Retrofit.Builder()
                                .baseUrl(HostUrl.HOST)
                                .client(HttpClient.get())
                                .addConverterFactory(GsonConverterFactory.create())
                                .build();
                        api = retrofit.create(AppChannelsApi.class);
                    }
                }
            }
            return api;
        }
    }

进一步查看Retrofit源码：

静态内部类，Builder

    public static final class Builder {
    private Platform platform;
    private okhttp3.Call.Factory callFactory;
    private HttpUrl baseUrl;
    private List<Converter.Factory> converterFactories = new ArrayList<>();
    private List<CallAdapter.Factory> adapterFactories = new ArrayList<>();
    private Executor callbackExecutor;
    private boolean validateEagerly;

    Builder(Platform platform) {
      this.platform = platform;
      // Add the built-in converter factory first. This prevents overriding its behavior but also
      // ensures correct behavior when using converters that consume all types.
      converterFactories.add(new BuiltInConverters());
    }

    public Builder() {
      this(Platform.get());
    }

可使用链式编程，快速初始化参数

    public Builder client(OkHttpClient client) {
      return callFactory(checkNotNull(client, "client == null"));
    }


    public Builder callFactory(okhttp3.Call.Factory factory) {
      this.callFactory = checkNotNull(factory, "factory == null");
      return this;
    }


    public Builder baseUrl(String baseUrl) {
      checkNotNull(baseUrl, "baseUrl == null");
      HttpUrl httpUrl = HttpUrl.parse(baseUrl);
      if (httpUrl == null) {
        throw new IllegalArgumentException("Illegal URL: " + baseUrl);
      }
      return baseUrl(httpUrl);
    }

最终，以Retrofit构造器的形式生成Retrofit对象

    public Retrofit build() {
      if (baseUrl == null) {
        throw new IllegalStateException("Base URL required.");
      }

      okhttp3.Call.Factory callFactory = this.callFactory;
      if (callFactory == null) {
        callFactory = new OkHttpClient();
      }

      Executor callbackExecutor = this.callbackExecutor;
      if (callbackExecutor == null) {
        callbackExecutor = platform.defaultCallbackExecutor();
      }

      // Make a defensive copy of the adapters and add the default Call adapter.
      List<CallAdapter.Factory> adapterFactories = new ArrayList<>(this.adapterFactories);
      adapterFactories.add(platform.defaultCallAdapterFactory(callbackExecutor));

      // Make a defensive copy of the converters.
      List<Converter.Factory> converterFactories = new ArrayList<>(this.converterFactories);

      return new Retrofit(callFactory, baseUrl, converterFactories, adapterFactories,
          callbackExecutor, validateEagerly);
    }

    public final class Retrofit {
      private final Map<Method, ServiceMethod> serviceMethodCache = new LinkedHashMap<>();

      private final okhttp3.Call.Factory callFactory;
      private final HttpUrl baseUrl;
      private final List<Converter.Factory> converterFactories;
      private final List<CallAdapter.Factory> adapterFactories;
      private final Executor callbackExecutor;
      private final boolean validateEagerly;

      Retrofit(okhttp3.Call.Factory callFactory, HttpUrl baseUrl,
          List<Converter.Factory> converterFactories, List<CallAdapter.Factory> adapterFactories,
          Executor callbackExecutor, boolean validateEagerly) {
        this.callFactory = callFactory;
        this.baseUrl = baseUrl;
        this.converterFactories = unmodifiableList(converterFactories); // Defensive copy at call site.
        this.adapterFactories = unmodifiableList(adapterFactories); // Defensive copy at call site.
        this.callbackExecutor = callbackExecutor;
        this.validateEagerly = validateEagerly;
      }

可以看到，Retrofit获取对象的方式，是通过构造者模式。通过构造者这个静态内部类，链式编程的方式快速设置Retrofit参数，

最后将构造者设置的参数，以Retrofit构造器的形式生成Retrofit对象。

接下来，看Retrofit如何使用字节码，生成接口的实现类的。

    api = retrofit.create(AppChannelsApi.class);

进入create源码：

    public <T> T create(final Class<T> 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);
            }
            ServiceMethod serviceMethod = loadServiceMethod(method);
            OkHttpCall okHttpCall = new OkHttpCall<>(serviceMethod, args);
            return serviceMethod.callAdapter.adapt(okHttpCall);
          }
        });
    }

可以看到，通过动态代理的方式，生成接口的实现了。

接下来看这行代码：

    ServiceMethod serviceMethod = loadServiceMethod(method);
    OkHttpCall okHttpCall = new OkHttpCall<>(serviceMethod, args);
    return serviceMethod.callAdapter.adapt(okHttpCall);

loadServiceMethod方法，将接口实现类的method字段传递进去，生成一个ServieMethod对象。进入到方法里：

    ServiceMethod loadServiceMethod(Method method) {
    ServiceMethod result;
    synchronized (serviceMethodCache) {
      result = serviceMethodCache.get(method);
      if (result == null) {
        result = new ServiceMethod.Builder(this, method).build();
        serviceMethodCache.put(method, result);
      }
    }
    return result;
    }



    public final class Retrofit {
      private final Map<Method, ServiceMethod> serviceMethodCache = new LinkedHashMap<>();


    final class ServiceMethod<T> {
      // Upper and lower characters, digits, underscores, and hyphens, starting with a character.
      static final String PARAM = "[a-zA-Z][a-zA-Z0-9_-]*";
      static final Pattern PARAM_URL_REGEX = Pattern.compile("\\{(" + PARAM + ")\\}");
      static final Pattern PARAM_NAME_REGEX = Pattern.compile(PARAM);

      final okhttp3.Call.Factory callFactory;
      final CallAdapter<?> callAdapter;

      private final HttpUrl baseUrl;
      private final Converter<ResponseBody, T> responseConverter;
      private final String httpMethod;
      private final String relativeUrl;
      private final Headers headers;
      private final MediaType contentType;
      private final boolean hasBody;
      private final boolean isFormEncoded;
      private final boolean isMultipart;
      private final ParameterHandler<?>[] parameterHandlers;

可以看到，method对象作为Map集合的Key，存储了起来。ServiceMethod是一个Method的包装类。

可以猜的出，ServiceMethod是Retrofit的一次网络请求的具体Java Bean对象。

Retrofit的网络请求，以对象的方式存储到Map集合serviceMethodCache中。

接来下看这行代码：

    OkHttpCall okHttpCall = new OkHttpCall<>(serviceMethod, args);

将一次网络请求的所有信息serviceMethod对象传递给了OkHttpCall，意思是这次网络请求准备交给OkHttp处理。

    final class OkHttpCall<T> implements Call<T> {
      private final ServiceMethod<T> serviceMethod;
      private final Object[] args;

      private volatile boolean canceled;

      // All guarded by this.
      private okhttp3.Call rawCall;
      private Throwable creationFailure; // Either a RuntimeException or IOException.
      private boolean executed;

      OkHttpCall(ServiceMethod<T> serviceMethod, Object[] args) {
        this.serviceMethod = serviceMethod;
        this.args = args;
      }

内部可以看到，OkHttpCall拥有一个网络请求serviceMethod

    return serviceMethod.callAdapter.adapt(okHttpCall);




      List<CallAdapter.Factory> adapterFactories = new ArrayList<>(this.adapterFactories);
      adapterFactories.add(platform.defaultCallAdapterFactory(callbackExecutor));



    final class DefaultCallAdapterFactory extends CallAdapter.Factory {
      static final CallAdapter.Factory INSTANCE = new DefaultCallAdapterFactory();

      @Override
      public CallAdapter<?> get(Type returnType, Annotation[] annotations, Retrofit retrofit) {
        if (getRawType(returnType) != Call.class) {
          return null;
        }

        final Type responseType = Utils.getCallResponseType(returnType);
        return new CallAdapter<Call<?>>() {
          @Override public Type responseType() {
            return responseType;
          }

          @Override public <R> Call<R> adapt(Call<R> call) {
            return call;
          }
        };
      }
    }

这行代码会将okHttpCall返回出去。也就是我们自定义接口，方法的返回值：

    @GET("v2/fm/app_channels")
    Call<AppChannels> getAppCannels();

我们请求网络的时候是这样的：

    Call<AppChannels> call = AppChannelsClient.get().getAppCannels();
    call.enqueue(new MyCallBack<AppChannels>() {
        @Override
        public void onSuccess(AppChannels data) {
            Log.i(TAG, "size:" + data.getGroups().size() + "  " + data.toString());
            mTextView.setText(data.toString());
        }

        @Override
        public void onFailure(Call<AppChannels> call, Throwable t) {

        }
    });

在OkHttpCall里也有enqueue方法：

    @Override public void enqueue(final Callback<T> callback) {
    if (callback == null) throw new NullPointerException("callback == null");

    okhttp3.Call call;
    Throwable failure;

    ...

方法里找到：

     call = rawCall = createRawCall();


      private okhttp3.Call createRawCall() throws IOException {
        Request request = serviceMethod.toRequest(args);
        okhttp3.Call call = serviceMethod.callFactory.newCall(request);
        if (call == null) {
          throw new NullPointerException("Call.Factory returned null.");
        }
        return call;
      }



       call.enqueue(new okhttp3.Callback() {
          @Override public void onResponse(okhttp3.Call call, okhttp3.Response rawResponse)
              throws IOException {
            Response<T> response;
            try {
              response = parseResponse(rawResponse);
            } catch (Throwable e) {
              callFailure(e);
              return;
            }
            callSuccess(response);
          }

          @Override public void onFailure(okhttp3.Call call, IOException e) {
            try {
              callback.onFailure(OkHttpCall.this, e);
            } catch (Throwable t) {
              t.printStackTrace();
            }
          }

可以看到，Retrofit里面的确是通过OkHttpClient进行网络请求的。

okhttp3.Call call = serviceMethod.callFactory.newCall(request);

这个callFactory就行Retrofit外面设置的OkHttpClient对象，只是以接口的方式显示，数据跟踪可以知道。

总的来说，当我们以调用接口实现类的方法：

Call<AppChannels> call = AppChannelsClient.get().getAppCannels();

Retrofit会通过动态代理，获取到接口对象，method字段，再通过反射获取到method字段中的注解，请求参数，

将信息存储到serviceMethod中，一个serviceMethod就包含了一次完整请求网络所需要的数据，

Host，Uri，请求参数，请求类型都有，再通过OkHttp的方式去请求网络，获取到json，

在通过Gson转化工厂将json转化成Java Bean，回调的方式传递出去

这就是Retrofit请求网络的源码分析。

注解 + 反射 + 动态代理 ，依赖OkHttp库。

Retrofit源码分析就到这里。

2016年7月06日 02:35:16