Java HTTP 请求框架对比

Java 后端绕不开 HTTP 客户端选型。从调用第三方 API、微服务间通信到 webhook 回调，几乎所有项目都需要发起 HTTP 调用。JDK 自带的 HttpURLConnection API 陈旧、功能薄弱，难以满足连接池管理、异步非阻塞、HTTP/2、自动重试等现代需求。社区因此涌现了大量框架，各自针对不同场景做了优化。

---

框架分类与总览

按照抽象层次和设计理念，主流 Java HTTP 框架可分为四类：

类别	框架	出品方	编程模型	底层引擎	HTTP/2	异步支持	声明式	Spring 集成	学习成本	适用场景
底层命令式	Apache HttpClient 5	Apache	同步+异步	自研	支持(async)	Future/Callback	否	一般	中高	通用、企业级
底层命令式	OkHttp	Square	同步+异步	自研	支持	Callback	否	无原生	中	Android、通用
底层命令式	Java 11 HttpClient	Oracle/JDK	同步+异步	JDK 自带	支持	CompletableFuture	否	无	低	简单场景、零依赖
高层命令式	Spring RestTemplate	Spring	同步阻塞	多种可插拔	取决底层	弱	否	原生	低	传统 Spring MVC
高层命令式	Spring RestClient	Spring	同步阻塞	多种可插拔	取决底层	弱	否	原生	低	新 Spring 同步场景
高层命令式	Hutool HttpUtil	Dromara	同步工具类	JDK HttpURLConnection	否	否	否	无	极低	脚本、简单调用
响应式	Spring WebClient	Spring	响应式非阻塞	Reactor Netty	支持	Mono/Flux	否	原生	中高	高并发、响应式
声明式	Retrofit	Square	声明式	OkHttp	支持	可选适配器	是	无原生	中	移动端、REST API
声明式	OpenFeign	Netflix/Spring	声明式	可插拔	取决底层	可选	是	深度集成	低	Spring Cloud 微服务
声明式	Forest	Dromara	声明式	OkHttp/HttpClient	支持	支持	是	集成	低	国产项目、快速开发

高层框架的底层依赖请参考对应底层框架行。

---

各框架详解

Apache HttpClient 5

简介

Apache HttpClient 是 Apache HttpComponents 项目下的子项目，前身可追溯到 Jakarta Commons HttpClient。HttpClient 5 是一次重大重构，将原来混乱的 API 拆分为 Classic（阻塞）和 Async（异步）两套独立 API，并引入了新的 I/O 模型。它是 Java 企业级开发中最经典的 HTTP 客户端，被大量框架（如 Spring RestTemplate、Elasticsearch RestHighLevelClient）作为底层引擎使用。

核心架构

HttpClient 5 的核心架构围绕"请求执行链"展开，采用责任链模式组织各个处理环节：

HttpClient (CloseableHttpClient / CloseableHttpAsyncClient)
   │
   ├── HttpRequestExecutor / AsyncExecChain  ← 请求执行链
   │       │
   │       ├── MainExec / AsyncMainClientExec   (主请求执行)
   │       ├── RetryExec                         (重试)
   │       ├── RedirectExec                      (重定向)
   │       ├── ProtocolExec                      (协议处理)
   │       ├── ConnectExec                       (连接建立)
   │       └── ServiceUnavailableRetryExec       (503 重试)
   │
   ├── HttpClientConnectionManager / AsyncClientConnectionManager  ← 连接池
   │       └── PoolingHttpClientConnectionManager
   │
   └── HttpRequestRetryStrategy / AsyncHttpRequestRetryStrategy  ← 重试策略

核心源码分析

每个执行环节被抽象为 ExecChainHandler，通过 ExecChainElement 串成链表：

// org.apache.hc.client5.http.impl.classic.ExecChainElement
final class ExecChainElement {
    private final ExecChainHandler handler;
    private final ExecChainElement next;

    ClassicHttpResponse proceed(final ClassicHttpRequest request, final ExecChain.Scope scope) {
        return handler.handle(request, scope, new ExecChain(next, scope));
    }
}

PoolingHttpClientConnectionManager 内部维护 LinkedList<CPoolEntry>[] 按路由分组，每个路由有独立的连接队列，支持 maxPerRoute 和 maxTotal 双层限制。

使用示例

try (CloseableHttpClient httpclient = HttpClients.createDefault()) {
    HttpGet httpGet = new HttpGet("https://httpbin.org/get");
    try (CloseableHttpResponse response = httpclient.execute(httpGet)) {
        System.out.println(response.getCode()); // 200
        String body = EntityUtils.toString(response.getEntity());
        System.out.println(body);
    }
}

异步 POST 请求：

CloseableHttpAsyncClient asyncClient = HttpAsyncClients.createDefault();
asyncClient.start();

HttpPost httpPost = new HttpPost("https://httpbin.org/post");
httpPost.setEntity(new StringEntity("{\"name\":\"test\"}", ContentType.APPLICATION_JSON));

Future<SimpleHttpResponse> future = asyncClient.execute(
    SimpleHttpRequest.create(Method.POST, URI.create("https://httpbin.org/post")),
    FutureCallback.<SimpleHttpResponse>builder()
        .onSuccess(resp -> System.out.println("OK: " + resp.getBodyText()))
        .onFailure(ex -> ex.printStackTrace())
        .build()
);
SimpleHttpResponse response = future.get();
asyncClient.close(CloseMode.IMMEDIATE);

优缺点

优点：

• 成熟稳定，社区庞大，文档完善
• 功能全面：连接池、重试、重定向、认证、Cookie、代理、SSL/TLS 全套支持
• 同步/异步双 API，迁移成本低
• 高度可配置，几乎所有行为可定制
• HTTP/2 支持通过 Async API 实现

缺点：

• API 较为繁琐，样板代码多
• 配置项过多，初学者容易踩坑（如连接池参数、超时设置分散在多处）
• Classic API 仍基于阻塞 I/O，高并发场景下线程开销大
• 5.x 与 4.x API 不兼容，迁移有成本

适用场景：企业级应用、需要精细控制 HTTP 行为的场景、作为其他框架的底层引擎。

---

OkHttp

简介

OkHttp 是 Square 公司开源的 HTTP 客户端，最初为 Android 设计，但因 API 优雅、性能优秀，在 Java 后端也被广泛使用。Android 4.4 起，系统内部 HttpURLConnection 的实现已替换为 OkHttp。OkHttp 默认支持连接池、GZIP 压缩、响应缓存、HTTP/2，开箱即用。

核心架构

OkHttp 的核心设计是拦截器链（Interceptor Chain），所有请求处理逻辑（重试、重定向、Cookie、桥接、缓存、连接、网络请求）都被建模为拦截器，串成一条链：

OkHttpClient
   │
   ├── Dispatcher          ← 调度器（异步请求队列管理）
   ├── ConnectionPool      ← 连接池
   ├── Authenticator        ← 认证
   ├── Cache               ← 响应缓存
   ├── Interceptors        ← 用户自定义应用拦截器
   └── networkInterceptors ← 用户自定义网络拦截器

请求执行流程：
RealCall.execute() / enqueue()
   │
   └── getResponseWithInterceptorChain()
           │
           └── Interceptor.Chain
                   ├── 用户 Interceptor
                   ├── RetryAndFollowUpInterceptor    (重试 & 重定向)
                   ├── BridgeInterceptor              (请求头补全、GZIP)
                   ├── CacheInterceptor               (缓存读写)
                   ├── ConnectInterceptor             (建立连接)
                   ├── 用户 networkInterceptor
                   └── CallServerInterceptor          (真正发送请求)

核心源码分析

拦截器链的核心——getResponseWithInterceptorChain，把所有拦截器按顺序组装，通过 chain.proceed 逐层传递：

Response getResponseWithInterceptorChain() throws IOException {
    List<Interceptor> interceptors = new ArrayList<>();
    interceptors.addAll(client.interceptors());                    // 应用拦截器
    interceptors.add(new RetryAndFollowUpInterceptor(client));     // 重试重定向
    interceptors.add(new BridgeInterceptor(client.cookieJar()));   // 桥接
    interceptors.add(new CacheInterceptor(client.cache()));        // 缓存
    interceptors.add(new ConnectInterceptor(client));              // 连接
    if (!forWebSocket) {
        interceptors.addAll(client.networkInterceptors());         // 网络拦截器
    }
    interceptors.add(new CallServerInterceptor(forWebSocket));     // 真正发请求

    Interceptor.Chain chain = new RealInterceptorChain(
        interceptors, transmitter, null, 0, originalRequest, this,
        client.connectTimeoutMillis(), client.readTimeoutMillis(),
        client.writeTimeoutMillis());

    return chain.proceed(originalRequest);
}

RealInterceptorChain#proceed 取出当前拦截器，创建下一层 chain，调用 interceptor.intercept(next)——递归式责任链，每个拦截器可在 intercept 中前置处理、调用 chain.proceed 让请求继续、后置处理响应。

异步请求通过 Dispatcher 统一调度，使用 SynchronousQueue + 缓存线程池执行，支持全局并发上限（默认 64）和单 host 并发上限（默认 5）。

使用示例

OkHttpClient client = new OkHttpClient.Builder()
    .connectTimeout(10, TimeUnit.SECONDS)
    .readTimeout(10, TimeUnit.SECONDS)
    .build();

Request request = new Request.Builder()
    .url("https://httpbin.org/get")
    .header("User-Agent", "MyApp")
    .build();

try (Response response = client.newCall(request).execute()) {
    if (response.isSuccessful()) {
        System.out.println(response.body().string());
    }
}

优缺点

优点：

• API 设计优雅，链式调用，拦截器机制扩展性强
• 默认开启连接池、GZIP、HTTP/2，开箱即用
• 性能优秀，Android 平台事实标准
• 支持响应缓存（基于磁盘）
• 文档完善，社区活跃

缺点：

• 不支持同步阻塞的 Future 模式（异步只能用 Callback）
• 配置 SSL 较繁琐
• 在 Spring 生态中无原生集成，需手动封装
• 不支持响应式（Reactive Streams）

适用场景：Android 开发、对 API 优雅度有要求的 Java 后端、需要自定义拦截逻辑的场景。

---

Java 11+ HttpClient

简介

java.net.http.HttpClient 是 JDK 11 正式引入的标准 HTTP 客户端（JDK 9 起以孵化模块形式存在）。它填补了 JDK 长期以来缺乏现代 HTTP 客户端的空白，原生支持 HTTP/2、WebSocket、异步非阻塞，无需任何第三方依赖。

核心架构

JDK HttpClient 拥抱了响应式流（Reactive Streams）模型，底层使用 Java 9 引入的 Flow API，并通过 CompletableFuture 实现异步化。其架构分为三层：

HttpClient (不可变，配置中心)
   │
   ├── HttpClientImpl
   │     ├── selectorManager          ← 单线程 Selector 管理所有连接
   │     ├── connections (Multimap)   ← 连接池
   │     └── Http1Exchange / Http2Exchange  ← 协议交换
   │
   ├── HttpRequest (不可变请求描述)
   │     ├── URI / Method / Headers
   │     ├── BodyPublishers           ← 请求体发布器（Flow.Publisher）
   │     └── timeout
   │
   └── HttpResponse (响应)
         ├── BodyHandlers             ← 响应体处理器（Flow.Subscriber）
         └── BodySubscribers

核心源码分析

同步 send 内部其实调的是 sendAsync，然后阻塞等待：

// jdk.internal.net.http.HttpClientImpl
@Override
public <T> HttpResponse<T> send(HttpRequest req, BodyHandler<T> responseBodyHandler)
        throws IOException, InterruptedException {
    CompletableFuture<HttpResponse<T>> cf = sendAsync(req, responseBodyHandler);
    try {
        return cf.get();
    } catch (ExecutionException e) {
        // unwrap
    }
}

@Override
public <T> CompletableFuture<HttpResponse<T>> sendAsync(...) {
    // 1. 创建 Exchange
    // 2. 通过 selectorManager 建立连接
    // 3. 通过 Flow API 异步读写
    return MultiExchange.responseAsyncImpl(...);
}

这是 JDK HttpClient 高性能的关键：所有连接的 I/O 复用由单个 Selector 线程管理，业务逻辑通过 CompletableFuture 在用户提供的 Executor 上执行，实现了 I/O 与业务解耦。

使用示例

HttpClient client = HttpClient.newBuilder()
    .version(HttpClient.Version.HTTP_2)
    .connectTimeout(Duration.ofSeconds(10))
    .build();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("https://httpbin.org/get"))
    .timeout(Duration.ofSeconds(10))
    .header("Accept", "application/json")
    .GET()
    .build();

HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.statusCode());
System.out.println(response.body());

异步 POST + JSON：

String json = "{\"name\":\"test\"}";
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("https://httpbin.org/post"))
    .header("Content-Type", "application/json")
    .POST(HttpRequest.BodyPublishers.ofString(json))
    .build();

client.sendAsync(request, HttpResponse.BodyHandlers.ofString())
    .thenApply(HttpResponse::body)
    .thenAccept(System.out::println)
    .exceptionally(e -> { e.printStackTrace(); return null; });

优缺点

优点：

• JDK 内置，零依赖，无版本冲突风险
• 原生支持 HTTP/2 和 WebSocket
• 真正的异步非阻塞，基于 CompletableFuture，易于组合
• API 设计现代，Builder 模式 + 不可变对象
• 性能优秀，单线程 Selector 模型高效

缺点：

• 需要 JDK 11+（部分老项目仍用 JDK 8）
• 不支持 HTTP/1.1 的 Keep-Alive 显式管理（自动管理）
• 错误处理相对繁琐（ExecutionException 嵌套）
• 生态集成较弱，Spring 等框架对其支持有限
• 不支持同步阻塞的细粒度控制（如 OkHttp 拦截器）

适用场景：JDK 11+ 项目、对依赖体积敏感的场景、需要 HTTP/2 或 WebSocket 的场景、简单到中等复杂度的 HTTP 调用。

---

Spring RestTemplate

简介

RestTemplate 是 Spring Framework 3.0 引入的同步 HTTP 客户端，封装了底层 HTTP 引擎（默认 SimpleClientHttpRequestFactory，可切换为 Apache HttpClient、OkHttp 等），提供面向对象的、与 Spring HttpMessageConverter 深度集成的 API。它是 Spring MVC 时代事实标准的 HTTP 客户端。

注意：Spring 官方已明确表示 RestTemplate 不再增加新特性，进入维护模式。新项目应优先使用 RestClient（同步）或 WebClient（响应式）。

核心架构

RestTemplate (extends InterceptingHttpAccessor)
   │
   ├── HttpMessageConverter(s)      ← 请求/响应体序列化
   │     ├── StringHttpMessageConverter
   │     ├── MappingJackson2HttpMessageConverter
   │     ├── FormHttpMessageConverter
   │     └── ...
   │
   ├── ClientHttpRequestInterceptor ← 请求拦截器（如 BasicAuth）
   │
   ├── RequestFactory               ← 底层引擎抽象
   │     ├── SimpleClientHttpRequestFactory   (JDK HttpURLConnection)
   │     ├── HttpComponentsClientHttpRequestFactory (Apache HttpClient)
   │     └── OkHttp3ClientHttpRequestFactory  (OkHttp)
   │
   ├── ResponseErrorHandler          ← 错误处理
   │     └── DefaultResponseErrorHandler
   │
   └── UriTemplateHandler            ← URI 模板展开

核心源码分析

所有高层方法（getForObject、postForObject、exchange）最终都委托给 doExecute，体现了模板方法模式：

// org.springframework.web.client.RestTemplate
protected <T> T doExecute(URI url, HttpMethod method,
        @Nullable RequestCallback requestCallback,
        @Nullable ResponseExtractor<T> responseExtractor) {

    ClientHttpResponse response = null;
    try {
        ClientHttpRequest request = createRequest(url, method);
        if (requestCallback != null) {
            requestCallback.doWithRequest(request);
        }
        response = request.execute();              // 真正发送请求
        handleResponse(url, method, response);     // 错误处理
        return (responseExtractor != null ?
                responseExtractor.extractData(response) : null);
    } catch (IOException ex) {
        // ...
    }
}

拦截器机制 InterceptingClientHttpRequest 同样采用递归式责任链，与 OkHttp 的拦截器思路类似。

使用示例

RestTemplate restTemplate = new RestTemplate();

// GET
String result = restTemplate.getForObject(
    "https://httpbin.org/get?name={name}", String.class, "test");

// POST + 对象转换
UserRequest req = new UserRequest("test", 18);
ResponseEntity<UserResponse> resp = restTemplate.postForEntity(
    "https://httpbin.org/post", req, UserResponse.class);

// Exchange（最灵活）
ResponseEntity<String> exchange = restTemplate.exchange(
    "https://httpbin.org/anything",
    HttpMethod.PUT,
    new HttpEntity<>(req, headers),
    String.class);

优缺点

优点：

• API 简洁，与 Spring 生态深度集成
• 自动序列化/反序列化（HttpMessageConverter）
• 支持拦截器、错误处理器扩展
• 底层引擎可插拔
• 学习成本低，文档丰富

缺点：

• 已进入维护模式，不再增加新特性，新项目不应使用
• 同步阻塞，高并发场景线程开销大
• 默认 SimpleClientHttpRequestFactory 不支持连接池
• 线程安全问题需注意（建议通过 RestTemplateBuilder 创建单例）
• API 设计相对陈旧（基于方法重载，扩展性受限）

适用场景：维护现有 Spring MVC 项目、短期过渡方案。新项目应优先选择 RestClient 或 WebClient。

---

Spring RestClient

简介

RestClient 是 Spring Framework 6.1（2023 年 11 月）引入的新一代同步 HTTP 客户端，定位为 RestTemplate 的现代化替代品。它采用 Fluent API 设计，链式调用更符合现代 Java 风格，同时保留了 HttpMessageConverter、拦截器等核心能力，并与 Spring Boot 的 RestTemplateBuilder 体系对齐。

核心架构

RestClient (不可变，线程安全)
   │
   ├── DefaultRestClient
   │     ├── RequestFactory               ← 底层引擎（同 RestTemplate）
   │     ├── MessageConverters
   │     ├── Interceptors
   │     ├── DefaultUriBuilderFactory     ← URI 模板
   │     ├── DefaultResponseErrorHandler  ← 错误处理
   │     └── ObservationRegistry          ← 可观测性（Micrometer）
   │
   └── Request 沿用 Builder + Spec 模式
         RestClient.Builder
            ├── baseUrl(String)
            ├── requestInterceptor(...)
            ├── messageConverters(...)
            └── build()

请求构建：
restClient.get().uri("/users/{id}", 1)
           .header("Authorization", "Bearer xxx")
           .retrieve()                    ← 触发请求
           .body(User.class)              ← 响应转换

核心源码分析

RestClient 一旦构建即不可变，线程安全，可作为单例共享。请求构建采用 Spec 模式，retrieve() 触发实际请求：

// org.springframework.web.client.DefaultRestClient
private class RequestDefault implements RequestSpec {
    @Override
    public ResponseSpec retrieve() {
        return exchange(exchange, request -> {
            ClientHttpResponse response = request.execute();
            handleError(response);
            return new DefaultResponseSpec(response, ...);
        }, true);
    }
}

RestClient 内部复用了 RestTemplate 的 HttpMessageConverter 体系和 ClientHttpRequestInterceptor 接口，但 API 完全重新设计。也支持通过 RestTemplate 的 RequestFactory 复用底层引擎配置。

使用示例

RestClient restClient = RestClient.builder()
    .baseUrl("https://httpbin.org")
    .defaultHeader("Accept", "application/json")
    .requestInterceptor(new LoggingInterceptor())
    .build();

// GET
User user = restClient.get()
    .uri("/get?id={id}", 1)
    .header("Authorization", "Bearer xxx")
    .retrieve()
    .body(User.class);

// POST
ResponseEntity<User> resp = restClient.post()
    .uri("/post")
    .contentType(MediaType.APPLICATION_JSON)
    .body(new UserRequest("test", 18))
    .retrieve()
    .toEntity(User.class);

// 错误处理
User result = restClient.get()
    .uri("/status/404")
    .retrieve()
    .onStatus(status -> status.value() == 404,
              (req, resp) -> { throw new UserNotFoundException(); })
    .body(User.class);

优缺点

优点：

• 现代 Fluent API，链式调用，可读性强
• 线程安全，可作为单例
• 与 Spring 生态深度集成（HttpMessageConverter、ObservationRegistry）
• 支持可观测性（Micrometer）
• 学习成本低，从 RestTemplate 迁移平滑
• 官方推荐，长期维护

缺点：

• 仍为同步阻塞模型，不适合超高并发
• 需要 Spring 6.1+ / Spring Boot 3.2+
• 生态尚在完善中，部分第三方库尚未适配

适用场景：新 Spring Boot 3.2+ 项目的同步 HTTP 调用、从 RestTemplate 平滑迁移、需要可观测性的场景。

---

Spring WebClient

简介

WebClient 是 Spring Framework 5.0 引入的非阻塞、响应式 HTTP 客户端，属于 Spring WebFlux 体系。它基于 Reactor 项目，通过 Mono（0/1 元素）和 Flux（0/N 元素）抽象异步数据流，底层默认使用 Reactor Netty，也可切换到其他 ClientHttpConnector。WebClient 是 Spring 官方推荐的高并发 HTTP 客户端，也是 RestTemplate 在响应式场景下的替代品。

核心架构

WebClient (顶层接口)
   │
   ├── DefaultWebClient
   │     ├── Builder
   │     │     ├── baseUrl
   │     │     ├── defaultHeaders / defaultCookies
   │     │     ├── filters (ExchangeFilterFunction)
   │     │     ├── clientConnector (ClientHttpConnector)
   │     │     ├── messageReaders / messageWriters
   │     │     └── observationRegistry
   │     │
   │     └── ExchangeStrategies  ← 编解码策略
   │
   ├── ClientHttpConnector       ← 底层引擎抽象
   │     ├── ReactorClientHttpConnector   (Reactor Netty，默认)
   │     ├── JettyClientHttpConnector     (Jetty)
   │     └── HttpComponentsClientHttpConnector (Apache HttpClient 5 async)
   │
   └── 请求构建（响应式流）
         WebClient.get().uri(...)
                   .header(...)
                   .body(...)              ← BodyInserter
                   .retrieve() / exchange()
                        │
                        ├── .bodyToMono(Class)    ← Mono<T>
                        ├── .bodyToFlux(Class)    ← Flux<T>
                        └── .toEntity(Class)      ← Mono<ResponseEntity<T>>

核心源码分析

请求执行的核心在 exchange 方法，应用过滤器链后委托给底层引擎：

private Mono<ClientResponse> exchange(Mono<ClientRequest> requestMono, boolean withDefaultStatusHandlers) {
    return requestMono
        .flatMap(request -> {
            ExchangeFunction exchange = DefaultWebClient.this.exchangeFunction;
            for (ExchangeFilterFunction filter : filters) {
                exchange = filter.filter(exchange);
            }
            return exchange.exchange(request);
        })
        .switchIfEmpty(Mono.error(...))
        .doOnNext(response -> {
            if (withDefaultStatusHandlers) {
                applyDefaultStatusHandlers(response);
            }
        });
}

底层委托给 Reactor Netty 的 HttpClient，后者基于 Netty 的 EventLoop 实现 NIO，少量线程即可处理海量连接。响应体被建模为 Flux<DataBuffer>，消费者通过 subscribe 时的 request(n) 控制流速，实现响应式背压。

使用示例

WebClient client = WebClient.builder()
    .baseUrl("https://httpbin.org")
    .defaultHeader("Accept", "application/json")
    .codecs(c -> c.defaultCodecs().maxInMemorySize(16 * 1024 * 1024))
    .build();

// GET（Mono）
Mono<User> userMono = client.get()
    .uri("/get?id={id}", 1)
    .retrieve()
    .bodyToMono(User.class);

User user = userMono.block();  // 阻塞获取（不推荐在响应式代码中使用）

// POST
Mono<User> result = client.post()
    .uri("/post")
    .contentType(MediaType.APPLICATION_JSON)
    .bodyValue(new UserRequest("test", 18))
    .retrieve()
    .bodyToMono(User.class);

// 流式响应（如 SSE）
Flux<Event> events = client.get()
    .uri("/events")
    .retrieve()
    .bodyToFlux(Event.class);

// 错误处理
Mono<User> safe = client.get()
    .uri("/users/{id}", 1)
    .retrieve()
    .onStatus(status -> status.is4xxClientError(),
              resp -> Mono.error(new UserNotFoundException()))
    .bodyToMono(User.class)
    .onErrorResume(e -> Mono.just(User.DEFAULT));

优缺点

优点：

• 真正的非阻塞异步，少量线程支撑高并发
• 原生支持背压（Reactive Streams）
• 流式响应处理能力强（SSE、分块传输）
• 与 Spring WebFlux 体系无缝集成
• 底层引擎可插拔（Reactor Netty / Jetty / Apache）
• 支持可观测性（Micrometer）

缺点：

• 学习曲线陡峭，需掌握 Reactor
• 调试困难（异步堆栈不直观）
• 阻塞调用（.block()）在响应式上下文中是反模式
• 生态依赖 Reactor，与阻塞式代码混用需谨慎
• 内存管理需注意 DataBuffer 释放

适用场景：Spring WebFlux 响应式应用、高并发 API 网关、流式数据处理、SSE/WebSocket 场景。

---

Retrofit

简介

Retrofit 是 Square 公司开源的声明式 HTTP 客户端，构建在 OkHttp 之上。开发者只需定义 Java 接口 + 注解描述请求，Retrofit 通过动态代理自动生成实现，将接口方法调用转换为 HTTP 请求。它极大简化了 REST API 的调用代码，是 Android 开发的标配，也被 Java 后端广泛使用。

核心架构

Retrofit (核心入口)
   │
   ├── Builder
   │     ├── baseUrl
   │     ├── callFactory (OkHttpClient)        ← 底层引擎
   │     ├── callAdapterFactories              ← 请求适配器（Call/RxJava/Coroutine）
   │     ├── converterFactories                ← 数据转换器（Gson/Moshi/Jackson）
   │     └── callbackExecutor
   │
   ├── create(Class<T> service)                ← 动态代理生成接口实例
   │
   └── ServiceMethod                           ← 接口方法元数据
         ├── parseAnnotations()                ← 解析方法注解
         ├── parseParameterAnnotation()        ← 解析参数注解
         └── CallAdapter / Converter

请求执行流程：
MyApi api = retrofit.create(MyApi.class);
   │
   └── Proxy.newProxyInstance(...)
           │
           └── InvocationHandler.invoke()
                   │
                   └── ServiceMethod.invoke(args)
                           │
                           └── CallAdapter.adapt(OkHttpCall)
                                   │
                                   ├── Call<T>          (默认)
                                   ├── Observable<T>    (RxJava)
                                   └── Deferred<T>      (Kotlin 协程)

核心源码分析

Retrofit 的核心是 create 方法，通过 Proxy.newProxyInstance 为接口生成动态代理。每次方法调用都会加载或缓存 ServiceMethod（注解解析结果）：

// retrofit2.Retrofit
public <T> T create(final Class<T> service) {
    validateServiceInterface(service);
    return (T) Proxy.newProxyInstance(
        service.getClassLoader(),
        new Class<?>[] {service},
        new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) {
                if (method.getDeclaringClass() == Object.class) {
                    return method.invoke(this, args);
                }
                return loadServiceMethod(method).invoke(args);
            }
        });
}

loadServiceMethod 使用缓存避免重复反射解析。最终请求执行委托给 OkHttp——Retrofit 只负责"接口方法 → OkHttp Request"的转换。通过 CallAdapter，可将 Call<T> 适配为任意返回类型（Observable、Deferred、CompletableFuture 等）。

使用示例

// 1. 定义接口
public interface GitHubApi {
    @GET("users/{user}/repos")
    Call<List<Repo>> listRepos(@Path("user") String user);

    @POST("repos")
    Call<Repo> createRepo(@Body Repo repo);

    @FormUrlEncoded
    @POST("oauth/token")
    Call<Token> getToken(@Field("code") String code);
}

// 2. 构建 Retrofit
Retrofit retrofit = new Retrofit.Builder()
    .baseUrl("https://api.github.com/")
    .addConverterFactory(GsonConverterFactory.create())
    .client(new OkHttpClient())
    .build();

// 3. 调用
GitHubApi api = retrofit.create(GitHubApi.class);
Call<List<Repo>> call = api.listRepos("octocat");
Response<List<Repo>> response = call.execute();
List<Repo> repos = response.body();

优缺点

优点：

• 声明式 API，代码极简，可读性极强
• 注解丰富，覆盖 REST 各种场景
• 通过 CallAdapter 和 Converter 高度可扩展
• 与 OkHttp 无缝集成，性能优秀
• 支持 RxJava、Kotlin 协程等异步模型

缺点：

• 依赖 OkHttp，无法切换底层引擎
• 不支持 Spring 生态原生集成
• 注解解析在运行时，有一定性能开销（虽有缓存）
• 不支持非 REST 风格的复杂请求（如动态 URL）
• 错误处理相对繁琐

适用场景：Android 开发、调用第三方 REST API、对代码简洁性要求高的场景。

---

Spring Cloud OpenFeign

简介

OpenFeign 起源于 Netflix Feign，后由 Spring Cloud 团队接管并深度集成，成为 Spring Cloud 体系下声明式 HTTP 客户端的事实标准。它在 Feign 的基础上增加了 Spring MVC 注解支持，与 Spring Cloud LoadBalancer、Circuit Breaker、Sleuth 等组件无缝集成，是微服务间调用的首选。

核心架构

@EnableFeignClients
   │
   └── FeignClientFactoryBean (每个 @FeignClient 接口对应一个)
           │
           ├── getObject()                  ← Spring 容器获取代理实例
           │     └── FeignClientBuilder
           │           └── Feign.builder()...
           │                 .target(FeignClient)
           │
           └── Feign.builder()
                 ├── Contract                ← 注解解析（SpringMvcContract）
                 ├── Encoder / Decoder       ← 编解码（Spring HttpMessageConverter）
                 ├── Client                  ← 底层引擎（默认 JDK，可换 OkHttp/Apache）
                 ├── Interceptors            ← 请求拦截器
                 ├── RequestInterceptor
                 └── InvocationHandlerFactory

请求执行流程：
myFeignClient.hello("world");
   │
   └── Proxy.invoke()
           │
           └── ReflectiveFeign.FeignInvocationHandler.invoke()
                   │
                   └── MethodHandler.invoke(args)
                           │
                           └── SynchronousMethodHandler
                                   │
                                   ├── RequestTemplate (构建请求模板)
                                   ├── Interceptor 链
                                   ├── Client.execute()  ← 真正发送
                                   └── Decoder.decode()  ← 响应解码

核心源码分析

方法调用的核心在 SynchronousMethodHandler，构建请求模板后执行，失败时按重试策略重试：

// feign.SynchronousMethodHandler
@Override
public Object invoke(Object[] argv) throws Throwable {
    RequestTemplate template = buildTemplateFromArgs.create(argv);
    Retryer retryer = this.retryer.clone();
    while (true) {
        try {
            return executeAndDecode(template);
        } catch (RetryableException e) {
            retryer.continueOrPropagate(e);
        }
    }
}

Object executeAndDecode(RequestTemplate template) {
    Request request = targetRequest(template);
    Response response = client.execute(request, options);
    return decoder.decode(response, metadata.returnType());
}

@EnableFeignClients 通过 FeignClientRegistrar 扫描 @FeignClient 接口，为每个接口注册 FeignClientFactoryBean，Spring 容器启动时调用 getObject() 生成代理实例。注解解析由 SpringMvcContract 完成，支持 @RequestMapping、@GetMapping、@PathVariable、@RequestBody 等 Spring MVC 注解。

与 Spring Cloud 组件的集成：

• 负载均衡：通过 FeignBlockingLoadBalancerClient 包装 Client，使用 Spring Cloud LoadBalancer 选择实例
• 熔断：通过 CircuitBreaker 集成 Resilience4j / Sentinel
• 链路追踪：通过 RequestInterceptor 注入 trace header

使用示例

// 1. 启用 Feign
@SpringBootApplication
@EnableFeignClients
public class App { ... }

// 2. 定义接口
@FeignClient(name = "user-service", url = "${user-service.url}")
public interface UserClient {
    @GetMapping("/users/{id}")
    User getUser(@PathVariable("id") Long id);

    @PostMapping("/users")
    User createUser(@RequestBody User user);

    @GetMapping("/users")
    List<User> listUsers(@RequestParam("page") int page,
                         @RequestParam("size") int size);
}

// 3. 注入使用
@Service
public class OrderService {
    @Autowired
    private UserClient userClient;

    public Order createOrder(Long userId) {
        User user = userClient.getUser(userId);
        // ...
    }
}

优缺点

优点：

• 声明式，代码极简，与 Spring MVC 注解一致
• 与 Spring Cloud 生态深度集成（负载均衡、熔断、链路追踪）
• 底层引擎可插拔（JDK / OkHttp / Apache HttpClient）
• 支持拦截器、错误解码器扩展
• 社区活跃，文档完善

缺点：

• 强依赖 Spring Cloud，非 Spring Cloud 项目不适用
• 默认同步阻塞，高并发场景需切换底层引擎
• 配置项繁多，初学者容易踩坑
• 超时、重试配置分散，需注意全局与局部优先级
• 不支持响应式（虽有 ReactiveFeign 第三方扩展）

适用场景：Spring Cloud 微服务架构、服务间调用、需要负载均衡和熔断的场景。

---

Forest

简介

Forest 是国产开源的声明式 HTTP 客户端框架，由 Dromara 社区维护。它结合了 Retrofit 的声明式理念和 Spring 的生态集成，支持 OkHttp 和 Apache HttpClient 双底层引擎，并提供了大量本土化特性（如 JSON 注解、文件上传下载、SSL 证书配置、模板表达式等）。Forest 在国内 Java 社区有一定影响力，适合快速开发场景。

核心架构

Forest (核心入口)
   │
   ├── ForestConfiguration (全局配置)
   │     ├── Backend (OKHTTP3 / HTTPCLIENT)
   │     ├── Interceptors
   │     ├── Converters
   │     └── Variables
   │
   ├── ForestProxy (动态代理工厂)
   │     └── create(Class<T> interface)
   │             │
   │             └── ForestMethod (接口方法元数据)
   │                     ├── AnnotationParser  ← 解析 @Get/@Post/@Var/@DataParam 等
   │                     ├── RequestTemplate
   │                     └── BackendClient.execute()
   │
   └── Backend (底层引擎抽象)
         ├── OkHttp3Backend
         └── HttpClientBackend

请求执行流程：
myClient.hello("world");
   │
   └── ForestProxy.invoke()
           │
           └── ForestMethod.invoke(args)
                   │
                   ├── 解析参数 + 模板表达式
                   ├── 构建 ForestRequest
                   ├── 应用 Interceptor 链
                   ├── Backend.execute(request)
                   └── Converter.convert(response)

核心源码分析

ForestMethod.invoke 是请求执行的核心——绑定参数、应用拦截器、执行请求、转换响应：

// com.dtflys.forest.reflection.ForestMethod
public Object invoke(Object proxy, Object[] args) {
    // 1. 绑定参数到 ForestRequest
    ForestRequest request = template.makeRequest(args);
    // 2. 应用拦截器链
    for (ForestInterceptor interceptor : interceptors) {
        interceptor.beforeExecute(request);
    }
    // 3. 执行请求
    ForestResponse response = backend.execute(request);
    // 4. 转换响应
    Object result = request.getResponseType().getResult(response);
    return result;
}

Forest 的模板表达式引擎支持 #{name}、${expr} 等语法，可在注解中引用变量、调用方法：

@Get("#{baseUrl}/users/#{id}")
User getUser(@Var("id") Long id);

@Get("http://#{host}:#{port}/api")
User get(@Var("host") String host, @Var("port") int port);

@Post("#{baseUrl}/users")
@Headers("Authorization: Bearer #{token}")
User create(@Var("token") String token, @Body User user);

底层引擎通过 Backend 接口抽象，OkHttp 和 Apache HttpClient 各有一个实现，可在配置中切换。

使用示例

// 1. 定义接口
@BaseRequest(baseURL = "https://httpbin.org")
public interface HttpBinClient {

    @Get("/get")
    @Headers("Accept: application/json")
    String get(@Query("name") String name);

    @Post("/post")
    @Headers("Content-Type: application/json")
    String post(@Body User user);

    @Get("/download/{filename}")
    @DownloadFile(dir = "/tmp", filename = "{filename}")
    File download(@Var("filename") String filename);
}

// 2. Spring Boot 集成
@Configuration
public class ForestConfig {
    @Bean
    public HttpBinClient httpBinClient() {
        return Forest.client(HttpBinClient.class);
    }
}

// 或通过 @ForestScan 自动扫描
@ForestScan(basePackages = "com.example.client")
@SpringBootApplication
public class App { ... }

// 3. 使用
@Autowired
private HttpBinClient client;
String result = client.get("test");

优缺点

优点：

• 声明式，注解丰富，支持模板表达式
• 双底层引擎（OkHttp / Apache HttpClient）可切换
• 与 Spring Boot 集成简单（@ForestScan）
• 文档中文化，对国内开发者友好
• 支持文件上传下载、SSL 证书、代理等高级特性
• 支持异步调用（返回 Future）

缺点：

• 社区规模和生态不如 Retrofit / OpenFeign
• 国际化程度低，海外项目慎用
• 性能优化空间有限（动态代理 + 反射开销）
• 部分高级特性文档不够完善
• 与 Spring Cloud 体系集成较弱

适用场景：国内 Java 项目、快速开发、需要灵活模板表达式的场景、对 OkHttp 和 HttpClient 都有需求的项目。

---

Hutool HttpUtil

简介

Hutool 是国内知名的 Java 工具类库，其中的 hutool-http 模块提供了极简的 HTTP 工具类 HttpUtil 和 HttpRequest。它基于 JDK 的 HttpURLConnection 封装，无需任何第三方依赖，API 极其简洁，适合脚本、快速原型、简单 HTTP 调用场景。

核心架构

HttpUtil (静态工具类，一行代码完成请求)
   │
   └── HttpRequest (链式构建请求)
         ├── url / method / headers / body / form / file
         ├── execute()                       ← 真正发送
         │     └── JdkHttpConnection (封装 HttpURLConnection)
         └── HttpResponse
                 ├── status / headers / body
                 ├── body() / bodyBytes()
                 └── readBody()

核心源码分析

HttpRequest 链式构建后调用 execute，底层就是封装 HttpURLConnection：

// cn.hutool.http.HttpRequest
public class HttpRequest extends HttpBase<HttpRequest> {
    private URL url;
    private Method method = Method.GET;
    private Map<String, List<String>> headers = new LinkedHashMap<>();
    private String body;
    private Map<String, Object> form;
    private int timeout = -1;

    public static HttpRequest get(String url) {
        return of(url).method(Method.GET);
    }

    public HttpRequest header(String name, String value) {
        putHeader(name, value);
        return this;
    }

    public HttpResponse execute() {
        return doExecute();
    }

    private HttpResponse doExecute() {
        HttpURLConnection conn = createConnection();
        // 写入请求头、请求体
        // 发送请求
        // 读取响应
        return new HttpResponse(conn, this);
    }
}

createConnection 内部就是 url.openConnection()，设置超时、请求头、SSL 等，然后通过 HttpURLConnection 发送请求。

使用示例

// 一行代码 GET
String result = HttpUtil.get("https://httpbin.org/get?name=test");

// 一行代码 POST
String resp = HttpUtil.post("https://httpbin.org/post", "{\"name\":\"test\"}");

// 链式构建（更灵活）
String body = HttpRequest.get("https://httpbin.org/get")
    .header("Authorization", "Bearer xxx")
    .timeout(5000)
    .execute()
    .body();

// 表单提交
String form = HttpRequest.post("https://httpbin.org/post")
    .form("name", "test")
    .form("age", 18)
    .execute()
    .body();

// 文件上传
HashMap<String, Object> uploadParams = new HashMap<>();
uploadParams.put("file", FileUtil.file("/tmp/test.txt"));
String upload = HttpRequest.post("https://httpbin.org/post")
    .form(uploadParams)
    .execute()
    .body();

优缺点

优点：

• API 极简，一行代码完成请求，学习成本几乎为零
• 零第三方依赖（仅依赖 JDK）
• 与 Hutool 其他工具类（JSON、IO、文件）无缝配合
• 适合脚本、快速原型、简单场景
• 文档中文化，对国内开发者友好

缺点：

• 基于 HttpURLConnection，性能一般
• 不支持连接池（每次请求新建连接，虽有简单复用）
• 不支持 HTTP/2
• 不支持异步
• 不支持响应式
• 不适合高并发、高性能场景
• 错误处理较粗糙

适用场景：脚本、单元测试、简单 HTTP 调用、对性能要求不高的内部工具、快速原型开发。

---

横向对比

性能对比

性能是 HTTP 客户端选型的重要维度，但需注意：实际性能受底层引擎、连接池配置、网络环境、负载特征等多因素影响，以下结论基于典型场景的相对比较。

框架	I/O 模型	单连接吞吐	高并发表现	内存占用	连接池
Apache HttpClient 5 (Classic)	阻塞 I/O	中	中（线程瓶颈）	中	内置
Apache HttpClient 5 (Async)	NIO	高	高	中	内置
OkHttp	阻塞 I/O + 异步队列	中高	中高	低	内置
Java 11 HttpClient	NIO（单 Selector）	高	高	低	内置
RestTemplate	取决底层	取决底层	取决底层	取决底层	取决底层
RestClient	取决底层	取决底层	取决底层	取决底层	取决底层
WebClient	NIO（Reactor Netty）	极高	极高	低	内置
Retrofit	取决 OkHttp	中高	中高	低	内置
OpenFeign	取决底层	取决底层	取决底层	取决底层	取决底层
Forest	取决底层	取决底层	取决底层	取决底层	取决底层
Hutool HttpUtil	阻塞 I/O	低	低	低	无

高层框架（RestTemplate、RestClient、OpenFeign、Forest）的性能取决于其底层引擎，参考对应底层框架行。

关键结论：

• 响应式非阻塞（WebClient、Java 11 HttpClient）在高并发场景下优势明显，少量线程即可支撑海量连接
• 阻塞 I/O + 连接池（OkHttp、Apache HttpClient）在中等并发下性能足够，且调试简单
• 声明式框架（Retrofit、OpenFeign、Forest）的性能瓶颈通常在底层引擎，而非代理层
• Hutool HttpUtil 不适合生产环境高并发场景，仅适合简单调用

易用性对比

框架	API 风格	样板代码	学习成本	文档质量	中文支持
Apache HttpClient 5	命令式	多	中高	优秀	一般
OkHttp	链式 Builder	少	中	优秀	一般
Java 11 HttpClient	Builder + CompletableFuture	少	低	优秀（JDK）	一般
RestTemplate	方法重载	少	低	优秀	优秀
RestClient	Fluent API	极少	低	优秀	优秀
WebClient	Fluent + 响应式	少	中高	优秀	优秀
Retrofit	声明式注解	极少	中	优秀	一般
OpenFeign	声明式注解	极少	低	优秀	优秀
Forest	声明式注解 + 模板	极少	低	良好	优秀
Hutool HttpUtil	静态工具	极少	极低	良好	优秀

功能特性对比

特性	Apache HC 5	OkHttp	Java 11 HC	RestTemplate	RestClient	WebClient	Retrofit	OpenFeign	Forest	Hutool
HTTP/2	✓(async)	✓	✓	取决底层	取决底层	✓	✓	取决底层	✓	✗
WebSocket	✗	✗	✓	✗	✗	✗	✗	✗	✗	✗
连接池	✓	✓	✓	取决底层	取决底层	✓	✓	取决底层	✓	✗
异步	✓	✓	✓	弱	弱	✓	✓(适配器)	弱	✓	✗
响应式	✗	✗	✗	✗	✗	✓	✓(适配器)	✗	✗	✗
自动重试	✓	✓	✗	✗	✗	✗	✗	✓	✓	✗
自动重定向	✓	✓	✓	✓	✓	✓	✓	✓	✓	✓
GZIP 压缩	✓	✓(自动)	✗	取决底层	取决底层	✓	✓	取决底层	✓	✗
响应缓存	✗	✓(磁盘)	✗	✗	✗	✗	✓	✗	✗	✗
拦截器	✓	✓	✗	✓	✓	✓	✓	✓	✓	✗
声明式	✗	✗	✗	✗	✗	✗	✓	✓	✓	✗
自动序列化	✗	✗	✗	✓	✓	✓	✓(转换器)	✓	✓	✗
文件上传下载	✓	✓	✓	✓	✓	✓	✓	✓	✓	✓
SSL/TLS	✓	✓	✓	✓	✓	✓	✓	✓	✓	✓
代理	✓	✓	✓	✓	✓	✓	✓	✓	✓	✓
认证	✓	✓	✓	✓	✓	✓	✓	✓	✓	弱
可观测性	弱	弱	弱	弱	✓(Micrometer)	✓(Micrometer)	弱	✓(Sleuth)	弱	✗

生态与集成对比

框架	Spring Boot 集成	Spring Cloud 集成	Android 适配	Kotlin 协程	Micrometer	社区活跃度
Apache HttpClient 5	一般	一般	一般	✗	弱	高
OkHttp	无原生	无原生	极佳	✓(社区)	弱	极高
Java 11 HttpClient	无	无	✗	✓(社区)	弱	中（JDK）
RestTemplate	原生	原生	一般	✗	✓	高（维护模式）
RestClient	原生	原生	一般	✗	✓	高（新）
WebClient	原生	原生	✗	✓	✓	高
Retrofit	无原生	无原生	极佳	✓(官方)	弱	极高
OpenFeign	原生	深度集成	一般	✓(社区)	✓	高
Forest	原生	弱	一般	✗	弱	中
Hutool HttpUtil	无	无	一般	✗	✗	中

---

选型建议

决策树

是否 Spring Cloud 微服务？
├── 是 → OpenFeign（深度集成负载均衡、熔断、链路追踪）
└── 否
    │
    是否需要响应式/非阻塞？
    ├── 是 → WebClient（Spring 生态）或 Java 11 HttpClient（非 Spring）
    └── 否
        │
        是否 Spring Boot 3.2+ 项目？
        ├── 是 → RestClient（同步，官方推荐）
        │       或 WebClient（如需响应式）
        └── 否
            │
            是否需要声明式 API？
            ├── 是 → Retrofit（非 Spring）或 Forest（国内项目）
            └── 否
                │
                是否 Android 项目？
                ├── 是 → OkHttp 或 Retrofit
                └── 否
                    │
                    是否需要零依赖？
                    ├── 是 → Java 11 HttpClient（JDK 11+）
                    └── 否
                        │
                        是否需要精细控制？
                        ├── 是 → Apache HttpClient 5
                        └── 否 → OkHttp（API 优雅）
                                  或 Hutool HttpUtil（极简脚本）

场景化推荐

Spring Cloud 微服务

推荐：OpenFeign

与 Spring Cloud 生态深度集成，开箱即用的负载均衡、熔断、链路追踪，声明式 API 极简。底层可切换为 OkHttp 或 Apache HttpClient 以提升性能。

# application.yml
spring:
  cloud:
    openfeign:
      okhttp:
        enabled: true  # 切换底层引擎为 OkHttp
      circuitbreaker:
        enabled: true  # 启用熔断

Spring Boot 3.2+ 同步调用

推荐：RestClient

官方推荐的新一代同步客户端，Fluent API 优雅，线程安全，与 Spring 生态深度集成，支持 Micrometer 可观测性。从 RestTemplate 迁移成本低。

高并发 API 网关

推荐：WebClient

基于 Reactor Netty 的非阻塞模型，少量线程支撑海量连接，原生支持背压和流式响应。配合 Spring WebFlux 构建全栈响应式架构。

Android 移动端

推荐：OkHttp + Retrofit

OkHttp 是 Android 事实标准，性能优秀，拦截器机制灵活；Retrofit 提供声明式 API，配合 Kotlin 协程实现优雅的异步调用。

interface GitHubApi {
    @GET("users/{user}/repos")
    suspend fun listRepos(@Path("user") user: String): List<Repo>
}

调用第三方 REST API（非 Spring）

推荐：Retrofit 或 OkHttp

Retrofit 声明式 API 极简，适合调用规范的 REST API；OkHttp 适合需要精细控制的场景。两者生态成熟，文档完善。

JDK 11+ 项目，零依赖

推荐：Java 11 HttpClient

JDK 内置，无第三方依赖，原生支持 HTTP/2 和异步，API 现代。适合对依赖体积敏感的场景（如库开发、云函数）。

企业级应用，需要精细控制

推荐：Apache HttpClient 5

功能最全面，配置项最丰富，几乎所有 HTTP 行为可定制。适合需要处理复杂认证、代理、SSL、重试策略的企业级场景。

国内快速开发

推荐：Forest 或 OpenFeign

Forest 文档中文化，支持模板表达式，双底层引擎可切换；OpenFeign 生态成熟。两者都提供声明式 API，开发效率高。

脚本 / 单元测试 / 简单调用

推荐：Hutool HttpUtil

一行代码完成请求，零学习成本，适合非生产环境或简单场景。

组合使用建议

实际项目中，常需组合使用多个框架：

组合	场景
OpenFeign + OkHttp/Apache HttpClient	微服务调用，底层引擎优化
Retrofit + OkHttp	移动端或非 Spring 项目
WebClient + RestClient	同一项目并存响应式和同步调用
Forest + OkHttp	国内项目，需要模板表达式
Apache HttpClient + RestTemplate/RestClient	复用底层连接池配置

迁移建议

RestTemplate → RestClient

// Before
RestTemplate restTemplate = new RestTemplate();
User user = restTemplate.getForObject("/users/{id}", User.class, 1);

// After
RestClient restClient = RestClient.create();
User user = restClient.get().uri("/users/{id}", 1).retrieve().body(User.class);

RestTemplate → WebClient（响应式迁移）

// Before
User user = restTemplate.getForObject("/users/{id}", User.class, 1);

// After
Mono<User> userMono = webClient.get().uri("/users/{id}", 1)
    .retrieve().bodyToMono(User.class);

OkHttp → Java 11 HttpClient

// Before
OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder().url(url).build();
try (Response resp = client.newCall(request).execute()) {
    String body = resp.body().string();
}

// After
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder().uri(URI.create(url)).build();
HttpResponse<String> resp = client.send(request, BodyHandlers.ofString());
String body = resp.body();

---

总结

选型核心原则

1. 跟随生态：Spring Boot 项目优先选择 Spring 原生客户端（RestClient/WebClient），Spring Cloud 项目优先选择 OpenFeign，Android 项目优先选择 OkHttp/Retrofit。生态一致性降低维护成本。

2. 匹配并发模型：高并发、I/O 密集型场景选择非阻塞框架（WebClient、Java 11 HttpClient）；中等并发、CPU 密集型场景选择阻塞框架（OkHttp、Apache HttpClient）即可，调试更简单。

3. 权衡学习成本：团队对响应式不熟悉时，不要盲目追求 WebClient；声明式框架虽简洁，但调试和扩展需理解动态代理原理。

4. 关注长期维护：避免选择已进入维护模式（RestTemplate）或社区停滞的框架；优先选择官方推荐、社区活跃的方案。

5. 性能不是唯一：除极端高并发场景外，大多数框架性能差异不显著。API 优雅度、生态集成、团队熟悉度往往比性能更重要。

一句话推荐

你的情况	推荐
Spring Cloud 微服务	OpenFeign
Spring Boot 3.2+ 同步调用	RestClient
Spring WebFlux 响应式	WebClient
Android 开发	OkHttp + Retrofit
非 Spring 的 REST API 调用	Retrofit 或 OkHttp
JDK 11+ 零依赖	Java 11 HttpClient
企业级精细控制	Apache HttpClient 5
国内快速开发	Forest
脚本/简单调用	Hutool HttpUtil