最小实现

1. 定义接口

public interface ApiService {
// @GET("user")
// 声明这是一个 GET 请求，请求路径是 baseUrl + "user"
// 注意：这里只是“接口定义”，Retrofit 还没有真正发请求
    @GET("user")
    Call<String> getUser();
}

2. 创建 Retrofit

Retrofit retrofit = new Retrofit.Builder()
        .baseUrl("https://example.com/")// 设置根地址，所有接口路径都会拼接在后面
        // 设置数据转换器：这里是把 response body 当 String 处理  
		// 常见还有 GsonConverterFactory（解析 JSON）
        .addConverterFactory(ScalarsConverterFactory.create())//
        .build(); //构建 Retrofit 实例（完成配置）

3. 创建接口实现 (动态代理生成)

// 关键点：这里不是 new ApiService()  
// 而是 Retrofit 用“动态代理 Proxy”生成实现类  
// 本质：返回的是一个 Proxy.newProxyInstance(...) 生成的对象  
// 你调用 api.getUser() 实际进入 InvocationHandler 调用 invoke 方法
ApiService api = retrofit.create(ApiService.class);

4. 发起请求

Call<String> call = api.getUser();

call.enqueue(new Callback<String>() { // 异步请求，同步请求 使用 call.executor()
    @Override
    public void onResponse(Call<String> call, Response<String> response) {
        System.out.println(response.body());
    }

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

---

Retrofit 原理

Retrofit 本质是一个“接口驱动的 HTTP 请求框架”，是对 OkHttp 的封装。通过动态代理把接口方法转换为 HTTP 请求，再交给 OkHttp 执行。

使用了 建造者模式 创建 Retrofit 对象
使用了 代理模式 实例化 请求接口

动态代理 retrofit.create(ApiService.class)

方法 转发给 InvocationHandler.invoke() 执行

• Retrofit.create() 做了什么？
  核心代码逻辑（简化）

return (ApiService) Proxy.newProxyInstance(
        ApiService.class.getClassLoader(),
        new Class[]{ApiService.class},
        new InvocationHandler()
);

• Proxy 生成一个 “假类”， 执行的方法 例如 api.getUser() 转发给 InvocationHandler.invoke() 执行
  简化逻辑：

class $Proxy0 implements ApiService {
    InvocationHandler handler;
    public Call<User> getUser(String id) {
        return handler.invoke(
                this,
                ApiService.getUserMethod,
                new Object[]{id}
        );
    }
}

invoke 内部逻辑

1. 解析方法（Method），提取Method 上的注解信息

@GET("user")
Call<User> getUser()

Retrofit 会解析：

• HTTP Method = GET
• URL = /user

2. 找Method 对应的 ServiceMethod
   Retrofit 会缓存

ServiceMethod serviceMethod = loadServiceMethod(method);

里面包含：

• 请求方式
• baseUrl
• 注解解析结果
• 参数解析规则（如果 getUser() 中有参数的话）

Retrofit 将 Method 转换并缓存为 ServiceMethod，用于封装请求解析规则；

3. 构建 Request

Request request = new Request.Builder()
    .url("https://api.com/user?id=123")
    .build();

4. 返回Call对象

return new OkHttpCall(request);

Retrofit 首先通过反射解析 Method 上的注解信息，提取 HTTP 请求描述；然后将 Method 转换并缓存为 ServiceMethod，用于封装请求解析规则；当方法被调用时，ServiceMethod 会结合参数生成最终 Request，最后封装为 OkHttpCall 交由 OkHttp 执行。

完整链路

api.getUser()
        ↓
Proxy 代理类
        ↓
InvocationHandler.invoke()
        ↓
Retrofit 解析 Method + Annotation
        ↓
生成 ServiceMethod
        ↓
构建 Request
        ↓
返回 Call
        ↓
OkHttp 执行请求

动态代理的本质就是：用一个运行时生成的代理对象，把接口方法调用统一转发到 InvocationHandler，从而实现“方法级别的拦截与增强”。

---

总结：
Retrofit 本质是对 OkHttp 的封装。
它通过动态代理为接口生成实现类。当调用接口方法时，会进入 InvocationHandler.invoke()，然后通过反射解析方法上的 @GET、@POST、@Query 等注解，并将解析结果封装、缓存为 ServiceMethod。
接着，ServiceMethod 会结合实际参数构建 OkHttp 的 Request，再封装成 Call 返回。只有调用 execute() 或 enqueue() 时，才会真正交给 OkHttp 发起请求。
一句话总结：Retrofit 通过动态代理和反射，把接口方法转换成 HTTP 请求，最终交给 OkHttp 执行。