在 Android 开发中。面对网络请求需求时大多数人会直接选用 OkHttp，却忽视了更易用的封装层——Retrofit。很多新人在阅读 Retrofit 源码时会遇到以下痛点：

• 源码体量大。结构复杂——不知道从哪个入口开始，看得眼花缭乱。
• 动态代理和注解解析难以捉摸——看不清楚接口方法到底是怎么被转化为网络请求的。

今天聊聊围绕两个主要方向帮助你突破这些痛点：

• Retrofit 主流程
• 如何实现线程切换

Retrofit 主流程

val retrofit: Retrofit by lazy {
Retrofit.Builder
.baseUrl
.client
.addConverterFactory))
.build
}
retrofit.create
fun demoBasicEnqueue {
val call = userApiCall.getUserByIdCall
call.enqueue(object : Callback {
override fun onResponse { }
override fun onFailure { }
})
}

UserApiService 是我们自定义的接口。在调用 retrofit.create 后得到一个实现了 Call 接口的对象，再通过 enqueue 发起网络请求。

痛点拆解：很多人看到 .enqueue 直接跳进去。却只看到抽象类和接口，根本不知道真正执行了什么。

1️⃣ 动态代理生成实现类

public  T create {
validateServiceInterface;return Proxy.newProxyInstance(
service.getClassLoader,new Class {service}。new InvocationHandler {
private final Object emptyArgs = new Object;@Override
public @Nullable Object invoke
throws Throwable {
if == Object.class) {
return method.invoke;}
args = args!= null，args : emptyArgs;Reflection reflection = Platform.reflection;return reflection.isDefaultMethod
reflection.invokeDefaultMethod
: loadServiceMethod.invoke;}
})，其实，}

2️⃣ 缓存并解析 ServiceMethod

ServiceMethod loadServiceMethod {
while {
Object lookup = serviceMethodCache.get;if {
return lookup;}
if {
Object lock = new Object;synchronized {
lookup = serviceMethodCache.putIfAbsent;if {
try {
ServiceMethod result = ServiceMethod.parseAnnotations;serviceMethodCache.put;怎么说呢，return result;} catch {
serviceMethodCache.remove;throw e，不过，}
}
}
}
synchronized {
ServiceMethod result = serviceMethodCache.get;if return result;}
}
}

*痛点*：缓存机制让人误以为每次调用都会重新解析。第一次访问才会走到 parseAnnotations,之后直接命中缓存。

3️⃣ 注解解析 → HttpServiceMethod 建立

static  ServiceMethod parseAnnotations(Retrofit retrofit。Class service,Method method) {
RequestFactory requestFactory = RequestFactory.parseAnnotations;Type returnType = method.getGenericReturnType;// 略去类型校验，return HttpServiceMethod.parseAnnotations;}

if {
return new CallAdapted<>(requestFactory。callFactory,responseConverter,callAdapter);} else if { …} else { ，}

*痛点*：Kotlin 挂起函数的兼容代码容易让人混淆，这里先聚焦非挂起方法。即返回 CallAdapted.

4️⃣ 调用链路：从 HttpServiceMethod 到 OkHttpCall

@Override
final @Nullable ReturnT invoke {
Call call = new OkHttpCall<>(requestFactory,instance,args,callFactory,responseConverter);不过，return adapt;
}

The created HelloWorldCall,i.e.。is concrete implementation of Retrofit’s Call.

OkHttpCall 实现细节

@Override
public void enqueue {
// 省略参数检查…okhttp3.Call rawCall = rawCall;// 真正的 OkHttp Call
rawCall.enqueue {
@Override
public void onResponse(okhttp3.Call call,okhttp3.Response rawResponse) {
Response response;try {
response = parseResponse;} catch { ，}
callback.onResponse;}
@Override
public void onFailure(okhttp3.Call call,IOException e) { …}
})，说起来，}

*结论*：Till now we have proved that Retrofit finally delegates network I/O to OkHttp’s own asynchronous API.

如何实现线程切换

The previous section ends with a call to .adapt. This is where Retrofit injects its thread‑switching logic.

适配器链路概览

@Override
final @Nullable ReturnT invoke {
Call call = new OkHttpCall<>;return adapt;其实，// ← 关键入口
}
...
static final class CallAdapted
extends HttpServiceMethod {
private final CallAdapter callAdapter;CallAdapted(RequestFactory requestFactory,okhttp3.Call.Factory callFactory。Converter responseConverter,CallAdapter callAdapter) {
super;this.callAdapter = callAdapter;}
@Override
protected ReturnT adapt(Call call,Object args) {
return callAdapter.adapt;// 真正的切线程逻辑在这里
}
}

默认适配器 —— DefaultCallAdapterFactory 的作用

// 在 Retrofit.Builder 中加入默认工厂
addCallAdapterFactory);怎么说呢，...
return new CallAdapter{
@Override public Type responseType{return responseType;}
@Override public Call