Spring WebClient：响应式HTTP客户端

好的，各位观众老爷们，欢迎来到“响应式编程大舞台”！今天，咱们不聊那些高大上的架构，也不谈那些深奥的理论，就聊聊一个实实在在，能让你在代码世界里飞起来的神器——Spring WebClient！

🚀🚀🚀

开场白：告别阻塞，拥抱响应式！

话说江湖上流传着这么一句话：“阻塞一时爽，一直阻塞火葬场”。在传统的HTTP客户端里，你发送一个请求，就得老老实实地等着服务器回应，这段时间啥也干不了，CPU都闲得长草了。这就像你跑去餐厅吃饭，点完菜就只能眼巴巴地等着，不能玩手机，不能跟朋友聊天，时间都浪费在等待上了。

但是！有了Spring WebClient，一切都不一样了！它就像一个风一样的男子（或者女子），嗖嗖嗖地发送请求，嗖嗖嗖地处理响应，完全异步非阻塞，让你的程序在等待的时候也能做其他事情，真正实现“一心多用”，效率蹭蹭往上涨！

第一幕：WebClient，何方神圣？

Spring WebClient是Spring 5引入的一个响应式HTTP客户端，它基于Reactor库，采用响应式编程模型，可以处理大量的并发请求，提供高性能和可伸缩性。简单来说，它可以让你以一种更优雅、更高效的方式进行HTTP通信。

为什么要用WebClient？

• 异步非阻塞： 避免了传统同步阻塞的性能瓶颈，提高了吞吐量和响应速度。
• 响应式编程： 基于Reactor库，可以方便地处理数据流，实现复杂的业务逻辑。
• 灵活配置： 提供了丰富的配置选项，可以根据实际需求进行定制。
• 易于测试： 可以方便地进行单元测试和集成测试。
• 与Spring生态无缝集成： 可以轻松地与Spring的其他组件集成，例如Spring MVC，Spring WebFlux等。

第二幕：WebClient，初相识

咱们先来个简单的例子，感受一下WebClient的魅力。

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

public class WebClientExample {

    public static void main(String[] args) {
        WebClient client = WebClient.create("https://api.example.com");

        String response = client.get()
                .uri("/users")
                .retrieve()
                .bodyToMono(String.class)
                .block(); // 阻塞等待结果，仅用于演示

        System.out.println(response);
    }
}

这段代码的作用是从https://api.example.com/users获取数据，并将其打印到控制台。是不是很简单？

代码解读：

• WebClient.create("https://api.example.com")：创建一个WebClient实例，指定基础URL。
• .get()：指定HTTP方法为GET。
• .uri("/users")：指定URI。
• .retrieve()：开始获取响应。
• .bodyToMono(String.class)：将响应体转换为Mono<String>，Mono是Reactor库中的一个类，表示一个包含0或1个元素的异步序列。
• .block()：阻塞等待结果，这在实际生产环境中应该避免，这里只是为了方便演示。

第三幕：WebClient，进阶之路

上面只是WebClient的一个简单示例，它还有很多强大的功能等着我们去探索。

1. 请求头和请求体

WebClient可以方便地设置请求头和请求体。

import org.springframework.http.HttpHeaders;
import org.springframework.http.MediaType;
import org.springframework.web.reactive.function.BodyInserters;

// ...

WebClient client = WebClient.create("https://api.example.com");

String requestBody = "{"name":"John Doe", "age":30}";

String response = client.post()
        .uri("/users")
        .header(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE)
        .body(BodyInserters.fromValue(requestBody))
        .retrieve()
        .bodyToMono(String.class)
        .block();

System.out.println(response);

这段代码发送一个POST请求，请求头包含Content-Type: application/json，请求体包含一个JSON字符串。

2. 处理响应

WebClient提供了多种方式处理响应，例如：

• retrieve()：获取响应体。
• exchange()：获取完整的响应信息，包括状态码、响应头等。

import org.springframework.http.HttpStatus;
import org.springframework.web.reactive.function.client.ClientResponse;

// ...

WebClient client = WebClient.create("https://api.example.com");

ClientResponse response = client.get()
        .uri("/users")
        .exchange()
        .block();

HttpStatus statusCode = response.statusCode();
String responseBody = response.bodyToMono(String.class).block();

System.out.println("Status Code: " + statusCode);
System.out.println("Response Body: " + responseBody);

这段代码获取完整的响应信息，并打印状态码和响应体。

3. 错误处理

WebClient提供了强大的错误处理机制。

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

// ...

WebClient client = WebClient.create("https://api.example.com");

try {
    String response = client.get()
            .uri("/users/123")
            .retrieve()
            .bodyToMono(String.class)
            .block();

    System.out.println(response);
} catch (WebClientResponseException ex) {
    System.err.println("Error: " + ex.getStatusCode());
    System.err.println("Error Body: " + ex.getResponseBodyAsString());
}

这段代码尝试获取ID为123的用户，如果服务器返回错误，则捕获WebClientResponseException并打印错误信息。

4. 异步非阻塞

前面我们使用了.block()方法来阻塞等待结果，这在实际生产环境中应该避免。WebClient的真正威力在于它的异步非阻塞特性。

import reactor.core.publisher.Mono;

// ...

WebClient client = WebClient.create("https://api.example.com");

Mono<String> responseMono = client.get()
        .uri("/users")
        .retrieve()
        .bodyToMono(String.class);

responseMono.subscribe(
        response -> System.out.println("Response: " + response),
        error -> System.err.println("Error: " + error)
);

System.out.println("Request sent!"); // 这行代码会立即执行，不会阻塞

// ... 其他代码

这段代码使用subscribe()方法来处理响应，它是异步的，不会阻塞主线程。subscribe()方法接受两个参数：一个Consumer用于处理成功响应，一个Consumer用于处理错误。

5. 数据流处理

WebClient可以处理数据流，例如：

• bodyToFlux(String.class)：将响应体转换为Flux<String>，Flux是Reactor库中的一个类，表示一个包含0到多个元素的异步序列。

import reactor.core.publisher.Flux;

// ...

WebClient client = WebClient.create("https://api.example.com");

Flux<String> responseFlux = client.get()
        .uri("/events")
        .retrieve()
        .bodyToFlux(String.class);

responseFlux.subscribe(
        event -> System.out.println("Event: " + event),
        error -> System.err.println("Error: " + error)
);

System.out.println("Request sent!");

这段代码从/events获取事件流，并逐个打印事件。

第四幕：WebClient，实战演练

咱们来个更实际的例子，假设我们需要从一个API获取用户信息，并将其保存到数据库。

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import reactor.core.publisher.Mono;

@Service
public class UserService {

    @Autowired
    private WebClient webClient;

    @Autowired
    private UserRepository userRepository;

    public Mono<User> fetchAndSaveUser(String userId) {
        return webClient.get()
                .uri("/users/" + userId)
                .retrieve()
                .bodyToMono(User.class)
                .flatMap(user -> userRepository.save(user));
    }
}

这段代码定义了一个UserService，它使用WebClient从API获取用户信息，并使用UserRepository将其保存到数据库。

代码解读：

• @Autowired private WebClient webClient;：注入WebClient实例。
• @Autowired private UserRepository userRepository;：注入UserRepository实例。
• .flatMap(user -> userRepository.save(user))：使用flatMap将Mono<User>转换为Mono<User>，并在转换的过程中保存用户到数据库。

第五幕：WebClient，配置之道

WebClient提供了丰富的配置选项，可以根据实际需求进行定制。

1. 配置超时

可以配置连接超时和响应超时。

import io.netty.channel.ChannelOption;
import io.netty.handler.timeout.ReadTimeoutHandler;
import io.netty.handler.timeout.WriteTimeoutHandler;
import org.springframework.http.client.reactive.ReactorClientHttpConnector;
import reactor.netty.http.client.HttpClient;
import java.time.Duration;
import java.util.concurrent.TimeUnit;

// ...

HttpClient httpClient = HttpClient.create()
        .option(ChannelOption.CONNECT_TIMEOUT_MILLIS, 5000) // 连接超时 5秒
        .responseTimeout(Duration.ofSeconds(5)) // 响应超时 5秒
        .doOnConnected(conn ->
                conn.addHandlerLast(new ReadTimeoutHandler(5, TimeUnit.SECONDS)) // 读超时 5秒
                        .addHandlerLast(new WriteTimeoutHandler(5, TimeUnit.SECONDS))); // 写超时 5秒

WebClient client = WebClient.builder()
        .baseUrl("https://api.example.com")
        .clientConnector(new ReactorClientHttpConnector(httpClient))
        .build();

2. 配置代理

可以配置代理服务器。

import java.net.InetSocketAddress;
import java.net.Proxy;

// ...

HttpClient httpClient = HttpClient.create()
        .proxy(proxy -> proxy.type(Proxy.Type.HTTP).address(new InetSocketAddress("proxy.example.com", 8080)));

WebClient client = WebClient.builder()
        .baseUrl("https://api.example.com")
        .clientConnector(new ReactorClientHttpConnector(httpClient))
        .build();

3. 配置拦截器

可以配置拦截器来修改请求和响应。

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

// ...

ExchangeFilterFunction logRequest = ExchangeFilterFunction.ofRequestProcessor(clientRequest -> {
    System.out.println("Request: " + clientRequest.method() + " " + clientRequest.url());
    clientRequest.headers().forEach((name, values) -> values.forEach(value -> System.out.println(name + ": " + value)));
    return Mono.just(clientRequest);
});

ExchangeFilterFunction logResponse = ExchangeFilterFunction.ofResponseProcessor(clientResponse -> {
    System.out.println("Response: " + clientResponse.statusCode());
    clientResponse.headers().asHttpHeaders().forEach((name, values) -> values.forEach(value -> System.out.println(name + ": " + value)));
    return Mono.just(clientResponse);
});

WebClient client = WebClient.builder()
        .baseUrl("https://api.example.com")
        .filter(logRequest)
        .filter(logResponse)
        .build();

这段代码配置了两个拦截器，一个用于记录请求信息，一个用于记录响应信息。

第六幕：WebClient，测试之道

WebClient可以方便地进行单元测试和集成测试。

1. 单元测试

可以使用MockWebServer来模拟服务器。

import okhttp3.mockwebserver.MockResponse;
import okhttp3.mockwebserver.MockWebServer;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.springframework.web.reactive.function.client.WebClient;
import reactor.core.publisher.Mono;
import reactor.test.StepVerifier;

import java.io.IOException;

public class WebClientTest {

    private MockWebServer mockWebServer;
    private WebClient webClient;

    @BeforeEach
    void setUp() throws IOException {
        mockWebServer = new MockWebServer();
        mockWebServer.start();

        webClient = WebClient.builder()
                .baseUrl(mockWebServer.url("/").toString())
                .build();
    }

    @AfterEach
    void tearDown() throws IOException {
        mockWebServer.shutdown();
    }

    @Test
    void testGetUser() {
        MockResponse mockResponse = new MockResponse()
                .addHeader("Content-Type", "application/json")
                .setBody("{"id":"123", "name":"John Doe"}");

        mockWebServer.enqueue(mockResponse);

        Mono<User> userMono = webClient.get()
                .uri("/users/123")
                .retrieve()
                .bodyToMono(User.class);

        StepVerifier.create(userMono)
                .expectNextMatches(user -> user.getId().equals("123") && user.getName().equals("John Doe"))
                .verifyComplete();
    }
}

这段代码使用MockWebServer模拟服务器，并验证WebClient是否能够正确地获取用户信息。

2. 集成测试

可以使用@SpringBootTest和@AutoConfigureWebTestClient来进行集成测试。

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.web.reactive.server.WebTestClient;

@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
public class WebClientIntegrationTest {

    @Autowired
    private WebTestClient webTestClient;

    @Test
    void testGetUser() {
        webTestClient.get()
                .uri("/users/123")
                .exchange()
                .expectStatus().isOk()
                .expectBody()
                .jsonPath("$.id").isEqualTo("123")
                .jsonPath("$.name").isEqualTo("John Doe");
    }
}

这段代码使用WebTestClient来发送HTTP请求，并验证响应是否符合预期。

第七幕：WebClient，注意事项

• 避免阻塞： 尽量避免使用.block()方法，充分利用WebClient的异步非阻塞特性。
• 错误处理： 完善的错误处理机制可以提高程序的健壮性。
• 性能优化： 合理配置WebClient，例如连接池大小、超时时间等，可以提高性能。
• 数据类型： 选择合适的数据类型，例如Mono和Flux，可以更好地处理数据流。

谢幕：WebClient，未来可期！

Spring WebClient是一个功能强大、灵活易用的响应式HTTP客户端，它可以帮助你构建高性能、可伸缩的应用程序。希望通过今天的讲解，大家能够对WebClient有一个更深入的了解，并在实际项目中灵活运用。

🎉🎉🎉

总结：

特性	描述
异步非阻塞	避免了传统同步阻塞的性能瓶颈，提高了吞吐量和响应速度。
响应式编程	基于Reactor库，可以方便地处理数据流，实现复杂的业务逻辑。
灵活配置	提供了丰富的配置选项，可以根据实际需求进行定制，例如配置超时、代理、拦截器等。
易于测试	可以方便地进行单元测试和集成测试，例如使用MockWebServer模拟服务器，使用WebTestClient进行集成测试。
与Spring集成	可以轻松地与Spring的其他组件集成，例如Spring MVC，Spring WebFlux等。
错误处理	提供了强大的错误处理机制，例如可以捕获WebClientResponseException并处理错误信息。

希望这篇文章能帮助你更好地理解和使用Spring WebClient。 祝你在响应式编程的道路上越走越远！ 💪💪💪