Retrofit 工作原理解读

 

Retrofit是由square开发的基于okhttp的用于网络请求的框架，我相信知道retrofit的人应该都知道其核心原理为动态代理。那我们问题来了他动态代理到底干了什么呢，现在让我解读一遍其源码，知道其具体的工作原理。

使用：

 val retrofit = Retrofit.Builder()
            .baseUrl("https://api.github.com/")
            .build()

        val service: GitApi = retrofit.create(GitApi::class.java)
        val call =service.listRepos("")
        call.enqueue(object: Callback>{
            override fun onFailure(call: Call>, t: Throwable) {
                TODO("Not yet implemented")
            }

            override fun onResponse(call: Call>, response: Response>) {
                TODO("Not yet implemented")
            }

        })

由build()方式生产retrofit，这个就是一个打包调用的数据过程

create方法

下一行创建了定义了连接的接口的对象实例，来看一下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);
              }
            });
  }

在这里看到了其核心动态代理的方法，先不急着去看动态代理里面干了什么先看下validateServiceInterface(service) 里干了什么

private void validateServiceInterface(Class service) {
    if (!service.isInterface()) {
      throw new IllegalArgumentException("API declarations must be interfaces.");
    }

    Deque> check = new ArrayDeque<>(1);
    check.add(service);
    while (!check.isEmpty()) {
      Class candidate = check.removeFirst();
      if (candidate.getTypeParameters().length != 0) {
        StringBuilder message =
            new StringBuilder("Type parameters are unsupported on ").append(candidate.getName());
        if (candidate != service) {
          message.append(" which is an interface of ").append(service.getName());
        }
        throw new IllegalArgumentException(message.toString());
      }
      Collections.addAll(check, candidate.getInterfaces());
    }
//判断是否需要一次加载api接口里所有的方法 
    if (validateEagerly) {
      Platform platform = Platform.get();
      for (Method method : service.getDeclaredMethods()) {
        if (!platform.isDefaultMethod(method) && !Modifier.isStatic(method.getModifiers())) {
          loadServiceMethod(method);
        }
      }
    }
  }

可以见得里先判断了api接口类是否为接口，如果不是的话就直接抛出异常。然后将其加入到一个双向队列中，

private void validateServiceInterface(Class service) {
    if (!service.isInterface()) {//判断api接口类是否为接口 否则抛出异常
      throw new IllegalArgumentException("API declarations must be interfaces.");
    }

    Deque> check = new ArrayDeque<>(1);
    check.add(service);//将api接口加入到一个双向队列中
    while (!check.isEmpty()) {
      Class candidate = check.removeFirst();
      if (candidate.getTypeParameters().length != 0) {//判断api接口类里是否有用泛型，用了就会抛出异常
        StringBuilder message =
            new StringBuilder("Type parameters are unsupported on ").append(candidate.getName());
        if (candidate != service) {
          message.append(" which is an interface of ").append(service.getName());
        }
        throw new IllegalArgumentException(message.toString());
      }
      Collections.addAll(check, candidate.getInterfaces());//将api接口的父接口加入到队列中
    }
    //判断是否需要一次性将所有的api方法都加载出来 validateEagerly由用户设置默认为false
    if (validateEagerly) {
      Platform platform = Platform.get();//根据虚假机类型判断当前执行的平台
      for (Method method : service.getDeclaredMethods()) {
        if (!platform.isDefaultMethod(method) && !Modifier.isStatic(method.getModifiers())) {//不加载接口中的默认方法和静态方法
          loadServiceMethod(method);
        }
      }
    }
  }

可以看到定义的api接口类必须为一个接口而且不能有用泛型。Retrofit可以由根据用户需求是否一次性加载所有的方法还是在调用的时候加载当前的方法，因为加载方法是通过java的反射的机制，由于反射会影响运行的速度，如果一次加载所有那么最开执行的时候会比较耗时后面的调用就不会有影响，如果为false则在每次调用时会先加载方法会有一个小耗时。因此用户可选择一次就吧反射需要的时间给耗了还是将所要耗的时间分散在每次调用的时候。

现在来看动态代理的实现

 Proxy.newProxyInstance(
            service.getClassLoader(),
            new Class[] {service},
            new InvocationHandler() {
              private final Platform platform = Platform.get();//获取当前的平台Android，java
              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;
                //如果为default方法则直接调用
                return platform.isDefaultMethod(method)
                    ? platform.invokeDefaultMethod(method, service, proxy, args)
                    : loadServiceMethod(method).invoke(args);
              }
            });

动态代理里判断了来自object的方法和default的方法，那关键就是loadServiceMethod方法和他返回的invoke方法了

loadServiceMethod

 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不是就加载一个。现在关键在ServiceMethod.parseAnnotations(this, method)是怎么创建一个serviceMethod对象的再找到它的invoke方法的实现就大功告成了

parseAnnotations

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.parseAnnotation这个从名字上看是通过解析方法的注解创建了一个请求的工厂对象，这个先放着后面在来看他是怎么解析方法的。先看这个返回的HttpServiceMethod.parseAnnotations方法看看它干了什么。

  static  HttpServiceMethod parseAnnotations(
      Retrofit retrofit, Method method, RequestFactory requestFactory) {
    boolean isKotlinSuspendFunction = requestFactory.isKotlinSuspendFunction;
    boolean continuationWantsResponse = false;
    boolean continuationBodyNullable = false;

    Annotation[] annotations = method.getAnnotations();
    Type adapterType;

 /**
  * 获取方法返回类型
  */
    if (isKotlinSuspendFunction) {//是否为kotlin的协程方法
      Type[] parameterTypes = method.getGenericParameterTypes();
      Type responseType =
          Utils.getParameterLowerBound(
              0, (ParameterizedType) parameterTypes[parameterTypes.length - 1]);
      if (getRawType(responseType) == Response.class && responseType instanceof ParameterizedType) {
        // Unwrap the actual body type from Response.
        responseType = Utils.getParameterUpperBound(0, (ParameterizedType) responseType);
        continuationWantsResponse = true;
      } else {
        // TODO figure out if type is nullable or not
        // Metadata metadata = method.getDeclaringClass().getAnnotation(Metadata.class)
        // Find the entry for method
        // Determine if return type is nullable or not
      }

      adapterType = new Utils.ParameterizedTypeImpl(null, Call.class, responseType);
      annotations = SkipCallbackExecutorImpl.ensurePresent(annotations);
    } else {
      adapterType = method.getGenericReturnType();
    }

    CallAdapter callAdapter =
        createCallAdapter(retrofit, method, adapterType, annotations);
    //获取方法的响应类型
    Type responseType = callAdapter.responseType();
    //判断响应类型是否合法
    if (responseType == okhttp3.Response.class) {
      throw methodError(
          method,
          "'"
              + getRawType(responseType).getName()
              + "' is not a valid response body type. Did you mean ResponseBody?");
    }
    if (responseType == Response.class) {
      throw methodError(method, "Response must include generic type (e.g., Response)");
    }
    // TODO support Unit for Kotlin?
    if (requestFactory.httpMethod.equals("HEAD") && !Void.class.equals(responseType)) {
      throw methodError(method, "HEAD method must use Void as response type.");
    }

    Converter responseConverter =
        createResponseConverter(retrofit, method, responseType);

    okhttp3.Call.Factory callFactory = retrofit.callFactory;
    if (!isKotlinSuspendFunction) {//kotlin协程方法判断
      return new CallAdapted<>(requestFactory, callFactory, responseConverter, callAdapter);
    } else if (continuationWantsResponse) {
      //noinspection unchecked Kotlin compiler guarantees ReturnT to be Object.
      return (HttpServiceMethod)
          new SuspendForResponse<>(
              requestFactory,
              callFactory,
              responseConverter,
              (CallAdapter>) callAdapter);
    } else {
      //noinspection unchecked Kotlin compiler guarantees ReturnT to be Object.
      return (HttpServiceMethod)
          new SuspendForBody<>(
              requestFactory,
              callFactory,
              responseConverter,
              (CallAdapter>) callAdapter,
              continuationBodyNullable);
    }
  }

哇。。。。。一大坨。仔细一看，其实主要是return new CallAdapted<>(requestFactory, callFactory, responseConverter, callAdapter);这段前面的是获取返回类型和对响应类型的判断。先知道了loadServiceMethod返回了一个CallAdapted

CallAdapted

 static final class CallAdapted extends HttpServiceMethod {
    private final CallAdapter callAdapter;

    CallAdapted(
        RequestFactory requestFactory,
        okhttp3.Call.Factory callFactory,
        Converter responseConverter,
        CallAdapter callAdapter) {
      super(requestFactory, callFactory, responseConverter);
      this.callAdapter = callAdapter;
    }

    @Override
    protected ReturnT adapt(Call call, Object[] args) {
      return callAdapter.adapt(call);
    }
  }

 

它是HttpServiceMethod的子类，loadServiceMethor的invoke 调用的就是HttpServiceMethod的invoke就是

 @Override
  final @Nullable ReturnT invoke(Object[] args) {
    Call call = new OkHttpCall<>(requestFactory, args, callFactory, responseConverter);
    return adapt(call, args);
  }

这里生成了一个okhttpcall和并进行了适配。

好了目前位置知道了create最后得到的是一个适配过的okhttpcall,如果没有适配那后面调用的enqueue方法就是调用的okhttpcall里的enqueue。

OkHttpCall

@Override
  public void enqueue(final Callback callback) {
    Objects.requireNonNull(callback, "callback == null");
       //okhttp里的call
    okhttp3.Call call;
    Throwable failure;

    synchronized (this) {
      if (executed) throw new IllegalStateException("Already executed.");
      executed = true;

      call = rawCall;
      failure = creationFailure;
      if (call == null && failure == null) {
        try {
            //生产一个okhttpcall
          call = rawCall = createRawCall();
        } catch (Throwable t) {
          throwIfFatal(t);
          failure = creationFailure = t;
        }
      }
    }

    if (failure != null) {
      callback.onFailure(this, failure);
      return;
    }

    if (canceled) {
      call.cancel();
    }

    //同okhttp来访问网络
    call.enqueue(
        new okhttp3.Callback() {
          @Override
          public void onResponse(okhttp3.Call call, okhttp3.Response rawResponse) {
            Response response;
            try {
              response = parseResponse(rawResponse);
            } catch (Throwable e) {
              throwIfFatal(e);
              callFailure(e);
              return;
            }

            try {
              callback.onResponse(OkHttpCall.this, response);
            } catch (Throwable t) {
              throwIfFatal(t);
              t.printStackTrace(); // TODO this is not great
            }
          }

          @Override
          public void onFailure(okhttp3.Call call, IOException e) {
            callFailure(e);
          }

          private void callFailure(Throwable e) {
            try {
              callback.onFailure(OkHttpCall.this, e);
            } catch (Throwable t) {
              throwIfFatal(t);
              t.printStackTrace(); // TODO this is not great
            }
          }
        });
  }

 

如果没进行适配，那参数里的callback就是外面调用enqueue时传入的callback。但它时进行了适配的有个adapter的方法，先来看看adapter干了什么

adapter

  @Override
    protected ReturnT adapt(Call call, Object[] args) {
      return callAdapter.adapt(call);
    }

即使之前calladapter里的adapter，找到这个callAdapte的传入的实现类

public CallAdapter nextCallAdapter(
      @Nullable CallAdapter.Factory skipPast, Type returnType, Annotation[] annotations) {
    Objects.requireNonNull(returnType, "returnType == null");
    Objects.requireNonNull(annotations, "annotations == null");

    int start = callAdapterFactories.indexOf(skipPast) + 1;
    for (int i = start, count = callAdapterFactories.size(); i < count; i++) {
      CallAdapter adapter = callAdapterFactories.get(i).get(returnType, annotations, this);
      if (adapter != null) {
        return adapter;
      }
    }

    StringBuilder builder =
        new StringBuilder("Could not locate call adapter for ").append(returnType).append(".\n");
    if (skipPast != null) {
      builder.append("  Skipped:");
      for (int i = 0; i < start; i++) {
        builder.append("\n   * ").append(callAdapterFactories.get(i).getClass().getName());
      }
      builder.append('\n');
    }
    builder.append("  Tried:");
    for (int i = start, count = callAdapterFactories.size(); i < count; i++) {
      builder.append("\n   * ").append(callAdapterFactories.get(i).getClass().getName());
    }
    throw new IllegalArgumentException(builder.toString());
  }

这段时跟到retrofit类里取到了，可见是由callAdapterFactories里取到的通过get方法，现在看callAdapterFactories是在那赋值的地方

  List callAdapterFactories = new ArrayList<>(this.callAdapterFactories);
      callAdapterFactories.addAll(platform.defaultCallAdapterFactories(callbackExecutor));

 

@Override
  public @Nullable CallAdapter get(
      Type returnType, Annotation[] annotations, Retrofit retrofit) {
    if (getRawType(returnType) != Call.class) {
      return null;
    }
    if (!(returnType instanceof ParameterizedType)) {
      throw new IllegalArgumentException(
          "Call return type must be parameterized as Call or Call");
    }
    final Type responseType = Utils.getParameterUpperBound(0, (ParameterizedType) returnType);
    //获取线程池
    final Executor executor =
        Utils.isAnnotationPresent(annotations, SkipCallbackExecutor.class)
            ? null
            : callbackExecutor;

    return new CallAdapter>() {
      @Override
      public Type responseType() {
        return responseType;
      }

      @Override
      public Call