【WebClient、spring】WebClient—Spring5引入的一个非阻塞、反应式类型的安全HTTP客户端

Sinvon
3,031 阅读39分钟

一、WebClient 是什么

WebClient是Spring Framework 5引入的一个非阻塞、反应式类型的安全HTTP客户端，它是Spring WebFlux模块的一部分，专为异步和事件驱动的应用程序设计。相比于传统的同步客户端如RestTemplate，WebClient提供了更高效地利用系统资源的能力，特别是在处理高并发场景时。

二、WebClient 特点

  1. 非阻塞IO: WebClient基于非阻塞I/O模型，这意味着在等待网络响应时，线程不会被阻塞，可以继续处理其他任务，从而提高了系统的吞吐量和伸缩性。
  2. 反应式编程: 它与反应式编程模型紧密集成，支持 Reactive Streams 规范，可以轻松地与其他反应式库（如Reactor）一起使用，实现复杂的异步数据流处理。
  3. 异步处理: 支持异步请求处理，使得应用程序可以在等待远程服务响应的同时进行其他操作，提高效率。
  4. 流式处理: 支持响应体的流式处理，这对于处理大文件下载或上传、实时数据流等场景非常有用，因为它可以边读取边处理数据，而不是一次性加载所有数据到内存中。
  5. 灵活的API: 提供了一套丰富的API，允许细粒度地控制HTTP请求的各个方面，包括请求头、 cookies、超时设置、SSL配置等。

三、为什么开发 WebClient

  • 性能和可伸缩性: 随着微服务架构和云服务的普及，系统需要处理更高的并发量和提供更快的响应时间。非阻塞的WebClient能够更好地满足这些需求，减少线程资源的消耗，提升服务性能。
  • 适应反应式编程趋势: 随着反应式编程模型的流行，Spring通过引入WebClient支持这种编程范式，使得开发者能更容易地构建响应式、弹性的分布式系统。
  • 更好的资源管理: 在处理大量并发连接时，传统的阻塞IO模型可能导致线程池耗尽的问题。WebClient的非阻塞特性有效缓解了这一问题，减少了系统资源的占用。
  • 现代化的API设计: 与RestTemplate相比，WebClient的设计更加面向现代Web服务的需求，提供了更简洁、灵活且功能强大的API接口。

综上所述，WebClient的开发是为了满足现代应用程序对高性能、低延迟、高并发处理能力的需求，同时也是对反应式编程范式的一种拥抱，旨在帮助开发者构建更加高效、可扩展的Web服务。

四、WebClient的优势

WebClient作为Spring Framework中的一个关键组件，尤其在Spring WebFlux框架内，展现出了多方面的优势，使其成为构建现代、响应式应用程序的理想选择。以下是WebClient的主要优势：

  1. 响应式编程模型: 支持异步、非阻塞式请求和响应处理，这意味着在等待I/O操作（如网络请求）时，线程可以被释放去处理其他任务，显著提升了应用的并发处理能力和资源利用效率。
  2. 高性能: 由于采用了非阻塞I/O，WebClient能够用较少的线程处理更多的并发请求，降低了系统的资源消耗，提高了吞吐量，特别适合处理高并发场景。
  3. 流式处理能力: 支持从服务器上或下流式传输数据，这对于处理大文件或实时数据流尤为重要，可以逐步处理数据而不需要一次性加载全部到内存中。
  4. 强类型安全的API: 提供了类型安全的API，避免了编译时错误，增强了代码的可读性和稳定性。Fluent API风格使得构建请求更为直观和简洁。
  5. 函数式编程友好: 能够很好地与Java 8及更高版本的Lambda表达式和函数式接口集成，使得代码更加简洁、易于理解和维护。
  6. 自定义配置灵活性: 允许用户根据需要配置连接池、超时时间、重试策略等，以适应不同的网络环境和业务需求。
  7. 集成Spring生态系统: 无缝集成Spring框架，可以与Spring Security、Spring Boot以及其他Spring组件协同工作，简化了配置和使用过程。
  8. 背压支持: 作为反应式堆栈的一部分，WebClient支持背压机制，当消费者（如处理数据的应用服务）无法跟上生产者（如数据源）的速度时，可以通过主动通知生产者减缓速度，防止系统过载。
  9. 未来导向: 随着Spring框架的发展，RestTemplate逐渐被视为遗留技术，而WebClient作为其现代替代品，代表了Spring对于反应式编程和非阻塞通信的持续支持和推进方向。

综上，WebClient以其高性能、低延迟、资源高效和易用性等特性，成为构建高性能、可伸缩的现代Web服务的理想工具。

五、WebClient对比RestTemplate的优势是什么

WebClient相较于RestTemplate的主要优势体现在以下几个方面：

  1. 非阻塞与异步处理:
    • WebClient: 基于非阻塞IO，允许在等待响应的同时，线程可以处理其他任务，提高了系统并发处理能力和资源利用率。
    • RestTemplate: 是阻塞式的，发出请求后会一直等待响应，期间占用线程资源，可能导致线程池耗尽和系统响应变慢。
  1. 性能与可伸缩性:
    • WebClient: 由于非阻塞特性，能在相同的硬件资源下处理更多并发请求，非常适合高并发场景，提升应用的可伸缩性。
    • RestTemplate: 在高并发场景下，可能因线程阻塞而需要创建大量线程，增加资源消耗和降低性能。
  1. 反应式编程集成:
    • WebClient: 完全融入Spring的反应式编程模型，与Project Reactor库深度集成，支持复杂的异步数据流处理。
    • RestTemplate: 不支持反应式编程模型，无法充分利用现代异步和事件驱动架构的优势。
  1. 流式处理能力:
    • WebClient: 支持响应体的流式读取，特别适合处理大文件下载或实时数据流，减少内存占用。
    • RestTemplate: 通常需要先完全加载响应体到内存中，对于大数据处理可能不理想。
  1. API设计与灵活性:
    • WebClient: 提供了更现代、灵活的API，使用Fluent风格的链式调用来构造请求，易于理解和使用。
    • RestTemplate: API虽然直观，但相比WebClient，在配置复杂请求和处理响应时可能显得不够灵活。
  1. 资源管理与效率:
    • WebClient: 更有效地利用系统资源，减少线程和内存的消耗，提升整体应用性能。
    • RestTemplate: 在资源管理和效率方面逊色于WebClient，尤其是在处理大量并发请求时。

综上所述，WebClient在性能、可伸缩性、异步处理能力以及对现代编程范式的支持上均优于RestTemplate，是构建高性能、响应式服务的理想选择。随着技术的发展，Spring官方也推荐在新项目中使用WebClient。

六、WebClient的主要用途

WebClient的主要用途在于提供一个强大而灵活的HTTP客户端，用于在应用程序中执行各种HTTP请求并与Web服务进行交互。以下是其主要用途的总结：

  1. 数据检索：从Web服务或API获取数据，如JSON、XML或其他格式的内容。这常用于获取天气信息、新闻、社交媒体数据等。
  2. 文件上传与下载：支持上传文件到服务器或从服务器下载文件，适用于处理图片、文档、音频视频文件等。
  3. API消费：作为客户端应用程序的一部分，调用RESTful API获取或更新数据，支持CRUD（创建、读取、更新、删除）操作。
  4. 集成外部服务：企业级应用中常用作集成不同系统间的桥梁，如支付网关、第三方认证服务、数据分析平台等。
  5. 异步处理与并行请求：利用非阻塞特性，可以并行发起多个请求，提高处理效率，适用于需要同时从多个数据源获取信息的场景。
  6. 流式数据处理：特别适合处理大体积数据或实时数据流，能够在数据传输过程中就开始处理，减少内存占用。
  7. 认证与授权：支持各种HTTP认证机制，如基本认证、Bearer令牌、OAuth等，用于安全地访问受保护的资源。
  8. 请求与响应定制：允许详细控制请求头、请求体、超时设置、重试策略等，以及解析和验证响应内容。
  9. 错误处理与重试逻辑：内置错误处理机制，可以自定义错误处理策略，包括重试逻辑，增强应用的健壮性。
  10. 测试与调试：在开发和测试阶段，WebClient可以用来模拟HTTP请求，测试API的正确性和性能。

总之，WebClient作为一个功能全面的HTTP客户端，几乎可以用于任何需要与Web服务交互的应用场景，特别是那些追求高性能、低延迟和高并发处理能力的现代应用程序。

七、WebClient与RestTemplate对比的优缺点

WebClient与RestTemplate对比的优缺点如下：

WebClient的优点：

  1. 非阻塞和异步操作：WebClient基于响应式编程模型，可以异步发送请求并在等待响应时释放线程，这有助于提高系统并发处理能力和资源利用率。
  2. 高性能和可伸缩性：在高并发环境下，WebClient能更高效地处理请求，减少线程等待时间，提升应用性能。
  3. 流式处理：支持响应体的流式读取，这对于处理大文件或实时数据流非常有利，减少了内存占用。
  4. 现代API设计：提供了链式调用API，支持更复杂的请求配置，易于编写和阅读代码。
  5. 反应式集成：完美集成Spring WebFlux和其他反应式库，支持复杂的异步数据流处理。
  6. 资源效率：减少线程和内存使用，更适合微服务架构和云环境。

WebClient的缺点：

  1. 学习曲线：对于习惯了同步编程的开发者来说，掌握反应式编程模型和WebClient的使用可能需要一定时间。
  2. 调试难度：反应式编程的异步特性使得调试相对复杂，错误处理和跟踪也更具挑战性。

RestTemplate的优点：

  1. 简单易用：API设计直观，学习成本较低，适合快速开发和简单的同步请求场景。
  2. 广泛使用和成熟：作为Spring框架的老牌组件，有大量的社区支持和在线资源。

RestTemplate的缺点：

  1. 阻塞I/O：在处理请求时会阻塞线程，导致在高并发场景下资源利用率低，可能引起性能瓶颈。
  2. 不支持反应式编程：无法充分利用现代反应式编程模型的优势，限制了其在大规模分布式系统中的应用。
  3. 性能限制：在处理大量并发请求时，线程资源消耗大，可能导致应用响应慢和资源耗尽。

总体来说，WebClient是面向未来、针对高性能、高并发需求的现代化选择，而RestTemplate则更适合传统、同步调用为主的简单应用场景。随着技术的发展，对于新的项目，Spring官方推荐使用WebClient来替代RestTemplate。

八、HTTPClient、WebClient与RestTemplate之间如何选择

在选择HttpClient、WebClient和RestTemplate时，需要根据项目的需求、技术栈、性能目标以及团队熟悉程度等因素综合考虑。以下是三者的简要对比和选择建议：

1. HttpClient（Apache HttpClient 或 Java原生HttpClient）

  • 适用场景：当你需要高度自定义HTTP请求的每一个细节，或者是在非Spring环境中，HttpClient是一个可靠的选择。它提供了丰富的API来处理请求、响应、连接管理、SSL/TLS配置等。
  • 优点：灵活性高，功能全面，广泛应用于各种Java应用中，有成熟的社区支持。
  • 缺点：相比其他两个选项，它的API使用起来较为繁琐，且默认是非反应式的，不适合需要高度异步处理的场景。

2. WebClient (Spring 5+)

  • 适用场景：对于基于Spring的项目，特别是采用Spring WebFlux构建的反应式应用，WebClient是首选。它非常适合需要高并发、低延迟、流式处理的场景。
  • 优点：非阻塞、异步、反应式，性能优越，与Spring生态集成紧密，支持复杂的流处理和链式调用，易于编写和维护异步代码。
  • 缺点：有一定的学习曲线，尤其是对于不熟悉反应式编程的开发者。对于同步应用或老版本Spring项目，集成可能会比较复杂。

3. RestTemplate

  • 适用场景：在同步的Spring应用中，特别是对于现有项目或对反应式编程没有特别需求的情况，RestTemplate依然是一个稳定且足够使用的选项。
  • 优点：使用简单，广泛集成于Spring框架，对于传统的CRUD操作和简单的HTTP请求处理非常方便。
  • 缺点：阻塞式操作限制了其在高并发环境下的表现，且Spring官方已推荐新项目使用WebClient。

总结

  • 如果你的项目是基于Spring WebFlux的反应式应用，或者你需要高性能、低延迟的HTTP客户端，WebClient是最佳选择。

  • 对于需要高度自定义HTTP请求或在非Spring环境中，HttpClient可能是更灵活的选择。

  • 若是传统同步应用，对反应式编程无特殊需求，且项目中已经在使用，RestTemplate依然可用，但考虑到其未来可能的维护问题，如果条件允许，逐步迁移到WebClient是一个前瞻性的决策。

九、WebClient的整体架构

WebClient是Spring Framework 5引入的一个非阻塞、响应式的HTTP客户端，它是Spring WebFlux模块的一部分。整体架构设计围绕着反应式编程模型构建，主要基于Reactor项目中的Mono和Flux，以及Netty作为默认的网络通信层。以下是WebClient架构的核心组成部分和工作流程概述：

核心组件

  1. Reactor Core：
    • Mono：表示0或1个结果的异步序列，常用于处理单一响应或错误情况。
    • Flux：表示0到N个结果的异步序列，适用于处理流式响应或集合类型的数据。
  1. Netty：
    • 作为默认的传输层，Netty是一个高性能的异步事件驱动的网络应用框架，支持HTTP/1.1和HTTP/2协议，为WebClient提供了非阻塞的I/O能力。
  1. Request Processing：
    • 构建器模式（Builder Pattern）：用于构建请求，包括URL、HTTP方法、请求头、请求体等。
    • 过滤器链（Filter Chain）：允许在请求发送前后添加自定义逻辑，例如日志记录、鉴权、重试策略等。
  1. Response Handling：
    • 异步响应处理：使用反应式类型处理响应，支持直接映射到对象、流式处理、错误处理等。
    • 解码器（Decoders）和编码器（Encoders）：负责将HTTP响应体转换为Java对象，或反之，支持多种数据格式如JSON、XML等。

工作流程

  1. 初始化：创建WebClient实例，可以通过配置修改默认行为，如超时时间、代理设置等。
  2. 构建请求：使用WebClient实例，通过链式调用的方式构建HTTP请求，包括指定URL、HTTP方法、添加请求头和请求体等。
  3. 发送请求：调用请求方法（如.get()、.post()等）后，构建的请求被发送到服务器。在此过程中，不会阻塞当前线程，而是立即返回一个反应式类型（通常是Mono或Flux）。
  4. 响应处理：当响应到达时，WebClient使用解码器将其转换为Java对象（如字符串、对象模型等），并通过反应式流的方式传递给调用者。这允许用户以异步和非阻塞的方式处理响应数据。
  5. 错误处理：如果在请求过程中遇到错误，如网络问题、超时或HTTP错误状态，错误也会被封装在反应式类型中，允许开发者以声明式的方式处理异常情况。

通过上述架构和工作流程，WebClient实现了高效、可扩展的HTTP通信能力，特别适合构建高性能、可伸缩的现代微服务和云原生应用。

十、箭头说明WebClient的整体架构的加载顺序

虽然直接提供一张图示或具体的箭头指示不太可行，但我可以文字描述WebClient整体架构的工作流程及其加载顺序，帮助你理解其内部机制：

  1. 创建与配置 (WebClient.Builder):
    • 首先，通过WebClient.builder()开始构建WebClient实例。在这个阶段，你可以配置基础设置，比如baseUrl、默认header、超时时间、SSL配置等。
    • 使用mutate()方法可以在不影响原始WebClient.Builder的情况下进一步定制配置。
  1. 请求构建:
    • 调用WebClient实例的方法（如.get(), .post(), .uri()等）开始构建特定的HTTP请求。此时，可以通过链式调用来添加请求参数、头信息、请求体等。
  1. 过滤器链装配 (ExchangeFilterFunction):
    • 在请求实际发出之前，可以添加一系列ExchangeFilterFunction。这些过滤器允许你在请求发送前和响应接收后插入自定义逻辑，比如日志记录、认证、重试机制等。过滤器的执行顺序遵循它们被添加的顺序。
  1. 发送请求与响应处理:
    • 请求最终被发送到指定的URI。由于WebClient是基于响应式编程的，所以发送请求后会立即返回一个Mono或Flux对象，代表未来的响应结果或数据流。
    • 响应数据会被解码器处理（如JsonDecoder、StringDecoder等），转换成Java对象或流数据。
  1. 错误处理:
    • 在请求过程中，如果遇到任何错误（网络错误、超时、HTTP错误状态等），错误信息会被封装进Mono.error()或Flux.onError()中，供后续的错误处理逻辑使用。
  1. 资源释放与清理:
    • 在请求响应结束后，底层的网络资源（如连接）会由WebClient自动管理并适时释放，确保资源的有效利用。

整体来看，WebClient的工作流程遵循了典型的客户端请求生命周期，从配置到请求构建，再到发送、响应处理、错误管理，最后到资源清理，形成了一个完整且高效的请求响应闭环。

十一、使用箭头（=>）来表示WebClient整体架构加载顺序

WebClient是Spring Framework 5.0引入的非阻塞的、反应式的HTTP客户端，其设计用于Reactive编程模型。下面是WebClient的整体架构和加载顺序的简单文本表示，使用箭头 (=>) 来指示数据流或依赖关系的方向：

  1. 初始化 WebClient.Builder => 创建 WebClient 实例
    • 首先，通过WebClient.Builder开始配置WebClient，这允许你定义基础URI、默认标头、过滤器链等。
  1. 配置 WebClient.Builder (如: baseUrl, 默认Header, 过滤器等) => 自定义 WebClient 设置
    • 在Builder上设置诸如基本URL、默认HTTP标头、添加各种过滤器（日志记录、重试、超时等）。
  1. 定义请求 (如: GET, POST) => 请求构建
    • 使用创建好的WebClient实例，通过其方法定义具体的HTTP请求类型(GET, POST等)，并配置请求参数、uri、body等。
  1. 添加请求特定配置 (如: uriVariables, headers, body) => 完整请求定义
    • 在具体请求方法调用中，进一步指定如路径变量、请求头和请求体内容。
  1. 交换/检索 (exchange, retrieve) => 发送请求 & 处理响应
    • exchange方法用于发送请求并获得一个可响应式处理的ClientResponse。
    • retrieve方法更倾向于直接获取响应体，简化处理流程。
  1. 响应处理 (Mono, Flux) => 异步数据处理
    • 响应可以是Mono（零或一个结果）或Flux（零到多个结果），用于异步处理响应数据，包括映射、过滤、聚合等操作。
  1. 错误处理 (onErrorResume, doOnError) => 异常管理
    • 使用响应式流的错误处理机制来捕获并适当处理请求中的错误。

简化的加载顺序表示:

初始化 Builder => 
  (配置 BaseUrl, Headers, Filters) =>
    定义请求(GET, POST) =>
      添加请求配置(URI Variables, Headers, Body) =>
        交换/检索(exchange, retrieve) =>
          响应处理(Mono, Flux) =>
            错误处理(onErrorResume, doOnError)

此流程展示了从构建WebClient到发送请求、处理响应及错误管理的整个生命周期。

十二、WebClient的主要实现原理

WebClient 是 Spring Framework 5 中引入的一个非阻塞、响应式的 HTTP 客户端，其核心实现原理基于以下几个关键点：

  1. 反应式编程模型：WebClient 基于 Reactor 库中的 Mono 和 Flux 类，这两个类分别代表了0或1个结果的异步序列和0到N个结果的异步序列。这意味着WebClient在设计上完全支持异步和非阻塞操作，允许在等待响应时释放线程，提高了应用的并发处理能力。
  2. 非阻塞 I/O：利用Netty作为默认的网络通信库，WebClient能够进行非阻塞的网络I/O操作。Netty是一个高性能的网络应用框架，支持多种协议，包括HTTP/1.1和HTTP/2，这使得WebClient在处理网络请求时能够高效地利用系统资源。
  3. 请求构建与发送：通过链式调用API，开发者可以轻松地构建HTTP请求，包括设置URL、HTTP方法、请求头、请求体等。构建完成后，WebClient并不立即发送请求，而是返回一个反应式类型（如Mono<ClientResponse>或Mono<T>），这使得请求的实际发送与响应的处理可以异步进行。
  4. 过滤器链（ExchangeFilterFunctions） ：WebClient允许插入自定义的过滤器（ExchangeFilterFunction），这些过滤器可以在请求发送前和响应接收后执行额外的逻辑，比如日志记录、请求/响应拦截、身份验证等。这种机制为请求处理过程提供了高度的可扩展性和灵活性。
  5. 响应处理与解码：响应数据通过解码器（Decoders）转换为Java对象。Spring提供了多种预定义的解码器来处理不同类型的响应内容，如JSON、XML等。此外，用户也可以自定义解码器以处理特定格式的数据。
  6. 背压（Backpressure） ：WebClient支持反应式流的背压机制，可以有效地控制数据生产速度与消费速度之间的平衡，防止快速的响应数据淹没消费者，特别是在处理大量或高速数据流时。
  7. 资源管理：在非阻塞模型下，WebClient能够更有效率地管理资源，如连接池的自动维护，确保了即使在高并发场景下也能保持稳定的性能。

综上，WebClient通过其反应式、非阻塞的设计，结合强大的Netty网络库和灵活的过滤器机制，提供了高性能、易于使用且可扩展的HTTP通信解决方案，特别适合现代微服务架构和云原生应用。

十三、WebClient的主要方法

WebClient 提供了一系列方法来方便地构建和发送HTTP请求，以及处理响应。以下是一些主要方法及其用途概述：

初始化与配置

  • WebClient.Builder: 用于创建和配置WebClient实例。通过调用WebClient.builder()开始配置，如设置基础URL、默认头、超时、SSL配置等。

请求构建方法

  • get() : 构建一个HTTP GET请求。
  • post() : 构建一个HTTP POST请求。
  • put() : 构建一个HTTP PUT请求。
  • delete() : 构建一个HTTP DELETE请求。
  • head() : 构建一个HTTP HEAD请求。
  • options() : 构建一个HTTP OPTIONS请求。
  • patch() : 构建一个HTTP PATCH请求。

请求配置方法

  • uri(String uri) : 设置请求的目标URI。
  • uri(URI uri) : 同上，但直接使用URI对象。
  • uri(String uri, Object... uriVariables) : 设置带有变量占位符的URI，并填充变量值。
  • uriFunction(Function<ClientRequest, Mono> uriFunction) : 动态生成请求的URI。
  • headers(Consumer headersConsumer) : 配置请求头。
  • bodyValue(Object body) : 设置请求体的值，适合简单类型或对象。
  • body(BodyInserter<?, ? super ClientHttpRequest> inserter) : 更通用的请求体设置方法，支持复杂类型和流。
  • attribute(String name, Object value) : 添加请求属性，可用于过滤器中。

发送请求与响应处理

  • retrieve() : 发送请求并期望得到响应体。通常用于获取数据。
  • exchange() : 发送请求并返回ClientResponse，允许更细致地控制响应处理，比如获取响应头、状态码等。
  • method(HttpMethod method) : 明确指定HTTP方法，当使用不常见的HTTP方法时有用。

响应处理与映射

  • bodyToMono(Class elementClass) : 将响应体转换为指定类型的单个对象。
  • bodyToFlux(Class elementClass) : 将响应体转换为指定类型的流式对象序列。
  • exchangeToMono(Function<ClientResponse, Mono>> responseMapper) : 允许自定义函数处理整个ClientResponse，适合复杂的响应处理逻辑。

错误处理

  • onErrorResume(Function<Throwable, Mono<? extends T>> fallback) : 当请求失败时，定义回退逻辑。
  • doOnError(Consumer errorConsumer) : 注册一个消费者处理发生的错误，但不改变错误流本身。

过滤器

  • filter(ExchangeFilterFunction filterFunction) : 添加一个自定义的过滤器到请求处理链中，可以用来添加认证、日志、重试等逻辑。

以上方法通过链式调用的方式组合，形成了强大而灵活的请求构造和处理能力，体现了WebClient的易用性和强大功能。

十四、WebClient的主要方法——使用实例

以下是一些基于Spring WebClient的主要方法使用实例。请注意，这些示例假设你正在使用Spring Framework 5.x或更高版本，并且已经设置了好相关的依赖。

1.请求构建方法

初始化 WebClient

import org.springframework.web.reactive.function.client.WebClient;

public class WebClientExample {

    public static void main(String[] args) {
        WebClient client = WebClient.create();
    }
}

GET 请求

public Mono<String> fetchUserDetails(String userId) {
    return client.get()
                 .uri("/users/{userId}", userId)
                 .retrieve()
                 .bodyToMono(String.class);
}

// 调用示例
fetchUserDetails("123").subscribe(System.out::println);

POST 请求

public Mono<User> createUser(User newUser) {
    return client.post()
                 .uri("/users")
                 .bodyValue(newUser)
                 .retrieve()
                 .bodyToMono(User.class);
}

// 假设 User 类存在且有相应的构造方法和字段

PUT 请求

public Mono<Void> updateUser(String userId, User updatedUser) {
    return client.put()
                 .uri("/users/{userId}", userId)
                 .bodyValue(updatedUser)
                 .then();
}

DELETE 请求

public Mono<Void> deleteUser(String userId) {
    return client.delete()
                 .uri("/users/{userId}", userId)
                 .then();
}

响应处理

public Mono<String> fetchAndProcessData() {
    return client.get()
                 .uri("/data")
                 .retrieve()
                 .onStatus(HttpStatus::isError, 
                           response -> Mono.error(new RuntimeException("Error fetching data")))
                 .bodyToMono(String.class);
}

自定义Header

public Mono<String> getUserWithCustomHeader(String userId) {
    return client.get()
                 .uri("/users/{userId}", userId)
                 .header("Authorization", "Bearer myToken")
                 .retrieve()
                 .bodyToMono(String.class);
}

错误处理

public Mono<String> handleErrors(String userId) {
    return client.get()
                 .uri("/users/{userId}", userId)
                 .retrieve()
                 .onStatus(HttpStatus::is4xxClientError, 
                           error -> Mono.error(new ClientException("Client error occurred")))
                 .onStatus(HttpStatus::is5xxServerError, 
                           error -> Mono.error(new ServerException("Server error occurred")))
                 .bodyToMono(String.class);
}

当然，以下是关于HEAD、OPTIONS、和PATCH请求的使用示例：

HEAD 请求

HEAD请求用于获取资源的元信息，如HTTP头部，而不返回实际的内容。这对于检查资源是否存在或获取其最后修改时间等元数据很有用。

public Mono<HttpHeaders> checkResourceAvailability(String resourceId) {
    return client.head()
                 .uri("/resources/{resourceId}", resourceId)
                 .exchange()
                 .map(ClientResponse::headers);
}

OPTIONS 请求

OPTIONS请求用于获取服务器支持的HTTP方法列表，常用于CORS预检请求，以确定实际请求是否安全发起。

public Mono<HttpHeaders> getAllowMethods(String endpoint) {
    return client.options()
                 .uri(endpoint)
                 .exchange()
                 .map(ClientResponse::headers);
}

PATCH 请求

PATCH请求用于局部更新资源。它只更新资源的部分属性，而不是替换整个资源。

假设有一个更新用户邮箱的方法：

public Mono<User> updateEmail(String userId, String newEmail) {
    Map<String, Object> patchBody = Collections.singletonMap("email", newEmail);
    return client.patch()
                 .uri("/users/{userId}", userId)
                 .bodyValue(patchBody)
                 .retrieve()
                 .bodyToMono(User.class);
}

在updateEmail示例中，我们构造了一个简单的JSON补丁对象（在这个例子中是一个Map，实际应用中可能需要更复杂的对象或直接使用JSON字符串），然后使用PATCH方法发送给服务器，更新指定用户的邮箱地址。

请根据你的具体需求调整上述示例代码中的URL路径、请求体结构以及响应处理逻辑。

2.请求配置方法

  • uri(String uri) : 设置请求的目标URI。
  • uri(URI uri) : 同上，但直接使用URI对象。
  • uri(String uri, Object... uriVariables) : 设置带有变量占位符的URI，并填充变量值。
  • uriFunction(Function<ClientRequest, Mono> uriFunction) : 动态生成请求的URI。
  • headers(Consumer headersConsumer) : 配置请求头。
  • bodyValue(Object body) : 设置请求体的值，适合简单类型或对象。
  • body(BodyInserter<?, ? super ClientHttpRequest> inserter) : 更通用的请求体设置方法，支持复杂类型和流。
  • attribute(String name, Object value) : 添加请求属性，可用于过滤器中。

当然，下面是基于您给出的API说明的一些使用示例，这里我将使用Java的WebClient作为示例框架，因为它提供了类似的API来构建和配置HTTP请求。请注意，实际应用中您可能需要根据您使用的HTTP客户端库的具体API做适当调整。

设置请求的目标URI

直接使用字符串

public Mono<String> fetchResource(String resourceId) {
    return client.get()
                 .uri("/resources/" + resourceId)
                 .retrieve()
                 .bodyToMono(String.class);
}

使用URI对象

public Mono<String> fetchResourceWithUriObject(URI resourceUri) {
    return client.get()
                 .uri(resourceUri)
                 .retrieve()
                 .bodyToMono(String.class);
}

设置带有变量占位符的URI

public Mono<String> fetchUserResource(String userId) {
    return client.get()
                 .uri("/users/{userId}/details", userId)
                 .retrieve()
                 .bodyToMono(String.class);
}

动态生成请求的URI

public Mono<String> dynamicUriRequest(String base, String path) {
    return client.get()
                 .uriFunction(request -> {
                     URI uri = URI.create(base + "/" + path);
                     return Mono.just(uri);
                 })
                 .retrieve()
                 .bodyToMono(String.class);
}

配置请求头

public Mono<String> requestWithHeaders(String resourceId) {
    return client.get()
                 .uri("/resources/" + resourceId)
                 .headers(headers -> headers.setBearerAuth("yourToken"))
                 .retrieve()
                 .bodyToMono(String.class);
}

设置请求体的值

public Mono<String> updateResource(String resourceId, Map<String, String> updates) {
    return client.patch()
                 .uri("/resources/" + resourceId)
                 .bodyValue(updates)
                 .retrieve()
                 .bodyToMono(String.class);
}

使用BodyInserter设置请求体（更通用）

public Mono<String> uploadFile(File file) {
    return client.post()
                 .uri("/upload")
                 .body(new FileSystemResource(file), MediaType.MULTIPART_FORM_DATA)
                 .retrieve()
                 .bodyToMono(String.class);
}

添加请求属性

public Mono<String> requestWithAttribute(String resourceId) {
    return client.get()
                 .uri("/resources/" + resourceId)
                 .attribute("requestId", UUID.randomUUID().toString())
                 .retrieve()
                 .bodyToMono(String.class);
}

这些示例展示了如何使用不同的方法配置WebClient请求，包括目标URI的设定、请求头的配置、请求体的设置，以及添加请求属性等。请根据实际情况调整示例代码以满足特定需求。

3.发送请求与响应处理

  • retrieve() : 发送请求并期望得到响应体。通常用于获取数据。
  • exchange() : 发送请求并返回ClientResponse，允许更细致地控制响应处理，比如获取响应头、状态码等。
  • method(HttpMethod method) : 明确指定HTTP方法，当使用不常见的HTTP方法时有用。

使用 retrieve() 方法发送请求并处理响应体

假设我们有一个场景，需要从一个API获取用户信息。

public Mono<UserInfo> getUserInfo(String userId) {
    return client.get()
                 .uri("/users/" + userId)
                 .retrieve() // 发送请求并期望得到响应体
                 .onStatus(HttpStatus::isError, 
                           response -> Mono.error(new RuntimeException("Failed to get user info: " + response.statusCode())))
                 .bodyToMono(UserInfo.class)
                 .log();
}

在这个例子中，我们发送一个GET请求到/users/{userId}，期望服务器返回用户信息，并直接将其转换为UserInfo对象。如果响应状态码表示错误，我们通过onStatus方法抛出异常。

使用 exchange() 方法进行更细致的响应处理

如果你需要访问响应头或更细致地控制响应的处理流程，可以使用exchange()方法。

public Mono<String> getResponseBodyWithHeaderCheck(String resourceId) {
    return client.get()
                 .uri("/resources/" + resourceId)
                 .exchange() // 发送请求并返回ClientResponse
                 .flatMap(response -> {
                     if (response.statusCode().is2xxSuccessful()) {
                         return response.bodyToMono(String.class);
                     } else {
                         return Mono.error(new RuntimeException("Request failed with status: " + response.statusCode()));
                     }
                 })
                 .doOnNext(body -> System.out.println("Response Body: " + body))
                 .log();
}

这里，我们首先发送请求并获得ClientResponse对象。然后检查响应的状态码，如果是2xx系列的成功状态，则提取响应体；否则，抛出异常。这种方法允许在处理响应体之前检查响应头或状态码。

使用 method(HttpMethod method) 指定HTTP方法

在某些情况下，你可能需要使用非标准的HTTP方法，如PATCH或DELETE。这时可以使用method()方法明确指定。

public Mono<Void> deleteResource(String resourceId) {
    return client.method(HttpMethod.DELETE)
                 .uri("/resources/" + resourceId)
                 .exchange()
                 .then(); // 如果不需要处理响应体，可以使用then()直接完成Mono操作
}

这个例子展示了如何发送一个DELETE请求来删除资源。由于我们并不期望从删除操作中接收具体响应体，因此使用了.then()来表示操作完成后没有额外的数据流。

以上示例覆盖了发送不同类型的HTTP请求、处理响应体、以及对响应进行更细致控制的方法。请根据具体需求选择合适的方法使用。

4.响应处理与映射

  • bodyToMono(Class elementClass) : 将响应体转换为指定类型的单个对象。
  • bodyToFlux(Class elementClass) : 将响应体转换为指定类型的流式对象序列。
  • exchangeToMono(Function<ClientResponse, Mono>> responseMapper) : 允许自定义函数处理整个ClientResponse，适合复杂的响应处理逻辑。

使用 bodyToMono(Class<T> elementClass) 处理响应体

此方法适用于当你期望服务器返回单个对象的情况，例如获取某个用户的详细信息。

public Mono<User> fetchUser(String userId) {
    return client.get()
                 .uri("/users/{id}", userId)
                 .retrieve()
                 .bodyToMono(User.class);
}

在此示例中，我们发送一个GET请求到/users/{id}，并期望服务器返回一个User对象。

使用 bodyToFlux(Class<T> elementClass) 处理响应体为流式对象序列

当你期望服务器返回一系列对象时，比如获取所有用户的列表，可以使用此方法。

public Flux<User> fetchAllUsers() {
    return client.get()
                 .uri("/users")
                 .retrieve()
                 .bodyToFlux(User.class);
}

这里，我们请求/users端点，期望服务器返回一系列User对象，通过bodyToFlux方法将响应体转换成Flux<User>。

使用 exchangeToMono(Function<ClientResponse, Mono<T>>> responseMapper) 复杂响应处理

对于需要对整个响应（包括状态码、头和体）进行精细控制的场景，可以使用此方法。

public Mono<String> customResponseHandling(String resourceId) {
    return client.get()
                 .uri("/resources/{id}", resourceId)
                 .exchangeToMono(response -> {
                     if (response.statusCode().is2xxSuccessful()) {
                         return response.bodyToMono(String.class);
                     } else if (response.statusCode().equals(HttpStatus.NOT_FOUND)) {
                         return Mono.just("Resource not found");
                     } else {
                         return Mono.error(new RuntimeException("Unexpected status code: " + response.statusCode()));
                     }
                 });
}

在这个例子中，我们不仅检查了响应体，还根据不同的HTTP状态码做出了不同的响应处理。如果资源不存在（状态码为404），则返回一个特定的消息，而不是抛出错误。

这些示例展示了如何根据不同的需求处理响应体，包括单个对象、对象流，以及对整个ClientResponse的定制处理。

5.错误处理

  • onErrorResume(Function<Throwable, Mono<? extends T>> fallback) : 当请求失败时，定义回退逻辑。
  • doOnError(Consumer errorConsumer) : 注册一个消费者处理发生的错误，但不改变错误流本身。

错误处理示例

使用 onErrorResume 定义回退逻辑

当请求失败时，可以使用onErrorResume来定义一个回退逻辑，比如提供一个默认值或者执行其他恢复操作。

public Mono<User> fetchUserWithFallback(String userId) {
    return client.get()
                 .uri("/users/{id}", userId)
                 .retrieve()
                 .bodyToMono(User.class)
                 .onErrorResume(throwable -> {
                     if (throwable instanceof WebClientException) {
                         System.err.println("Error fetching user, returning default user.");
                         return Mono.just(new User("defaultId", "Default User"));
                     }
                     return Mono.error(throwable);
                 });
}

如果请求用户数据失败，这个方法会打印错误信息并返回一个默认用户对象。

使用 doOnError 记录错误但不改变错误流

doOnError可以用来注册一个错误处理器，它不会改变错误流本身，只是对错误进行记录或其他处理。

public Mono<User> fetchUserLoggingErrors(String userId) {
    return client.get()
                 .uri("/users/{id}", userId)
                 .retrieve()
                 .bodyToMono(User.class)
                 .doOnError(error -> System.err.println("Error fetching user: " + error.getMessage()));
}

即使发生错误，错误信息会被打印出来，但原始错误仍会被传递下去。

6.过滤器

  • filter(ExchangeFilterFunction filterFunction) : 添加一个自定义的过滤器到请求处理链中，可以用来添加认证、日志、重试等逻辑。

过滤器示例：添加认证信息

使用filter可以向请求处理链中插入自定义的过滤逻辑，比如自动添加认证头。

public WebClient addAuthHeaderFilter(WebClient client) {
    ExchangeFilterFunction authFilter = (clientRequest, next) -> {
        ClientRequest authRequest = ClientRequest.from(clientRequest)
                                                 .header("Authorization", "Bearer yourToken")
                                                 .build();
        return next.exchange(authRequest);
    };
    
    return client.mutate()
                 .filter(authFilter)
                 .build();
}

这个示例创建了一个过滤器，该过滤器会在每个请求中添加一个Authorization头。你可以通过调用addAuthHeaderFilter方法来增强你的WebClient实例，使其在每次请求时自动携带认证信息。

这些示例展示了如何在Spring WebClient中实现错误处理逻辑以及如何添加自定义过滤器以增强请求处理流程。

十五、WebClient的使用场景有哪些

WebClient是Spring Framework提供的一个非阻塞、响应式且类型安全的HTTP客户端，广泛应用于现代微服务架构和云原生应用中。以下是WebClient的一些典型使用场景：

  1. API集成：当你的应用需要与其他外部服务或内部微服务进行交互时，WebClient可以用来发送RESTful API请求，获取数据或触发远程服务的操作。例如，从第三方天气API获取天气预报信息，或向认证服务验证用户凭据。
  2. 数据同步与集成：在分布式系统中，WebClient可用来同步数据，如定期从其他服务拉取数据更新到本地数据库，或推送本地变更到其他服务。
  3. 文件上传与下载：利用其对流式传输的支持，WebClient能高效地上传大文件到远程服务器，或下载文件到本地存储。
  4. 异步处理与批处理：在需要高性能和低延迟响应的应用中，可以使用WebClient发起异步请求，处理大量并发任务，如批量导入导出数据、异步处理用户请求。
  5. 事件驱动与消息传递：在事件驱动架构中，WebClient可用于发布事件到消息队列或事件总线，或订阅并处理来自其他服务的事件。
  6. 认证与授权：可以集成OAuth2、JWT等认证协议，安全地管理API调用的认证过程，比如获取访问令牌、刷新令牌等。
  7. 健康检查与监控：定期使用WebClient检查依赖服务的健康状况，或者收集性能指标，作为监控和故障排查的一部分。
  8. 内容聚合：在构建内容聚合平台时，WebClient可以帮助从多个源抓取和整合数据，如新闻聚合、商品比价等。
  9. 微服务间通信：在微服务架构中，WebClient是实现服务间通信的一种方式，特别是对于那些需要低延迟、高吞吐量的场景。
  10. CI/CD流程集成：自动化部署流水线中，可以使用WebClient与CI/CD工具（如Jenkins、GitLab CI等）进行交互，触发构建、部署操作，或查询构建状态。

总的来说，WebClient因其高效的异步处理能力、响应式设计以及丰富的配置选项，成为了现代应用程序集成、数据交换和微服务通信的重要工具。

十六、WebClient开发业务实例

1. API集成：从第三方天气API获取天气预报信息

假设你要从一个假想的第三方天气API获取特定城市的天气预报。

import org.springframework.web.reactive.function.client.WebClient;
import reactor.core.publisher.Mono;

public class WeatherService {

    private final WebClient client = WebClient.create("https://api.weather.example");

    public Mono<WeatherForecast> getWeatherForecast(String city) {
        return client.get()
                     .uri(uriBuilder -> uriBuilder.path("/forecast")
                                                  .queryParam("city", city)
                                                  .build())
                     .retrieve()
                     .bodyToMono(WeatherForecast.class);
    }
}

2. 数据同步与集成：定期同步数据到本地数据库

假设你有一个微服务架构，需要定期从另一个服务同步用户数据到本地数据库。

import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import org.springframework.web.reactive.function.client.WebClient;
import reactor.core.publisher.Flux;

@Component
public class UserService {

    private final WebClient client = WebClient.create("http://user-service.example/api");
    private final UserRepository userRepository;

    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    @Scheduled(cron = "0 0 * * * ?") // 每小时同步一次
    public void syncUserData() {
        Flux<User> usersFromApi = client.get()
                                         .uri("/users")
                                         .retrieve()
                                         .bodyToFlux(User.class);

        usersFromApi.flatMap(this::saveOrUpdateUser)
                   .subscribe();
    }

    private Mono<User> saveOrUpdateUser(User user) {
        return userRepository.findByUserId(user.getUserId())
                             .map(existingUser -> {
                                 // 更新现有用户信息
                                 existingUser.setName(user.getName());
                                 // ...其他更新逻辑
                                 return userRepository.save(existingUser);
                             })
                             .switchIfEmpty(Mono.defer(() -> {
                                 // 新增用户
                                 return userRepository.save(user);
                             }));
    }
}

3. 文件上传与下载：上传大文件到远程服务器

这里展示如何使用WebClient上传一个大文件到一个假设的文件存储服务。

import org.springframework.core.io.Resource;
import org.springframework.http.MediaType;
import org.springframework.stereotype.Service;
import org.springframework.util.MultiValueMap;
import org.springframework.web.reactive.function.BodyInserters;
import org.springframework.web.reactive.function.client.WebClient;
import reactor.core.publisher.Mono;

@Service
public class FileUploadService {

    private final WebClient client = WebClient.create("https://file-storage.example");

    public Mono<String> uploadLargeFile(Resource file) {
        return client.post()
                     .uri("/files")
                     .contentType(MediaType.MULTIPART_FORM_DATA)
                     .body(BodyInserters.fromMultipartData("file", file))
                     .retrieve()
                     .bodyToMono(String.class);
    }
}

以上示例展示了WebClient在不同应用场景下的使用方法，包括调用外部API获取数据、数据同步与集成，以及文件的上传。请注意，为了简洁明了，示例中省略了一些错误处理和细节配置，请根据实际需求进行调整。

4. 异步处理与批处理：批量导入导出数据

假设你需要异步处理用户数据的批量导入，从CSV文件解析数据后，通过WebClient发送到用户服务。

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.web.reactive.function.client.WebClient;
import reactor.core.publisher.Flux;

@Service
public class UserService {

    private final WebClient client = WebClient.create("http://user-service.example/api");
    
    public void importUsersFromCsv(Flux<User> usersFlux) {
        usersFlux.flatMap(user -> client.post()
                                          .uri("/users")
                                          .bodyValue(user)
                                          .retrieve()
                                          .toBodilessEntity())
                 .subscribe();
    }
}

5. 事件驱动与消息传递：发布事件到消息队列

虽然WebClient直接用于消息队列不太常见（通常是AMQP客户端或Kafka生产者），但你可以用它来与消息代理的服务接口交互，比如发布事件到API Gateway。

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.web.reactive.function.client.WebClient;

@Component
public class EventPublisher {

    private final WebClient client = WebClient.create("http://event-bus.example/api/events");

    public Mono<Void> publishEvent(Event event) {
        return client.post()
                     .uri("")
                     .bodyValue(event)
                     .retrieve()
                     .toBodilessEntity()
                     .then();
    }
}

6. 认证与授权：集成OAuth2获取访问令牌

展示如何使用WebClient获取OAuth2的访问令牌。

import org.springframework.http.HttpHeaders;
import org.springframework.http.MediaType;
import org.springframework.stereotype.Service;
import org.springframework.web.reactive.function.BodyInserters;
import org.springframework.web.reactive.function.client.WebClient;

@Service
public class OAuth2TokenService {

    private final WebClient client = WebClient.create("https://oauth2-provider.example/token");

    public Mono<String> getAccessToken(String clientId, String clientSecret, String scope) {
        MultiValueMap<String, String> body = new LinkedMultiValueMap<>();
        body.add("grant_type", "client_credentials");
        body.add("scope", scope);
        
        HttpHeaders headers = new HttpHeaders();
        headers.setContentType(MediaType.APPLICATION_FORM_URLENCODED);
        
        return client.post()
                     .uri("/oauth2/token")
                     .headers(h -> h.addAll(headers))
                     .body(BodyInserters.fromFormData(body)
                                        .with("client_id", clientId)
                                        .with("client_secret", clientSecret))
                     .retrieve()
                     .bodyToMono(TokenResponse.class)
                     .map(TokenResponse::getAccessToken);
    }

    private static class TokenResponse {
        private String accessToken;

        public String getAccessToken() {
            return accessToken;
        }
    }
}

以上示例涵盖了WebClient在异步处理批处理任务、事件驱动架构中的消息发布，以及集成OAuth2进行认证授权的基础用法。请注意，实际应用中需要考虑错误处理、重试策略、安全性等高级配置。

7. 健康检查与监控：检查依赖服务的健康状况

下面的示例展示了如何使用WebClient定期检查一个依赖服务的健康状况。

import org.springframework.beans.factory.annotation.Value;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import org.springframework.web.reactive.function.client.WebClient;

@Component
public class HealthCheckService {

    private final WebClient client;
    private final String healthCheckUrl;

    public HealthCheckService(@Value("${dependency.service.url}") String serviceUrl) {
        this.client = WebClient.create();
        this.healthCheckUrl = serviceUrl + "/health";
    }

    @Scheduled(fixedRate = 60_000) // 每分钟检查一次
    public void checkDependencyHealth() {
        client.get()
              .uri(this.healthCheckUrl)
              .exchangeToMono(response -> {
                  if (response.statusCode().is2xxSuccessful()) {
                      return Mono.just("Dependency service is healthy");
                  } else {
                      return Mono.error(new RuntimeException("Dependency service is unhealthy"));
                  }
              })
              .doOnNext(System.out::println)
              .subscribe();
    }
}

8. 内容聚合：新闻聚合示例

假设你正在构建一个新闻聚合平台，需要从多个新闻API抓取最新的新闻标题。

import org.springframework.stereotype.Service;
import org.springframework.web.reactive.function.client.WebClient;
import reactor.core.publisher.Flux;

@Service
public class NewsAggregatorService {

    private final List<String> newsApiEndpoints = Arrays.asList(
        "https://news-api-1.example/latest",
        "https://news-api-2.example/top-stories"
    );
    private final WebClient client = WebClient.create();

    public Flux<NewsArticle> fetchLatestNews() {
        return Flux.fromIterable(newsApiEndpoints)
                    .flatMap(endpoint -> client.get()
                                                .uri(endpoint)
                                                .retrieve()
                                                .bodyToFlux(NewsArticle.class))
                    .distinct(NewsArticle::getId); // 假设每个新闻有唯一ID，避免重复
    }
}

class NewsArticle {
    private String id;
    private String title;
    private String source;
    // 其他属性及getter/setter
}

在上述示例中，HealthCheckService展示了如何使用定时任务来检查依赖服务的健康状况，而NewsAggregatorService则演示了如何从多个新闻API获取数据并整合为单一的新闻流，体现了内容聚合的概念。这些示例简化了实际操作中的错误处理和配置细节，具体实现时需要根据实际情况进行调整。

9. 微服务间通信：服务间低延迟、高吞吐量通信

在微服务架构中，WebClient可以用来实现服务间的异步通信。以下是一个简单的示例，展示如何从订单服务调用库存服务检查商品库存。

import org.springframework.stereotype.Service;
import org.springframework.web.reactive.function.client.WebClient;

@Service
public class OrderService {

    private final WebClient inventoryClient = WebClient.create("http://inventory-service.example");

    public Mono<Boolean> checkStockAvailability(String productId, int quantity) {
        return inventoryClient.get()
                              .uri("/products/{productId}/stock", productId)
                              .retrieve()
                              .bodyToMono(Integer.class)
                              .map(stock -> stock >= quantity);
    }
}

10. CI/CD流程集成：与Jenkins交互触发构建

在自动化部署流水线中，可以通过WebClient与CI/CD工具（如Jenkins）的API交互，以触发构建或查询构建状态。下面是一个基本示例，展示如何触发Jenkins作业。

import org.springframework.stereotype.Component;
import org.springframework.web.reactive.function.client.WebClient;

@Component
public class JenkinsClient {

    private final WebClient client = WebClient.create("http://your-jenkins-instance.com");

    public Mono<String> triggerBuild(String jobName) {
        return client.post()
                     .uri("/job/{jobName}/build", jobName)
                     .retrieve()
                     .toBodilessEntity()
                     .thenReturn("Build triggered successfully for " + jobName);
    }

    public Mono<String> getBuildStatus(String buildNumber, String jobName) {
        return client.get()
                     .uri("/job/{jobName}/{buildNumber}/api/json", jobName, buildNumber)
                     .retrieve()
                     .bodyToMono(String.class);
    }
}

请注意，这些示例提供了一种简化的视角，实际应用中可能需要处理认证、错误处理、以及根据具体的API文档调整请求参数和路径。特别是与CI/CD工具的集成，可能需要包含认证信息，以及处理API响应的JSON结构来准确获取所需信息。

十七、在springboot中使用WebClient

在Spring Boot中使用WebClient，你需要遵循以下步骤进行配置和使用：

1. 添加依赖

确保你的pom.xml文件中包含了Spring WebFlux的依赖，因为WebClient是Spring WebFlux的一部分。

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-webflux</artifactId>
</dependency>

2. 创建WebClient实例

你可以通过多种方式创建WebClient实例，以下是一些常见的方法：

无配置创建

import org.springframework.web.reactive.function.client.WebClient;

WebClient webClient = WebClient.create();

配置baseUrl

WebClient webClient = WebClient.builder()
                               .baseUrl("http://example.com/api")
                               .build();

高级配置（如超时、重试等）

WebClient webClient = WebClient.builder()
                               .baseUrl("http://example.com/api")
                               .clientConnector(new ReactorClientHttpConnector(HttpClient.create()
                                                                                      .option(ChannelOption.CONNECT_TIMEOUT_MILLIS, 5000) // 设置连接超时
                                                                                      .doOnConnect(conn -> conn.addHandlerLast(new ReadTimeoutHandler(5000, TimeUnit.MILLISECONDS))))) // 设置读取超时
                               .build();

3. 发送请求

GET请求

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

POST请求

Mono<User> newUser = webClient.post()
                              .uri("/users")
                              .bodyValue(new User("John", "Doe"))
                              .retrieve()
                              .bodyToMono(User.class);

4. 响应处理

单个对象

response.subscribe(data -> System.out.println("Response: " + data));

流式对象

Flux<User> users = webClient.get()
                            .uri("/users")
                            .retrieve()
                            .bodyToFlux(User.class);
users.subscribe(user -> System.out.println(user));

5. 错误处理

Mono<User> userMono = webClient.get()
                               .uri("/users/{id}", "1")
                               .retrieve()
                               .onStatus(HttpStatusCode::is4xxClientError,
                                        error -> Mono.error(new RuntimeException("Client error occurred")))
                               .onStatus(HttpStatusCode::is5xxServerError,
                                        error -> Mono.error(new RuntimeException("Server error occurred")))
                               .bodyToMono(User.class);

6. 自定义过滤器

可以添加过滤器来处理认证、日志、重试等逻辑。

ExchangeFilterFunction logRequest = (clientRequest, next) -> {
    System.out.println("Request: " + clientRequest.url());
    return next.exchange(clientRequest);
};
WebClient clientWithFilter = WebClient.builder()
                                      .filter(logRequest)
                                      .build();

7. 在Spring Boot应用中配置全局WebClient

可以在配置类中定义一个@Bean来配置全局的WebClient实例，并注入到需要使用它的组件中。

@Configuration
public class WebClientConfig {

    @Bean
    public WebClient webClient() {
        return WebClient.builder()
                         .baseUrl("http://example.com/api")
                         .build();
    }
}

然后在其他组件中注入并使用这个WebClient实例：

@Service
public class UserService {

    private final WebClient webClient;

    public UserService(WebClient webClient) {
        this.webClient = webClient;
    }

    // 使用webClient进行请求...
}

通过上述步骤，你可以在Spring Boot应用中充分利用WebClient的强大功能，实现高效、响应式的HTTP通信。

avatar
文章
阅读
粉丝