java后端http接口流式输出到前端的方法示例
作者：abcnull
这篇文章主要介绍了java后端http接口流式输出到前端的相关资料,对比SseEmitter与WebFlux两种实现方式,通过实例代码详细分析了其适用场景及优劣,需要的朋友可以参考下
前置
解释：
Server-Sent Events：服务器发送事件，是一种基于 HTTP 的轻量级协议，允许服务器主动向客户端推送文本数据（如 JSON、纯文本等）
特点：
- 单向通信：仅服务器 → 客户端方向
- 基于 HTTP/HTTPS：无需特殊协议
- 自动重连：浏览器内置支持断线重连
- 简单易用：前端直接使用 EventSource API
流程：
前端 (Vue) → 发起SSE请求 → Spring Boot (Controller)
↓ ↓
(EventSource) ← 流式数据 ← WebClient → 大模型API (流式HTTP)
后端流式输出
使用 springboot SseEmitter
传统项目小范围流式推送 → SseEmitter（改动成本低）
轻量级 SSE 推送、兼容旧 MVC 项目
每个请求占用一个线程，高并发时资源消耗大
@RestController
public class StreamingController {
@GetMapping("/stream")
public SseEmitter streamText() {
SseEmitter emitter = new SseEmitter(60_000L); // 设置超时时间（毫秒）
ExecutorService executor = Executors.newSingleThreadExecutor();
executor.execute(() -> {
try {
for (int i = 1; i <= 10; i++) {
String data = "这是第 " + i + " 段内容\n";
emitter.send(SseEmitter.event().name("message").data(data));
Thread.sleep(1000); // 模拟延迟
}
emitter.complete(); // 结束流
} catch (IOException | InterruptedException e) {
emitter.completeWithError(e);
} finally {
executor.shutdown();
}
});
return emitter;
}
}
代码内部直接承接大模型 api 调用，然后流式输出到前端
@RestController
public class ModelStreamController {
// 创建线程池
private final ExecutorService executor = Executors.newCachedThreadPool();
@GetMapping("/model-stream")
public SseEmitter streamModel() {
// 创建 SSE 发射器（60秒超时）
SseEmitter emitter = new SseEmitter(60_000L);
// 提交任务到线程池
executor.execute(() -> {
try (CloseableHttpClient httpClient = HttpClients.createDefault()) {
// 1. 创建到大模型API的请求
HttpGet request = new HttpGet("https://api.open-model.com/stream");
// 2. 执行请求
HttpResponse response = httpClient.execute(request);
// 3. 检查响应状态
if (response.getStatusLine().getStatusCode() != 200) {
throw new RuntimeException("API error: " +
response.getStatusLine().getStatusCode());
}
// 4. 获取响应流
try (InputStream is = response.getEntity().getContent();
BufferedReader reader = new BufferedReader(new InputStreamReader(is))) {
String line;
// 5. 逐行读取并转发
while ((line = reader.readLine()) != null) {
// 6. 发送给前端
emitter.send(line);
}
// 7. 完成后关闭SSE
emitter.complete();
}
} catch (Exception e) {
// 8. 错误处理
emitter.completeWithError(e);
}
});
return emitter;
}
}
使用 springboot WebFlux
新建高并发/代理外部流式 API → Flux + WebFlux（性能与扩展性更优）
响应式编程（Reactive Streams）
每个请求占用一个线程，高并发时资源消耗大
全链路非阻塞，适合代理外部流式 API
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-webflux</artifactId> <!-- 非阻塞IO -->
</dependency>
下面例子是转发大模型的响应结果
@RestController
public class WebFluxController {
@GetMapping(value = "/flux-stream", produces = MediaType.TEXT_EVENT_STREAM_VALUE)
public Flux<String> stream() {
// 直接转发大模型的流式响应（非阻塞）
WebClient webClient = WebClient.create("https://api.open-model.com/stream");
return webClient.get()
.retrieve()
.bodyToFlux(String.class)
.map(data -> "data: " + data + "\n\n") // 封装为 SSE 格式
.delayElements(Duration.ofMillis(100)); // 非阻塞延迟
}
}
使用 servlet
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws IOException {
// 设置响应头，声明内容类型为 SSE
response.setContentType("text/event-stream");
response.setCharacterEncoding("UTF-8");
response.setHeader("Cache-Control", "no-cache");
response.setHeader("Connection", "keep-alive");
OutputStream outputStream = response.getOutputStream();
try {
// 模拟流式传输数据
for (int i = 0; i < 5; i++) {
String data = "event: message\ndata: {" + i + "}\n\n";
outputStream.write(data.getBytes()); // 写入
outputStream.flush(); // 不断的发送 flush
Thread.sleep(1000); // 模拟延迟
}
// 发送自定义结束事件
String endEvent = "data: [DONE]\n\n";
outputStream.write(endEvent.getBytes());
outputStream.flush();
// 关闭流，通知前端结束
outputStream.close();
} catch (Exception e) {
e.printStackTrace();
outputStream.close();
}
}
如果是你的服务接入了大模型 api，大模型本身做的就是一个流式输出呢？承接后直接输出到前端
@WebServlet("/proxy-stream")
public class StreamingProxyServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
// 设置响应头
response.setContentType("text/event-stream");
response.setCharacterEncoding("UTF-8");
response.setHeader("Cache-Control", "no-cache");
response.setHeader("Connection", "keep-alive");
// 构造 JSON 请求体
String jsonBody = "{\"param1\": \"value1\", \"param2\": \"value2\"}";
// 创建 HttpClient 实例
try (CloseableHttpClient httpClient = HttpClients.createDefault()) {
HttpPost httpPost = new HttpPost("https://third-party.com/stream"); // 替换为你的流式接口地址
// 设置请求头
httpPost.setHeader("Content-Type", "application/json; charset=UTF-8");
// 设置请求体
httpPost.setEntity(new StringEntity(jsonBody, StandardCharsets.UTF_8));
// 执行请求
try (CloseableHttpResponse backendResponse = httpClient.execute(httpPost)) {
// 检查后端响应状态码
int statusCode = backendResponse.getStatusLine().getStatusCode();
if (statusCode != 200) {
response.sendError(HttpServletResponse.SC_BAD_GATEWAY, "后端接口返回状态码: " + statusCode);
return;
}
// 获取后端流式接口的输入流
InputStream backendStream = backendResponse.getEntity().getContent();
// 获取前端响应的输出流
OutputStream frontendStream = response.getOutputStream();
byte[] buffer = new byte[4096];
int bytesRead;
// 边读边写，实时透传
while ((bytesRead = backendStream.read(buffer)) != -1) {
frontendStream.write(buffer, 0, bytesRead);
frontendStream.flush(); // 必须立即刷新，确保数据实时到达前端
}
// 结束流式连接
frontendStream.close();
}
} catch (Exception e) {
e.printStackTrace();
response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, "流式传输失败: " + e.getMessage());
}
}
}
扩展
自定义事件类型：
后端发送：event: update\ndata: {…}\n\n
前端监听：.addEventListener(“update”, handler)
总结
到此这篇关于java后端http接口流式输出到前端的文章就介绍到这了,更多相关java后端http接口流式输出到前端内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！