Java的Spring Cloud生态中实现SSE（Server-Sent Events）服务端实践

原创 已于 2025-06-17 16:37:45 修改 · 644 阅读 · 6 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#后端 #架构 #SSE

于 2025-05-27 16:45:03 首次发布

SSE简介

sse是一个单向通讯的协议也是一个长链接，它只能支持服务端主动向客户端推送数据，但是无法让客户端向服务端推送消息。

长链接是一种HTTP/1.1的持久连接技术，它允许客户端和服务器在一次TCP连接上进行多个HTTP请求和响应，而不必为每个请求/响应建立和断开一个新的连接。长连接有助于减少服务器的负载和提高性能。

SSE的优点是，它是一个轻量级的协议，相对于websockte来说，他的复杂度就没有那么高，相对于客户端的消耗也比较少。而且SSE使用的是http协议（websocket使用的是ws协议），也就是现有的服务端都支持SSE，无需像websocket一样需要服务端提供额外的支持。

注意:IE大魔王不支持SSE

SSE对于各大浏览器的兼容性↓ 

在Java的Spring Cloud生态中实现SSE（Server-Sent Events）服务端推送功能，可以通过Spring Boot原生支持的SseEmitter类简化开发。以下是详细的实现步骤，包括依赖配置、核心代码及注意事项：

一、依赖配置

SSE的实现基于Spring Web模块，无需额外依赖，只需在pom.xml中添加基础Web依赖：

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

若需异步处理，可引入spring-boot-starter-async（非必需）

二、服务端实现

1. 控制器类

使用@RestController定义SSE接口，返回SseEmitter对象以建立长连接：

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.servlet.mvc.method.annotation.SseEmitter;

@RestController
@RequestMapping("/sse")
public class SseController {

    @GetMapping(value = "/stream", produces = "text/event-stream")
    public SseEmitter stream() {
        SseEmitter emitter = new SseEmitter(0L); // 设置超时时间（0表示无超时）
        
        // 使用线程池异步推送数据
        Executors.newSingleThreadExecutor().execute(() -> {
            try {
                for (int i = 0; i < 10; i++) {
                    // 发送SSE格式数据（支持自定义事件类型、ID和重试时间）
                    emitter.send(SseEmitter.event()
                            .name("message")    // 事件类型
                            .id(String.valueOf(i))  // 事件ID
                            .data("Data " + i)      // 消息内容
                            .reconnectTime(5000));  // 重连时间（毫秒）
                    Thread.sleep(1000);
                }
                emitter.complete(); // 正常关闭连接
            } catch (IOException | InterruptedException e) {
                emitter.completeWithError(e); // 异常关闭
            }
        });

        // 注册回调（处理连接关闭、超时或错误）
        emitter.onCompletion(() -> System.out.println("SSE连接关闭"));
        emitter.onTimeout(() -> System.out.println("SSE连接超时"));
        emitter.onError(ex -> System.out.println("SSE错误: " + ex.getMessage()));

        return emitter;
    }
}


package test;
import java.util.Random;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
@Controller
@RequestMapping(value = "/test")
public class SEEController {
//设置响应格式
	@RequestMapping(value = "/push", produces = "text/event-stream;charset=UTF-8")
	public @ResponseBody String push() {
		Random r = new Random();
		try {
			Thread.sleep(5000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
//SSE返回数据格式是固定的以data:开头，以\n\n结束
		return "data:Testing 1,2,3" + r.nextInt() + "\n\n";
	}
}

使用原生Servlet实现SSE（异步处理）

import javax.servlet.*;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.*;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

@WebServlet(urlPatterns = "/sse", asyncSupported = true)
public class SseServlet extends HttpServlet {

    private final ExecutorService executor = Executors.newCachedThreadPool();

    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) {
        // 设置响应头
        response.setContentType("text/event-stream");
        response.setCharacterEncoding("UTF-8");
        response.setHeader("Cache-Control", "no-cache");
        response.setHeader("Connection", "keep-alive");
        response.setHeader("Access-Control-Allow-Origin", "*");

        // 启动异步上下文
        AsyncContext asyncContext = request.startAsync();
        asyncContext.setTimeout(0); // 无超时限制

        // 提交任务到线程池
        executor.submit(() -> {
            try (PrintWriter writer = asyncContext.getResponse().getWriter()) {
                for (int i = 0; i < 10; i++) {
                    if (asyncContext.getResponse().isCommitted()) {
                        // 构建SSE格式数据（注意末尾的两个换行符）
                        String message = "data: Message " + i + "\n\n";
                        writer.write(message);
                        writer.flush(); // 立即发送数据
                        Thread.sleep(1000);
                    } else {
                        break; // 客户端已断开
                    }
                }
            } catch (IOException | InterruptedException e) {
                // 客户端断开连接或发生错误
            } finally {
                asyncContext.complete(); // 完成请求
            }
        });
    }
}

package com.example.sse;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.http.MediaType;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.servlet.mvc.method.annotation.SseEmitter;

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

@SpringBootApplication
@RestController
public class SseServerApplication {

    // 存储所有客户端的SseEmitter
    private final List<SseEmitter> emitters = new ArrayList<>();

    public static void main(String[] args) {
        SpringApplication.run(SseServerApplication.class, args);
    }

    // SSE端点
    @GetMapping(path = "/sse", produces = MediaType.TEXT_EVENT_STREAM_VALUE)
    public SseEmitter streamSseMvc() {
        SseEmitter emitter = new SseEmitter(60_000L); // 设置超时时间为60秒
        
        // 添加客户端到连接列表
        emitters.add(emitter);
        
        // 设置完成回调
        emitter.onCompletion(() -> emitters.remove(emitter));
        // 设置超时回调
        emitter.onTimeout(() -> emitters.remove(emitter));
        // 设置错误回调
        emitter.onError((ex) -> emitters.remove(emitter));
        
        // 发送连接成功消息
        try {
            emitter.send(SseEmitter.event()
                    .id(String.valueOf(System.currentTimeMillis()))
                    .name("message")
                    .data("{\"message\": \"连接已建立\"}"));
        } catch (IOException e) {
            emitters.remove(emitter);
            e.printStackTrace();
        }
        
        return emitter;
    }
    
    // 模拟定时发送数据的方法
    public void startPeriodicUpdates() {
        ScheduledExecutorService executor = Executors.newSingleThreadScheduledExecutor();
        executor.scheduleAtFixedRate(() -> {
            String data = "{\"timestamp\": " + System.currentTimeMillis() + 
                         ", \"message\": \"定期更新\"}";
            sendToAll(data);
        }, 0, 5, TimeUnit.SECONDS); // 每5秒发送一次更新
    }
    
    // 向所有客户端发送消息
    private void sendToAll(String data) {
        List<SseEmitter> deadEmitters = new ArrayList<>();
        
        emitters.forEach(emitter -> {
            try {
                emitter.send(SseEmitter.event()
                        .id(String.valueOf(System.currentTimeMillis()))
                        .name("data")
                        .data(data));
            } catch (IOException e) {
                deadEmitters.add(emitter);
                e.printStackTrace();
            }
        });
        
        // 移除失效的emitter
        emitters.removeAll(deadEmitters);
    }
}
2. 核心要点
  • 数据格式：遵循SSE协议，每条消息以data:开头，以\n\n结尾。使用SseEmitter.event()可自动处理格式45。
  • 异步处理：通过线程池或异步任务避免阻塞主线程，确保高并发下的性能69。
  • 超时与重连：通过SseEmitter(long timeout)设置超时，客户端断开后默认3秒重连（可通过retry字段调整）36。

三、客户端示例

前端通过EventSource监听服务端推送：

const eventSource = new EventSource('http://localhost:8080/sse/stream');

eventSource.onmessage = (e) => {
    console.log('收到消息:', e.data);
};

eventSource.addEventListener('message', (e) => { // 自定义事件类型
    console.log('自定义事件:', e.data);
});

eventSource.onerror = () => {
    eventSource.close(); // 错误时关闭连接
};

四、高级配置

1. 跨域支持

若前端与服务端域名不同，需添加跨域配置：

@Configuration
public class CorsConfig implements WebMvcConfigurer {
    @Override
    public void addCorsMappings(CorsRegistry registry) {
        registry.addMapping("/sse/**")
                .allowedOrigins("*")
                .allowedMethods("GET");
    }
}
2. 性能优化
  • 线程池管理：避免频繁创建线程，推荐使用ThreadPoolTaskExecutor6。
  • 连接数限制：浏览器对同一域名SSE连接数有限制（通常6个），需合理设计接口3。

五、SSE与WebSocket对比

特性

SSE

WebSocket

协议

HTTP（单向）

独立协议（双向）

实现复杂度

简单（无需额外协议）

较高（需握手协议）

断线重连

原生支持

需手动实现

适用场景

服务端单向推送（如实时通知）

双向通信（如聊天室）

选型建议：

  • 使用SSE：低频单向推送、兼容性要求高46。
  • 使用WebSocket：高频双向交互、低延迟需求910。

六、常见问题

  1. 客户端收不到消息
    • 检查数据格式是否正确（必须以\n\n结尾）。
    • 确保响应头Content-Type为text/event-stream25。
  1. 连接频繁断开
    • 调整服务端超时时间（如new SseEmitter(-1L)）。
    • 客户端增加错误处理逻辑，自动重连36。
  1. 高并发性能问题
    • 使用异步非阻塞模型（如Reactive WebFlux）替代传统Servlet8。

通过上述实现，可快速构建基于Spring Cloud的SSE服务端，适用于实时通知、数据监控等场景。

相关文档：

服务器推送消息SSE以及springmvc后台实现例子_sse 多实例如何区分-CSDN博客

SpringBoot 系列教程(六十九)：SpringBoot2.x整合SSE服务端实时单向推送消息
Thinkingcao的专栏
11-29 5745
一、需求背景 最近需要做一个微信公众号H5端，微信打卡签到页面，在用户每天进入打卡页面时，其中其他用户打卡签到的数据需要以姓名头像的弹幕的形式在H5页面飘浮，当这个用户自己打卡签到完了之后，他的打卡数据需要以弹幕的形式展示，这是一个需要服务端实时推送消息给前端，后端一经查询到新数据，立刻通过接口返回给前端；这时候想到了WebSokcet，但是WebSocket过于笨重、复杂，我只需要这么一个效...
Java Server-Sent Events通信
无心
01-22 1124
等待数据推送：虽然 stream() 方法创建了连接，但实际的数据推送是由其他部分的代码来处理的。通常，这涉及到在服务层或控制器的其他部分设置逻辑，以在某些事件发生时调用 SseEmitter 的 send() 方法来推送数据。stream() 方法返回的 SseEmitter 对象用于建立一个 SSE (Server-Sent Events) 连接，但它本身并不负责推送数据。保持连接开启：这个连接将保持开启状态，直到服务器发送完成信号或连接超时。连接默认超时时间为三十分钟，这是设置为1天。
Spring SseEmitter 系统详细讲解
最新发布
HGX-DJK
07-03 684
/ 不超时，或设置时间，如30_000Ltry {i <= 5;i++) {emitter.send("第 " + i + " 条消息");// 关闭连接});.data("这是自定义事件")console.log("收到自定义事件:", event.data);});特性支持情况异步发送✅多用户并发✅超时与关闭管理✅自定义事件类型✅应用场景实时推送、轻量通知。
java使用sse(Server-Sent Events)实现实时数据推送，用于监控，通知，实时统计
weixin_45559862的博客
04-16 520
【代码】java使用sse(Server-Sent Events)实现实时数据推送，用于监控，通知，实时统计。
Java：SpringBoot整合SSE（Server-Sent Events）实现后端主动向前端推送数据
热门推荐
彭世瑜的博客
08-31 1万+
SpringBoot整合SSE（Server-Sent Events）可以实现后端主动向前端推送数据。
HTML5 Server-Sent Events With Java Servlets Example
zha_zi的专栏
05-15 163
Since the dawn of modern web applications, push notifications have gained significant traction in industry. Instead of pooling data from server it has now become common that server should notify cli...
SpringCloud微服务实现的服务端消息推送SSE[RabbitMQ消息队列]
kaizq的专栏
05-25 6359
SpringCloud微服务，实现服务端消息推送SSE，有两种方式：“定时长连接保持”和“Emitter事件监听处理”，都需要实现跨域操作。这里选用RabbitMQ监听接收消息，并以SSE方式及时推送到请求前端。 1 前端EventSource请求发起 if(typeof(EventSource) !== "undefined") { var evtSrc = new EventSource('http://localhost:9005/sseMsgSvc"); ...
服务端实时推送技术之SSE（Server-Send Events）
大山博客
02-20 2327
服务端推送，也称为消息推送或通知推送，是一种允许应用服务器主动将信息发送到客户端的能力，为客户端提供了实时的信息更新和通知，增强了用户体验。服务端推送的背景与需求主要基于以下几个诉求：实时通知：在很多情况下，用户期望实时接收到应用的通知，如新消息提醒、商品活动提醒等。节省资源：如果没有服务端推送，客户端需要通过轮询的方式来获取新信息，会造成客户端、服务端的资源损耗。通过服务端推送，客户端只需要在收到通知时做出响应，大大减少了资源的消耗。
SSE 实践：用 Vue 和 Spring Boot 实现实时数据传输
xyendjsj的博客
01-17 1169
SSE 看着有些高级，实际实现一点儿不难，跟着我一起实现吧
sse springcloud
02-20
在Spring Cloud应用程序中实现服务器发送事件(Server-Sent Events, SSE)，可以利用Spring WebFlux或Spring MVC的支持。下面展示了一个基于Spring WebFlux的简单例子，该方法允许客户端持续接收来自服务端的消息更新...
三、Spring-WebFlux实战案例-流式
平凡之路无尽路的博客
08-03 2266
为了使用 WebClient 实现流式响应，我们需要在。
Java Web 中的 Server-Sent Events (SSE) 入门介绍
zru_9602的博客
03-05 1400
Server-Sent Events（服务器发送事件，简称 SSE）是一种用于实现服务器向客户端推送实时更新的技术。与 WebSocket 不同，SSE 是一种单向通信技术，适用于只需要从服务器到客户端的数据流场景。通过 SSE 技术，可以在 Java Web 应用中轻松实现服务器向客户端推送实时数据的功能。SSE 的实现简单且高效，特别适用于单向数据流场景。如果你需要更复杂的双向通信功能，则可以考虑使用 WebSocket。希望以上内容对你理解 Java Web 中的 SSE 实现有帮助！
Java Server-Sent Event 服务端发送事件
zhou_Tian的博客
08-09 914
实现后端单方面向前端发消息。
Java版本的SSE服务端实现样例
gzt19881123的专栏
10-05 2439
Server-Sent Events (SSE) 是一种用于在客户端和服务器之间建立单向通信的技术。 它允许服务器主动向客户端推送实时更新，而不需要客户端不断地请求数据。 Server-Sent Events (SSE) 的流行可以追溯到 HTML5 的引入，最大特点：他和我们现在经常接触的 websocket，mqtt，类rabbitmq 有说明区别， 同样是客户端服务端的数据访问，同样用于取代客户端轮询访问方式，他们有审美不一样或者说使用场景是什么，下面表格简要说明一下：关于java版本的SSE服务端实
java sse spring_SpringBoot服务端主动推送SSE
weixin_32836713的博客
02-24 508
长时间和后台保持通讯的有三种方式，分别是ajax的setInterval()，和websocket，已经SSE。ajax长时间和合同保持通讯太占内存。websocket可以进行服务端和后台双向通讯。SSE只能进行服务器往前端单向传送数据。服务端接口写法import java.text.DecimalFormat;import org.springframework.web.bind.annotat...
Java server sent_Server-Sent Events的Java简单实现
weixin_42537499的博客
02-15 1540
Server-Sent Events (SSE)是一种基于HTTP协议的单向通讯技术，只能服务器向客户端发送消息，如果客户端需要向服务器发送消息，则需要一个新的 HTTP 请求。SSE的实现方法可能参考阮一锋老师的文章。在Java中，并没有像HTML5中SSE的封装实现，但我们可以模拟一个，以下为Java与Node.js服务器后台通讯的实现:import java.io.*;import java...
轻量化server-sent-events，java后端推送消息给客户端，并实现所有打开客户端，都收到此一条消息（类似消息中间件topic）...
一念轮回君千殇的博客
10-30 2156
后端与后端消息推送，直接使用消息中间件即可，后端->多个客户端推送消息，怎么推送呢？ 1.消息来源。（由于没有安装redis等数据库，就直接用mysql来...
Java服务端实时推送之SSE（Server-Send Events）
weixin_54821991的博客
01-04 2811
服务端推送的背景与需求主要基于以下几个诉求：1. 传统实时处理方案 轮询：这是一种较为传统的方式，客户端会定时地向服务端发送请求，询问是否有新数据。服务端只需要检查数据状态，然后将结果返回给客户端。轮询的优点是实现简单，兼容性好；缺点是可能产生较大的延迟，且对服务端资源消耗较高。 长轮询（Long Polling）：轮询的改进版。客户端向服务器发送请求，服务器收到请求后，如果有新的数据，立即返回给客户端；如果没有新数据，服务器会等待一定时间（比如30秒超时时间），在这段时间内，如果有新数据，就返回给客户端，
Java建立SSE连接
weixin_50016308的博客
04-13 2118
最近有一个新的需求，服务器任务执行完成后需要给客户端发送消息，告诉客户端已经完成这个任务了。用到了SSE（Server Sent Events，服务器发送）。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值