Retrofit源码分析&小结

Retrofit源码分析&小结

简介

Retrofit是对Okhttp网络请求的二次封装，通过注解+动态代理的方式，简化了Okhttp的使用，使得通过简单的配置就可以像调用接口一样去请求网络接口；除此之外Retrofit还支持RxJava和kotlin的协程

基本使用

1. 引入依赖库

//网络请求
implementation 'com.squareup.retrofit2:retrofit:2.9.0'//Retrofit基本库
implementation 'com.squareup.retrofit2:converter-gson:2.1.0'//用于将结果转换成对象
implementation 'com.squareup.retrofit2:adapter-rxjava2:2.3.0'//用于转换成RxJava支持的Observer对象
implementation 'io.reactivex.rxjava2:rxandroid:2.0.1'//RxJava对Android的支持
implementation 'com.squareup.okhttp3:logging-interceptor:3.9.0'//Okhttp日志拦截器，用于打印接口请求相关log
//协程
implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-core:1.6.4'//Retrofit对Kotlin协程的支持
implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.6.4'//协程对Android的支持
implementation('androidx.lifecycle:lifecycle-runtime-ktx:2.6.0-alpha02')//协程对LifeCycle的支持

2. 定义一个用于网络请求的服务接口

package com.example.myapplication.retrofit

import android.service.autofill.UserData
import io.reactivex.Observable
import retrofit2.Call
import retrofit2.http.*

interface IUserServer {
    /**
     * 以GET方式请求
     */
    @GET("getUserInfo/")
    fun getUserInfo(@Query("userId") userId: String): Call

    /**
     * 以POST方式请求，并结合RxJava
     */
    @POST("getUserInfo/")
    @FormUrlEncoded
    fun getUserInfoByRxJava(@Field("userId") userId: String): Observable

    /**
     * 结合kotlin协程完成线程切换
     */
    @GET("banner/json")
    suspend fun getUserInfoBySuspend2(@Query("userId") userId: String): UserData

}

3. 创建Retrofit对象和自定义接口代理实现对象

val retrofit = Retrofit.Builder()
    .baseUrl("http://www.xxx.com/")
    .addConverterFactory(GsonConverterFactory.create())//支持Gson
    .addCallAdapterFactory(RxJava2CallAdapterFactory.create())//支持Rxjava
    .build()
val server = retrofit.create(IUserServer::class.java)

4. 普通发起网络请求

val userInfo = server.getUserInfo("1").execute()//同步执行
server.getUserInfo("1").enqueue(object : Callback {//异步执行
    override fun onResponse(call: Call, response: Response) {
        //网络请求返回结果
    }

    override fun onFailure(call: Call, t: Throwable) {
        //网络请求错误
    }
})

5. 结合RxJava

server.getUserInfoByRxJava("1").subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribe(object : Observer {
    override fun onSubscribe(d: Disposable?) {
        //网络请求前
    }

    override fun onNext(value: UserData?) {
        //网络请求返回结果
    }

    override fun onError(e: Throwable?) {
        //网络请求错误
    }

    override fun onComplete() {
        //网络请求结束
    }
})

6. 结合Kotlin协程

lifecycleScope.launch {
    val userInfo = withContext(Dispatchers.IO) {
        val userInfo = server.getUserInfoBySuspend2("1")//子线程中请求网络
    }
    //回到主线程
    Log.i("testRetrofit", "userInfo:$userInfo")
}

核心源码分析

1. Retrofit.create方法，根据注解为我们声明的接口创建动态代理

```
public  T create(final Class service) {
validateServiceInterface(service);//检验接口中的方法是否符合要求
return (T)
    Proxy.newProxyInstance(
        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 {
            // If the method is a method from Object then defer to normal invocation.
            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);//开始解析该方法并返回接口请求对象，比如Call、Observable(需结合Rxjava)
          }
        });
}
```

• 在validateServiceInterface方法中，如果配置了Retrofit.Builder().validateEagerly(true)，会立刻根据注解解析接口中定义的所有方法，如果是false，则会等待方法调用时才会解析接口中的方法；

  设置为true的好处是在创建接口代理时就能检查出各个方法配置的注解、返回值等是否正确，如果为默认的false，则只有在方法调用时才能发现问题；

  所以建议在debug阶段设置为true便于及早发现问题，release阶段设置false以提高性能

  private void validateServiceInterface(Class service) {
      ... ...
      if (validateEagerly) {
        Platform platform = Platform.get();
        for (Method method : service.getDeclaredMethods()) {//遍历所有方法，根据注解进行解析
          if (!platform.isDefaultMethod(method) && !Modifier.isStatic(method.getModifiers())) {
            loadServiceMethod(method);
          }
        }
      }
  }
  

• 默认实现中接口返回的Call实际上是一个Retrofit中定义的一个接口，定义了同步请求和异步请求的方法；

  public interface Call extends Cloneable {
    ... ...
    /**
     * Synchronously send the request and return its response.
     *
     * @throws IOException if a problem occurred talking to the server.
     * @throws RuntimeException (and subclasses) if an unexpected error occurs creating the request or
     *     decoding the response.
     */
    Response execute() throws IOException;
  
    /**
     * Asynchronously send the request and notify {@code callback} of its response or if an error
     * occurred talking to the server, creating the request, or processing the response.
     */
    void enqueue(Callback callback);
    ... ...
  }
  

• Call的实现类根据是否有注解@SkipCallbackExecutor来决定，当有该注解时，Call的实现类是OkHttpCall.java，里面封装了OkHttp的网络请求，如果没有该注解，则Call实现类是DefaultCallAdapterFactory.ExecutorCallbackCall；这个类仅仅是个代理类，真正实现网络请求的还是OkHttpCall；
  代理类存在的意义是Okhttp进行异步请求返回结果后，会先通过Handler将线程切换到主线程再返回结果

  final class OkHttpCall implements Call {
      @Override
      public void enqueue(final Callback callback) {
          ...
          okhttp3.Call call;
          call.enqueue(
          new okhttp3.Callback() {
            @Override
            public void onResponse(okhttp3.Call call, okhttp3.Response rawResponse) {
            }
            @Override
            public void onFailure(okhttp3.Call call, IOException e) {
              callFailure(e);
            }
          }
          ...
      }
  
      @Override
      public Response execute() throws IOException {
      okhttp3.Call call;
      ...
      return parseResponse(call.execute());
    }
  }
  

  static final class ExecutorCallbackCall implements Call {
      final Executor callbackExecutor;//在主线程执行，实现类是Platform.Android.MainThreadExecutor
      final Call delegate;//这个实现类是OkHttpCall
  
      @Override
      public void enqueue(final Callback callback) {
        delegate.enqueue(
            new Callback() {
              @Override
              public void onResponse(Call call, final Response response) {
                callbackExecutor.execute(() -> {
                      //切换到主线程执行
                        callback.onResponse(ExecutorCallbackCall.this, response);
                      }
                    });
              }
  
              @Override
              public void onFailure(Call call, final Throwable t) {
                //切换到主线程执行
                callbackExecutor.execute(() -> callback.onFailure(ExecutorCallbackCall.this, t));
              }
            });
      }
  
      @Override
      public Response execute() throws IOException {
        return delegate.execute();//在当前所在线程执行
      }
  }
  

2. 注解的解析过程和使用

• 在Retrofit.create方法中，loadServiceMethod方法中会先从缓存中查找ServiceMethod对象，如果之前有解析过则直接返回，如果没有则调用ServiceMethod.parseAnnotations方法返回一个ServiceMethod对象

  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;
  }
  

• 接着会调用RequestFactory.parseAnnotations方法真正进行注解的解析，并构建一个HttpServiceMethod对象返回

  abstract class ServiceMethod {
    static  ServiceMethod parseAnnotations(Retrofit retrofit, Method method) {
      //真正解析方法上的注解入口
      RequestFactory requestFactory = RequestFactory.parseAnnotations(retrofit, method);
  
      //检查方法返回类型是否符合规范
      Type returnType = method.getGenericReturnType();
      if (Utils.hasUnresolvableType(returnType)) {
        throw methodError(
            method,
            "Method return type must not include a type variable or wildcard: %s",
            returnType);
      }
      if (returnType == void.class) {
        throw methodError(method, "Service methods cannot return void.");
      }
  
      return HttpServiceMethod.parseAnnotations(retrofit, method, requestFactory);
  }
  

• RequestFactory.Builder中解析方法中的注解,可以理解为RequestFactory对象保存着所有请求的数据

  final class RequestFactory {
    static RequestFactory parseAnnotations(Retrofit retrofit, Method method) {
      return new Builder(retrofit, method).build();
    }
    static final class Builder {
      final Annotation[] methodAnnotations;//方法上的注解
      final Annotation[][] parameterAnnotationsArray;//方法参数上的注解
      final Type[] parameterTypes;//参数类型
      @Nullable String httpMethod;//请求的方式get、post等
      @Nullable String relativeUrl;//解析处理后的请求接口
      @Nullable Headers headers;//封装的请求头信息
      boolean isKotlinSuspendFunction; //用于标记是否kotlin协程中suspend方法
      ...
      private Headers parseHeaders(String[] headers) {}//解析请求头信息
      private void parseHttpMethodAndPath(String httpMethod, String value, boolean hasBody) //解析请求方式和接口路径
      private void parseMethodAnnotation(Annotation annotation) {//解析方法上的注解
        if (annotation instanceof DELETE) {
          parseHttpMethodAndPath("DELETE", ((DELETE) annotation).value(), false);
        } else if (annotation instanceof GET) {
          parseHttpMethodAndPath("GET", ((GET) annotation).value(), false);
        } else if (annotation instanceof HEAD) {
          parseHttpMethodAndPath("HEAD", ((HEAD) annotation).value(), false);
        } else if (annotation instanceof PATCH) {
          parseHttpMethodAndPath("PATCH", ((PATCH) annotation).value(), true);
        } else if (annotation instanceof POST) {
          parseHttpMethodAndPath("POST", ((POST) annotation).value(), true);
        } else if (annotation instanceof PUT) {
          parseHttpMethodAndPath("PUT", ((PUT) annotation).value(), true);
        }
        ...
      }
      private ParameterHandler parseParameterAnnotation(){//解析参数上注解
          if (annotation instanceof Path) {
          } else if (annotation instanceof Query) {
          } else if (annotation instanceof QueryName) {
          } else if (annotation instanceof QueryMap) {
          } else if (annotation instanceof Header) {
          } else if (annotation instanceof HeaderMap) {
          } else if (annotation instanceof Field) {
          } else if (annotation instanceof FieldMap) {
          }  else if (annotation instanceof Body) {
          }
          ...
      }
    }
  }
  

• 请求参数的使用，是在真正发起网络请求OkhttpCall.createRawCall()方法中创建Okhttp Call对象的时候，通过RequestFactory.create方法将所有请求参数封装成OkHttp的Request对象

class OkHttpCall{
    private okhttp3.Call createRawCall() throws IOException {
        okhttp3.Call call = callFactory.newCall(requestFactory.create(args));
        return call;
    }
}
class RequestFactory{
    okhttp3.Request create(Object[] args) throws IOException {
        RequestBuilder requestBuilder =
            new RequestBuilder(
                httpMethod,
                baseUrl,
                relativeUrl,
                headers,
                contentType,
                hasBody,
                isFormEncoded,
                isMultipart);

        if (isKotlinSuspendFunction) {//协程suspen方法会自动在最后面加一个Continuation对象类型参数，所以实际请求时要去掉
          // The Continuation is the last parameter and the handlers array contains null at that index.
          argumentCount--;
        }

        List