Retrofit2源码分析

傷城~ 2023-07-17 09:55 29阅读 0赞

# 一、概述 #

在了解Retrofit2源码架构之前先说明，本文默认读者对Retrofit2框架的使用有一定了解，除此之外还要先熟悉okhttp3框架和Java代理模式中的动态代理，不然后面咱们看Retrofit2源码时会很难理解：

[Java代理模式][Java]

严格地说，Retrofit2并不是一个网络请求交易框架，它只是对网络请求框架的封装。底层把实现交给了okhttp3，由okhttp3做真正的网络请求。Retrofit2框架和其他的用于网络请求的框架流程大体相同，Retrofit2优势在于，它使用了大量的设计模式将功能模块解耦，这样做的好处在于可以让流程更加清晰，可塑性更强。

注：本文基于Retrofit 2.4.0版本的源码分析。

# 二、Retrofit2源码地址 #

Retrofit2源码地址：[https://github.com/square/retrofit][https_github.com_square_retrofit]

# 三、Retrofit2简单使用 #

1、首先创建用于网络请求的API接口：

public interface NetService { 
       @GET( "cozing") 
       Call<NetResponse> serviceApi(); 
       }

2、创建用于接收请求返回的数据接收：

public class NetResponse { 
       private int id; 
       private String name; 
       }

3、创建Retrofit实例并做交易请求：

public class Retrofit2TestForBlogActivity extends BaseActivity{ 
       ... 
       private void retrofitTest(){ 
       Retrofit retrofit = new Retrofit.Builder() 
       .baseUrl( "https://github.com/") //必须以"/"结尾，不然将抛出异常 
       .addConverterFactory(GsonConverterFactory.create()) 
       //.addCallAdapterFactory(RxJava2CallAdapterFactory.create()) 
       .build(); 
       
       NetService netApi = retrofit.create(NetService.class); 
       Call<NetResponse> call = netApi.serviceApi(); 
       try { 
       //① 同步请求 
       Response response = call.execute(); 
       } catch (IOException e) { 
       e.printStackTrace(); 
       } 
       //②异步请求 
       call.enqueue( new Callback<NetResponse>() { 
       @Override 
       public void onResponse(Call<NetResponse> call, Response<NetResponse> response) { 
       
       } 
       
       @Override 
       public void onFailure(Call<NetResponse> call, Throwable t) { 
       
       } 
       }); 
       } 
       }

通过以上代码，咱们完成了请求，其中咱们向：

url = https://github.com/cozing

发送GET请求，在注释①处发起同步请求，在注释②处发送异步请求，交易的结果通过调用返回的Response对象实例的response.body()获取，这个结果就是咱们在构建网络请求时传入的NetResponse数据结构。

接下来看Retrofit2整体架构流程图。

# 四、架构流程 #

### 1、流程图 ###

![70][]

### 2、流程讲解 ###

1、创建Retrofit实例；

2、创建网络请求接口和相关属性注解；

3、通过动态代理解析请求接口的注解，并生成网络请求对象；

4、通过CallAdapter进行平台适配，平台包括（Android/java8/iOS）；

5、通过OkHttpCall发送网络请求；

6、通过Converter数据转换适配器转换交易返回的数据；

7、通过线程切换执行器切换到主线程（仅限异步请求）。

# 五、源码分析 #

### 1、Retrofit的内部成员变量 ###

public final class Retrofit { 
       private final Map<Method, ServiceMethod <?, ?>> serviceMethodCache = new ConcurrentHashMap<>(); //网络请求缓存，如：请求方法、请求头、请求体，各种适配器等 
       
       final okhttp3.Call.Factory callFactory; //okhttp工厂，真正发送交易的处理类 
       final HttpUrl baseUrl; //请求url前半部，基地址 
       final List<Converter.Factory> converterFactories; //数据转换器工厂集 
       final List<CallAdapter.Factory> adapterFactories; //网络请求适配器工厂集 
       final @Nullable Executor callbackExecutor; //异步请求结果线程切换执行器 
       final boolean validateEagerly; //标志位、是否马上解析接口方法 
       ... 
       }

### 2、Retrofit内部类Builder ###

public final class Retrofit { 
       ... 
       public static final class Builder { 
       private final Platform platform; //适配平台，通常默认android 
       private @Nullable okhttp3.Call.Factory callFactory; //okhttp网络请求工厂，默认okhttp 
       private HttpUrl baseUrl; //基地址 
       private final List<Converter.Factory> converterFactories = new ArrayList<>(); //数据转换器集，用于生产数据转换器，默认GsonConverterFactory 
       private final List<CallAdapter.Factory> adapterFactories = new ArrayList<>(); //网络请求适配器，如RxJava2CallAdapterFactory 
       private @Nullable Executor callbackExecutor; //执行异步回调的线程切换 
       private boolean validateEagerly; //是否立即解析接口注解方法 
       } 
       ... 
       }

### 3、创建Retrofit实例 ###

Retrofit retrofit = new Retrofit.Builder() 
       .baseUrl( "https://github.com") 
       .addConverterFactory(GsonConverterFactory.create()) 
       .addCallAdapterFactory(RxJava2CallAdapterFactory.create()) 
       .build();

内部类Builder实现：

public final class Retrofit { 
       ... 
       public static final class Builder { 
       ... 
       Builder(Platform platform) { 
       this.platform = platform; 
       converterFactories.add( new BuiltInConverters()); //添加默认数据解析器 
       } 
       
       public Builder() { 
       this(Platform.get()); 
       } 
       } 
       }

咱们在创建Builder实例时调用的是Builder的无参构造放法，里面调用了Builder(Platform)这个构造方法，传入的是Platform.get()返回数据，这个方法是获取适配平台，默认是Android，其他平台咱们不做过多分析，直接查看Android：

class Platform { 
       ... 
       static class Android extends Platform { 
       @Override public Executor defaultCallbackExecutor() { 
       return new MainThreadExecutor(); 
       } 
       
       @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); 
       } 
       } 
       } 
       ... 
       }

可以看到在创建Builder实例的设配平台时，将工作线程切换到了主线程，这也是后面可以通过主线程回调返回请求数据的原因。

接着将会在Builder的有参构造方法中的添加Retrofit默认的数据解析器：

converterFactories.add(new BuiltInConverters());

### 4、Builder.build()方法 ###

public final class Retrofit { 
       ... 
       public static final class Builder { 
       ... 
       public Retrofit build() { 
       if (baseUrl == null) { //对baseurl进行非空判断 
       throw new IllegalStateException( "Base URL required."); 
       } 
       
       //注释① 
       okhttp3.Call.Factory callFactory = this.callFactory; 
       if (callFactory == null) { 
       callFactory = new OkHttpClient(); //创建okhttp客户端 
       } 
       //注释② 
       Executor callbackExecutor = this.callbackExecutor; 
       if (callbackExecutor == null) { 
       callbackExecutor = platform.defaultCallbackExecutor(); 
       } 
       
       List<CallAdapter.Factory> adapterFactories = new ArrayList<>( this.adapterFactories); 
       adapterFactories.add(platform.defaultCallAdapterFactory(callbackExecutor)); 
       
       List<Converter.Factory> converterFactories = new ArrayList<>( this.converterFactories); 
       
       return new Retrofit(callFactory, baseUrl, converterFactories, adapterFactories, 
       callbackExecutor, validateEagerly); 
       } 
       } 
       }

首先咱们看注释①处，上面说过Retrofit2框架的底层发送交易其实是提交给了okhttp框架，在okhttp3源码讲解时咱们说过在okhttp中OkhttpClient在整个进程中只创建一次，所以在这里做了相关判断。

注释②处，可以看到是获取回调执行器，如果没有设置回调执行器，就创建一个默认的主线程回调执行器。

最后调用Retrofit的构造方法，创建一个Retrofit实例。可以看到整个创建Retrofit过程中，通过构建者模式来执行一系列初始化和对象的创建。

### 5、retrofit.create() ###

接着咱们创建了网络请求接口类NetService.class，在下面的步骤中咱们调用retrofit.create(NetService.class)，这个方法是Retrofit的核心，内部采用动态代理，将咱们自定义的网络请求接口转换成一个ServiceMethod对象，ServiceMethod就是咱们Retrofit中的具体请求对象，里面封装了网络请求所必须的全部信息，包括请求方法、url、请求头、请求体等网络配置参数！

咱们现在看看create（）源码：

... 
       public <T> T create( final Class<T> service) { 
       Utils.validateServiceInterface(service); 
       if (validateEagerly) { //创建retrofit实例时提到的标志位 
       //注释① 
       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, @Nullable Object[] args) 
       throws Throwable { 
       
       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.callAdapter.adapt(okHttpCall); 
       } 
       }); 
       } 
       ...

咱们先看注释①处，如果提前验证的标志位为true，将会调用eagerlyValidateMethods(service)方法，咱们来看：

... 
       private void eagerlyValidateMethods(Class<?> service) { 
       Platform platform = Platform. get(); 
       for (Method method : service.getDeclaredMethods()) { 
       if (!platform.isDefaultMethod(method)) { 
       loadServiceMethod(method); 
       } 
       } 
       } 
       ...

可以看到这个方法内部通过反射机制，来获取咱们自定义的请求接口对象类的内部方法。isDefaultMethod默认为false，因此loadServiceMethod(method)方法一定会走到，咱们接着看这个方法：

... 
       ServiceMethod<?, ?> loadServiceMethod(Method method) { 
       ServiceMethod<?, ?> result = serviceMethodCache. get(method); 
       if (result != null) return result; 
       
       synchronized (serviceMethodCache) { 
       result = serviceMethodCache. get(method); 
       if (result == null) { 
       result = new ServiceMethod.Builder<>( this, method).build(); 
       serviceMethodCache.put(method, result); 
       } 
       } 
       return result; 
       } 
       ...

其中serviceMethodCache是一个ConcurrentHashMap实例，ConcurrentHashMap是HashMap的一个线程安全的、支持高效并发的版本。继续看代码，创建serviceMethod时并不是每次都创建一个新的实例，而是先去缓存吃中去获取，如果缓存池中没有存储，则会调用builder构建者模式去重新创建method，并将该对象实例存入serviceMethodCache缓存池中。

接着看注释②，返回了一个动态代理对象，如果不清楚什么是动态代理，[请点击这里][Java]。熟悉动态代理模式的童鞋应该都知道

真正处理事务逻辑的地方是在代理对象的invoke回调方法内，在Retrofit2代码里，也就是注释③处。

看注释③的invoke方法，对Retrofit源码理解的重中之重，就是这个方法中的最后三行。接下来咱们将在6、7、8点详细分析这三行代码。

### 6、loadServiceMethod() ###

这个方法用于加载serviceMethod，一个serviceMethod对应咱们定义的网络请求接口中的一个方法，比如栗子中的serviceApi()这个方法。接着来看loadServiceMethod源码：

先看ServiceMethod的成员变量：

final class ServiceMethod<R, T> { 
       ... 
       private final okhttp3.Call.Factory callFactory; //okhttp call的工厂 
       private final CallAdapter<R, T> callAdapter; //网络请求适配器 
       
       private final HttpUrl baseUrl; //基地址 
       private final Converter<ResponseBody, R> responseConverter; //数据转换器 
       private final String httpMethod; //网络请求方法 
       private final String relativeUrl; //网络请求相对地址，和基地址拼接成完整地址 
       private final Headers headers; //请求头 
       private final MediaType contentType; //请求体 
       private final boolean hasBody; 
       private final boolean isFormEncoded; 
       private final boolean isMultipart; 
       private final ParameterHandler<?>[] parameterHandlers; //方法参数处理器 
       
       ... 
       
       }

咱们开始时候说过，Retrofit2底层是基于okhttp框架来发送请求，可以看到在ServiceMrthod中维护了okhttp用于网络请求的Call工厂，用于生产Call，并且ServiceMrthod声明了网络请求所需元素的所有基本信息。咱们看ServiceMrthod的源码发现，它和Retrofit这个类的初始化非常相似，都是通过构建者模式来创建实例。咱们回过头看loadServiceMethod()方法的：

... 
       result = new ServiceMethod.Builder<>( this, method).build(); 
       ...

这一行，跟进去Builder内部类：

final class ServiceMethod<R, T> { 
       ... 
       Builder(Retrofit retrofit, Method method) { 
       this.retrofit = retrofit; //retrofit实例 
       this.method = method; //网络请求方法 
       this.methodAnnotations = method.getAnnotations(); //网络请求方法的注解 
       this.parameterTypes = method.getGenericParameterTypes(); //获取网络请求方法里的注解的类型 
       this.parameterAnnotationsArray = method.getParameterAnnotations(); //获取网络请求方法里的注解的内容 
       } 
       ... 
       }

然后调用ServiceMrthod

... 
       static final class Builder<T, R> { 
       ... 
       public ServiceMethod build() { 
       //注释① 
       callAdapter = createCallAdapter(); 
       responseType = callAdapter.responseType(); 
       if (responseType == Response.class || responseType == okhttp3.Response.class) { 
       throw methodError( "'" 
       + Utils.getRawType(responseType).getName() 
       + "' is not a valid response body type. Did you mean ResponseBody?"); 
       } 
       //注释② 
       responseConverter = createResponseConverter(); 
       
       //注释③ 
       for (Annotation annotation : methodAnnotations) { 
       parseMethodAnnotation(annotation); 
       } 
       
       ... 
       
       //注释④ 
       int parameterCount = parameterAnnotationsArray.length; 
       parameterHandlers = new ParameterHandler<?>[parameterCount]; 
       for ( int p = 0; p < parameterCount; p++) { 
       Type parameterType = parameterTypes[p]; 
       if (Utils.hasUnresolvableType(parameterType)) { 
       throw parameterError(p, "Parameter type must not include a type variable or wildcard: %s", 
       parameterType); 
       } 
       
       Annotation[] parameterAnnotations = parameterAnnotationsArray[p]; 
       if (parameterAnnotations == null) { 
       throw parameterError(p, "No Retrofit annotation found."); 
       } 
       
       parameterHandlers[p] = parseParameter(p, parameterType, parameterAnnotations); 
       } 
       
       ... 
       
       return new ServiceMethod<>( this); 
       } 
       ... 
       ...

看注释①的createCallAdapter，创建callAdapter，内部实现:

... 
       private CallAdapter<T, R> createCallAdapter() { 
       Type returnType = method.getGenericReturnType(); 
       if (Utils.hasUnresolvableType(returnType)) { 
       throw methodError( 
       "Method return type must not include a type variable or wildcard: %s", returnType); 
       } 
       if (returnType == void.class) { 
       throw methodError( "Service methods cannot return void."); 
       } 
       Annotation[] annotations = method.getAnnotations(); 
       try { 
       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中获取网络请求接口适配器。首先从网络请求接口方法中获取注释，然后根据注释和注释返回类型，接着调用retrofit.callAdapter()方法从retrofit中获取适配器。咱们跟着代码会发发现其实最后调用的是retrofit的nextCallAdapter()，来看看它内部实现的主要代码：

... 
       public CallAdapter<?, ?> nextCallAdapter( @Nullable CallAdapter.Factory skipPast, Type returnType, 
       Annotation[] annotations) { 
       ... 
       
       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; 
       } 
       } 
       ... 
       } 
       ...

在for循环中，根据请求参数在网络适配工厂中创建网络适配器并返回该适配器，

接着看build()方法中的注释②：

responseConverter = createResponseConverter();

跟进去：

... 
       private Converter<ResponseBody, T> createResponseConverter() { 
       Annotation[] annotations = method.getAnnotations(); 
       try { 
       return retrofit.responseBodyConverter(responseType, annotations); 
       } catch (RuntimeException e) { // Wide exception range because factories are user code. 
       throw methodError(e, "Unable to create converter for %s", responseType); 
       } 
       } 
       ...

这个方法是创建网络请求返回数据转换器，和创建网络请求适配器的方式一样，调用的是retrofit的responseBodyConverter()方法，内部真正调用的是nextResponseBodyConverter()方法，nextResponseBodyConverter()的内部主要实现：

... 
       public <T> Converter<ResponseBody, T> nextResponseBodyConverter( 
       ... 
       int start = converterFactories.indexOf(skipPast) + 1; 
       for ( int i = start, count = converterFactories.size(); i < count; i++) { 
       Converter<ResponseBody, ?> converter = 
       converterFactories. get(i).responseBodyConverter(type, annotations, this); 
       if (converter != null) { 
       return (Converter<ResponseBody, T>) converter; 
       } 
       } 
       ... 
       } 
       ...

可以看到，和创建网络请求适配器一样的创建方法，根据响应类型和请求方法注释数值，从数据转换器工厂中创建数据转换器并返回。

继续看build()方法中的注释③：

for (Annotation annotation : methodAnnotations) { 
       parseMethodAnnotation( annotation); 
       }

是解析请求接口中的所有注释。

接着看注释④的代码：

... 
       public ServiceMethod build() { 
       ... 
       int parameterCount = parameterAnnotationsArray.length; 
       parameterHandlers = new ParameterHandler<?>[parameterCount]; 
       for ( int p = 0; p < parameterCount; p++) { 
       Type parameterType = parameterTypes[p]; 
       if (Utils.hasUnresolvableType(parameterType)) { 
       throw parameterError(p, "Parameter type must not include a type variable or wildcard: %s", 
       parameterType); 
       } 
       
       Annotation[] parameterAnnotations = parameterAnnotationsArray[p]; 
       if (parameterAnnotations == null) { 
       throw parameterError(p, "No Retrofit annotation found."); 
       } 
       
       parameterHandlers[p] = parseParameter(p, parameterType, parameterAnnotations); 
       } 
       ... 
       } 
       ....

这部分做的主要是解析网络请求接口的参数，包括自定义请求接口参数和配置的请求参数，其中ParameterHandler类就是接口参数解析器。

至此，loadServiceMethod()方法的分析完成，这个方法主要是创建并加载ServiceMehod，用于解析网络请求接口参数、网络请求适配器、response数据解析器等工作。

### 7、创建OkHttpCall对象 ###

OkHttpCall<Object> okHttpCall = new OkHttpCall<>(serviceMethod, args);

咱们前面说过Retrofit2框架的交易发送是由okhttp实现， 所以很容易想到，这个OkHttpCall就是对okhttp的call对象的封装，咱们现在看OkHttpCall的实现：

final class OkHttpCall<T> implements Call<T> { 
       ... 
       @GuardedBy( "this") 
       private @Nullable okhttp3.Call rawCall; 
       ... 
       
       @Override public void enqueue(final Callback<T> callback) { 
       call.enqueue( new okhttp3.Callback() { 
       @Override public void onResponse(okhttp3.Call call, okhttp3.Response rawResponse) { 
       Response<T> response; 
       try { 
       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(); 
       } 
       } 
       }); 
       
       ... 
       
       @Override public Response<T> execute() throws IOException { 
       okhttp3.Call call; 
       
       synchronized ( this) { 
       if (executed) throw new IllegalStateException( "Already executed."); 
       executed = true; 
       
       if (creationFailure != null) { 
       if (creationFailure instanceof IOException) { 
       throw (IOException) creationFailure; 
       } else if (creationFailure instanceof RuntimeException) { 
       throw (RuntimeException) creationFailure; 
       } else { 
       throw (Error) creationFailure; 
       } 
       } 
       
       call = rawCall; 
       if (call == null) { 
       try { 
       call = rawCall = createRawCall(); 
       } catch (IOException | RuntimeException | Error e) { 
       throwIfFatal(e); // Do not assign a fatal error to creationFailure. 
       creationFailure = e; 
       throw e; 
       } 
       } 
       } 
       
       if (canceled) { 
       call.cancel(); 
       } 
       
       return parseResponse(call.execute()); 
       } 
       ... 
       }

代码有点多，但是逻辑还是很清晰的，内部维护了一个okhttp3.Call rawCall的对象，接着看下面两个方法：enqueue()和execute()，可以看到内部调用的是rawCall的对应方法，也就是调用okhttp3.Call的enqueue()和execute()。

### 8、serviceMethod.adapt(okHttpCall) ###

这个方法很显然使用适配器模式，将某些咱们需要处理的事件，适配成其他平台可以使用的类型，并在该平台使用。这里调用serviceMethod的adapt适配方法，传入了上面步骤7中创建的OkHttpCall实例，并将适配对象返回。adapt()方法源码：

final class ServiceMethod<R, T> { 
       ... 
       T adapt(Call<R> call) { 
       return callAdapter.adapt(call); 
       } 
       ... 
       }

可以看到内部调用的是callAdapter.adapter(call)，而callAdapter对象实例是在loadServiceMethod()方法中调用ServiceMethod构建者模式创建实例时候创建的：

final class ServiceMethod<R, T> { 
       ... 
       static final class Builder<T, R> { 
       ... 
       CallAdapter<T, R> callAdapter; 
       public ServiceMethod build() { 
       ... 
       callAdapter = createCallAdapter(); 
       ... 
       } 
       } 
       ... 
       }

在调用callAdapter的adapter()方法，其实就是把一个个Retrofit中的Call适配成其他平台也能使用的Call类型，比如咱们栗子中使用的是RxJava2CallAdapterFactory.create()来创建了一个RxJava2CallAdapter的适配器来适配RxJava2平台，适配成RxJava2平台能使用的Call。

咱们接下来看Retrofit的CallAdapter接口中的Rxjava2CallAdapter实现类的adapter()方法：

final class RxJava2CallAdapter implements CallAdapter<Object> { 
       ... 
       @Override public <R> Object adapt(Call<R> call) { 
       Observable<Response<R>> responseObservable = new CallObservable<>(call); 
       Observable<?> observable; 
       ... 
       return observable; 
       } 
       ... 
       }

可以看到，该适配方法返回了一个Observable被观察者对象。所以在咱们栗子中最后创建Retrofit的Call接口的实例对象时，也就创建了一个被观察者对象。

最后，通过Retrofit的Call实现类，调用execute()方法，也就是调用okhttp3.Call的execute()方法来发送同步请求，请求结果同步返回；调用enqueue()方法，也就是调用okhttp3.Call的enqueue()方法来发送异步请求，请求结果通过Callback接口对象回调返回。

至此，有关Retrofit2的源码分析结束。

# 六、总结 #

咱们通过观察Retrofit2的源码发现Retrofit2代码量其实不多，但是有些童鞋看完整篇文章可能还一脸懵逼，这TM也太复杂了！其实不然，因为Retrofit2内部采用了大量的设计模式，导致咱们分析源码时候需要经常跳转着看源码，所以建议咱们在分析Retrofit2源码时候，一定要跟着流程仔细阅读源码，如果读懂了Retrofit2的流程，就会发现其实Retrofit2的整体框架还是挺简单的。

最后再说一句，Retrofit2采用大量的设计模式是Retrofit2的精髓所在，完全可以借鉴到咱们的日常开发中，这才是咱们分析框架源码的初衷！

[Java]: https://blog.csdn.net/qq_29152241/article/details/82142552
[https_github.com_square_retrofit]: https://github.com/square/retrofit
[70]: /images/20230528/313123ac314e4f0db59e24e970e2999d.png