Retrofit源码分析

Retrofit是对OkHttp进一步封装，底层依然是OkHttp进行网络请求；通过注解的方式，设置参数；里面用到的设计模式：动态代理设计模式、Builder设计模式、工厂设计模式、适配器设计模式、单例模式等，非常值得我们学习和研究。

最好首先了解深入理解Java注解类型(@Annotation)和OkHttp3源码分析；

Retrofit的构建

Retrofit 的构建；

private String baseUrl="http://www.wanandroid.com/";
private final Retrofit retrofit = new Retrofit.Builder().baseUrl(baseUrl)
            //.addConverterFactory(GsonConverterFactory.create())//json 转换器 返回json
            .addConverterFactory(ScalarsConverterFactory.create())//返回文本
            //.addCallAdapterFactory(RxJavaCallAdapterFactory.create())
            .addCallAdapterFactory(RxJava2CallAdapterFactory.create())//Rxjava2 同步
            //.addCallAdapterFactory(RxJava2CallAdapterFactory.createAsync())//异步
            //.callFactory()
            //.client()
            //.callbackExecutor()
            .build();

Retrofit的Builder类：构建一个Retrofit；在调用build()之前，需要调用baseUrl，其他方法都是可选的。

主要参数

• baseUrl：必须以“/”结尾；
• converterFactories：转换器，常用两种GsonConverterFactory（直接转换成需要的json）、ScalarsConverterFactory（返回字符串文本）；
• callAdapterFactories：回调适配器，RxJava配合Retrofit使用；
• platform：分为Android、Java8和Platform三种；主要提供defaultCallbackExecutor()，defaultCallAdapterFactories()，defaultConverterFactories()；
• callFactory：默认是OkHttpClient；
• callbackExecutor：没有设置callbackExecutor()，默认使用Platform的defaultCallbackExecutor()提供的；

Retrofit的Builder类的Builder()；

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

Builder(Platform platform) {
   this.platform = platform;
}

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

   //如果没有通过callFactory()设置，默认使用OkHttpClient；
   okhttp3.Call.Factory callFactory = this.callFactory;
   if (callFactory == null) {
       callFactory = new OkHttpClient();
   }
     
   //callbackExecutor为null,使用platform的defaultCallbackExecutor；
   Executor callbackExecutor = this.callbackExecutor;
   if (callbackExecutor == null) {
       callbackExecutor = platform.defaultCallbackExecutor();
   }

   //回调适配器集合；
   List<CallAdapter.Factory> callAdapterFactories = new ArrayList<>	 (this.callAdapterFactories);

 //转换器集合；   
 callAdapterFactories.addAll(platform.defaultCallAdapterFactories(callbackExecutor));
   List<Converter.Factory> converterFactories = new ArrayList<>(
         1 + this.converterFactories.size() +platform.defaultConverterFactoriesSize());
     
   converterFactories.add(new BuiltInConverters());
   converterFactories.addAll(this.converterFactories);
   converterFactories.addAll(platform.defaultConverterFactories());

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

Retrofit相关类

1）Platform：根据不同的环境，设置不同的参数；

class Platform {
  //单例
  private static final Platform PLATFORM = findPlatform();

  static Platform get() {
    return PLATFORM;
  }
    
  private static Platform findPlatform() {
 	 //Android系统
      Class.forName("android.os.Build");
      if (Build.VERSION.SDK_INT != 0) {
          return new Android();
      }
   
      Class.forName("java.util.Optional");
      return new Java8();
   
      return new Platform();
  }
}

Platform的内部类Android：Android环境；

static class Android extends Platform {

  //Platform提供的默认CallbackExecutor；
  @Override
  public Executor defaultCallbackExecutor() {
    return new MainThreadExecutor();
  }

  //Platform提供的默认CallAdapterFactories；
  @Override
  List<? extends CallAdapter.Factory> defaultCallAdapterFactories(
      @Nullable Executor callbackExecutor) {
   
    //创建executorFactory；
    ExecutorCallAdapterFactory executorFactory = new ExecutorCallAdapterFactory(callbackExecutor);
    return Build.VERSION.SDK_INT >= 24
      ? asList(CompletableFutureCallAdapterFactory.INSTANCE, executorFactory)
      : singletonList(executorFactory);
  }
  
  //Platform提供的默认ConverterFactories；
  @Override
  List<? extends Converter.Factory> defaultConverterFactories() {
    return Build.VERSION.SDK_INT >= 24
        ? singletonList(OptionalConverterFactory.INSTANCE)
        : Collections.<Converter.Factory>emptyList();
  }

  static class MainThreadExecutor implements Executor {
    private final Handler handler = new Handler(Looper.getMainLooper());

    @Override 
    public void execute(Runnable r) {
      handler.post(r);
    }
  }
}

2）Converter：转换器；转换成指定的格式（可以是json，文本等），常用实现类如GsonConverterFactory、ScalarsConverterFactory等；

public interface Converter<F, T> {
  @Nullable
  T convert(F value) throws IOException;


  abstract class Factory {
   //转换Http响应体；
    public @Nullable Converter<ResponseBody, ?> responseBodyConverter(Type type,
        Annotation[] annotations, Retrofit retrofit) {
      return null;
    }
		
    //转换Http请求体；
    public @Nullable Converter<?, RequestBody> requestBodyConverter(Type type,
        Annotation[] parameterAnnotations, Annotation[] methodAnnotations, Retrofit retrofit) {
      return null;
    }

    //转化为String，用于为Field、FieldMap值、Header、HeaderMap、Path、Query和QueryMap值指定的类型创建转换器。
    public @Nullable Converter<?, String> stringConverter(Type type, Annotation[] annotations,
        Retrofit retrofit) {
      return null;
    }
  }
}

3）CallAdapter：回调适配器，将响应的R类型调整为所希望的的T类型；通过Retrofit的addCallAdapterFactory()设置；

**适配器模式（Adapter Pattern）**的定义：将一个类的接口变换成客户端所期待的另一个接口，从而使原本因接口不匹配而无法在一起工作的两个类能够在一起工作。

public interface CallAdapter<R, T> {
  //返回此适配器在将HTTP响应体转换为Java对象时使用的值类型。例如,Call<Repo>的响应类型是Repo;
  Type responseType();
  
  //返回T的实例；
  T adapt(Call<R> call);

   //通过Retrofit的create()方法创建CallAdapter实例；
  abstract class Factory {
  	//返回CallAdapter实例；有可能为null;
    public abstract @Nullable CallAdapter<?, ?> get(Type returnType, Annotation[] annotations, Retrofit retrofit);
  }
}

CallAdapter.Factory的常用的具体实现类

• DefaultCallAdapterFactory的get()：判断getRawType(returnType)是否为Call类
• ExecutorCallAdapterFactory的get()：判断rgetRawType(returnType)是否为Call类
• CompletableFutureCallAdapterFactory的get()：判断getRawType(returnType)是否为CompletableFuture类
• RxJava2CallAdapterFactory的get()：判断getRawType(returnType)是否为Completable类；

以DefaultCallAdapterFactory为例

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

  @Override 
  public @Nullable CallAdapter<?, ?> get(
      Type returnType, Annotation[] annotations, Retrofit retrofit) {
     
    //不是Call类型，就返回null;
    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 call;
      }
    };
  }
}

Demo–可略过

Service的事例：GitHubService类有两种返回值类型；

public interface GitHubService {
    //1)返回类型为Call<?>
    //无需设置addCallAdapterFactory(),使用的是Platform内部类Android提供的默认ExecutorCallAdapterFactory；
    @GET("/hotkey/json")
    Call<Repo> listRepos();
    
    //2)返回值类型为Observable<?>
    //通过addCallAdapterFactory(RxJava2CallAdapterFactory.create())设置；
    @GET("/hotkey/json")
    Observable<String> getRxjava2String();
}

调用

 public void getJson() {
     //创建一个代理对象；
     GitHubService service = retrofit.create(GitHubService.class);
     //调用
     Call<Repo> call = service.listRepos();
     //发起请求
     call.enqueue(new Callback<Repo>() {
         @Override
         public void onResponse(Call<Repo> call, Response<Repo> response) {
             Repo body = response.body();
             Logger.e(body.toString());
         }

         @Override
         public void onFailure(Call<Repo> call, Throwable t) {
         }
     });
 }

public void getRxJava2() {
    GitHubService service = retrofit.create(GitHubService.class);
        Observable<String> observable = service.getRxjava2String();
        observable.subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Observer<String>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        //销毁之后，后续的方法就不在执行；
                        //d.dispose();
                    }

                    @Override
                    public void onNext(String s) {
                        Logger.e(s);
                    }
                    @Override
                    public void onError(Throwable e) {
                    }
                    @Override
                    public void onComplete() {
                    }
                });
}

流程分析

1）Retrofit的create()返回代理类对象;

2）代理对象调用method；

3）发起请求；

Retrofit的create()返回代理类对象;

以下面代码为例

GitHubService service = retrofit.create(GitHubService.class);

Retrofit的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();
        private final Object[] emptyArgs = new Object[0];

        /**
        *invoke():当代理对象调用真实对象的方法时，其会自动的跳转到代理对象关联的handler对象的invoke方法来进行调用
    	* proxy:　 指代我们所代理的那个真实对象
    	* method:　指代的是我们所要调用真实对象的某个方法的Method对象
      	* args:　　指代的是调用真实对象某个方法时接受的参数
     	*/
        @Override 
        public Object invoke(Object proxy, Method method, @Nullable Object[] args)
            throws Throwable {
          
          //getDeclaringClass():得到目标方法所在类对应的Class对象;
          if (method.getDeclaringClass() == Object.class) {//是否为Object对象；
            return method.invoke(this, args);
          }
          //是否为默认方法；
          if (platform.isDefaultMethod(method)) {
            return platform.invokeDefaultMethod(method, service, proxy, args);
          }
          //调用ServiceMethod的invoke();
          return loadServiceMethod(method).invoke(args != null ? args : emptyArgs);
        }
      });
}

代理对象调用method

以下面代码为例

Call<String> call = service.getString();

InvocationHandler的invoke()：当代理对象调用真实对象的方法时，其会自动的跳转到代理对象关联的handler对象的invoke方法来进行调用；

Retrofit的 loadServiceMethod()

//ConcurrentHashMap:key是某个方法的Method对象，value是
private final Map<Method, ServiceMethod<?>> serviceMethodCache = new ConcurrentHashMap<>();

ServiceMethod<?> loadServiceMethod(Method method) {
  ServiceMethod<?> result = serviceMethodCache.get(method);
  if (result != null) return result;

  synchronized (serviceMethodCache) {
    result = serviceMethodCache.get(method);
    if (result == null) {
      //当value为null时，创建一个ServiceMethod；
      result = ServiceMethod.parseAnnotations(this, method);
      serviceMethodCache.put(method, result);
    }
  }
  return result;
}

ServiceMethod的parseAnnotations()主要做两件事；1） RequestFactory.parseAnnotations()解析method的注解，在RequestFactory的parseAnnotations()中操作，返回一个requestFactory对象；2）HttpServiceMethod.parseAnnotations()选择对应的callAdapter和converter。注请求方法的注解解析省略，具体细节，可自行研究。

static <T> ServiceMethod<T> parseAnnotations(Retrofit retrofit, Method method) {
  //解析方法的注解
  RequestFactory requestFactory = RequestFactory.parseAnnotations(retrofit, method);
  
  //返回ServiceMethod对象；
  return HttpServiceMethod.parseAnnotations(retrofit, method, requestFactory);
}

HttpServiceMethod的parseAnnotations()这个方法主要做了两件事；1）createCallAdapter()根据method方法返回值类型的原始类，Retrofit的nextCallAdapter()方法从callAdapterFactories集合中找打对应的CallAdapter实现类；2）根据responseType，在Retrofit的nextResponseBodyConverter()方法从converterFactories集合找到对应的Converter的实现类；

static <ResponseT, ReturnT> HttpServiceMethod<ResponseT, ReturnT> parseAnnotations(
    Retrofit retrofit, Method method, RequestFactory requestFactory) {
  
  //根据method方法返回值类型的原始类，在Retrofit的nextCallAdapter()方法从callAdapterFactories集合中找打对应的CallAdapter的实现类；
  CallAdapter<ResponseT, ReturnT> callAdapter = createCallAdapter(retrofit, method);
  Type responseType = callAdapter.responseType();
 
  //根据responseType，在Retrofit的nextResponseBodyConverter()方法从converterFactories集合找到对应的Converter的实现类；
  Converter<ResponseBody, ResponseT> responseConverter =
      createResponseConverter(retrofit, method, responseType);

  okhttp3.Call.Factory callFactory = retrofit.callFactory;
  //返回HttpServiceMethod对象；
  return new HttpServiceMethod<>(requestFactory, callFactory, callAdapter, responseConverter);
}

Retrofit的nextCallAdapter()：根据method方法返回值类型returnType的原始类，找到CallAdapter；否则会报异常；

public CallAdapter<?, ?> nextCallAdapter(@Nullable CallAdapter.Factory skipPast, Type returnType,Annotation[] annotations) {
 
  int start = callAdapterFactories.indexOf(skipPast) + 1;
  //根据method方法返回值类型returnType的原始类，找到CallAdapter；
  for (int i = start, count = callAdapterFactories.size(); i < count; i++) {
    CallAdapter<?, ?> adapter = callAdapterFactories.get(i).get(returnType, annotations, this);
    if (adapter != null) {
      return adapter;
    }
  }
}

Retrofit的nextResponseBodyConverter()：根据responseType找到converter；否则会报异常；

public <T> Converter<T, RequestBody> nextRequestBodyConverter(
    @Nullable Converter.Factory skipPast, Type type, Annotation[] parameterAnnotations,
    Annotation[] methodAnnotations) {
 
  int start = converterFactories.indexOf(skipPast) + 1;
  //找到converter，否则报异常；
  for (int i = start, count = converterFactories.size(); i < count; i++) {
    Converter.Factory factory = converterFactories.get(i);
    Converter<?, RequestBody> converter =
        factory.requestBodyConverter(type, parameterAnnotations, methodAnnotations, this);
    if (converter != null) {
      return (Converter<T, RequestBody>) converter;
    }
  }
}

HttpServiceMethod的invoke()，callAdapter由Retrofit的nextCallAdapter()获取的；

@Override 
ReturnT invoke(Object[] args) {
  return callAdapter.adapt(
      new OkHttpCall<>(requestFactory, args, callFactory, responseConverter));
}

以ExecutorCallAdapterFactory为例，ExecutorCallAdapterFactory的get()方法为例，返回CallAdapter对象；CallAdapter的adapt()方法，返回的是Call的实现类ExecutorCallbackCall；但是adapt()方法的参数call是OkHttpCall的实例；

@Override 
public @Nullable 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;
    }

    //参数call是OkHttpCall的实例；
    @Override 
    public Call<Object> adapt(Call<Object> call) {
      return new ExecutorCallbackCall<>(callbackExecutor, call);
    }
  };
}

也可以自行分析以RxJava2CallAdapterFactory为例，RxJava2CallAdapterFactory的get()方法；

发起请求

Retrofit的Call接口和OkHttp3的Call方法基本一致；execute()同步请求，enqueue()异步请求；OkHttpCall是Call的实现类；

以下面的代码为例；

call.enqueue(new Callback<String>() {
	@Override
	public void onResponse(Call<String> call, Response<String> response) {           
	}
    @Override
    public void onFailure(Call<String> call, Throwable t) {
    }
});

从上面分析可知，获取的call实例是ExecutorCallAdapterFactory内部类ExecutorCallbackCall实例，看下其enqueue()方法。主要是调用OkHttpCall的enqueue()，在网络请求响应之后，在onResponse()或onFailure()方法通过线程池callbackExecutor回调Callback的onResponse()或onFailure()方法；

final Executor callbackExecutor;
//delegate是OkHttpCall实例；
final Call<T> delegate;

@Override 
public void enqueue(final Callback<T> callback) {
  //调用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()) {
            callback.onFailure(ExecutorCallbackCall.this, new IOException("Canceled"));
          } else {
            //回调onResponse();
            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);
        }
      });
    }
  });
}

OkHttpCall的enqueue()，Retrofit真正发送请求的地方；主要做两件事；1）通过OkHttpClient的newCall()获取RealCall；2）调用RealCall的enqueue();进而调用Dispatcher的enqueue()方法；剩下的执行流程有OkHttp来执行，具体可阅读OkHttp3源码分析；

@Override 
public void enqueue(final Callback<T> callback) {
  okhttp3.Call call;
  Throwable failure;

  synchronized (this) {
    call = rawCall;
    failure = creationFailure;
    //通过OkHttpClient的newCall()获取RealCall；
    if (call == null && failure == null) {
       call = rawCall = createRawCall();
    }
  }
 
  //请求被取消；
  if (canceled) {
    call.cancel();
  }
  //call为RealCall的实例，调用RealCall的enqueue();进而调用Dispatcher的enqueue()方法；
  call.enqueue(new okhttp3.Callback() {
    @Override 
    public void onResponse(okhttp3.Call call, okhttp3.Response rawResponse) {
      Response<T> response;
      try {
        //解析response;
        response = parseResponse(rawResponse);
      } catch (Throwable e) {
        callFailure(e);
        return;
      }
      //回调onResponse();
      callback.onResponse(OkHttpCall.this, response);
    }

    @Override 
    public void onFailure(okhttp3.Call call, IOException e) {
      callFailure(e);
    }
	//回调onFailure()方法；
    private void callFailure(Throwable e) {
       callback.onFailure(OkHttpCall.this, e);
    }
  });
}

到此，Retrofit的整体执行流程分析完了，没有太过于关注细节问题，部分内容可自行深入了解。如有问题，请多指教，谢谢。