SpringBoot3+AI

玩一下AI

1. SSE协议

我们都知道tcp，ip，http，https，websocket等等协议，今天了解一个新的协议SSE协议（Server-Sent Events）

SSE（Server-Sent Events） 是一种允许服务器主动向客户端推送数据的轻量级协议，基于 HTTP 长连接，实现 单向通信（服务器→客户端）。它是 W3C 标准，浏览器原生支持，无需额外插件（如 EventSource API）

核心特点与工作原理

• 单向通信：仅服务器向客户端发送数据，适合实时通知、日志流、实时更新等场景。
• 基于 HTTP：客户端通过 GET 请求建立连接，服务器返回特殊格式的文本流（text/event-stream），连接保持打开状态，直到服务器主动关闭或超时。
• 自动重连：浏览器内置重连机制，连接断开后自动尝试重新连接。
• 数据格式：每条消息以 \n 分隔，支持事件类型、数据内容、重试时间等字段，例如：

data: Hello, SSE!  // 数据内容
event: customEvent // 自定义事件类型（可选）
id: 123            // 消息ID（可选）
retry: 5000        // 重连时间（毫秒，可选）
\n

适用于无需双向通信，仅需服务器单向推送数据。【比如现在的 gpt，豆包这个问答形式】

前端客户端可以使用原生的 EventSource API：

// 创建EventSource实例，连接服务器
const eventSource = new EventSource('/sse-endpoint');
// 监听默认事件（"message"）
eventSource.onmessage = (event) => {
  console.log('Received:', event.data);
};
// 监听自定义事件（如"customEvent"）
eventSource.addEventListener('customEvent', (event) => {
  console.log('Custom Event:', event.data);
});
// 处理错误
eventSource.onerror = (error) => {
  console.error('SSE Error:', error);
  // 浏览器会自动重连，无需手动处理
};

服务端可用的就太多了。（本文以SpringBoot3.4.2为例子）

在知道这个协议之前，我们想要达到gpt这种问答形式，输出内容是一点一点拼接的，该怎么弄呢？是不是还可以用websocket。

下面结合Spring Boot 简单用一下SSE

 // sse协议测试
@PostMapping(value = "/chat", produces = "text/event-stream;charset=UTF-8")
public SseEmitter streamSseMvc() {
    SseEmitter emitter = new SseEmitter(30_000L);
    // 模拟发送消息
    System.out.println("SSE connection started");
    ScheduledFuture<?> future = service.scheduleAtFixedRate(() -> {
        try {
            String message = "Message at " + System.currentTimeMillis();
            emitter.send(SseEmitter.event().data(message));
        } catch (IOException e) {
            try {
                emitter.send(SseEmitter.event().name("error").data(Map.of("error", e.getMessage())));
            } catch (IOException ex) {
                // ignore
            }
            emitter.completeWithError(e);
        }
    }, 0, 5, TimeUnit.SECONDS);
    emitter.onCompletion(() -> {
        System.out.println("SSE connection completed");

    });
    emitter.onTimeout(() -> {
        System.out.println("SSE connection timed out");
        emitter.complete();

    });
    emitter.onError((e) -> {
        System.out.println("SSE connection error: " + e.getMessage());
        emitter.completeWithError(e);
    });

    return emitter;
}

在SpringBoot中，用SseEmitter就可以达到这个效果了，它也和Websocket一样有onXXX这种类似的方法。上面是使用一个周期性的任务，来模拟AI生成对话的效果的。emitter.send(SseEmitter.event().data(message)); 这个就是服务端向客户端推送数据。

2. okhttp3+sse+deepseek

简单示例：就问一句话

申请deepseekKey这里就略过了，各位读者自行去申请。【因为deepseek官网示例是用的okhttp，所以我这里也用okhttp了】

我们先准备一个接口

@RestController
@RequestMapping("/deepseek")
public class DeepSeekController {
    @Resource
    private DeepSeekUtil deepSeekUtil;

    /**
     * 访问deepseek-chat
     */
    @PostMapping(value = "/chat", produces = "text/event-stream;charset=UTF-8")
    public SseEmitter chatSSE() throws IOException {
        SseEmitter emitter = new SseEmitter(60000L);
        deepSeekUtil.sendChatReqStream("123456", "你会MySQL数据库吗？", emitter);
        return emitter; // 这里把该sse对象返回了
    }

    private boolean notModel(String model) {
        return !"deepseek-chat".equals(model) && !"deepseek-reasoner".equals(model);
    }
}

可以看到我们创建了一个SseEmitter对象，传给了我们自定义的工具

@Component
public class DeepSeekUtil {
    public static final String DEEPSEEK_CHAT = "deepseek-chat";
    public static final String DEEPSEEK_REASONER = "deepseek-reasoner";
    public static final String url = "https://api.deepseek.com/chat/completions";
    // 存储每个用户的消息列表
    private static final ConcurrentHashMap<String, List<Message>> msgList = new ConcurrentHashMap<>();

    // 1.调用api，然后以以 SSE（server-sent events）的形式以流式发送消息增量。消息流以 data: [DONE] 结尾。
    public void sendChatReqStream(String uid, String message, SseEmitter sseEmitter) throws IOException {
        // 1.构建一个普通的聊天body请求
        AccessRequest tRequest = buildNormalChatRequest(uid, message);

        OkHttpClient client = new OkHttpClient().newBuilder()
                .build();
        // 封装请求体参数
        MediaType mediaType = MediaType.parse("application/json; charset=utf-8");
        RequestBody body = RequestBody.create(JSON.toJSONString(tRequest), mediaType);
        // 构建请求和请求头
        Request request = new Request.Builder()
                .url(url)
                .method("POST", body)
                .addHeader("Content-Type", "application/json")
                .addHeader("Accept", "text/event-stream")
            	// 比如你的key是：s-123456
            	// .addHeader("Authorization", "Bearer s-123456")
                .addHeader("Authorization", "Bearer 你的key")
                .build();
		// 创建一个监听器
        SseChatListener listener = new SseChatListener(sseEmitter);
        RealEventSource eventSource = new RealEventSource(request, listener);
        eventSource.connect(client);
    }

    private AccessRequest buildNormalChatRequest(String uid, String message) {
        // 这里，我们messages，添加了一条“你会MySQL数据库吗？"，来达到一种对话具有上下文的效果
        List<Message> messages = msgList.computeIfAbsent(uid, k -> new ArrayList<>());
        messages.add(new Message("user", message));
        /*
        [
	        {"system", "你好, 我是DeepSeek-AI助手！"},	
	        {"user", "你会MySQL数据库吗？"}
        ]
        */
        AccessRequest request = new AccessRequest();
        request.setMessages(messages);
        request.setModel(DEEPSEEK_CHAT);
        request.setResponse_format(Map.of("type", "text"));
        request.setStream(true); // 设置为true
        request.setTemperature(1.0);
        request.setTop_p(1.0);
        return request;
    }

    @PostConstruct
    public void init() {
        List<Message> m = new ArrayList<Message>();
        m.add(new Message("system", "你好, 我是DeepSeek-AI助手！"));
        // 初始化消息列表
        msgList.put("123456", m);
    }
}

// 请求体，参考deepseek官网
public class AccessRequest {
    private List<Message> messages;
    private String model; // 默认模型为deepseek-chat
    private Double frequency_penalty = 0.0;
    private Integer max_tokens;
    private Double presence_penalty = 0.0;
    //{
    //    "type": "text"
    //}
    private Map<String, String> response_format;
    private Object stop = null; // null
    private Boolean stream; //如果设置为 True，将会以 SSE（server-sent events）的形式以流式发送消息增量。消息流以 data: [DONE] 结尾。
    private Object stream_options = null;

    private Double temperature; // 1
    private Double top_p; // 1
    private Object tools; // null
    private String tool_choice = "none";
    private Boolean logprobs = false;
    private Integer top_logprobs = null;
    // get set
}

监听器

@Slf4j
public class SseChatListener extends EventSourceListener {
    private SseEmitter sseEmitter;
    public SseChatListener( SseEmitter sseEmitter) {
       this.sseEmitter = sseEmitter;
    }
    /**
     * 事件
     */
    @Override
    public void onEvent(EventSource eventSource, String id, String type, String data) {
        //log.info("sse数据:{}", data);
        DeepSeekResponse deepSeekResponse = JSON.parseObject(data, DeepSeekResponse.class);
        DeepSeekResponse.Choice[] choices = deepSeekResponse.getChoices();
        try {
            // 发送给前端【客户端】
            sseEmitter.send(SseEmitter.event().data(choices[0]));
        } catch (IOException e) {
            log.error("数据发送异常");
            throw new RuntimeException(e);
        }
    }
    /**
     * 建立sse连接
     */
    @Override
    public void onOpen(final EventSource eventSource, final Response response) {
        log.info("建立sse连接... {}");
    }

    /**
     * sse关闭
     */
    @Override
    public void onClosed(final EventSource eventSource) {
        log.info("sse连接关闭:{}");
    }
    /**
     * 出错了
     */
    @Override
    public void onFailure(final EventSource eventSource, final Throwable t, final Response response) {
        log.error("使用事件源时出现异常......");

    }
}
// DeepSeekResponse.java
@Data
@NoArgsConstructor
@AllArgsConstructor
public class DeepSeekResponse {
    private String id;
    private String object;
    private Long created;
    private String model;
    private String system_fingerprint;
    private Choice[] choices;

    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    public static class Choice {
        private Integer index;
        private Delta delta;
        private Object logprobs;
        private String finish_reason;
    }

    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    public static class Delta {
        private String content;
    }
}

然后我们用apifox测试一下：

返回这些信息，然后把ai返回的存起来，具体怎么存，就靠读者自行发挥了，添加到该对话，使该对话具有上下文。【DeepSeek /chat/completions API 是一个“无状态” API，即服务端不记录用户请求的上下文，用户在每次请求时，需将之前所有对话历史拼接好后，传递给对话 API。】

[
    {"system", "你好, 我是DeepSeek-AI助手！"},	
    {"user", "你会MySQL数据库吗？"},
    {"ststem", "是的,我熟悉........"} // 把ai返回的存起来
]

下一次对话的时候，请求体AccessRequest里面的List<Message> messages就向上面那样，再往后添加用户问的消息。

上面的例子还有一些小问题，比如说什么时候断开连接那些的。

3. SpringAI

Spring AI 是一个专注于 AI 工程的应用框架，其目标是将 Spring 生态的 “POJO 构建块” 和模块化设计引入 AI 场景，简化企业数据与第三方模型的对接和使用。

下面快速接入deepseek

<!--maven的pom.xml-->
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>3.4.3</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.feng.ai</groupId>
    <artifactId>spring-ai-chat</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>spring-ai-chat</name>
    <description>spring-ai-chat</description>
    
    <properties>
        <java.version>21</java.version>
        <spring-ai.version>1.0.0-M6</spring-ai.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-webflux</artifactId>
        </dependency>
        <!--openAI-->
        <dependency>
            <groupId>org.springframework.ai</groupId>
            <artifactId>spring-ai-openai-spring-boot-starter</artifactId>
        </dependency>

        <dependency>
            <groupId>com.alibaba.fastjson2</groupId>
            <artifactId>fastjson2</artifactId>
            <version>2.0.44</version>
        </dependency>
    </dependencies>

    <repositories>
        <repository>
            <id>spring-snapshots</id>
            <name>Spring Snapshots</name>
            <url>https://repo.spring.io/snapshot</url>
            <releases>
                <enabled>false</enabled>
            </releases>
            <snapshots>
                <enabled>true</enabled>
            </snapshots>
        </repository>
        <repository>
            <name>Central Portal Snapshots</name>
            <id>central-portal-snapshots</id>
            <url>https://central.sonatype.com/repository/maven-snapshots/</url>
            <releases>
                <enabled>false</enabled>
            </releases>
            <snapshots>
                <enabled>true</enabled>
            </snapshots>
        </repository>
    </repositories>


    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.ai</groupId>
                <artifactId>spring-ai-bom</artifactId>
                <version>${spring-ai.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>
</project>

然后是配置文件

spring:
  application:
    name: spring-ai-chat
  ai:
    # The DeepSeek API doesn't support embeddings, so we need to disable it.
    openai:
      embedding:
        enabled: false
      base-url: https://api.deepseek.com
      api-key: 你的key
      chat:
        options:
          model: deepseek-reasoner # 使用推理模型
          stream-usage: true

controller

@Slf4j
@RestController
@RequestMapping("/sp/deepseek")
public class SpDeepseekController {

    @Resource( name = "openAiChatModel")
    private OpenAiChatModel deepseekModel;
    
    // 直接回答 --- stream-usage: false
    //@GetMapping("/simpleChat")
    //public R chat() {
    //    String call = deepseekModel.call("你好, 你会java吗？");
    //    return R.success().setData("call", call);
    //}

    // 流式回答
    @PostMapping(value = "/streamChat", produces = "text/event-stream;charset=UTF-8")
    public Flux<SpMessage> streamChat(@RequestBody Map<String, String> p) {
        String userMessage = p.get("userMessage");
        String sessionId = p.get("sessionId");
        
        Prompt prompt = new Prompt(new UserMessage(userMessage));

        StringBuilder modelStr = new StringBuilder();
        return deepseekModel.stream(prompt)
                .doOnSubscribe(subscription -> log.info("SSE 连接已启动: {}", sessionId))
                .doOnComplete(() -> log.info("SSE 连接已关闭: {}", sessionId))
                .doOnCancel(() -> log.info("SSE 连接已取消: {}", sessionId))
                .timeout(Duration.ofSeconds(60)) // 超时设置
                .filter(chatResponse -> chatResponse.getResult().getOutput().getText() != null) // 过滤掉空的响应
                .map(chatResponse -> {
                        //log.info("SSE 响应: {}", chatResponse.getResult().getOutput());
                    modelStr.append(chatResponse.getResult().getOutput().getText());
                        return SpMessage.builder()
                            .role("system")
                            .content(chatResponse.getResult().getOutput().getText())
                            .build();
                    }
                );
    }
}

**TODO：**上面的对话没有记忆，新的请求来了，ai模型并不会带上以前的场景，故需要记忆化。 记忆化的同时还要注意如果把该会话历史中所有的对话全部传给deepseek的话，可能导致 token 超限，故还需要做一个窗口，避免把太多历史对话传过去了。

4. 延伸-Http远程调用

在不讨论微服务架构模式下，我们平时开发难免会碰到需要远程调用接口的情况，【比如说上面调用deepseek的服务】，那么，我们怎么做才是比较好的方式呢？

一次良好的调用过程，我们应该要考虑这几点：超时处理、重试机制、异常处理、日志记录；

此外，于性能来说，我们要避免频繁创建连接带来的开销，可以使用连接池管理；

① RestTemplate

RestTemplate 是一个同步的 HTTP 客户端，提供了简单的方法来发送 HTTP 请求并处理响应。它支持常见的 HTTP 方法（GET、POST、PUT、DELETE 等），并能自动处理 JSON/XML 的序列化和反序列化，这个也是我们非常熟悉的。

下面由于是基于SpringBoot3.4.3，所以httpclient的版本是httpclient5.

@Configuration
public class RestConfig {
    @Bean("restTemplate")
    public RestTemplate restTemplate() {
        // 使用Apache HttpClient连接池（替代默认的 SimpleClientHttpRequestFactory）
        PoolingHttpClientConnectionManager connectionManager = new PoolingHttpClientConnectionManager();
        connectionManager.setMaxTotal(100);      // 最大连接数
        connectionManager.setDefaultMaxPerRoute(20); // 每个路由的最大连接数

        CloseableHttpClient httpClient = HttpClients.custom()
                .setConnectionManager(connectionManager)
                .evictIdleConnections(TimeValue.of(10, TimeUnit.SECONDS))// 清理空闲连接
                .build();

        HttpComponentsClientHttpRequestFactory factory =
                new HttpComponentsClientHttpRequestFactory(httpClient);
        factory.setConnectTimeout(3000);  // 连接超时（ms）
        factory.setReadTimeout(5000);  // 读取超时（ms）
        RestTemplate restTemplate = new RestTemplate(factory);
		// 添加自定义的错误处理器
        restTemplate.setErrorHandler(new CustomErrorHandler());
        // 添加日志拦截器
        restTemplate.getInterceptors().add(new LoggingInterceptor());
        return restTemplate;
    }
}

@Slf4j
public class LoggingInterceptor implements ClientHttpRequestInterceptor {
    @NotNull
    @Override
    public ClientHttpResponse intercept(HttpRequest request, @NotNull byte[] body, ClientHttpRequestExecution execution) throws IOException {
        log.info("请求地址: {} {}", request.getMethod(), request.getURI());
        log.info("请求头: {}", request.getHeaders());
        log.info("请求体: {}", new String(body, StandardCharsets.UTF_8));
        ClientHttpResponse response = execution.execute(request, body);
        log.info("响应状态码: {}", response.getStatusCode());
        return response;
    }
}

@Slf4j
public class CustomErrorHandler implements ResponseErrorHandler {
    @Override
    public boolean hasError(@NotNull ClientHttpResponse response) throws IOException {
        // 获取 HTTP 状态码
        HttpStatusCode statusCode = response.getStatusCode();
        return statusCode.isError(); // 判断状态码是否为错误状态码 【4xx、5xx是true，执行下面的handleError，其他的就false】
    }

    @Override
    public void handleError(@NotNull URI url, @NotNull HttpMethod method, @NotNull ClientHttpResponse response) throws IOException {
        log.info("请求地址: {}  Method: {}",url, method);
        HttpStatusCode code = response.getStatusCode();
        if (code.is4xxClientError()) {
            log.info("客户端错误：{}", code.value());
            // xxx
        } else {
            log.info("服务器错误：{}", code.value());
            // xxx
        }
    }
}

重试降级机制:

@Configuration
@EnableRetry // 开启重试 -- 需要引入AOP
public class RetryConfig {
}

// 在service层调用的时候
@Service
public class OrderService {
    @Resource
    private RestTemplate restTemplate;

    @Retryable(
        maxAttempts = 3, 
        backoff = @Backoff(delay = 1000, multiplier = 2), // 重试间隔 1s, 2s, 4s
        retryFor = {Exception.class} // 默认重试所有异常
        //retryFor = {ResourceAccessException.class} // 仅在网络异常时重试
    )
    public String queryOrder(String orderId) {
        return restTemplate.getForObject("/orders/" + orderId, String.class); // 远程调用
    }

    @Recover // 重试全部失败后的降级方法
    public String fallbackQueryOrder(ResourceAccessException e, String orderId) {
        return "默认订单";
    }
}

当然还可以再远程调用那里try catch起来，有异常的时候，throw出去可以被@Retryable捕获。

② RestClient

Spring Framework 6.1 引入了全新的同步 HTTP 客户端 RestClient，它在底层使用了与 RestTemplate 相同的基础设施（比如消息转换器和拦截器），但提供了如同 WebClient 一样的现代、流式（fluent）API，兼顾了简洁性与可复用性。与传统的阻塞式 RestTemplate 相比，RestClient 更加直观易用，同时也保持了对同步调用语境的全量支持

同步调用：RestClient 是一个阻塞式客户端，每次 HTTP 请求都会阻塞调用线程直到响应完成。

流式 API：借鉴 WebClient 的设计风格，所有操作均可链式调用，代码更具可读性和可维护性。

复用基础组件：与 RestTemplate 共用 HTTP 请求工厂、消息转换器、拦截器等组件，便于平滑迁移与统一配置

@Configuration
@Slf4j
public class RestClientConfig {

    @Bean("serviceARestClient")
    public RestClient restClientA(@Value("${api-service.a-base-url}") String baseUrl) {
        // 创建连接池
        PoolingHttpClientConnectionManager manager = new PoolingHttpClientConnectionManager();
        manager.setMaxTotal(100);
        manager.setDefaultMaxPerRoute(20);
        // 创建HttpClient
        HttpClient httpClient = HttpClientBuilder.create()
                .setConnectionManager(manager)
                .build();
        // 创建HttpComponentsClientHttpRequestFactory
        HttpComponentsClientHttpRequestFactory factory =
                new HttpComponentsClientHttpRequestFactory(httpClient);
        factory.setConnectTimeout(3000);
        factory.setReadTimeout(5000);
        return RestClient.builder()
                .baseUrl(baseUrl)
                .defaultHeader(HttpHeaders.ACCEPT, MediaType.APPLICATION_JSON_VALUE)
                .defaultCookie("myCookie", "1234")
                .requestInterceptor(clientRequestInterceptor())
                .requestFactory(factory) // 连接池与超时
                .build();
    }

    @Bean("serviceBRestClient")
    public RestClient restClientB(@Value("${api-service.b-base-url}") String baseUrl) {
        return RestClient.builder()
                .baseUrl(baseUrl)
                .defaultHeader(HttpHeaders.ACCEPT, MediaType.APPLICATION_JSON_VALUE)
                .defaultCookie("myCookie", "1234")
                .requestInterceptor(clientRequestInterceptor())
                .build();
    }

    private ClientHttpRequestInterceptor clientRequestInterceptor() {
        return (request, body, execution) -> {
            // 添加统一请求头（如认证信息）
            request.getHeaders().add("my-head", "head-gggggg");
            // 日志记录
            log.debug("Request: {} {}", request.getMethod(), request.getURI());
            request.getHeaders().forEach((name, values) ->
                    values.forEach(value -> log.debug("Header: {}={}", name, value)));

            ClientHttpResponse response = execution.execute(request, body);
            log.debug("Response status: {}", response.getStatusCode());
            return response;
        };
    }
}

简单调用:

@Service
public class AService {
    @Resource(name = "serviceARestClient")
    private RestClient restClientA;

    public String queryA(String a) {
        return restClientA.get()
                .uri("/api/a?a={a}", a)
                .retrieve()
                .onStatus(HttpStatusCode::is4xxClientError, (request, response) -> {
                    throw new HttpClientErrorException(response.getStatusCode());
                })
                .onStatus(HttpStatusCode::is5xxServerError, (request, response) -> {
                    throw new ServerErrorException(response.getStatusCode().toString(), null);
                })
                .body(String.class);
    }

    // 复杂query参数
    public String queryA(String a, String b) {
        return restClientA.get()
                .uri(  uriBuilder ->
                        uriBuilder.path("/api/bbb")
                        .queryParam("a", 25)
                        .queryParam("b", "30")
                        .build()
                )
                .retrieve()
                .onStatus(HttpStatusCode::is4xxClientError, (request, response) -> {
                    throw new HttpClientErrorException(response.getStatusCode());
                })
                .onStatus(HttpStatusCode::is5xxServerError, (request, response) -> {
                    throw new ServerErrorException(response.getStatusCode().toString(), null);
                })
                .body(String.class);
    }

    // post
    public String postA(String a) {
        HashMap<String, Object> map = new HashMap<>();
        map.put("a", a); map.put("page", 1); map.put("size", 10);

        return restClientA.post()
                .uri("/api/post")
                .body(map)
                .retrieve()
                .onStatus(HttpStatusCode::is4xxClientError, (request, response) -> {
                    throw new HttpClientErrorException(response.getStatusCode());
                })
                .onStatus(HttpStatusCode::is5xxServerError, (request, response) -> {
                    throw new ServerErrorException(response.getStatusCode().toString(), null);
                })
                .body(String.class);
    }


}

③ WebClient

Spring框架中包含的原始web框架Spring web MVC是专门为Servlet API和Servlet容器构建的。响应式堆栈web框架Spring WebFlux是在5.0版本中添加的。它是完全非阻塞的，支持响应式流回压，并运行在诸如Netty、Undertow和Servlet容器之类的服务器上。

这两个web框架都镜像了它们的源模块的名字（Spring-webmvc和Spring-webflux 他们的关系图如下，节选自官网），并在Spring框架中共存。每个模块都是可选的。应用程序可以使用其中一个或另一个模块，或者在某些情况下，两者都使用——例如，Spring MVC控制器与响应式WebClient。它对同步和异步以及流方案都有很好的支持。

非阻塞异步模型：基于 Reactor 库（Mono/Flux）实现异步调用，避免线程阻塞，通过少量线程处理高并发请求，显著提升性能

函数式编程：支持链式调用（Builder 模式）与 Lambda 表达式，代码更简洁

流式传输：支持大文件或实时数据的分块传输（Chunked Data），减少内存占用。

这里就不介绍了。

end. 参考

1. https://segmentfault.com/a/1190000021133071 【思否-Spring5的WebClient使用详解】
2. https://docs.spring.io/spring-framework/reference/integration/rest-clients.html 【Spring官网】