当前位置：首页 > news >正文

Retrofit源码分析小结

news 文章来源：https://blog.csdn.net/guangdeshishe/article/details/129903236 2025/5/10 5:11:01

Retrofit源码分析&小结

简介

Retrofit是对Okhttp网络请求的二次封装，通过注解+动态代理的方式，简化了Okhttp的使用，使得通过简单的配置就可以像调用接口一样去请求网络接口；除此之外Retrofit还支持RxJava和kotlin的协程

基本使用

引入依赖库

//网络请求
implementation 'com.squareup.retrofit2:retrofit:2.9.0'//Retrofit基本库
implementation 'com.squareup.retrofit2:converter-gson:2.1.0'//用于将结果转换成对象
implementation 'com.squareup.retrofit2:adapter-rxjava2:2.3.0'//用于转换成RxJava支持的Observer对象
implementation 'io.reactivex.rxjava2:rxandroid:2.0.1'//RxJava对Android的支持
implementation 'com.squareup.okhttp3:logging-interceptor:3.9.0'//Okhttp日志拦截器，用于打印接口请求相关log
//协程
implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-core:1.6.4'//Retrofit对Kotlin协程的支持
implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.6.4'//协程对Android的支持
implementation('androidx.lifecycle:lifecycle-runtime-ktx:2.6.0-alpha02')//协程对LifeCycle的支持

定义一个用于网络请求的服务接口

package com.example.myapplication.retrofitimport android.service.autofill.UserData
import io.reactivex.Observable
import retrofit2.Call
import retrofit2.http.*interface IUserServer {/*** 以GET方式请求*/@GET("getUserInfo/")fun getUserInfo(@Query("userId") userId: String): Call<UserData>/*** 以POST方式请求，并结合RxJava*/@POST("getUserInfo/")@FormUrlEncodedfun getUserInfoByRxJava(@Field("userId") userId: String): Observable<UserData>/*** 结合kotlin协程完成线程切换*/@GET("banner/json")suspend fun getUserInfoBySuspend2(@Query("userId") userId: String): UserData}

创建Retrofit对象和自定义接口代理实现对象

val retrofit = Retrofit.Builder().baseUrl("http://www.xxx.com/").addConverterFactory(GsonConverterFactory.create())//支持Gson.addCallAdapterFactory(RxJava2CallAdapterFactory.create())//支持Rxjava.build()
val server = retrofit.create(IUserServer::class.java)

普通发起网络请求

val userInfo = server.getUserInfo("1").execute()//同步执行
server.getUserInfo("1").enqueue(object : Callback<UserData> {//异步执行override fun onResponse(call: Call<UserData>, response: Response<UserData>) {//网络请求返回结果}override fun onFailure(call: Call<UserData>, t: Throwable) {//网络请求错误}
})

结合RxJava

server.getUserInfoByRxJava("1").subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribe(object : Observer<UserData> {override fun onSubscribe(d: Disposable?) {//网络请求前}override fun onNext(value: UserData?) {//网络请求返回结果}override fun onError(e: Throwable?) {//网络请求错误}override fun onComplete() {//网络请求结束}
})

结合Kotlin协程

lifecycleScope.launch {val userInfo = withContext(Dispatchers.IO) {val userInfo = server.getUserInfoBySuspend2("1")//子线程中请求网络}//回到主线程Log.i("testRetrofit", "userInfo:$userInfo")
}

核心源码分析

1. Retrofit.create方法，根据注解为我们声明的接口创建动态代理

```
public <T> T create(final Class<T> 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];@Overridepublic @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);//开始解析该方法并返回接口请求对象，比如Call、Observable(需结合Rxjava)}});
}
```

在validateServiceInterface方法中，如果配置了Retrofit.Builder().validateEagerly(true)，会立刻根据注解解析接口中定义的所有方法，如果是false，则会等待方法调用时才会解析接口中的方法；

设置为true的好处是在创建接口代理时就能检查出各个方法配置的注解、返回值等是否正确，如果为默认的false，则只有在方法调用时才能发现问题；

所以建议在debug阶段设置为true便于及早发现问题，release阶段设置false以提高性能
```
private void validateServiceInterface(Class<?> service) {... ...if (validateEagerly) {Platform platform = Platform.get();for (Method method : service.getDeclaredMethods()) {//遍历所有方法，根据注解进行解析if (!platform.isDefaultMethod(method) && !Modifier.isStatic(method.getModifiers())) {loadServiceMethod(method);}}}
}
```

默认实现中接口返回的Call实际上是一个Retrofit中定义的一个接口，定义了同步请求和异步请求的方法；

public interface Call<T> extends Cloneable {... .../*** Synchronously send the request and return its response.** @throws IOException if a problem occurred talking to the server.* @throws RuntimeException (and subclasses) if an unexpected error occurs creating the request or*     decoding the response.*/Response<T> execute() throws IOException;/*** Asynchronously send the request and notify {@code callback} of its response or if an error* occurred talking to the server, creating the request, or processing the response.*/void enqueue(Callback<T> callback);... ...
}

Call的实现类根据是否有注解@SkipCallbackExecutor来决定，当有该注解时，Call的实现类是OkHttpCall.java，里面封装了OkHttp的网络请求，如果没有该注解，则Call实现类是DefaultCallAdapterFactory.ExecutorCallbackCall；这个类仅仅是个代理类，真正实现网络请求的还是OkHttpCall；
代理类存在的意义是Okhttp进行异步请求返回结果后，会先通过Handler将线程切换到主线程再返回结果

final class OkHttpCall<T> implements Call<T> {@Overridepublic void enqueue(final Callback<T> callback) {...okhttp3.Call call;call.enqueue(new okhttp3.Callback() {@Overridepublic void onResponse(okhttp3.Call call, okhttp3.Response rawResponse) {}@Overridepublic void onFailure(okhttp3.Call call, IOException e) {callFailure(e);}}...}@Overridepublic Response<T> execute() throws IOException {okhttp3.Call call;...return parseResponse(call.execute());}
}

static final class ExecutorCallbackCall<T> implements Call<T> {final Executor callbackExecutor;//在主线程执行，实现类是Platform.Android.MainThreadExecutorfinal Call<T> delegate;//这个实现类是OkHttpCall@Overridepublic void enqueue(final Callback<T> callback) {delegate.enqueue(new Callback<T>() {@Overridepublic void onResponse(Call<T> call, final Response<T> response) {callbackExecutor.execute(() -> {//切换到主线程执行callback.onResponse(ExecutorCallbackCall.this, response);}});}@Overridepublic void onFailure(Call<T> call, final Throwable t) {//切换到主线程执行callbackExecutor.execute(() -> callback.onFailure(ExecutorCallbackCall.this, t));}});}@Overridepublic Response<T> execute() throws IOException {return delegate.execute();//在当前所在线程执行}
}

2. 注解的解析过程和使用

在Retrofit.create方法中，loadServiceMethod方法中会先从缓存中查找ServiceMethod对象，如果之前有解析过则直接返回，如果没有则调用ServiceMethod.parseAnnotations方法返回一个ServiceMethod对象

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;
}

接着会调用RequestFactory.parseAnnotations方法真正进行注解的解析，并构建一个HttpServiceMethod对象返回

abstract class ServiceMethod<T> {static <T> ServiceMethod<T> 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.Builder中解析方法中的注解,可以理解为RequestFactory对象保存着所有请求的数据

final class RequestFactory {static RequestFactory parseAnnotations(Retrofit retrofit, Method method) {return new Builder(retrofit, method).build();}static final class Builder {final Annotation[] methodAnnotations;//方法上的注解final Annotation[][] parameterAnnotationsArray;//方法参数上的注解final Type[] parameterTypes;//参数类型@Nullable String httpMethod;//请求的方式get、post等@Nullable String relativeUrl;//解析处理后的请求接口@Nullable Headers headers;//封装的请求头信息boolean isKotlinSuspendFunction; //用于标记是否kotlin协程中suspend方法...private Headers parseHeaders(String[] headers) {}//解析请求头信息private void parseHttpMethodAndPath(String httpMethod, String value, boolean hasBody) //解析请求方式和接口路径private void parseMethodAnnotation(Annotation annotation) {//解析方法上的注解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);} 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);}...}private ParameterHandler<?> parseParameterAnnotation(){//解析参数上注解if (annotation instanceof Path) {} else if (annotation instanceof Query) {} else if (annotation instanceof QueryName) {} else if (annotation instanceof QueryMap) {} else if (annotation instanceof Header) {} else if (annotation instanceof HeaderMap) {} else if (annotation instanceof Field) {} else if (annotation instanceof FieldMap) {}  else if (annotation instanceof Body) {}...}}
}

请求参数的使用，是在真正发起网络请求OkhttpCall.createRawCall()方法中创建Okhttp Call对象的时候，通过RequestFactory.create方法将所有请求参数封装成OkHttp的Request对象

class OkHttpCall{private okhttp3.Call createRawCall() throws IOException {okhttp3.Call call = callFactory.newCall(requestFactory.create(args));return call;}
}
class RequestFactory{okhttp3.Request create(Object[] args) throws IOException {RequestBuilder requestBuilder =new RequestBuilder(httpMethod,baseUrl,relativeUrl,headers,contentType,hasBody,isFormEncoded,isMultipart);if (isKotlinSuspendFunction) {//协程suspen方法会自动在最后面加一个Continuation对象类型参数，所以实际请求时要去掉// The Continuation is the last parameter and the handlers array contains null at that index.argumentCount--;}List<Object> argumentList = new ArrayList<>(argumentCount);for (int p = 0; p < argumentCount; p++) {argumentList.add(args[p]);handlers[p].apply(requestBuilder, args[p]);}//构建okhttp3.Request对象return requestBuilder.get().tag(Invocation.class, new Invocation(method, argumentList)).build();}
}

3. RxJava2CallAdapterFactory：对Rxjava的支持,将默认返回的的Call对象转换成Observer对象

当调用接口方法的时候，通过动态代理默认会调用HttpServiceMethod.CallAdapted的invoke方法，而CallAdapted继承自HttpServiceMethod，并重写了adapt方法;
adapt方法用于封装Call对象并将结果转化成我们定义的接口方法所声明的返回对象

class HttpServiceMethod{@Overridefinal @Nullable ReturnT invoke(Object[] args) {Call<ResponseT> call = new OkHttpCall<>(requestFactory, args, callFactory, responseConverter);return adapt(call, args);}protected abstract @Nullable ReturnT adapt(Call<ResponseT> call, Object[] args);static final class CallAdapted<ResponseT, ReturnT> extends HttpServiceMethod<ResponseT, ReturnT> {private final CallAdapter<ResponseT, ReturnT> callAdapter;//默认的适配器是通过DefaultCallAdapterFactory动态生成的CallAdapter实现类CallAdapted(RequestFactory requestFactory,okhttp3.Call.Factory callFactory,Converter<ResponseBody, ResponseT> responseConverter,CallAdapter<ResponseT, ReturnT> callAdapter) {super(requestFactory, callFactory, responseConverter);this.callAdapter = callAdapter;//通过RxJava2CallAdapterFactory生成的Rxjava2适配器RxJava2CallAdapter}@Overrideprotected ReturnT adapt(Call<ResponseT> call, Object[] args) {return callAdapter.adapt(call);//调用适配器，将返回结果转换成我们定义的返回类型，比如默认是返回Call，Rxjava返回的是Observer对象}}
}

RxJava2CallAdapterFactory在创建时，可以选择调用create、createAsync、createWithScheduler(Scheduler)方法进行创建，他们的主要区别是create是调用Call.execute方法请求网络，也就是在当前线程执行；
而createAsync则是调用Call.enqueue方法请求网络，也就是异步请求;createWithScheduler可以传入一个Scheduler，指定网络请求在哪个线程上执行，通过observable.subscribeOn(scheduler)实现

public final class RxJava2CallAdapterFactory extends CallAdapter.Factory {/*** Returns an instance which creates synchronous observables that do not operate on any scheduler* by default.*/public static RxJava2CallAdapterFactory create() {return new RxJava2CallAdapterFactory(null, false);}/*** Returns an instance which creates asynchronous observables. Applying* {@link Observable#subscribeOn} has no effect on stream types created by this factory.*/public static RxJava2CallAdapterFactory createAsync() {return new RxJava2CallAdapterFactory(null, true);}public static RxJava2CallAdapterFactory createWithScheduler(Scheduler scheduler) {if (scheduler == null) throw new NullPointerException("scheduler == null");return new RxJava2CallAdapterFactory(scheduler, false);}@Overridepublic CallAdapter<?, ?> get(Type returnType, Annotation[] annotations, Retrofit retrofit) {...return new RxJava2CallAdapter(responseType, scheduler, isAsync, isResult, isBody, isFlowable,isSingle, isMaybe, false);}
}

调用RxJava2CallAdapter.adapt方法，将Call传入并返回Observer

final class RxJava2CallAdapter<R> implements CallAdapter<R, Object> {@Override public Object adapt(Call<R> call) {Observable<Response<R>> responseObservable = isAsync? new CallEnqueueObservable<>(call): new CallExecuteObservable<>(call);//真正网络请求包装在在这里面...Observable<?> observable;if (isResult) {observable = new ResultObservable<>(responseObservable);} else if (isBody) {observable = new BodyObservable<>(responseObservable);} else {observable = responseObservable;}if (scheduler != null) {observable = observable.subscribeOn(scheduler);}...return observable;}
}

当外部调用Observer的subscribe方法时，后就会立刻执行CallExecuteObservable/CallExecuteObservable里的subscribeActual方法，从而调用Call的execute或者enqueue方法实现网络请求

class Observable{public final void subscribe(Observer<? super T> observer) {subscribeActual(observer);}
}final class CallExecuteObservable<T> extends Observable<Response<T>> {@Override protected void subscribeActual(Observer<? super Response<T>> observer) {Call<T> call = originalCall.clone();Response<T> response = call.execute();//发起网络请求并返回结果if (!call.isCanceled()) {//传递给onNext方法observer.onNext(response);}if (!call.isCanceled()) {terminated = true;observer.onComplete();}}
}

4. GsonConverterFactory：网络请求返回结果的处理

在OkHttpCall发起网络请求后，会调用parseResponse方法解析返回结果，然后通过结果转换器进行转换，默认转换器是BuiltInConverters，如果配置了GsonConverterFactory，则支持转换成我们自定义对象，实现类是GsonResponseBodyConverter

class OkHttpCall{@Overridepublic Response<T> execute() throws IOException {okhttp3.Call call;call = getRawCall();...return parseResponse(call.execute());}Response<T> parseResponse(okhttp3.Response rawResponse) throws IOException {ResponseBody rawBody = rawResponse.body();...ExceptionCatchingResponseBody catchingBody = new ExceptionCatchingResponseBody(rawBody);try {//调用结果转换器进行转换，这里会根据声明方法返回值类型选择不同转换器，比如返回默认的ResponseBody，则使用自带的BuiltInConverters转换，返回自定义对象则会使用GsonResponseBodyConverter进行转换T body = responseConverter.convert(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;}}
}

Retrofit自带的默认转换器BuiltInConverters，支持处理返回类型是ResponseBody/Void 或者kotlin的Unit

final class BuiltInConverters extends Converter.Factory {/** Not volatile because we don't mind multiple threads discovering this. */private boolean checkForKotlinUnit = true;@Overridepublic @Nullable Converter<ResponseBody, ?> responseBodyConverter(Type type, Annotation[] annotations, Retrofit retrofit) {if (type == ResponseBody.class) {return Utils.isAnnotationPresent(annotations, Streaming.class)? StreamingResponseBodyConverter.INSTANCE: BufferingResponseBodyConverter.INSTANCE;}if (type == Void.class) {return VoidResponseBodyConverter.INSTANCE;}if (checkForKotlinUnit) {try {if (type == Unit.class) {return UnitResponseBodyConverter.INSTANCE;}} catch (NoClassDefFoundError ignored) {checkForKotlinUnit = false;}}return null;}
}

Gson转换器GsonResponseBodyConverter，支持自定义对象类型的转换

final class GsonResponseBodyConverter<T> implements Converter<ResponseBody, T> {private final Gson gson;private final TypeAdapter<T> adapter;GsonResponseBodyConverter(Gson gson, TypeAdapter<T> adapter) {this.gson = gson;this.adapter = adapter;}@Override public T convert(ResponseBody value) throws IOException {JsonReader jsonReader = gson.newJsonReader(value.charStream());try {return adapter.read(jsonReader);} finally {value.close();}}
}

5. 对kotlin协程的支持

判断是否kotlin suspend方法，在kotlin中suspend修饰的方法在编译成字节码并反编译成java代码后会发现方法参数里最后会多一个Continuation类型的参数，用于对协程的支持

kotlin字节码反编译后的java代码
public interface IUserServer {... ...@GET("banner/json")@NullableObject getUserInfoBySuspend2(@Query("userId") @NotNull String var1, @NotNull Continuation var2);
}

Retrofit在RequestFactory解析方法参数时做判断

class RequestFactory{class Builder{boolean isKotlinSuspendFunction;private @Nullable ParameterHandler<?> parseParameter(int p, Type parameterType, @Nullable Annotation[] annotations, boolean allowContinuation) {try {if (Utils.getRawType(parameterType) == Continuation.class) {//判断是否suspend协程方法isKotlinSuspendFunction = true;return null;}} catch (NoClassDefFoundError ignored) {}}}
}

根据方法返回类型，返回不同的HttpServiceMethod，当suspend方法直接返回自定义数据类型时(比如 UserData)，返回的是SuspendForBody对象; 如果方法返回的是Response,则返回SuspendForResponse对象,这两个返回对象其实差不多，只是返回类型不一样

class HttpServiceMethod{static <ResponseT, ReturnT> HttpServiceMethod<ResponseT, ReturnT> parseAnnotations(Retrofit retrofit, Method method, RequestFactory requestFactory) {boolean isKotlinSuspendFunction = requestFactory.isKotlinSuspendFunction;boolean continuationWantsResponse = false;if (getRawType(responseType) == Response.class && responseType instanceof ParameterizedType) {// Unwrap the actual body type from Response<T>.responseType = Utils.getParameterUpperBound(0, (ParameterizedType) responseType);continuationWantsResponse = true;}if (continuationWantsResponse) {//返回Response<UserData>类型结果return (HttpServiceMethod<ResponseT, ReturnT>)new SuspendForResponse<>(requestFactory,callFactory,responseConverter,(CallAdapter<ResponseT, Call<ResponseT>>) callAdapter);} else {//返回UserData类型结果return (HttpServiceMethod<ResponseT, ReturnT>)new SuspendForBody<>(requestFactory,callFactory,responseConverter,(CallAdapter<ResponseT, Call<ResponseT>>) callAdapter,continuationBodyNullable);}}
}

继续以SuspendForBody分析,在adapt方法被调用时，Retrofit会调用kotlin的扩展方法await/awaitNullable

static final class SuspendForBody<ResponseT> extends HttpServiceMethod<ResponseT, Object> {private final CallAdapter<ResponseT, Call<ResponseT>> callAdapter;private final boolean isNullable;@Overrideprotected Object adapt(Call<ResponseT> call, Object[] args) {call = callAdapter.adapt(call);//这里是默认的DefaultCallAdapterFactorys产生的Adapter//获取suspend最后一个参数用于协程Continuation<ResponseT> continuation = (Continuation<ResponseT>) args[args.length - 1];try {//调用Retrofit使用kotlin对Call类的扩展方法return isNullable //返回的对象是否可为空? KotlinExtensions.awaitNullable(call, continuation): KotlinExtensions.await(call, continuation);} catch (Exception e) {return KotlinExtensions.suspendAndThrow(e, continuation);}}
}

kotlin对Call方法扩展解析，协程方法中会异步发起网络请求并返回结果，当结束后会恢复到父协程地方继续执行

//这里是suspend方法，执行时协程会挂起
suspend fun <T : Any> Call<T>.await(): T {return suspendCancellableCoroutine { continuation ->continuation.invokeOnCancellation {cancel()//设置协程取消时的回调，调用Call的cancel方法}enqueue(object : Callback<T> {//调用Call方法异步请求网络override fun onResponse(call: Call<T>, response: Response<T>) {if (response.isSuccessful) {val body = response.body()if (body == null) {val invocation = call.request().tag(Invocation::class.java)!!val method = invocation.method()val e = KotlinNullPointerException("Response from " +method.declaringClass.name +'.' +method.name +" was null but response body type was declared as non-null")continuation.resumeWithException(e)//恢复协程并抛出异常} else {continuation.resume(body)//恢复协程并返回结果}} else {//恢复协程并抛出异常continuation.resumeWithException(HttpException(response))}}override fun onFailure(call: Call<T>, t: Throwable) {continuation.resumeWithException(t)//恢复协程并抛出异常}})}
}

小结

Retrofit实现原理：
答：Retrofit通过Create方法创建我们自定义接口实例时，会为我们接口创建一个动态代理；当调用接口方法的时候，会先根据配置的注解解析这个方法的信息，包括请求路径、请求参数、返回值等等，并把解析后的信息封装成对象并缓存起来；
然后根据方法的信息封装成一个Call对象，这个Call对象的默认实现类是OkHttpCall，内部是通过Okhttp发起同步或者异步网络请求；
然后调用Call的execute同步或者enqueue异步方法进行网络请求，返回结果后，会调用转换器对结果进行转换，默认是返回ResponseBody，也可以通过配置Gson转换器转成我们自定义类型；
如果需要对RxJava支持，返回Observer对象，则是需要配置一个Rxjava的CallAdapter，在适配器中将Call对象封装到Observer对象中并返回，当Observer的subscribe方法调用时会触发Call的网络请求操作，最后通过RxJava对结果分发；
如果需要对kotlin协程支持，Retrofit在对方法解析时会判断是否suspend方法，如果是的话，会执行Call的kotlin扩展方法，扩展方法也是suspend类型，在扩展方法中会挂起协程，通过Call对象执行网络请求操作，最后通过Continuation.resume方法恢复协程到父协程调用的地方
静态代理和动态代理的区别？
答：静态代理是指在代码编写的时候，代理类和被代理类的关系就确定了，编译后也会生成代理类字节码文件；而动态代理是指在运行时期，动态的通过反射方式为被代理的接口生成一个代理类，当调用这个接口的方法时，都会进入InvokeHandler的invoke方法中，从而实现对这个被代理接口的统一处理；
静态代理适合被代理的类比较少的情况，如果代理的类比较多，而且不需要做统一处理，则动态代理方便很多
Retrofit返回结果是如何切换到主线程的？
答：Retrofit会通过系统属性来判断是否Android平台，如果是Android平台，则会创建一个执行器，内部会创建一个主线程Looper的Handler，当网络请求结束返回结果时，会封装一个Runnable通过这个主线程Handler去执行，从而切换到主线程；
或者通过RxJava或者协程进行线程切换
对Kotlin协程(suspend方法)的支持
- 判断协程方法条件：判断方法最后一个参数是否是Continuation.class类型
- Retrofit使用kotlin对Call类扩展了suspend方法，在suspend方法中执行Call的网络请求，然后通过Continuation的resume方法恢复协程挂起并返回结果
- 什么时候切回主线程的？在协程中调用continuation.resume方法后会自动回到它父协程所在线程，也就是主线程继续执行