RestTemplate、WebClient、OpenFeign 有什么区别？微服务里调用 HTTP 接口该用哪个？

简化版

Java/Spring 里发 HTTP 请求（调别的服务的 REST 接口）主要有三个选择：RestTemplate、WebClient、OpenFeign，区别在「同步/异步、命令式/声明式、是否已过时」：① RestTemplate——Spring 传统的同步、阻塞的 HTTP 客户端，命令式（手动拼 URL、传参、处理响应）；简单直接但已进入维护模式（官方建议新项目别用了、用 WebClient）；② WebClient——Spring 5 引入的响应式、非阻塞HTTP 客户端（基于 Reactor），支持异步和流式，也能当同步用（.block()）；是官方推荐替代 RestTemplate 的新客户端；③ OpenFeign——声明式HTTP 客户端：你只需定义一个接口 + 注解（@FeignClient + @GetMapping），Feign 自动生成实现去发请求，像调本地方法一样调远程接口，代码最简洁，且和 Spring Cloud 生态（负载均衡、熔断）无缝集成，是微服务间调用的主流选择。怎么选：微服务间调用用 OpenFeign（声明式、简洁、集成好）；需要响应式/异步/流式用 WebClient；RestTemplate 老项目还在用但新项目别选。

详细版

三者对比：

维度	RestTemplate	WebClient	OpenFeign
编程风格	命令式（手动调用）	命令式/响应式	声明式（接口+注解）
同步/异步	同步阻塞	非阻塞（也能 block 同步）	同步（默认）
底层	阻塞 IO	Reactor Netty（非阻塞）	可配底层
代码量	中	中	最少（接口+注解）
微服务集成	需手动配负载均衡	需手动配	无缝（LoadBalancer/熔断）
状态	维护模式（不推荐新用）	推荐	微服务主流

// ① RestTemplate（同步阻塞，命令式，已过时）
RestTemplate rt = new RestTemplate();
User user = rt.getForObject("http://user-service/users/1", User.class);

// ② WebClient（响应式非阻塞，也能同步）
WebClient client = WebClient.create();
Mono<User> mono = client.get()
    .uri("http://user-service/users/1")
    .retrieve()
    .bodyToMono(User.class);
User user2 = mono.block();   // .block() 转同步（异步用 subscribe）

// ③ OpenFeign（声明式，最简洁，微服务主流）
@FeignClient(name = "user-service")   // 指定目标服务（配合注册中心+负载均衡）
public interface UserClient {
    @GetMapping("/users/{id}")
    User getUser(@PathVariable Long id);   // 定义接口即可，Feign 自动实现
}
// 使用：注入 UserClient，像调本地方法
@Autowired UserClient userClient;
User user3 = userClient.getUser(1L);   // 底层是 HTTP 调用，且自带负载均衡/熔断

⚠️ 微服务间调用为什么主流用 OpenFeign，关键在「声明式 + 与 Spring Cloud 生态无缝集成」。用 RestTemplate/WebClient 调另一个服务，要手动拼 URL、手动配置负载均衡（从注册中心选实例）、手动加熔断降级——代码繁琐、每个调用点都要处理。而 OpenFeign 只需定义一个接口（@FeignClient("user-service") + @GetMapping），就把「服务发现（user-service 是服务名，Feign 配合 LoadBalancer 从注册中心找实例）、负载均衡、熔断（配合 Resilience4j/Sentinel）、请求编解码」全部自动化了，调用时像调本地方法一样。这就是它成为微服务主流的原因——把「远程调用的复杂度」藏在声明式接口后面。不过要注意 Feign 默认是同步阻塞的（底层可换，但编程模型是同步），需要高并发非阻塞的场景可能要用 WebClient 或响应式的方案。

完整版教学

一、三个客户端的定位

先建立三者的整体定位：

它们都是"发 HTTP 请求"的客户端，但设计理念和适用场景不同：

RestTemplate（老大哥，已退休）：
  Spring 传统的同步 HTTP 客户端
  命令式——你手动发请求、处理响应
  简单直接，但已进入"维护模式"（不再增强，官方建议用 WebClient）

WebClient（响应式新秀）：
  Spring 5（WebFlux）引入的非阻塞 HTTP 客户端
  响应式——基于 Reactor，返回 Mono/Flux，支持异步、流式
  也能当同步用（.block()）
  官方推荐用它替代 RestTemplate

OpenFeign（声明式，微服务主流）：
  声明式 HTTP 客户端——定义接口 + 注解，自动生成实现
  像调本地方法一样调远程服务
  和 Spring Cloud 生态（负载均衡、熔断）无缝集成
  微服务间调用的主流选择

一句话定位：
  RestTemplate：同步、命令式、过时
  WebClient：响应式、非阻塞、推荐
  OpenFeign：声明式、简洁、微服务主流

三者定位：RestTemplate（Spring 传统同步命令式 HTTP 客户端，简单但已维护模式、官方建议用 WebClient）、WebClient（Spring 5 引入的响应式非阻塞客户端，基于 Reactor 返回 Mono/Flux、也能同步 .block()、官方推荐替代 RestTemplate）、OpenFeign（声明式客户端，接口+注解自动生成实现、像调本地方法、和 Spring Cloud 生态无缝、微服务间调用主流）。理解「RestTemplate 同步命令式过时、WebClient 响应式非阻塞推荐、OpenFeign 声明式简洁微服务主流」，就建立了三者的整体定位。

二、RestTemplate：同步阻塞、已过时

先看 RestTemplate 的特点和现状：

RestTemplate：
  Spring 传统的同步 HTTP 客户端
  命令式 API：
    getForObject / getForEntity（GET）
    postForObject / postForEntity（POST）
    exchange（通用）
    → 手动指定 URL、参数、响应类型

  User u = rt.getForObject("http://svc/users/{id}", User.class, 1);

特点：
  ① 同步阻塞——发请求后，线程阻塞等待响应
  ② 命令式——手动调用、手动处理
  ③ 简单直接——上手容易

现状（已过时）：
  Spring 官方把 RestTemplate 标为"维护模式"（maintenance mode）
  → 不再添加新功能，但仍可用（不会立刻删除）
  → 官方建议新项目用 WebClient

Spring 6 的新选择：
  RestClient——Spring 6.1 引入的同步客户端
  提供类似 WebClient 的流式 API，但是同步的
  → 想要"同步 + 现代 API"可以用 RestClient（比 RestTemplate 新）

所以：
  RestTemplate 老项目还在用，新项目别选
  想同步 → RestClient（Spring 6.1+）或 WebClient.block()

RestTemplate 是 Spring 传统同步阻塞、命令式 HTTP 客户端（getForObject/postForObject/exchange，手动指定 URL/参数/响应类型）。特点：同步阻塞（线程等待响应）、命令式、简单。现状：已维护模式（不再加新功能但可用，官方建议新项目用 WebClient）。Spring 6.1 引入 RestClient（同步但流式 API、比 RestTemplate 现代）。所以 RestTemplate 老项目还用、新项目别选（想同步用 RestClient 或 WebClient.block()）。理解「RestTemplate 同步阻塞命令式(getForObject 等)、已维护模式官方建议用 WebClient、Spring6.1 有 RestClient 同步现代、老项目用新项目别选」，就掌握了 RestTemplate。

三、WebClient：响应式非阻塞

再看 WebClient 的响应式特点：

WebClient：
  Spring 5（WebFlux）引入的响应式 HTTP 客户端
  基于 Reactor（Mono/Flux）、底层 Reactor Netty（非阻塞 IO）

  流式 API：
    webClient.get()
      .uri("http://svc/users/{id}", 1)
      .retrieve()
      .bodyToMono(User.class)   // 返回 Mono<User>（异步）

响应式/非阻塞的价值：
  ① 非阻塞——发请求不阻塞线程，线程可以去干别的
     → 少量线程支撑大量并发请求（高并发省线程）
  ② 异步——返回 Mono/Flux，可以链式组合、并发多个请求
     Mono.zip(callA, callB, callC)  // 并发调用多个服务
  ③ 流式——支持流式响应（SSE、大数据流）

也能当同步用：
  mono.block()  // 阻塞等待结果，转成同步
  → 但在响应式栈里 block 是反模式（浪费响应式的优势）

适用：
  ① 需要非阻塞、高并发（省线程）
  ② 需要异步、并发调用多个服务（聚合场景）
  ③ 需要流式（SSE）
  ④ WebFlux 响应式项目（技术栈一致）

注意：
  响应式编程有学习成本（Reactor 的 Mono/Flux、操作符）
  传统同步项目里用 WebClient 也行（但常 .block() 转同步）

WebClient 是 Spring 5 引入的响应式非阻塞 HTTP 客户端（基于 Reactor 的 Mono/Flux、底层 Reactor Netty）。响应式/非阻塞的价值：① 非阻塞（发请求不阻塞线程、少量线程支撑大量并发、高并发省线程）、② 异步（返回 Mono/Flux 可链式组合、Mono.zip 并发调多个服务聚合）、③ 流式（SSE/大数据流）。也能同步（.block()，但响应式栈里是反模式）。适用：非阻塞高并发、异步并发调多服务、流式、WebFlux 项目。注意响应式有学习成本（Reactor 操作符）。理解「WebClient 响应式非阻塞(基于 Reactor)、价值:非阻塞高并发省线程/异步并发调多服务(Mono.zip)/流式、也能.block()同步(响应式栈里是反模式)、适用非阻塞/异步聚合/流式/WebFlux 项目」，就掌握了 WebClient。

四、OpenFeign：声明式

再看 OpenFeign 的声明式特点——微服务主流：

OpenFeign：声明式 HTTP 客户端
  你只定义一个接口 + 注解，Feign 自动生成实现去发请求

  @FeignClient(name = "user-service")   // 目标服务名
  public interface UserClient {
      @GetMapping("/users/{id}")
      User getUser(@PathVariable Long id);
  }
  // 使用：注入接口，像调本地方法
  User u = userClient.getUser(1L);   // 底层是 HTTP 调用

声明式的价值（对比命令式）：
  RestTemplate/WebClient（命令式）：
    每个调用都要手动拼 URL、传参、处理响应
  Feign（声明式）：
    定义接口 = 定义"要调什么"，实现自动生成
    → 调用像本地方法，代码最简洁、意图清晰

和 Spring Cloud 生态无缝集成（关键）：
  ① 服务发现 + 负载均衡：
     @FeignClient("user-service") 里 user-service 是服务名
     Feign 配合 LoadBalancer 从注册中心找实例、负载均衡
     → 不用手动拼 IP、不用手动选实例
  ② 熔断降级：
     配合 Resilience4j/Sentinel，加 fallback
  ③ 请求/响应编解码、拦截器、超时、重试

所以 Feign 是微服务间调用的主流：
  声明式简洁 + 服务发现/负载均衡/熔断 全自动化
  把"远程调用的复杂度"藏在接口后面

底层：
  Feign 默认同步阻塞（编程模型是同步的）
  底层 HTTP 实现可换（Apache HttpClient、OkHttp）

OpenFeign 是声明式 HTTP 客户端——定义接口 + 注解，Feign 自动生成实现（@FeignClient("user-service") + @GetMapping），调用像本地方法。声明式价值（对比命令式手动拼 URL/传参）：定义接口=定义要调什么、实现自动生成、代码最简洁。和 Spring Cloud 生态无缝集成（关键）：① 服务发现+负载均衡（user-service 是服务名、Feign 配合 LoadBalancer 从注册中心找实例、不用手动拼 IP）、② 熔断降级（配 Resilience4j/Sentinel fallback）、③ 编解码/拦截器/超时/重试。所以 Feign 是微服务主流（声明式简洁 + 服务发现/负载均衡/熔断全自动化）。底层默认同步阻塞、HTTP 实现可换。理解「OpenFeign 声明式(接口+注解自动生成实现、像调本地方法)、和 Spring Cloud 无缝(服务名找实例+负载均衡+熔断+编解码全自动)、微服务主流、默认同步阻塞」，就掌握了 OpenFeign。

五、怎么选

综合对比，给出选择建议：

选择（按场景）：

微服务间调用 → OpenFeign（主流）：
  声明式简洁 + 服务发现/负载均衡/熔断无缝集成
  → 内部服务互调，Feign 最省心

需要非阻塞/异步/高并发/流式 → WebClient：
  响应式非阻塞、少量线程高并发、异步并发调多服务、流式
  → WebFlux 项目、高并发聚合、SSE 等

需要同步、命令式、简单场景 → RestClient（新）或 RestTemplate（老）：
  Spring 6.1+ 用 RestClient（同步 + 现代流式 API）
  老项目已有 RestTemplate 继续用（但别在新代码里选）

对比记忆：
  声明式、微服务集成好 → OpenFeign
  响应式、非阻塞、异步 → WebClient
  同步、命令式、简单 → RestClient（新）/RestTemplate（老，过时）

实践中的常见组合：
  微服务内部互调：OpenFeign（配合 Nacos/Eureka + LoadBalancer + Sentinel）
  需要并发调多个服务聚合：WebClient（Mono.zip）
  简单的、一次性的 HTTP 调用：RestClient/RestTemplate

一句话：
  微服务间调用首选 OpenFeign（声明式 + 生态集成）；
  非阻塞/异步/流式用 WebClient；
  同步简单用 RestClient（RestTemplate 已过时）

选择建议（按场景）：微服务间调用用 OpenFeign（声明式简洁 + 服务发现/负载均衡/熔断无缝，最省心）；需要非阻塞/异步/高并发/流式用 WebClient（WebFlux 项目、高并发聚合、SSE）；需要同步简单用 RestClient（Spring 6.1+，现代）或 RestTemplate（老项目，已过时）。常见组合：内部互调 OpenFeign（配 Nacos+LoadBalancer+Sentinel）、并发聚合 WebClient（Mono.zip）、简单调用 RestClient。理解「选择:微服务间调用用 OpenFeign(声明式+生态)、非阻塞异步流式用 WebClient、同步简单用 RestClient(RestTemplate 过时);组合:内部互调 Feign、并发聚合 WebClient、简单调用 RestClient」，就掌握了选择建议。

六、演进与注意点

理解演进现状和注意点：

演进现状（避免过时认知）：
  RestTemplate → 维护模式（Spring 建议用别的）
  RestClient（Spring 6.1）→ 同步的现代客户端（替代 RestTemplate 的同步场景）
  WebClient → 响应式客户端（替代 RestTemplate 的异步/非阻塞场景）
  OpenFeign → 微服务声明式调用主流

  所以现在：
    同步现代 API → RestClient
    响应式非阻塞 → WebClient
    微服务声明式 → OpenFeign
    RestTemplate → 别在新项目选

注意点：
  ① Feign 默认同步阻塞——高并发场景可能是瓶颈
     （可配底层连接池、或用响应式方案）
  ② WebClient 的响应式有学习成本——别为了用而用
     （非响应式项目，同步需求用 RestClient 更简单）
  ③ 超时、重试、熔断——不管用哪个，都要配好
     （尤其微服务调用，下游可能慢/挂，要有保护）
  ④ 连接池——RestTemplate/WebClient/Feign 都要配连接池
     （默认可能没连接复用，性能差）

核心总结：
  微服务间调用 → OpenFeign（声明式 + 生态）
  非阻塞/异步/流式 → WebClient
  同步简单 → RestClient（RestTemplate 已过时）
  都要配好超时/重试/熔断/连接池

演进现状：RestTemplate 维护模式、RestClient（Spring 6.1）同步现代、WebClient 响应式、OpenFeign 微服务声明式主流——现在同步用 RestClient、响应式用 WebClient、微服务用 OpenFeign、RestTemplate 别在新项目选。注意点：① Feign 默认同步阻塞（高并发可能瓶颈）、② WebClient 响应式有学习成本（别为用而用）、③ 超时/重试/熔断都要配好（下游可能慢/挂）、④ 连接池都要配（默认可能没连接复用）。理解「演进:RestTemplate 维护模式/RestClient 同步现代/WebClient 响应式/OpenFeign 微服务主流;注意:Feign 默认同步阻塞、WebClient 有学习成本、超时重试熔断连接池都要配好」，就掌握了演进和注意点。

记忆钩子：「Java/Spring HTTP 客户端三选:①RestTemplate(同步阻塞/命令式/手动拼 URL,已维护模式官方建议别用,Spring6.1 有 RestClient 替代同步场景)②WebClient(Spring5 响应式非阻塞/基于 Reactor Mono-Flux,非阻塞高并发省线程+异步并发调多服务 Mono.zip+流式,也能.block()同步,官方推荐替代 RestTemplate)③OpenFeign(声明式:接口+注解自动生成实现像调本地方法,和 Spring Cloud 无缝-服务名找实例+负载均衡+熔断全自动,微服务间调用主流,默认同步阻塞);选择:微服务间调用用 OpenFeign(声明式+生态)、非阻塞异步流式用 WebClient、同步简单用 RestClient;都要配超时/重试/熔断/连接池」。

七、常见误区与追问

• 误区：新项目还应该用 RestTemplate。 RestTemplate 已进入维护模式（Spring 不再增强、官方建议别在新项目用）；新项目想同步用 RestClient（Spring 6.1+，同步+现代流式 API），想响应式/非阻塞用 WebClient，微服务间调用用 OpenFeign；RestTemplate 只是老项目继续兼容用。
• 误区：WebClient 只能异步用。 WebClient 也能同步——调 .block() 阻塞等待结果转成同步；但在响应式栈（WebFlux）里用 .block() 是反模式（浪费了响应式非阻塞的优势）；WebClient 主要价值在非阻塞、异步、流式，纯同步需求用 RestClient 更简单。
• 误区：OpenFeign 是异步非阻塞的。 OpenFeign 默认是同步阻塞的（编程模型是同步，调用会阻塞等待响应）；底层 HTTP 实现可换（Apache HttpClient、OkHttp），但编程模型不变；需要非阻塞/高并发时要用 WebClient 或响应式方案，不是 Feign。
• 误区：用 RestTemplate/WebClient 调微服务和用 Feign 一样方便。 Feign 更方便——用 RestTemplate/WebClient 要手动拼 URL、手动配负载均衡（从注册中心选实例）、手动加熔断，每个调用点都要处理；Feign 声明式只需定义接口+注解，服务发现、负载均衡、熔断、编解码全自动化，调用像本地方法；所以微服务间调用主流用 Feign。
• 追问：为什么微服务间调用主流用 OpenFeign？ 因为声明式 + 与 Spring Cloud 生态无缝集成——只需定义一个接口（@FeignClient(“服务名”) + @GetMapping），就把服务发现（服务名配合 LoadBalancer 从注册中心找实例）、负载均衡、熔断降级（配合 Resilience4j/Sentinel）、请求编解码全部自动化，调用时像调本地方法一样简洁；而 RestTemplate/WebClient 要手动处理这些；Feign 把远程调用的复杂度藏在声明式接口后面。
• 追问：WebClient 相比 RestTemplate 的核心优势是什么？ 非阻塞和异步——WebClient 基于 Reactor（返回 Mono/Flux）、底层 Reactor Netty 非阻塞 IO，发请求不阻塞线程，少量线程能支撑大量并发请求（省线程）；还能异步链式组合、并发调用多个服务（Mono.zip 聚合）、支持流式（SSE）；RestTemplate 是同步阻塞的（每个请求阻塞一个线程）；所以高并发、异步聚合、流式场景 WebClient 优势明显。
• 追问：Spring 6 的 RestClient 是什么？和 WebClient、RestTemplate 什么关系？ RestClient 是 Spring 6.1 引入的同步 HTTP 客户端——它提供类似 WebClient 的现代流式 API（链式调用），但是同步阻塞的（不像 WebClient 是响应式）；定位是「替代 RestTemplate 的同步场景」（RestTemplate 已过时、API 老旧）；所以现在：同步现代 API 用 RestClient、响应式非阻塞用 WebClient、微服务声明式用 OpenFeign、RestTemplate 别在新项目选。

八、加强记忆

Java/Spring 里调 HTTP 接口三个主要选择：① RestTemplate——Spring 传统的同步阻塞、命令式 HTTP 客户端（getForObject 等，手动拼 URL/传参），简单但已进入维护模式（官方建议新项目别用，同步场景 Spring 6.1 有 RestClient 替代，同步+现代流式 API）；② WebClient——Spring 5 引入的响应式非阻塞客户端（基于 Reactor 的 Mono/Flux、底层 Reactor Netty），非阻塞高并发省线程、异步并发调多服务（Mono.zip）、流式（SSE），也能 .block() 同步（响应式栈里是反模式），官方推荐替代 RestTemplate；③ OpenFeign——声明式客户端（定义接口 + 注解，Feign 自动生成实现，像调本地方法），和 Spring Cloud 生态无缝集成（@FeignClient("服务名") 配合 LoadBalancer 从注册中心找实例 + 负载均衡 + 熔断 + 编解码全自动），微服务间调用主流（默认同步阻塞）。怎么选：微服务间调用用 OpenFeign（声明式 + 生态集成）、非阻塞/异步/高并发/流式用 WebClient、同步简单用 RestClient（RestTemplate 已过时）；都要配好超时/重试/熔断/连接池。一句话「HTTP 客户端:RestTemplate(同步命令式,维护模式别用新项目)、WebClient(响应式非阻塞,高并发/异步聚合/流式,推荐)、OpenFeign(声明式接口+注解自动实现,和 Spring Cloud 无缝-服务发现/负载均衡/熔断全自动,微服务主流);微服务间调用用 OpenFeign、非阻塞异步用 WebClient、同步简单用 RestClient」。