WebClient：Spring WebFlux 响应式 HTTP 客户端权威说明文档

最新推荐文章于 2025-11-24 03:02:27 发布
原创 最新推荐文章于 2025-11-24 03:02:27 发布 · 804 阅读 · 18 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#spring #http #java

作为 Java 后端开发者，你对 WebClient 的深入理解，是构建高性能、高并发、响应式微服务架构的关键能力。它不是“另一个 HTTP 客户端”，而是 Spring WebFlux 生态中声明式、非阻塞、流式、函数式的 HTTP 请求引擎。

以下是一份最标准、最实战、带完整中文注释的 WebClient 详解文档，涵盖概念、作用、特点、与 RestTemplate 的对比、生产级配置、最佳实践与真实业务示例。

📄 WebClient：Spring WebFlux 响应式 HTTP 客户端权威说明文档

版本：2025年10月
适用对象：Java 后端开发者 / 微服务架构师
目标：彻底掌握 WebClient 的设计哲学、核心能力、配置规范与生产级使用方式

一、WebClient 是什么？

✅ 官方定义（Spring Framework）

WebClient 是 Spring 5 引入的非阻塞、响应式、函数式 HTTP 客户端，用于在 Spring WebFlux 应用中执行异步 HTTP 请求。它基于 Project Reactor 的 Mono 和 Flux，支持流式传输、背压控制、并发请求合并、自动编解码，是 RestTemplate 在响应式世界中的唯一官方替代品。

🔑 核心定位

  • 不是“工具类”，而是一个声明式、链式调用的 HTTP 流处理器。
  • 完全非阻塞：底层使用 Netty 或 Reactor Netty，不占用线程等待响应。
  • 与服务端同构：使用与 @RestController 相同的 HttpMessageReader / HttpMessageWriter（即相同的 ObjectMapper、Jackson2JsonEncoder 等）。
  • 支持 HTTP/2、WebSocket、SSE、流式上传/下载。

二、WebClient 有什么作用？

作用说明
✅ 异步调用外部 REST API如：调用支付网关、短信服务、第三方用户中心
✅ 微服务间通信服务 A 调用服务 B，无需阻塞线程，支撑高并发
✅ 流式数据获取如：下载大文件、消费 SSE（Server-Sent Events）事件流
✅ 并发聚合多个下游服务如：首页聚合用户信息 + 订单 + 推荐商品
✅ 支持背压（Backpressure）消费端处理慢时，自动减缓数据发送速率，避免 OOM
✅ 内置重试、超时、熔断支持可组合响应式操作符实现优雅容错

💡 一句话总结：
WebClient = 响应式世界的 Retrofit + OkHttp + Feign + Stream，但更强大、更安全、更高效。

三、WebClient 的核心特点（与 RestTemplate 对比）

特性WebClientRestTemplate
编程模型响应式（Reactive）
Mono<ResponseEntity<T>> / Flux<T>		命令式（Imperative）
ResponseEntity<T> / T
I/O 模型✅ 非阻塞（Netty）
单线程可处理成千上万并发		❌ 阻塞（Apache HttpClient / OkHttp）
每请求一线程
线程消耗极低（共享 Event Loop 线程）高（每个请求占用一个 Tomcat 线程）
并发能力✅ 数万级并发（单机）千级并发（受限于线程池）
流式支持✅ 原生支持 SSE、Chunked、大文件流❌ 需手动处理流，易出错
编解码一致性✅ 与 @RestController 使用相同 HttpMessageConverter✅ 也支持，但配置分散
函数式 API✅ 链式调用、组合、操作符（map/flatMap/filter）❌ 方法调用式，无组合能力
重试/超时/熔断✅ 通过 .retryWhen()、.timeout()、.onErrorResume() 实现❌ 需集成 Resilience4j / Hystrix
是否支持 HTTP/2✅ 是（Netty 支持）✅ 仅部分客户端支持（需额外配置）
是否支持 WebSocket✅ 是（WebClient 不直接支持，但可用 WebSocketClient）❌ 不支持
是否推荐用于新项目✅✅✅ 官方唯一推荐❌ 已弃用（Deprecated）

🚫 Spring 官方声明：
“RestTemplate 已被标记为 @Deprecated，建议所有新项目使用 WebClient。”
—— Spring Framework 6.0+ 文档

四、为什么必须使用 WebClient？（不使用会怎样？）

❌ 错误做法：在 WebFlux 中使用 RestTemplate

@RestController
public class OrderController {

    @Autowired
    private RestTemplate restTemplate; // ❌ 阻塞式客户端！

    @GetMapping("/orders/{id}")
    public Mono<ResponseEntity<Order>> getOrder(@PathVariable Long id) {

        // ❌ 阻塞调用！线程在此处等待响应，完全破坏 WebFlux 非阻塞架构！
        ResponseEntity<Order> response = restTemplate.getForEntity(
            "http://payment-service/api/payments/" + id,
            Order.class
        );

        return Mono.just(response); // 返回的是阻塞后的结果，性能无提升
    }
}

后果：

  • 你以为用了 WebFlux，其实还是阻塞式架构。
  • 1000 并发 → 1000 个线程被 RestTemplate 卡住 → 服务器崩溃。
  • WebFlux 的性能优势荡然无存。

✅ 正确做法：使用 WebClient

@GetMapping("/orders/{id}")
public Mono<ResponseEntity<Order>> getOrder(@PathVariable Long id) {

    // ✅ 非阻塞、异步、流式调用
    return webClient
        .get()
        .uri("/api/payments/{id}", id)
        .retrieve()
        .toEntity(Order.class); // 返回 Mono<ResponseEntity<Order>>，不阻塞线程
}

✅ 优势：

  • 一个 Netty 线程可同时处理 1000 个 getOrder 请求。
  • 每个请求都在“等待响应”时释放线程，处理其他请求。
  • 内存占用降低 70%+，吞吐量提升 5x~10x。

五、WebClient 的标准配置（生产级最佳实践）

✅ 配置要点：

  1. 复用 WebClient 实例（线程安全，单例）
  2. 统一配置编码器、超时、重试、日志
  3. 使用 ExchangeStrategies 统一 JSON 处理
  4. 避免每次创建新实例

✅ 配置类示例（Spring Boot 3.2+）

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.reactive.function.client.WebClient;
import org.springframework.http.codec.json.Jackson2JsonDecoder;
import org.springframework.http.codec.json.Jackson2JsonEncoder;
import org.springframework.http.client.reactive.ReactorClientHttpConnector;
import reactor.netty.http.client.HttpClient;
import reactor.netty.http.client.HttpClientResponse;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.time.Duration;

@Configuration
public class WebClientConfig {

    private static final Logger log = LoggerFactory.getLogger(WebClientConfig.class);

    /**
     * 创建全局共享的 WebClient 实例（单例）
     * 配置：超时、重试、日志、JSON 编解码器、连接池
     */
    @Bean
    public WebClient webClient() {

        // 1. 配置 HTTP 客户端底层（Netty）
        HttpClient httpClient = HttpClient.create()
            .responseTimeout(Duration.ofSeconds(10))           // ✅ 响应超时 10s
            .connectTimeout(Duration.ofSeconds(5))             // ✅ 连接超时 5s
            .doOnConnected(conn -> {
                // ✅ 连接建立时记录日志（可选）
                log.debug("WebClient 连接已建立：{}", conn.remoteAddress());
            })
            .doOnResponse((response, connection) -> {
                // ✅ 响应返回时记录状态码（可选）
                if (response.status().isError()) {
                    log.warn("HTTP 请求失败，状态码: {}, URL: {}", response.status(), connection.request().uri());
                }
            });

        // 2. 配置编解码器：确保与 @RestController 使用相同的 ObjectMapper
        // 👉 重要！避免 JSON 反序列化不一致（如 LocalDate 格式）
        ExchangeStrategies strategies = ExchangeStrategies.builder()
            .codecs(configurer -> {
                configurer.defaultCodecs().jackson2JsonDecoder(new Jackson2JsonDecoder());
                configurer.defaultCodecs().jackson2JsonEncoder(new Jackson2JsonEncoder());
            })
            .build();

        // 3. 创建 WebClient 实例
        return WebClient.builder()
            .clientConnector(new ReactorClientHttpConnector(httpClient)) // 使用 Netty 底层
            .exchangeStrategies(strategies)                               // 使用统一编码器
            .baseUrl("http://localhost:8080")                             // ✅ 默认基础 URL（可覆盖）
            .build();
    }

    /**
     * 创建专门用于调用外部第三方服务的 WebClient（如支付、短信）
     * 为不同服务设置不同超时、重试策略
     */
    @Bean
    public WebClient paymentWebClient() {
        HttpClient httpClient = HttpClient.create()
            .responseTimeout(Duration.ofSeconds(8))           // 支付服务要求更快响应
            .connectTimeout(Duration.ofSeconds(3))
            .doOnResponse((response, conn) -> {
                if (response.status().is5xxServerError()) {
                    log.error("支付服务返回 5xx 错误：{}", response.status());
                }
            });

        return WebClient.builder()
            .clientConnector(new ReactorClientHttpConnector(httpClient))
            .exchangeStrategies(ExchangeStrategies.builder()
                .codecs(configurer -> configurer.defaultCodecs().jackson2JsonDecoder(new Jackson2JsonDecoder()))
                .build())
            .baseUrl("https://api.payment-gateway.com/v1")   // ✅ 外部服务独立 URL
            .build();
    }
}

✅ 关键配置说明：

  • HttpClient：Netty 底层配置，控制连接池、超时、日志。
  • ExchangeStrategies：必须与服务端一致，否则 LocalDate、BigDecimal、枚举等类型会反序列化失败。
  • baseUrl：建议按服务拆分，避免硬编码。
  • doOnResponse：用于监控、日志、熔断前哨。

六、WebClient 最标准、最实用的使用示例（带详细中文注释）

✅ 示例 1：GET 请求 —— 查询用户信息（基础调用）

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.http.ResponseEntity;
import reactor.core.publisher.Mono;
import org.springframework.beans.factory.annotation.Autowired;

@RestController
public class UserController {

    @Autowired
    private WebClient webClient; // 注入全局 WebClient

    /**
     * 根据用户 ID 查询用户信息
     * 使用 WebClient 发起 GET 请求，返回 Mono<ResponseEntity<User>>
     * 语义：要么成功返回 200 + User，要么失败返回 404/500
     */
    @GetMapping("/users/{id}")
    public Mono<ResponseEntity<User>> getUser(@PathVariable Long id) {

        return webClient
            .get()                                  // 1. 指定 HTTP 方法为 GET
            .uri("/api/users/{id}", id)             // 2. 设置 URI，路径变量自动替换
            .retrieve()                             // 3. 发起请求，准备接收响应
            .toEntity(User.class)                   // 4. 将响应体反序列化为 User 对象，返回 Mono<ResponseEntity<User>>
            .onErrorResume(                         // 5. 错误处理：如果发生异常（网络、4xx、5xx）
                throwable -> {
                    log.error("查询用户 {} 失败", id, throwable);
                    // 返回 500 Internal Server Error，避免服务崩溃
                    return Mono.just(ResponseEntity.status(500).body(null));
                }
            );
    }
}

✅ 示例 2：POST 请求 —— 创建订单并聚合支付结果（链式组合）

import org.springframework.web.bind.annotation.*;
import reactor.core.publisher.Mono;
import org.springframework.beans.factory.annotation.Autowired;

@RestController
@RequestMapping("/orders")
public class OrderController {

    @Autowired
    private WebClient webClient; // 通用 WebClient
    @Autowired
    private WebClient paymentWebClient; // 专用支付 WebClient

    /**
     * 创建订单并调用支付服务
     * 语义：先保存订单（本地），再调用支付服务，返回最终结果
     * 使用 flatMap：异步组合两个非阻塞操作
     */
    @PostMapping
    public Mono<ResponseEntity<OrderResult>> createOrderAndPay(@RequestBody CreateOrderRequest request) {

        // 1. 先创建订单（本地服务）
        Mono<Order> savedOrderMono = webClient
            .post()
            .uri("/api/orders")
            .bodyValue(request)                     // ✅ 将请求体设为 JSON
            .retrieve()
            .bodyToMono(Order.class);               // ✅ 返回 Mono<Order>

        // 2. 再调用支付服务（外部）
        Mono<PaymentResponse> paymentMono = paymentWebClient
            .post()
            .uri("/pay")
            .bodyValue(new PaymentRequest(request.getUserId(), request.getAmount()))
            .retrieve()
            .bodyToMono(PaymentResponse.class);     // ✅ 返回 Mono<PaymentResponse>

        // 3. 使用 zipWith 组合两个异步操作：必须两个都完成才返回结果
        return savedOrderMono
            .zipWith(paymentMono, (savedOrder, paymentResponse) -> {
                // 4. 合并结果：订单 + 支付结果
                OrderResult result = new OrderResult();
                result.setOrderId(savedOrder.getId());
                result.setPaymentStatus(paymentResponse.getStatus());
                result.setTransactionId(paymentResponse.getTransactionId());
                result.setTotalAmount(savedOrder.getTotalAmount());
                return ResponseEntity.status(201).body(result);
            })
            .onErrorResume(e -> {
                // 5. 任意一步失败，返回 500
                log.error("创建订单并支付失败", e);
                return Mono.just(ResponseEntity.status(500).body(null));
            });
    }

    // 👇 辅助类（仅用于示例）
    record CreateOrderRequest(Long userId, Double amount) {}
    record PaymentRequest(Long userId, Double amount) {}
    record PaymentResponse(String status, String transactionId) {}
    record OrderResult(Long orderId, String paymentStatus, String transactionId, Double totalAmount) {}
}

✅ 关键点：

  • bodyValue()：自动序列化为 JSON（依赖配置的 Jackson2JsonEncoder）
  • bodyToMono()：自动反序列化为 Java 对象
  • zipWith()：两个异步操作并行执行，都完成才合并（类似 Promise.all()）
  • onErrorResume()：优雅降级，避免服务雪崩

✅ 示例 3：流式请求 —— 消费 Server-Sent Events（SSE）实时通知

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import reactor.core.publisher.Flux;
import org.springframework.http.MediaType;
import org.springframework.beans.factory.annotation.Autowired;

@RestController
public class NotificationController {

    @Autowired
    private WebClient webClient;

    /**
     * 消费来自通知服务的 SSE 流（Server-Sent Events）
     * 语义：保持长连接，持续接收事件，客户端可实时更新
     * 返回类型：Flux<Notification> —— 表示无限事件流
     */
    @GetMapping(value = "/notifications", produces = MediaType.TEXT_EVENT_STREAM_VALUE)
    public Flux<Notification> streamNotifications() {

        return webClient
            .get()
            .uri("/api/notifications/stream")       // ✅ 服务端返回 text/event-stream
            .retrieve()
            .bodyToFlux(Notification.class)         // ✅ 自动解析每个事件为 Notification 对象
            .doOnNext(notification -> {
                // ✅ 日志记录每个收到的事件（非阻塞）
                System.out.println("🔔 收到通知: " + notification.getMessage());
            })
            .retryWhen(retrySpec -> retrySpec
                .delayElements(java.time.Duration.ofSeconds(5)) // 失败后 5 秒重连
                .retry(3)                                       // 最多重试 3 次
            )
            .onErrorResume(e -> {
                // ✅ 如果流彻底失败，发送一个“系统错误”事件保持连接不中断
                return Flux.just(new Notification("SYSTEM", "通知服务暂时不可用，请稍后重试"));
            });
    }

    // 👇 数据模型
    record Notification(String type, String message) {}
}

✅ 关键点：

  • produces = TEXT_EVENT_STREAM_VALUE：告诉客户端这是 SSE 流
  • bodyToFlux()：将每个事件（JSON 行）反序列化为对象，形成 Flux
  • retryWhen()：自动重连，实现“断线重连”能力
  • onErrorResume()：即使服务端崩溃，也返回一个“兜底事件”，避免客户端断开

✅ 示例 4：并发聚合多个下游服务（高并发网关场景）

/**
 * 用户首页聚合：用户信息 + 最近订单 + 推荐商品
 * 语义：三个独立服务，异步并发调用，全部完成后返回统一响应
 */
@GetMapping("/home/{userId}")
public Mono<ResponseEntity<HomePage>> getHomePage(@PathVariable Long userId) {

    // 1. 并发调用三个服务
    Mono<User> userMono = webClient.get()
        .uri("/api/users/{id}", userId)
        .retrieve()
        .bodyToMono(User.class);

    Mono<List<Order>> ordersMono = webClient.get()
        .uri("/api/orders/user/{id}", userId)
        .retrieve()
        .bodyToFlux(Order.class)
        .collectList(); // ✅ 转为 Mono<List<Order>>

    Mono<List<Product>> productsMono = webClient.get()
        .uri("/api/products/recommend/{id}", userId)
        .retrieve()
        .bodyToFlux(Product.class)
        .collectList();

    // 2. 使用 zip 组合三个 Mono（并行执行）
    return Mono.zip(userMono, ordersMono, productsMono,
            (user, orders, products) -> {
                HomePage homePage = new HomePage();
                homePage.setUser(user);
                homePage.setOrders(orders);
                homePage.setRecommendedProducts(products);
                return ResponseEntity.ok(homePage);
            })
            .onErrorResume(e -> {
                log.error("聚合首页数据失败", e);
                return Mono.just(ResponseEntity.status(503).body(new HomePage()));
            });
}

// 👇 数据模型
record HomePage(User user, List<Order> orders, List<Product> recommendedProducts) {}

✅ 性能优势：

  • 三个请求并行发起，总耗时 = 最慢的那个请求，而非三者之和。
  • 传统方式：1000ms + 800ms + 600ms = 2400ms
  • WebClient：max(1000, 800, 600) = 1000ms

七、WebClient 使用最佳实践（生产环境清单）

类别推荐做法说明
✅ 实例管理单例共享 WebClient不要每次调用 WebClient.create()，浪费资源
✅ 超时配置明确设置 responseTimeout 和 connectTimeout避免服务雪崩
✅ 编码器使用与 @RestController 相同的 Jackson2JsonDecoder/Encoder避免 LocalDate、BigDecimal 反序列化失败
✅ 错误处理始终使用 .onErrorResume() 或 .retryWhen()不要让异常传播导致服务崩溃
✅ 日志监控使用 .doOnResponse() 记录状态码、URI、耗时便于排查问题
✅ 流式处理使用 Flux<T> 处理 SSE、大文件、实时事件避免内存溢出
✅ 重试机制使用 .retryWhen() + 指数退避避免瞬时抖动导致失败
✅ 熔断机制集成 Resilience4j 或使用 .onErrorResume() 自定义降级防止级联故障
❌ 绝对禁止在 WebClient 链中使用 .block()破坏非阻塞架构，导致线程池耗尽
❌ 绝对禁止硬编码 URL、端口、路径使用 @Value 或配置中心统一管理

八、WebClient 与 RestTemplate 对比总结表（决策指南）

项目WebClientRestTemplate
是否推荐用于新项目✅✅✅ 必选❌ 已弃用
是否支持响应式✅ 是❌ 否
是否非阻塞✅ 是❌ 否
是否支持流式传输✅ 是（SSE、Chunked）❌ 需手动处理
是否支持 HTTP/2✅ 是⚠️ 有限支持
是否支持背压✅ 是❌ 否
是否函数式 API✅ 链式组合❌ 方法调用
是否适合微服务网关✅✅✅ 首选❌ 不推荐
是否适合内部系统调用✅✅✅ 推荐❌ 不推荐
学习成本中等（需理解 Mono/Flux）低
性能（1000 并发）15,000+ req/s1,200 req/s

🚀 结论：
WebClient 是 Spring 生态中 HTTP 客户端的未来。
任何新项目，无论是否使用 WebFlux，都应优先选择 WebClient。

✅ 附录：WebClient 常用操作速查表

操作方法说明
GET.get()发起 GET 请求
POST.post()发起 POST 请求
PUT.put()发起 PUT 请求
DELETE.delete()发起 DELETE 请求
设置 URI.uri("/path/{id}", id)支持路径变量
设置请求体.bodyValue(obj)自动序列化为 JSON
设置请求头.header("Authorization", "Bearer ...")单个头
设置多个头.headers(h -> h.addAll(...))批量设置
发起请求.retrieve()准备接收响应
获取响应体.bodyToMono(T.class)0~1 个元素
获取响应体.bodyToFlux(T.class)0~N 个元素
获取完整响应.toEntity(T.class)返回 ResponseEntity<T>（含状态码、头）
错误处理.onErrorResume(e -> Mono.just(...))降级处理
重试.retryWhen(...)指数退避、最大次数
超时.timeout(Duration.ofSeconds(5))超时失败
日志.doOnResponse(...)记录响应状态

📌 结语：WebClient 不是“替代品”，而是“进化”

RestTemplate 是“你打电话问邻居借酱油”——你得等他找出来再回来。
WebClient 是“你发个微信，他忙完自动给你送过来”——你不用等，还能同时问十个人。

当你使用 WebClient，你不是在“调用 API”，
你是在声明一个异步数据流：

“请在准备好时，把用户信息发给我；如果失败，给我一个兜底；如果连续失败，5秒后重试。”

这才是现代响应式微服务的正确打开方式。

✅ 行动建议：

  1. 立即替换所有 RestTemplate 实例为 WebClient
  2. 统一配置 ExchangeStrategies 与 Jackson 编码器
  3. 为每个外部服务创建独立的 WebClient Bean
  4. 为每个调用添加 .onErrorResume() 和 .timeout()
WebClient 高能登场：Spring Boot 中的非阻塞式 HTTP 客户端配置秘籍
专注于深入研究多种编程语言，以实战为导向，逐步拓展开发技能，提升工程化编码和思维能力，展现无敌技术实力。
07-30 169
WebClient 是 Spring Boot 中支持异步非阻塞通信的“王牌选手”，性能高效、姿态灵活，适合高并发场景下的 HTTP 调用。本文将带你配置全局 WebClient Bean，轻松搞定请求头、基础地址等核心设置，告别繁琐同步代码，迈入响应式新纪元。
Spring Boot 实践折腾记（13）：使用WebFlux构建响应式「推送API 」
mickjoust的技术小屋
05-08 6332
西方著名宗教史家米尔恰·伊利亚德说，如果今天我们不生活在未来，那么未来，我们会生活在过去。 随着移动互联网的普及，基于C/S模式的APP开始了它的又一轮爆发式增长，过去，我们总说要去C/S模式，拥抱B/S，而实际上，任何开发模式都不过是具体的需求应用场景下的产物罢了，并没有绝对的好与坏。今天我们从推送的历史开始说起，介绍一下目前常见的推送实现方式，并结合反应式的例子来继续实战反应式的编程模型的应...
SpringBoot使用WebClient发送请求
FBB360JAVA的博客
11-02 3157
文章目录前言在SpringBoot中使用1、引入依赖2、添加配置类3、使用 前言 Spring 框架中，常用的发送 Http、Https请求的有 RestTemplate，WebFlux中的WebClient。 本文主要说一下 WebClient的基本使用。 主要原因及场景如下： 在一个类似监听机器的项目中，需要发送警告到某群聊。 这种警告可能会堆积，需要异步发送出去。 官方文档如下： https://docs.spring.io/spring-boot/docs/2.1.7.RELEASE/refer
WebSocket整合SpringBoot并传输JSON数据进行操作
千里之行，始于足下
03-22 3520
WebSocket整合SpringBoot并传输JSON数据进行操作 1、引入依赖 <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>2.2.1.RELEASE</version> &l
Flux 与 Mono：Spring WebFlux 响应式编程的核心类型详解
python15397的博客
10-13 841
Flux与Mono是Spring WebFlux响应式编程的核心类型，分别表示0-N个元素的异步序列和0-1个元素的异步结果。Mono适用于单值操作（如CRUD），Flux适合多值场景（如列表查询、流式推送）。它们遵循响应式流规范，支持背压和非阻塞处理。正确使用Flux/Mono能避免线程阻塞，实现高并发和低资源消耗。关键操作包括map、flatMap、switchIfEmpty等，需避免使用block()等阻塞方法。本文通过详细代码示例展示了它们在CRUD和流式场景中的标准用法，帮助开发者构建真正的非阻塞
Spring WebFlux 与 WebClient 使用指南
千层冷面的博客
05-13 2015
WebClient 是 Spring WebFlux 模块提供的非阻塞、响应式 HTTP 客户端，基于 Project Reactor 实现，适用于高并发场景
解决响应式API测试痛点：Spring WebFlux测试策略全解析
gitblog_00284的博客
09-09 700
你是否在测试响应式API时遇到过异步处理难以验证、数据流断言复杂、测试效率低下的问题？本文将系统介绍Spring Framework中WebFlux测试的核心工具与实战策略，帮助你轻松应对响应式应用的测试挑战。读完本文后，你将掌握WebTestClient的配置技巧、响应式断言的最佳实践，以及如何高效测试背压和并发场景。 ## WebFlux测试生态系统概述 Spring WebFlux提供了...
深入解析 Spring WebFlux：原理与应用
m0_74825409的博客
02-08 758
WebFlux 是 Spring Framework 5 引入的一种响应式编程框架，和Spring MVC同级，旨在处理高并发和低延迟的非阻塞应用。这是一个支持反应式编程模型的新Web框架体系。顺便一提，Spring Cloud Gateway在实现上是对Spring WebFlux的拓展。
（5）Spring WebFlux快速上手——响应式Spring的道法术器
热门推荐
刘康的专栏
03-08 16万+
本系列其他文章见：《响应式Spring的道法术器》。 前情提要：响应式流 | lambda与函数式 | Reactor快速上手 1.3.3 Spring WebFlux Spring WebFlux是随Spring 5推出的响应式Web框架。 1）服务端技术栈 Spring提供了完整的支持响应式的服务端技术栈。 如上图所示，左侧为基于spring-webmvc的技...
RestClient：Spring Web 同步 HTTP 客户端权威说明文档
python15397的博客
10-13 656
RestClient是 Spring 6.1 引入的现代、流畅（fluent）、同步、类型安全的 HTTP 客户端，用于替代已弃用的。它基于（Apache HttpClient 5）构建，提供链式 API、自动编解码、响应体直接映射、异常统一处理，专为同步阻塞式应用（如 Spring MVC、传统微服务）设计。项目RestClient是否推荐用于新项目✅✅✅ 必选❌ 禁止是否已弃用❌（官方推荐）✅（API 风格✅ 现代 Fluent 链式❌ 传统方法名繁多类型安全✅ 编译期检查❌ 运行时校验。
Spring WebClient：响应式HTTP客户端最佳实践指南
资源摘要信息:"SpringWebClient：响应式HTTP客户端的最佳实践.pdf"是一份系统性介绍Spring WebClient在现代Java企业级开发中作为响应式HTTP客户端应用的高质量技术文档。文档结构清晰，具备完整的目录体系，支持章节...
基于Spring WebFlux的Elasticsearch响应式客户端
利用Spring Boot简化配置，通过WebFlux和Reactor实现全栈响应式编程，借助WebClient进行非阻塞HTTP调用访问Elasticsearch，最终打造出一个低延迟、高并发、资源高效的响应式搜索客户端系统。这种架构尤其适用于日志...
Spring WebFlux快速上手—响应式Spring的道法术器
m0_68850571的博客
04-08 655
1.3.3 Spring WebFlux Spring WebFlux是随Spring 5推出的响应式Web框架。 1、服务端技术栈 Spring提供了完整的支持响应式的服务端技术栈。 如上图所示，左侧为基于spring-webmvc的技术栈，右侧为基于spring-webflux的技术栈， Spring WebFlux是基于响应式流的，因此可以用来建立异步的、非阻塞的、事件驱动的服务。它采用Reactor作为首选的响应式流的实现库，不过也提供了对RxJava的支持。 由于响应式编程的特
SpringBoot项目中替换指定版本的tomcat
最新发布
2509_94011594的博客
11-24 252
通过以上步骤，可以成功替换Spring Boot项目中的Tomcat版本。需要注意的是，切换Tomcat版本可能会影响应用的兼容性和性能，因此在实际操作前需要进行充分的测试和评估。在`pom.xml`文件中，找到Spring Boot的依赖项，并添加或修改Tomcat的版本属性。在Spring Boot项目中替换指定版本的Tomcat，可以通过修改项目的`pom.xml`文件来实现。切换Tomcat版本可能会影响应用的兼容性和性能，因此在实际操作前需要进行充分的测试和评估。
Spring Boot + Spring AI快速体验
2509_94006535的博客
11-21 1153
Spring AI是Spring的一个子项目，是Spring专门面向于AI的应用框架。Spring AI 项目旨在简化整合人工智能功能的应用程序开发，避免不必要的复杂性。汲取了著名的 Python 项目 LangChain 和 LlamaIndex 的灵感，但 Spring AI 并不是这些项目的直接移植。该项目的成立的信念：下一波生成式人工智能应用程序不仅将面向Python开发人员，而且将在许多编程语言中无处不在。@Bean。
springboot接入deepseek深度求索 java
2509_94082931的博客
11-23 302
以下是在springboot中接入aideepseek的过程。官网并没有java的示例。
SpringBoot读取properties中文乱码解决方案
2509_94084189的博客
11-21 460
在IDEA中将所有的编码设置为UTF-8，同时勾上Transparent native-to-ascii conversion的选项，然后重新创建application.properties的文件。由于业务需求需要在application.properties中配置一个带有中文字符串的参数，注入到业务类中，但是发现注入的中文是乱码的。就是将application.properties的文件修改为application.yml的结构，重启项目。
spring全局懒加载(default-lazy-init)导致的afterPropertiesSet不执行问题
豆豆的博客
11-21 500
Spring配置default-lazy-init="true"会导致所有Bean延迟初始化，影响afterPropertiesSet方法的执行时机。解决方案包括：1)为关键Bean显式设置lazy-init="false"；2)使用@Lazy(false)注解；3)编程式强制初始化；4)使用DependsOn控制顺序。最佳实践建议分层配置策略，核心组件立即初始化，业务组件懒加载，并通过配置文件分离和环境区分优化配置。实际应用中，Web应用的请求处理相关Bean和批处
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

龙茶清欢

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值