Retrofit2完全解析和与okhttp之间的关系

刨析Retrofit源码前先简单介绍以下几个和Method相关的方法

Method method;
//第一: 获取方法上所有的注解
Annotation[] methodAnnotations = method.getAnnotations();
//第二: 获取方法参数上的所有注解
//为什么是二维数组: 因为一个参数会有多个注解, 一个方法可以有多个参数
Annotation[][] parameterAnnotationsArray = method.getParameterAnnotations();
//eg:
@POST("user/register")
Observable<RegisterBean> test(@FieldMap @Query("account") Map<String, Object> params, @QueryName String name);

//获取方法参数的类型,*如果有泛型也会展示出来
Type[] parameterTypes = method.getGenericParameterTypes();
ParameterizedType type;
//可以获取对象里的泛型类型如果是Map<String,Object> types[0]:String.class;  types[1]:Object.class;
Type[] types = type.getActualTypeArguments();

//获取方法参数的类型,*如果有泛型不会展示出来
Class<?>[] parameterTypes = method.getParameterTypes();

通过代码分析getGenericParameterTypes和getParameterTypes区别

public class Test2 {
    public void setDatas(List<String> datas) { }
    public void setName(String name) { }
    public void test() throws Exception {
        Class<? extends Test2> sampleClassClass = getClass();
        Method[] methods = sampleClassClass.getMethods();
        for (Method method : methods) {
            Type[] genericParameterTypes = method.getGenericParameterTypes();
            Class<?>[] parameterTypes = method.getParameterTypes();
            for (Class parameterType : parameterTypes) {
                System.out.println("parameterTypes:  " + parameterType + "====" + parameterType.getName());
            }
            for (int i = 0; i < genericParameterTypes.length; i++) {
                System.out.println("genericParameterTypes:  " + genericParameterTypes[i] + "=====" + genericParameterTypes[i].getTypeName());
            }
        }
    }
}
//打印日志好下 区别一目了然
//parameterTypes:  class java.lang.String====java.lang.String
//genericParameterTypes:  class java.lang.String=====java.lang.String

//parameterTypes:  interface java.util.List====java.util.List
//genericParameterTypes:  java.util.List<java.lang.String>=====java.util.List<java.lang.String>

正式分析

分析new Retrofit.Builder()做了什么

public Builder() {
  //通过Platform,get()获取到适配各种平台的Platform
  this(Platform.get());
}

private static final Platform PLATFORM = findPlatform();
//get()方法主要是返回了一个静态的PLATFORM 是通过findPlatform();生成
static Platform get() {
  return PLATFORM;
}

//这里会根据不同的平台创建不一样的Platform 
private static Platform findPlatform() {
  try {
  	//创建Android平台
    Class.forName("android.os.Build");
    if (Build.VERSION.SDK_INT != 0) {
      return new Android();
    }
  } catch (ClassNotFoundException ignored) {
  }
  try {
    Class.forName("java.util.Optional");
    return new Java8();
  } catch (ClassNotFoundException ignored) {
  }
  return new Platform();
}

static class Android extends Platform {
  @Override public Executor defaultCallbackExecutor() {
    return new MainThreadExecutor();
  }
  //这里是获取默认的适配器，下面分析的时候会调用这个方法，返回的是ExecutorCallAdapterFactory适配器工厂
  @Override CallAdapter.Factory defaultCallAdapterFactory(@Nullable Executor callbackExecutor) {
    if (callbackExecutor == null) throw new AssertionError();
    return new ExecutorCallAdapterFactory(callbackExecutor);
  }
  static class MainThreadExecutor implements Executor {
    private final Handler handler = new Handler(Looper.getMainLooper());
    @Override public void execute(Runnable r) {
      handler.post(r);
    }
  }
}

分析new Retrofit.Builder().build()

//Retorfit一般用法如下
Retrofit retrofit = new Retrofit.Builder().client(mClient).baseUrl(host)
                    .addCallAdapterFactory(RxJava2CallAdapterFactory.create())
                    .addConverterFactory(ScalarsConverterFactory.create())
                    .addConverterFactory(GsonConverterFactory.create())
                    .build();
                    
public Retrofit build() {
  if (baseUrl == null) {
    throw new IllegalStateException("Base URL required.");
  }
  okhttp3.Call.Factory callFactory = this.callFactory;
  //由于我们传进了一个mClient，所以这里的callFactory不为null
  //假如没有调用.client(mClient)则callFactory = new OkHttpClient();
  if (callFactory == null) {
    callFactory = new OkHttpClient();
  }
  
  Executor callbackExecutor = this.callbackExecutor;
  if (callbackExecutor == null) {
  	//由于是Android平台所以platform是Retorfi框架里的Android类
  	//获取的是MainThreadExecutor implements Executor
    callbackExecutor = platform.defaultCallbackExecutor();
  }
  //适配器集合我们上面调用了.addCallAdapterFactory(RxJava2CallAdapterFactory.create())
  //所以callAdapterFactories创建的时候就会有一个值RxJava2CallAdapterFactory
  List<CallAdapter.Factory> callAdapterFactories = new ArrayList<>(this.callAdapterFactories);
  //然后再添加了一个默认的适配器工厂由于platform为Android类
  //所以platform.defaultCallAdapterFactory(callbackExecutor) = ExecutorCallAdapterFactory
  //callAdapterFactories最终大小为2第一个为RxJava2CallAdapterFactory第二个为ExecutorCallAdapterFactory
  callAdapterFactories.add(platform.defaultCallAdapterFactory(callbackExecutor));

  //数据转换工厂，逻辑跟上面的适配器工厂一样
  List<Converter.Factory> converterFactories = new ArrayList<>(1 + this.converterFactories.size());
  converterFactories.add(new BuiltInConverters());
  converterFactories.addAll(this.converterFactories);
  //创建了Retrofit
  return new Retrofit(callFactory, baseUrl, unmodifiableList(converterFactories),
      unmodifiableList(callAdapterFactories), callbackExecutor, validateEagerly);
}

分析Retrofit.create(Class)方法做了什么

public <T> T create(final Class<T> service) {
    ...  //判断service是否是一个接口,是否有多继承,  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, @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);
            }
            if (platform.isDefaultMethod(method)) {
              return platform.invokeDefaultMethod(method, service, proxy, args);
            }
            //第一步
            ServiceMethod<Object, Object> serviceMethod = (ServiceMethod<Object, Object>) loadServiceMethod(method);
            OkHttpCall<Object> okHttpCall = new OkHttpCall<>(serviceMethod, args);
            return serviceMethod.adapt(okHttpCall);
          }
        });
  }

很简单

• 首先: 返回的是 Proxy.newProxyInstance创建的对象,其这里就是创建了通过参数传过来的Class,当然这里一定要是接口retrofit也有判断如果不是接口会直接抛异常
  想看newProxyInstance源码分析可点击

• 其实InvocationHandler的invoke方法里面主要是通过loadServiceMethod创建了一个ServiceMethod,然后把获取到的ServiceMethod和参数agrs通构造方法创建了OkHttpCall

• 最后通过适配器模式调用serviceMethod的adapt并把创建的okHttpCall当作参数给返回出去(serviceMethod.adapt(okHttpCall))

分析Retrofit.create代码里的(第一步)

ServiceMethod<Object, Object> serviceMethod = (ServiceMethod<Object, Object>) loadServiceMethod(method);

ServiceMethod<?, ?> loadServiceMethod(Method method) {
  ServiceMethod<?, ?> result = serviceMethodCache.get(method);
  if (result != null) return result;
  // 这里用了synchronized 是为了双重验证
  synchronized (serviceMethodCache) {
    result = serviceMethodCache.get(method);
    if (result == null) {
      result = new ServiceMethod.Builder<>(this, method).build();
      serviceMethodCache.put(method, result);
    }
  }
  return result;
}

//核心代码 new ServiceMethod.Builder<>(this, method).build();
//这里用了构建者设计模式  new ServiceMethod.Builder<>(this, method);这里主要是为一些成员变量附
Builder(Retrofit retrofit, Method method) {
	this.retrofit = retrofit;
	this.method = method;
	//获取方法上所有注解
	this.methodAnnotations = method.getAnnotations();
	//获取方法形参类型的  返回的是完整的泛型
	this.parameterTypes = method.getGenericParameterTypes();
	//获取方法参数上的所有注解 
	this.parameterAnnotationsArray = method.getParameterAnnotations();
}

//核心代码其实在.build()里, 去掉一些逻辑加强,代码如下
public ServiceMethod build() {
	//1:这个是创建adapter适配器,如果初始化Retrofit没有执行.addCallAdapterFactory(RxJava2CallAdapterFactory.create())方法时,它就会自己创建一个CallAdapter,直到获取到合适的才返回
	//下面会具体分析这一行代码
  callAdapter = createCallAdapter();//第二步
  //2:获取返回值里的泛型类型比如Call<LoginBean>  responseType这个Type就是LoginBean.class
  responseType = callAdapter.responseType();
  //3:这行代码是创建解析器,比如用Gson来解析数据 创建Retrofit时就要执行: .addConverterFactory(GsonConverterFactory.create())
  //这个跟适配器不一样,他会一直判断,直到取到转换成功的数据才返回
  responseConverter = createResponseConverter();
  //4:解析方法注解上的参数比如@Post @Get 都有相应处理
  for (Annotation annotation : methodAnnotations) {
    parseMethodAnnotation(annotation);
  }
  //5:处理方法参数上的注解
  int parameterCount = parameterAnnotationsArray.length;
  parameterHandlers = new ParameterHandler<?>[parameterCount];
  for (int p = 0; p < parameterCount; p++) {
    Type parameterType = parameterTypes[p];
    Annotation[] parameterAnnotations = parameterAnnotationsArray[p];
    parameterHandlers[p] = parseParameter(p, parameterType, parameterAnnotations);
  }
  return new ServiceMethod<>(this);
}

下面详细分析一下适配器工厂是怎么实现的

callAdapter = createCallAdapter();//第二步

private CallAdapter<T, R> createCallAdapter() {
	//获取方法的返回值类型
  Type returnType = method.getGenericReturnType();
  Annotation[] annotations = method.getAnnotations();
  try {
  	//这里直接是从Retrofit类获取适配器了
    return (CallAdapter<T, R>) retrofit.callAdapter(returnType, annotations);
  } catch (RuntimeException e) { // Wide exception range because factories are user code.
    throw methodError(e, "Unable to create call adapter for %s", returnType);
  }
}
//Retrofit里面的方法
public CallAdapter<?, ?> callAdapter(Type returnType, Annotation[] annotations) {
  return nextCallAdapter(null, returnType, annotations);
}
public CallAdapter<?, ?> nextCallAdapter(CallAdapter.Factory skipPast, Type returnType,Annotation[] annotations) {
  int start = callAdapterFactories.indexOf(skipPast) + 1;
  //获取适配器集合
  for (int i = start, count = callAdapterFactories.size(); i < count; i++) {
  	//通过返回类型来找合适的适配器,只到找到才返回
  	//自己也可以实现一个适配器,只要继承CallAdapter.Factory并实现里面方法就行
	    CallAdapter<?, ?> adapter = callAdapterFactories.get(i).get(returnType, annotations, this);
    if (adapter != null) {
      return adapter;
    }
  }
}
//假如我们没有添加任何适配器这里就会创建一个默认的适配器ExecutorCallAdapterFactory.get();
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<Object, Call<?>>() {
    @Override public Type responseType() {
      return responseType;
    }
    //第三步
    @Override public Call<Object> adapt(Call<Object> call) {
      return new ExecutorCallbackCall<>(callbackExecutor, call);
    }
  };

分析serviceMethod.adapt(okHttpCall);

OkHttpCall<Object> okHttpCall = new OkHttpCall<>(serviceMethod, args);
return serviceMethod.adapt(okHttpCall);
T adapt(Call<R> call) {
	//这就很简单了,执行的是适配器里的adapter方法,也就是会到第三步那里返回的是一个new ExecutorCallbackCall<>(callbackExecutor, call);
	return callAdapter.adapt(call);
}
//而ExecutorCallbackCall是implements Call
static final class ExecutorCallbackCall<T> implements Call<T> ;
//当我们执行Call的enqueue方法时也就是ExecutorCallbackCall的enqueue
//代码如下
@Override public void enqueue(final Callback<T> callback) {
  checkNotNull(callback, "callback == null");
  //delegate是什么, delegate就是我们创建的OkHttpCall
  //所以这里最终还是到了OkHttpCall.enqueue
  delegate.enqueue(new Callback<T>() {
    @Override public void onResponse(Call<T> call, final Response<T> response) {
      callbackExecutor.execute(new Runnable() {
        @Override public void run() {
          if (delegate.isCanceled()) {
            // Emulate OkHttp's behavior of throwing/delivering an IOException on cancellation.
            callback.onFailure(ExecutorCallbackCall.this, new IOException("Canceled"));
          } else {
            callback.onResponse(ExecutorCallbackCall.this, response);
          }
        }
      });
    }
    @Override public void onFailure(Call<T> call, final Throwable t) {
      callbackExecutor.execute(new Runnable() {
        @Override public void run() {
          callback.onFailure(ExecutorCallbackCall.this, t);
        }
      });
    }
  });
}

delegate.enqueue(new Callback() 这个delegate其实就是OkHttpCall所以最终还是会来到OkHttpCall的enqueue方法中

@Override public void enqueue(final Callback<T> callback) {
  checkNotNull(callback, "callback == null");
  okhttp3.Call call;
  Throwable failure;
  synchronized (this) {
    if (executed) throw new IllegalStateException("Already executed.");
    executed = true;
    //开始创建okhttp3.Call
    call = rawCall;
    failure = creationFailure;
    if (call == null && failure == null) {
      try {
        call = rawCall = createRawCall();
      } catch (Throwable t) {
        throwIfFatal(t);
        failure = creationFailure = t;
      }
    }
  }
  if (failure != null) {
    callback.onFailure(this, failure);
    return;
  }
  if (canceled) {
    call.cancel();
  }

  //执行okhttp3.Call的enqueue方法
  call.enqueue(new okhttp3.Callback() {
    @Override public void onResponse(okhttp3.Call call, okhttp3.Response rawResponse) {
      Response<T> response;
      try {
        //解析response 这里会获取解析器比如GsonConverterFactory.create()，或者默认的BuiltInConverters
        response = parseResponse(rawResponse);
      } catch (Throwable e) {
        callFailure(e);
        return;
      }
      try {
        callback.onResponse(OkHttpCall.this, response);
      } catch (Throwable t) {
        t.printStackTrace();
      }
    }
    @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) {
        t.printStackTrace();
      }
    }
  });
}

Response<T> parseResponse(okhttp3.Response rawResponse) throws IOException {
...
	//核心代码也就这一点点
    try {
      T body = serviceMethod.toResponse(catchingBody);
      return Response.success(body, rawResponse);
    } catch (RuntimeException e) {
      // If the underlying source threw an exception, propagate that rather than indicating it was
      // a runtime exception.
      catchingBody.throwIfCaught();
      throw e;
    }

...
}

在OkHttpCall的enqueue方法主要是通过createRawCall()创建了Okhttp的Call

private okhttp3.Call createRawCall() throws IOException {
	//通过toCall方法进行封装Okhttp需要的参数	
  okhttp3.Call call = serviceMethod.toCall(args);
  if (call == null) {
    throw new NullPointerException("Call.Factory returned null.");
  }
  return call;
}
//toCall方法的主要职者是将Hook方法里的参数值转化为Okhttp的Request,再通过callFactory.newCall返回了okhttp3.Call
okhttp3.Call toCall(@Nullable Object... args) throws IOException {
  RequestBuilder requestBuilder = new RequestBuilder(httpMethod, baseUrl, relativeUrl, headers,
      contentType, hasBody, isFormEncoded, isMultipart);
  @SuppressWarnings("unchecked") // It is an error to invoke a method with the wrong arg types.
  //这个集合是每个方法参数里注解的key
  ParameterHandler<Object>[] handlers = (ParameterHandler<Object>[]) parameterHandlers;
  int argumentCount = args != null ? args.length : 0;
  for (int p = 0; p < argumentCount; p++) {
  	//封装requestBuilder
    handlers[p].apply(requestBuilder, args[p]);
  }
//callFactory 就是OkHttpClient
//在Retrofit.Builder().build()方法中有体现
//okhttp3.Call.Factory callFactory = this.callFactory;
//if (callFactory == null) {
//  callFactory = new OkHttpClient();
//}
  return callFactory.newCall(requestBuilder.build());
}