Retrofit源码解析

Posted 流云易采

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Retrofit源码解析相关的知识,希望对你有一定的参考价值。

square公司开源了一系列的优秀库,比如Retrofit,OkHttp,Picasso等,
前面简单分析了Picasso的源码,这里来分析下Retrofit的使用:

一、gradle添加依赖

compile 'com.squareup.okhttp:okhttp:2.4.0'
compile 'com.squareup.okhttp:okhttp-urlconnection:2.4.0'
compile 'com.squareup.okio:okio:1.5.0'
compile 'com.google.code.gson:gson:2.2.4'

compile 'com.squareup.retrofit:retrofit:2.0.0-beta2'
compile 'com.squareup.retrofit:adapter-rxjava:2.0.0-beta2'
compile 'com.squareup.retrofit:converter-gson:2.0.0-beta2'

compile 'io.reactivex:rxandroid:1.1.0'
compile 'io.reactivex:rxjava:1.1.0'

盗两张网上的图:
下面是从创建Retrofit出发,具体的使用流程;Retrofit最终的请求操作都是交由okHttp去执行的,执行的结果返回Response,再根据转换器进行解析成相对应的返回类型T;
Retrofit中使用了动态代理,方便了使用;通过retrofit.create返回的其实是个动态代理类,所有具体的处理逻辑交由MethodHandler进行处理;

下面是Retrofit系统中的整个类图,有点像外观模式,Retrofit持有所有子系统的引用;Retrofit比较重要的是两个Factory,一个使用来生成CallAdapter的CallAdapterFactory;一个是用来转换结果的ConvertFactory;这两个都可以用户自己进行添加。
在自定义的Service中,每一个method对应一个MethodHandler,MethodHandler持有retrofit,前面两个Factory以及生成Request的RequestFactory;在okHttp中,Request需要自己进行定义创建,而Retrofit简化了这个操作,进行了相应的封装,使用注解的方式来定义Request的相关参数信息;注解信息的解析则在RequestFactory中完成,通过RequestFactoryParser对注解信息进行简单解析,RequestBuilderAction是解析method中参数中的注解如@Path这些产生的中间产物,最终通过RequestBuilder来具体产生一个Request,RequestBuilder中持有okHttp中的Request.Builder类的引用,其创建Request过程其实都是交给okHttp来操作的;
生成的Request最终封装成为一个OkHttpCall,OkHttpCall则可以看做是对okHttp中Call的通过,它的enqueue等网络请求操作都是委托个给okHttp来操作的;同时对okHttp的返回Response进行解析,使用convertFactory,将其解析为用户所期望的返回类型;

二、使用

(一)使用Call形式

1、定义请求接口:

public interface RetrofirHttpService 
    @GET("user")
    Call<UserInfo> getData(@Path("user") String user);

注:UserInfo是自己定义的解析类:
public class UserInfo 
    String username;
    String password;

2、使用GET获取信息:

// 原始的CallBack方式
private void getUseCall() 
    // 添加拦截器
    OkHttpClient client = new OkHttpClient();
    client.interceptors().add(new LoggingInterceptor());

    Retrofit retrofit = new Retrofit.Builder()
            .baseUrl("http://115.156.187.146/TransferServer/")
            .client(client)                                     // 添加okHttp
            .addConverterFactory(GsonConverterFactory.create()) // GSON进行转换
            .build();
    RetrofirHttpService apiStores = retrofit.create(RetrofirHttpService.class);
    Call<UserInfo> call = apiStores.getData("ServerMain.php");

    // 异步调用
    call.enqueue(new Callback<UserInfo>() 
        @Override
        public void onResponse(Response<UserInfo> response, Retrofit retrofit) 
            UserInfo data = response.body();
            LogUtils.i("Call Result:" + data.m);
        

        @Override
        public void onFailure(Throwable t) 
            LogUtils.e(t.toString());
        
    );

(二)使用RxJava形式

1、定义请求接口

public interface RxHttpService 
    @GET("path")
    Observable<UserInfo> getData(@Path("path") String path);

2、具体使用

// 使用RxJava方式
private void getUseRxJava() 
    // 添加拦截器
    OkHttpClient client = new OkHttpClient();
    client.interceptors().add(new LoggingInterceptor());

    Retrofit retrofit = new Retrofit.Builder()
            .baseUrl("http://115.156.187.146/TransferServer/")
            .client(client)  // 添加okHttp
            .addConverterFactory(GsonConverterFactory.create()) // GSON进行转换
            .addCallAdapterFactory(RxJavaCallAdapterFactory.create())
            .build();

    RxHttpService apiStores = retrofit.create(RxHttpService.class);
    Observable<UserInfo> observable = apiStores.getData("ServerMain.php");
    observable.subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(new Observer<UserInfo>() 
                @Override
                public void onNext(UserInfo user) 
                    LogUtils.i("Call Result:" + user.m);
                

                @Override
                public void onCompleted() 
                

                @Override
                public void onError(Throwable error) 
                    LogUtils.e(error.toString());
                
            );

三、源码分析:

(一)先来看创建动态代理类的过程:

RxHttpService apiStores = retrofit.create(RxHttpService.class);

动态代理的知识具体见《 设计模式汇总:结构型模型(上)》中的代理模式中的解释。

1)Retrofit#create:

/** Create an implementation of the API defined by the @code service interface. */
@SuppressWarnings("unchecked") // Single-interface proxy creation guarded by parameter safety.
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();

                @Override
                public Object invoke(Object proxy, Method method, 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);
                    
                    return loadMethodHandler(method).invoke(args);
                
            );

标准的动态代理创建过程;
来看代理类和委托类之间的中间InvocationHandler类的invoke函数具体执行逻辑;
loadMethodHandler(method).invoke(args);

2)Retrofit#loadMethodHandler:

private final Map<Method, MethodHandler<?>> methodHandlerCache = new LinkedHashMap<>();

MethodHandler<?> loadMethodHandler(Method method) 
    MethodHandler<?> handler;
    synchronized (methodHandlerCache) 
        handler = methodHandlerCache.get(method);
        if (handler == null) 
            handler = MethodHandler.create(this, method);
            methodHandlerCache.put(method, handler);
        
    
    return handler;

Retrofit维护了一个method对应的Map,这里将method都封装成一个MethodHandler类(可以当作是委托类);调用代理类,其实就是调用MethodHandler的invoke;所以具体的实现逻辑都在MethodHandler中;

(二)MethodHanlder

1)MethodHandler类:

final class MethodHandler<T> 
    // MethodHandler持有一个retrofit对象
    private final Retrofit retrofit;
    // 类似于Volley中的 Request ,包含了HTTP请求的Url、Header信息,MediaType、Method以及RequestAction数组
    private final RequestFactory requestFactory;
    // HTTP请求返回数据的类型
    private final CallAdapter<T> callAdapter;
    // 对返回数据进行转换的类型转换器
    private final Converter<ResponseBody, T> responseConverter;

    private MethodHandler(Retrofit retrofit, RequestFactory requestFactory,
                          CallAdapter<T> callAdapter, Converter<ResponseBody, T> responseConverter) 
        this.retrofit = retrofit;
        this.requestFactory = requestFactory;
        this.callAdapter = callAdapter;
        this.responseConverter = responseConverter;
    

    // 每一次请求的最终具体调用的函数
    Object invoke(Object... args) 
        // 可以发现最终是调用callAdapter的adapt函数
        // 并且将相应的请求事务封装成一个OkHttpCall类进行处理
        return callAdapter.adapt(new OkHttpCall<>(retrofit, requestFactory, responseConverter, args));
    

    // 调用该静态类创建一个MethodHandler实例
    @SuppressWarnings("unchecked")
    static MethodHandler<?> create(Retrofit retrofit, Method method) 
        // 创建CallAdapter
        CallAdapter<Object> callAdapter = (CallAdapter<Object>) createCallAdapter(method, retrofit);
        // 根据callAdapter来获取相应的返回类型
        Type responseType = callAdapter.responseType();
        // 创建结果类型转换器
        Converter<ResponseBody, Object> responseConverter =
                (Converter<ResponseBody, Object>) createResponseConverter(method, retrofit, responseType);
        // 创建RequestFactory
        RequestFactory requestFactory = RequestFactoryParser.parse(method, responseType, retrofit);
        return new MethodHandler<>(retrofit, requestFactory, callAdapter, responseConverter);
    

    // 创建相应的CallAdapter
    private static CallAdapter<?> createCallAdapter(Method method, Retrofit retrofit) 
        // 这个method即为service中自定义的一个方法,一般返回都是泛型类
        Type returnType = method.getGenericReturnType();
        if (Utils.hasUnresolvableType(returnType)) 
            throw Utils.methodError(method,
                    "Method return type must not include a type variable or wildcard: %s", returnType);
        
        if (returnType == void.class) 
            throw Utils.methodError(method, "Service methods cannot return void.");
        
        // 获取Method上对应的注解即(GET这些)
        Annotation[] annotations = method.getAnnotations();
        try 
            // 根据注解来获取相应的Adapter
            return retrofit.callAdapter(returnType, annotations);
         catch (RuntimeException e)  // Wide exception range because factories are user code.
            throw Utils.methodError(e, method, "Unable to create call adapter for %s", returnType);
        
    

    // 最后也是调用retrofit来实现的;
    private static Converter<ResponseBody, ?> createResponseConverter(Method method,
                                                                      Retrofit retrofit, Type responseType) 
        Annotation[] annotations = method.getAnnotations();
        try 
            return retrofit.responseConverter(responseType, annotations);
         catch (RuntimeException e)  // Wide exception range because factories are user code.
            throw Utils.methodError(e, method, "Unable to create converter for %s", responseType);
        
    

MethodHandler是系统为定义的每一个Service中的method中创建的一个具体执行类,通过调用其invoke函数,来执行具体的请求的逻辑;
它主要包含四个变量:
Retrofit: MethodHandler持有一个retrofit对象
private final Retrofit retrofit;
RequestFactory: 类似于Volley中的 Request ,包含了HTTP请求的Url、Header信息,MediaType、Method以及RequestAction数组
private final RequestFactory requestFactory;
CallAdapter: HTTP请求返回数据的类型
private final CallAdapter<T> callAdapter;
ResponseConverter: 对返回数据进行转换的类型转换器
private final Converter<ResponseBody, T> responseConverter;
具体来看每个变量的创建;

2)Retrofit#callAdapter:

private final List<CallAdapter.Factory> adapterFactories;

public CallAdapter<?> callAdapter(Type returnType, Annotation[] annotations) 
    return nextCallAdapter(null, returnType, annotations);

/**
 * Returns the @link CallAdapter for @code returnType from the available @linkplain
 * #callAdapterFactories() factories except @code skipPast.
 */
// 返回相关的可用的CallAdapter(除了指定跳过的skipPast)
public CallAdapter<?> nextCallAdapter(CallAdapter.Factory skipPast, Type returnType,
                                      Annotation[] annotations) 
    checkNotNull(returnType, "returnType == null");
    checkNotNull(annotations, "annotations == null");

    int start = adapterFactories.indexOf(skipPast) + 1;
    // 遍历adapterFactories中所有的Factory
    for (int i = start, count = adapterFactories.size(); i < count; i++) 
        CallAdapter<?> adapter = adapterFactories.get(i).get(returnType, annotations, this);
        // 如果找到,则返回该Adapter
        if (adapter != null) 
            return adapter;
        
    

    // 如果获取不到相应的CallAdapter,则抛出异常
    StringBuilder builder = new StringBuilder("Could not locate call adapter for ")
            .append(returnType)
            .append(". Tried:");
    for (int i = start, count = adapterFactories.size(); i < count; i++) 
        builder.append("\\n * ").append(adapterFactories.get(i).getClass().getName());
    
    if (skipPast != null) 
        builder.append("\\nSkipped:");
        for (int i = 0; i < start; i++) 
            builder.append("\\n * ").append(adapterFactories.get(i).getClass().getName());
        
    
    throw new IllegalArgumentException(builder.toString());

RetroFit中有一个adapterFactories保存了所有CallAdapter.Factory,通过遍历这些factory来获取相应符合的CallAdapter;
先来看adapterFactories都保存了哪些Factory;从Retrofit创建开始

(三)Retrofit的创建

private final OkHttpClient client;
private final BaseUrl baseUrl;
private final List<Converter.Factory> converterFactories;
private final List<CallAdapter.Factory> adapterFactories;
private final Executor callbackExecutor;
private final boolean validateEagerly;

private Retrofit(OkHttpClient client, BaseUrl baseUrl, List<Converter.Factory> converterFactories,
                 List<CallAdapter.Factory> adapterFactories, Executor callbackExecutor,
                 boolean validateEagerly) 
    this.client = client;
    this.baseUrl = baseUrl;
    this.converterFactories = converterFactories;
    this.adapterFactories = adapterFactories;
    this.callbackExecutor = callbackExecutor;
    this.validateEagerly = validateEagerly;


/** Create the @link Retrofit instances. */
public Retrofit build() 
    if (baseUrl == null) 
        throw new IllegalStateException("Base URL required.");
    

    // 默认使用OkhttpClient
    OkHttpClient client = this.client;
    if (client == null) 
        client = new OkHttpClient();
    

    // 向adapterFactories添加了一个默认的CallAdapterFactory
    // 如果前面add了CallAdpterfactory(如RxJavaCallAdapterFactory),则可以看到默认的Factory会添加到用户指定的Factory后面
    // 则在遍历的时候,会优先遍历用户指定的Factory
    List<CallAdapter.Factory> adapterFactories = new ArrayList<>(this.adapterFactories);
    adapterFactories.add(Platform.get().defaultCallAdapterFactory(callbackExecutor));

    // Make a defensive copy of the converters.
    List<Converter.Factory> converterFactories = new ArrayList<>(this.converterFactories);

    return new Retrofit(client, baseUrl, converterFactories, adapterFactories, callbackExecutor,
            validateEagerly);




/**
 * 用户添加自定义的CallAdapterFactory
 */
public Builder addCallAdapterFactory(CallAdapter.Factory factory) 
    adapterFactories.add(checkNotNull(factory, "factory == null"));
    return this;

用户可以根据自己需要来添加自定义的CallAdapterFactory,这里来看系统默认的CallAdapterFactory;
Platform.get()是根据系统不同来创建不同的运行环境,比如是再Android上还是Java上运行时由区别的,如下所示:

1)Platform:

class Platform 
    private static final Platform PLATFORM = findPlatform();

    static Platform get() 
        return PLATFORM;
    

    private static Platform findPlatform() 
        // 如果是Android系统
        try 
            Class.forName("android.os.Build");
            if (Build.VERSION.SDK_INT != 0) 
                return new Android();
            
         catch (ClassNotFoundException ignored) 
        
        // 如果是Java系统
        try 
            Class.forName("java.util.Optional");
            return new Java8();
         catch (ClassNotFoundException ignored) 
        
        // 如果是其他系统
        return new Platform();
    

    static class Android extends Platform 
        // 创建默认的CallAdapterFactory过程
        @Override CallAdapter.Factory defaultCallAdapterFactory(Executor callbackExecutor) 
            if (callbackExecutor == null) 
                // 如果没有指定callbackExecutor,或者为null,则新创建一个MainThreadExecutor
                callbackExecutor = new MainThreadExecutor();
            
            return new ExecutorCallAdapterFactory(callbackExecutor);
        

        // 该Executor的主要工作逻辑就是调用主线程的Looper来创建一个对应的Handler
        // 执行execute就是操作Handler进行post事件(Runnable)
        static class MainThreadExecutor implements Executor 
            private final Handler handler = new Handler(Looper.getMainLooper());

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

可以看到对应不同的系统平台,Retrofit提供了不同的Platform版本; 默认的CallAdapterFactory是个ExecutorCallAdapterFactory,它是通过callbackExecutor来创建的;
如果用户没有执行相应的callbackExecutor,系统或创建一个默认的MainThreadExecutor,该MainThreadExecutor的主要执行逻辑就是使用主线程的Handler来post Runnable消息;
然后Retrofit把ExecutorCallAdapterFactory实例添加到adapterFactories中;

2)继续前面MethodHandler的查找CallAdapter的逻辑:

CallAdapter<?> adapter = adapterFactories.get(i).get(returnType, annotations, this);
final class ExecutorCallAdapterFactory implements CallAdapter.Factory 
    private final Executor callbackExecutor;

    ExecutorCallAdapterFactory(Executor callbackExecutor) 
        this.callbackExecutor = callbackExecutor;
    

    @Override
    public CallAdapter<Call<?>> get(Type returnType, Annotation[] annotations, Retrofit retrofit) 
        // 根据returnType获得具体的返回类型
        if (Utils.getRawType(returnType) != Call.class) 
            return null;
        
        final Type responseType = Utils.getCallResponseType(returnType);
        // 返回一个CallAdapter
        return new CallAdapter<Call<?>>() 
            @Override
            public Type responseType() 
                return responseType;
            

            // 调用adapt返回一个ExecutorCallbackCall类
            @Override
            public <R> Call<R> adapt(Call<R> call) 
                return new ExecutorCallbackCall<>(callbackExecutor, call);
            
        ;
    

将前面所有的逻辑串在一起,使用动态代理创建的代理类使用的InvokeHandler,调用其invoke来实现一个具体的方法调用;委托类是系统自定义创建的MethodHandler,系统根据method来创建相应的MethodHandler;MethodHandler中持有对CallAdapter的引用,CallAdapter是通过相应的CallAdpterFactory来创建的,如果加入了自定义的比如RxJava,最终会添加到Retrofit中的一个factory链表中,系统通过扫描链表来获取合适的CallAdpterFactory来创建CallAdapter;
如果没有自定义CallAdapterFactory,则会默认生成一个CallAdapterFactory;通过这个默认的Factory会创建一个默认的CallAdapter;
代理类的方法实现,是通过InvokeHandler的invoke来实现的;在系统定义的Invokehandler中进而调用MethodHandler的invoke函数,该invoke函数会继续调用CallAdpter的adapt,由上知,最终返回一个ExecutorCallbackCall类;

继续来看ExecutorCallbackCall类:

3)ExecutorCallbackCall类:

final class ExecutorCallAdapterFactory implements CallAdapter.Factory 
    static final class ExecutorCallbackCall<T> implements Call<T> 
        private final Executor callbackExecutor;
        private final Call<T> delegate;

        // 注意这里的Call传递进来的是一个封装好的OkHttpCall类
        ExecutorCallbackCall(Executor callbackExecutor, Call<T> delegate) 
            this.callbackExecutor = callbackExecutor;
            this.delegate = delegate;
        

        @Override public void enqueue(Callback<T> callback) 
            delegate.enqueue(new ExecutorCallback<>(callbackExecutor, callback));
        

        @Override public Response<T> execute() throws IOException 
            return delegate.execute();
        

        @Override public void cancel() 
            delegate.cancel();
        

        @SuppressWarnings("CloneDoesntCallSuperClone") // Performing deep clone.
        @Override public Call<T> clone() 
            return new ExecutorCallbackCall<>(callbackExecutor, delegate.clone());
        
    

    static final class ExecutorCallback<T> implements Callback<T> 
        private final Executor callbackExecutor;
        private final Callback<T> delegate;

        ExecutorCallback(Executor callbackExecutor, Callback<T> delegate) 
            this.callbackExecutor = callbackExecutor;
            this.delegate = delegate;
        

        @Override public void onResponse(final Response<T> response, final Retrofit retrofit) 
            callbackExecutor.execute(new Runnable() 
                @Override public void run() 
                    delegate.onResponse(response, retrofit);
                
            );
        

        @Override public void onFailure(final Throwable t) 
            callbackExecutor.execute(new Runnable() 
                @Override public void run() 
                    delegate.onFailure(t);
                
            );
        
    

可以看出来ExecutorCallbackCall也是一个代理类,它的委托类是OkHttpCall;所以使用默认的CallAdapterFactory返回的是一个封装了OkHttpCall的一个Call类,其具体的类型是ExecutorCallbackCall;

4)OkHttpCall:

final class OkHttpCall<T> implements Call<T> 
    private final Retrofit retrofit;
    private final RequestFactory requestFactory;
    private final Converter<ResponseBody, T> responseConverter;
    private final Object[] args;

    private volatile com.squareup.okhttp.Call rawCall;
    private boolean executed; // Guarded by this.
    private volatile boolean canceled;

    OkHttpCall(Retrofit retrofit, RequestFactory requestFactory,
               Converter<ResponseBody, T> responseConverter, Object[] args) 
        this.retrofit = retrofit;
        this.requestFactory = requestFactory;
        this.responseConverter = responseConverter;
        this.args = args;
    

    @SuppressWarnings("CloneDoesntCallSuperClone")
    // We are a final type & this saves clearing state.
    @Override
    public OkHttpCall<T> clone() 
        return new OkHttpCall<>(retrofit, requestFactory, responseConverter, args);
    

来看enqueue操作;在用户代码中:

call.enqueue(new Callback<UserInfo>() 
    @Override
    public void onResponse(Response<UserInfo> response, Retrofit retrofit) 
        UserInfo data = response.body();
        LogUtils.i("Call Result:" + data.m);
    

    @Override
    public void onFailure(Throwable t) 
        LogUtils.e(t.toString());
    
);

由前面知这里的Call对应的是一个ExecutorCallbackCall,来看起enqueue操作:

5)ExecutorCallbackCall#enqueue:

@Override 
public void enqueue(Callback<T> callback) 
    delegate.enqueue(new ExecutorCallback<>(callbackExecutor, callback));

delegate对应的即是OkHttpCall,先来看其enqueue传入的参数: ExecutorCallback

static final class ExecutorCallback<T> implements Callback<T> 
    private final Executor callbackExecutor;
    private final Callback<T> delegate;

    ExecutorCallback(Executor callbackExecutor, Callback<T> delegate) 
        this.callbackExecutor = callbackExecutor;
        this.delegate = delegate;
    

    @Override
    public void onResponse(final Response<T> response, final Retrofit retrofit) 
        callbackExecutor.execute(new Runnable() 
            @Override
            public void run() 
                delegate.onResponse(response, retrofit);
            
        );
    

    @Override
    public void onFailure(final Throwable t) 
        callbackExecutor.execute(new Runnable() 
            @Override public void run() 
                delegate.onFailure(t);
            
        );
    

ExecutorCallback也是一个代理类,用来封装用户定义的Callback,即类内部的变量delegate;callbackExecutor是查找Platform过程中new Android时创建的,其execute的逻辑较为简单,就是使用主线程对应的Handler来将Runnable事件post出去;可以看到,这里最终的响应都会在主线程中,而且调用用户自定义的onResponse和onFailure;
ExecutorCallback的主要作用就是封装Callback,将Callback的响应切换到主线程中;

6)继续来看对应的OkHttpCall的enqueue操作:

@Override
public void enqueue(final Callback<T> callback) 
    synchronized (this) 
        if (executed) throw new IllegalStateException("Already executed");
        executed = true;
    

    // 注意okHttp的call和retrofit的Call是不同
    com.squareup.okhttp.Call rawCall;
    try 
        // 创建一个okhttp类型的Call
        rawCall = createRawCall();
     catch (Throwable t) 
        callback.onFailure(t);
        return;
    
    // 如果取消
    if (canceled) 
        rawCall.cancel();
    
    this.rawCall = rawCall;

    // 将Call中事务全部委托给okHttp来操作
    // 调用okHttp的enqueue,使用okHttp的Callback来封装retrofit中的Callback
    rawCall.enqueue(new com.squareup.okhttp.Callback() 
        // 请求失败的响应
        private void callFailure(Throwable e) 
            try 
                callback.onFailure(e);
             catch (Throwable t) 
                t.printStackTrace();
            
        
        // 请求成功的响应
        private void callSuccess(Response<T> response) 
            try 
                callback.onResponse(response, retrofit);
             catch (Throwable t) 
                t.printStackTrace();
            
        

        @Override
        public void onFailure(Request request, IOException e) 
            callFailure(e);
        

        @Override
        public void onResponse(com.squareup.okhttp.Response rawResponse) 
            Response<T> response;
            try 
                // 获得结果,并且解析结果
                response = parseResponse(rawResponse);
             catch (Throwable e) 
                callFailure(e);
                return;
            
            callSuccess(response);
        
    );

OkHttpCall是对OkHttp里面的Call的封装,将所有的操作都委托给该Call进行操作;这里主要的是通过retrofit的call来创建一个okHttp的Call类;这里通过createRawCall来创建:

private com.squareup.okhttp.Call createRawCall() 
  return retrofit.client().newCall(requestFactory.create(args));

这里是通过okHttpClient来创建的一个Call;首先来看 requestFactory是如何根据args参数来创建一个相应的Call的;
先来看requestFactory,它是MethodHandler中创建传递过来的;
RequestFactory requestFactory = RequestFactoryParser.parse(method, responseType, retrofit);

(四)RequestFactory:

final class RequestFactoryParser 
    private final Method method;

    static RequestFactory parse(Method method, Type responseType, Retrofit retrofit) 
        RequestFactoryParser parser = new RequestFactoryParser(method);
        // Method对应的注解这里解析
        parser.parseMethodAnnotations(responseType);
        parser.parseParameters(retrofit);
        // 创建一个RequestFactory
        return parser.toRequestFactory(retrofit.baseUrl());
    

    private RequestFactoryParser(Method method) 
        this.method = method;
    

RequestFactoryParser主要是根据method对应的注解及返回类型进行相应解析,得出相应的解析结果,然后创建一个RequestFactory来保存所有解析后结果,供创建OkHttpCall来使用。

<一>parseMethodAnnotations:

1)RequestFactoryParser#parseMethodAnnotations:

// 这里是对注解进行解析的核心代码
// 根据注解类型的不同(即请求类型类型的不同进行相应解析)
// 这里也对应的retrofit的基本用法
private void parseMethodAnnotations(Type responseType) 
    for (Annotation annotation : method.getAnnotations()) 
        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);
            if (!Void.class.equals(responseType)) 
                throw methodError(method, "HEAD method must use Void as response type.");
            
         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);
         else if (annotation instanceof HTTP) 
            HTTP http = (HTTP) annotation;
            parseHttpMethodAndPath(http.method(), http.path(), http.hasBody());
         else if (annotation instanceof Headers) 
            // 只有Headers是通过parseHeaders来解析的
            String[] headersToParse = ((Headers) annotation).value();
            if (headersToParse.length == 0) 
                throw methodError(method, "@Headers annotation is empty.");
            
            headers = parseHeaders(headersToParse);
         else if (annotation instanceof Multipart) 
            // 可以看到Multipart和FormUrlEncoded不能同时定义
            if (isFormEncoded) 
                throw methodError(method, "Only one encoding annotation is allowed.");
            
            isMultipart = true;
         else if (annotation instanceof FormUrlEncoded) 
            if (isMultipart) 
                throw methodError(method, "Only one encoding annotation is allowed.");
            
            isFormEncoded = true;
        
    

    if (httpMethod == null) 
        throw methodError(method, "HTTP method annotation is required (e.g., @GET, @POST, etc.).");
    
    // 如果不存在实体,但是用户定义为isMultipart或者isFormEncoded类型,则会抛出异常
    if (!hasBody) 
        if (isMultipart) 
            throw methodError(method,
                    "Multipart can only be specified on HTTP methods with request body (e.g., @POST).");
        
        if (isFormEncoded) 
            throw methodError(method,
                    "FormUrlEncoded can only be specified on HTTP methods with request body "
                            + "(e.g., @POST).");
        
    

这里是对注解进行解析的核心代码 ,根据注解类型的不同(即请求类型类型的不同) 进行相应解析,这里也对应的retrofit的基本用法;
可以看到除了headers使用的parseheader进行解析外,其他都是通过 parseHttpMethodAndPath进行解析的;这里来重点分析下parseHttpMethodAndPath;

2)parseHttpMethodAndPath:

// 这个函数只是先做了一个前期判断
private void parseHttpMethodAndPath(String httpMethod, String value, boolean hasBody) 
    if (this.httpMethod != null) 
        throw methodError(method, "Only one HTTP method is allowed. Found: %s and %s.",
                this.httpMethod, httpMethod);
    
    // 对应"GET","POST"等
    this.httpMethod = httpMethod;
    // 标注有没有实体
    this.hasBody = hasBody;

    // 注解值为空直接返回
    if (value.isEmpty()) 
        return;
    

    // 判断URL是否已经有查询字符串query string
    // Get the relative URL path and existing query string, if present.
    int question = value.indexOf('?');
    if (question != -1 && question < value.length() - 1) 
        // 保证URL的查询字符串中没有...之类的字符
        // Ensure the query string does not have any named parameters.
        String queryParams = value.substring(question + 1);
        Matcher queryParamMatcher = PARAM_URL_REGEX.matcher(queryParams);
        if (queryParamMatcher.find()) 
            throw methodError(method, "URL query string \\"%s\\" must not have replace block. "
                    + "For dynamic query parameters use @Query.", queryParams);
        
    

    // 具体的解析继续由parsePathParameters来完成
    this.relativeUrl = value;
    this.relativeUrlParamNames = parsePathParameters(value);

这个函数仅是做了一个简单的前期判断,将method对应的请求类型(httpMethod) ,注解值(relativeUrl),以及是否包含实体信息(hasBody)赋值给该RequestFactoryParser;
来看POST和GET的简单调用实例:
parseHttpMethodAndPath("GET", ((GET) annotation).value(), false);
parseHttpMethodAndPath("POST", ((POST) annotation).value(), true);
继续来看解析函数parsePathParameters :

private static final String PARAM = "[a-zA-Z][a-zA-Z0-9_-]*";
private static final Pattern PARAM_NAME_REGEX = Pattern.compile(PARAM);
private static final Pattern PARAM_URL_REGEX = Pattern.compile("\\\\(" + PARAM + ")\\\\");
/**
 * Gets the set of unique path parameters used in the given URI. If a parameter is used twice
 * in the URI, it will only show up once in the set.
 */
// 检测出路径中所有..的字段,如user等,添加到一个Set中(因此不会重复添加)
static Set<String> parsePathParameters(String path) 
    Matcher m = PARAM_URL_REGEX.matcher(path);
    Set<String> patterns = new LinkedHashSet<>();
    while (m.find()) 
        patterns.add(m.group(1));
    
    return patterns;

这一步仅是根据正则表达式获取URL中所有…类型的数据,添加到patterns这个Set中,然后返回给RequestFactoryParser,对relativeUrlParamNames进行赋值;

第一步解析完毕,来到第二步parseParameters:

retrofit 2 源码解析

站在巨人的肩膀上 -- Retrofit源码解析

站在巨人的肩膀上 -- Retrofit源码解析

Retrofit源码解析-动态代理

Retrofit源码解析-动态代理

站在巨人的肩膀上 -- Retrofit源码解析