Android进阶之Retrofit源码解析

要相信时间的力量，更要相信刻苦努力的力量

简介

Retrofit是一个Restful设计风格的Http网络请求框架，其本质是通过对Okhttp网络请求的二次封装，简化Okhttp的使用。

App 应用程序通过 Retrofit 请求网络。实际上是使用 Retrofit 接口层封装请求参数，之后由 Okhttp 完成后续的请求操作。

在服务端返回数据之后，Okhttp 将原始的结果交给 Retrofit，Retrofit 根据用户的需求对结果进行解析。

总结如下：

Retrofit 是一个 RESTful 的 HTTP 网络请求框架的封装。
网络请求的工作本质上是 OkHttp 完成，而Retrofit 仅负责网络请求接口的封装
App应用程序通过 Retrofit 请求网络，实际上是使用Retrofit 接口层封装请求参数、Header、Url 等信息，之后由 OkHttp 完成后续的请求操作。

使用步骤

定义网络请求接口

创建Retrofit实例对象

创建网络请求对象

执行网络请求

源码分析

设计模式

建造者模式

Retrofit实例使用建造者模式通过Builder类完成创建的。建造者模式可以将Retrofit的构建与表示进行分离，使用者可以不必关心Retrofit内部的创建细节就能直接创建出Retrofit对象，简化了使用流程。

Retrofit构造函数中的每一个参数都可以通过内部的Builder对象进行设置。最终调用Builder中的build函数进行Retrofit对象的创建。

代理模式

 fun <T>getFlowService(t:Class<T>):T{
        return initService().create(t)
    }
 NetService.getFlowService(MainApi::class.java).getArticle().enqueue()

调用Retrofit的create方法创建请求对象进行网络数据请求时，通过代理模式创建MainApi接口的实例。通过接口实例调用接口中的getArticle()方法进行数据请求。

下面我们一起看看Retrofit是如何进行代理的。

public <T> T create(final Class<T> service) {
    //验证接口
    validateServiceInterface(service);
    return (T) //创建代理对象
            Proxy.newProxyInstance(
                //获取接口的classLoader
                service.getClassLoader(), 
                //代理的接口
                new Class<?>[] {service},
                //代理接口的实现
                new InvocationHandler() {
                    //获取当前平台
                    private final Platform platform = Platform.get();
                    private final Object[] emptyArgs = new Object[0];

                    @Override
                    public @Nullable Object invoke(Object proxy, Method method, @Nullable Object[] args)
                    throws Throwable {
                        //如果方法是来自Object的方法，则直接正常调用。
                        if (method.getDeclaringClass() == Object.class) {
                            return method.invoke(this, args);
                        }
                        //检查参数
                        args = args != null ? args : emptyArgs;
                        //检查是否是平台默认方法，否则解析方法参数，返回代理对象
                        return platform.isDefaultMethod(method)
                            ? platform.invokeDefaultMethod(method, service, proxy, args)
                            : loadServiceMethod(method).invoke(args);
                    }
                });
}

Retrofit通过代理模式中的动态代理模式，动态生成网络请求接口的代理类，并将代理类的实例创建交给InvocationHandler类作为具体的实现，loadServiceMethod(method)解析方法参数，并最终返回一个动态代理对象。

单例模式

ServiceMethod<?> loadServiceMethod(Method method) {
    //先从缓存中取
    ServiceMethod<?> result = serviceMethodCache.get(method);
    //如果缓存中有直接返回
    if (result != null) return result;
     //双重校验锁
    synchronized (serviceMethodCache) {
      result = serviceMethodCache.get(method);
      if (result == null) {
          //解析注解参数
        result = ServiceMethod.parseAnnotations(this, method);
          //缓存结果
        serviceMethodCache.put(method, result);
      }
    }
    return result;
  }

ServiceMethod的loadServiceMethod方法获取方法对象，不仅使用缓存机制而且采用单例设计模式确保一个ServiceMethod对象对应请求接口中的一个请求方法。

网络请求

异步请求

  NetService.getFlowService(MainApi::class.java).getArticle().enqueue()

使用Retrofit进行异步请求时，调用Call.enqueue()方法，实际是调用OKhttp.enquque()方法，call是一个静态代理，作用是在Okhttp发送网络请求后进行线程的切换。

1. 调用okhttp的call中的enqueue()方法


 override fun enqueue(responseCallback: Callback) {
    check(executed.compareAndSet(false, true)) { "Already Executed" }

    callStart()
     //真正的网络请求   
    client.dispatcher.enqueue(AsyncCall(responseCallback))
  }

2 .调用分发器Dispatcher中的enqueue方法


internal fun enqueue(call: AsyncCall) {
    synchronized(this) {
      //将异步请求加入异步请求队列
      readyAsyncCalls.add(call)
         //判断是是否是 同一个主机的请求
      if (!call.call.forWebSocket) {
        val existingCall = findExistingCallWithHost(call.host)
        if (existingCall != null) call.reuseCallsPerHostFrom(existingCall)
      }
    }
    //开始请求数据
    promoteAndExecute()
  }

3. 调用分发器Dispatcher中的promoteAndExecute方法


     private fun promoteAndExecute(): Boolean {
      ...
    //定义可执行任务集合
    val executableCalls = mutableListOf<AsyncCall>()
    val isRunning: Boolean
    synchronized(this) {
    //从准备队列中取出一个任务
      val i = readyAsyncCalls.iterator()
      while (i.hasNext()) {
        val asyncCall = i.next()
        //如果正在运行队列中的任务数超过最大64个，返回
        if (runningAsyncCalls.size >= this.maxRequests) break // Max capacity.
         //异步任务对同一个host请求超过5个则跳过当前请求，执行下一个
          if (asyncCall.callsPerHost.get() >= this.maxRequestsPerHost) continue // Host max capacity.
         //将当前任务从等待队列中移除
        i.remove()
        asyncCall.callsPerHost.incrementAndGet()
         //将异步任务加入可执行队列   
        executableCalls.add(asyncCall)
        //将异步任务加入正在执行队列
        runningAsyncCalls.add(asyncCall)
      }
      isRunning = runningCallsCount() > 0
    }
    //将可执行任务放进线程池执行
    for (i in 0 until executableCalls.size) {
      val asyncCall = executableCalls[i]
      asyncCall.executeOn(executorService)
    }

    return isRunning
  }

4.执行线程池executorService的run方法

 override fun run() {
        try {
          //真正的网络请求
          val response = getResponseWithInterceptorChain()
          signalledCallback = true
          responseCallback.onResponse(this@RealCall, response)
        } catch (e: IOException) {

        } catch (t: Throwable) {
          。。。。。。。。。。。。。
        } finally {
          client.dispatcher.finished(this)
        }
      }
    }
  }

5.调用getResponseWithInterceptorChain执行队列中的任务

internal fun getResponseWithInterceptorChain(): Response {
    // 添加拦截器
    val interceptors = mutableListOf<Interceptor>()
    interceptors += client.interceptors
    interceptors += RetryAndFollowUpInterceptor(client)
    interceptors += BridgeInterceptor(client.cookieJar)
    interceptors += CacheInterceptor(client.cache)
    interceptors += ConnectInterceptor
    if (!forWebSocket) {
      interceptors += client.networkInterceptors
    }
    interceptors += CallServerInterceptor(forWebSocket)
    //构建拦截器链条 --责任链模式
    val chain = RealInterceptorChain(
        call = this,
        interceptors = interceptors,
        index = 0,
        exchange = null,
        request = originalRequest,
        connectTimeoutMillis = client.connectTimeoutMillis,
        readTimeoutMillis = client.readTimeoutMillis,
        writeTimeoutMillis = client.writeTimeoutMillis
    )
    try {
        //网络请求
      val response = chain.proceed(originalRequest)

      return response

    }
  }

同步请求

1.通过Okhtt调用RealCall中的execute()方法


override fun execute(): Response {
    check(executed.compareAndSet(false, true)) { "Already Executed" }
    timeout.enter()
    callStart()
    try {
        //执行分发器中的executed
      client.dispatcher.executed(this)
      return getResponseWithInterceptorChain()
    } finally {
        //最终执行完调用finish方法
      client.dispatcher.finished(this)
    }
  }

将同步执行任务加入同步队列中


    @Synchronized internal fun executed(call: RealCall) {
    runningSyncCalls.add(call)
  }

3.调用getResponseWithInterceptorChain执行队列中的任务

internal fun getResponseWithInterceptorChain(): Response {
    // 添加拦截器
    val interceptors = mutableListOf<Interceptor>()
    interceptors += client.interceptors
    interceptors += RetryAndFollowUpInterceptor(client)
    interceptors += BridgeInterceptor(client.cookieJar)
    interceptors += CacheInterceptor(client.cache)
    interceptors += ConnectInterceptor
    if (!forWebSocket) {
      interceptors += client.networkInterceptors
    }
    interceptors += CallServerInterceptor(forWebSocket)
    //构建拦截器链条 --责任链模式
    val chain = RealInterceptorChain(
        call = this,
        interceptors = interceptors,
        index = 0,
        exchange = null,
        request = originalRequest,
        connectTimeoutMillis = client.connectTimeoutMillis,
        readTimeoutMillis = client.readTimeoutMillis,
        writeTimeoutMillis = client.writeTimeoutMillis
    )
    try {
        //网络请求
      val response = chain.proceed(originalRequest)

      return response

    }
  }

总结

Retrofit 本质上是一个 RESTful 的HTTP 网络请求框架的封装，其中通过大量的设计模式封装了 OkHttp ，使得简
洁易用。具体过程如下：

Retrofit 将 Http请求抽象成 Java 接口
在接口里用注解描述和配置网络请求参数
用动态代理的方式，动态将网络请求接口的注解解析
成HTTP 请求
最后执行HTTP 请求