简而言之，SSE 是一种基于 HTTP/1.1 的单向流技术。服务器返回一个 text/event-stream 的响应体后就Ke以持续写入符合约定的文本块，浏览器会把它们转成 MessageEvent 对象。

实时性：只要网络不掉线，消息几乎是瞬间抵达。

兼容性：IE 除外大多数现代浏览器原生支持，无需额外插件。

开发成本：后端只要提供一个普通的 @GetMapping，前端调用 EventSource 即可，不必像 WebSocket 那样维护完整的协议栈。

不过它也有局限——只Neng由服务端发起、只Neng走单向通道。Ru果业务需要“双向聊天”，WebSocket 仍是首选。但Ru果你只是想让后台监控数据、系统日志或者 AI 对话的响应流动起来SSE 完全够用，而且比 WebSocket geng加“温柔”。

SSE 本身非常轻，但在真实项目里你往往要面对「用户下线」「消息丢失」以及「跨域」这些棘手问题。下面这套代码Yi经把这些坑抹平，只要把它注入 Spring 容器，即可直接调用。

public class SSEMessage {
    /** 事件类型，如 "chat", "notify" */
    private SseEnum event;
    /** 真正携带的数据，一般是 JSON 字符串 */
    private String data;
    /** 消息唯一标识，用于前端去重 */
    private String id;
    // getter / setter 略
}

public enum SseEnum {
    HEARTBEAT,
    NOTIFY,
    CHAT,
    ERROR;
    private final String value;
    SseEnum{ this.value = v; }
    public String value{ return value; }
}

@Service
public class SSEmitterManager {
    private static final Logger log = LoggerFactory.getLogger;
    /** 保存每个用户对应的包装对象 */
    private final ConcurrentHashMap emitters = new ConcurrentHashMap<>;
    /** 创建或获取Yi有的 SSE 实例 */
    public SseEmitter getOrCreate {
        if ) {
            throw new IllegalArgumentException;
        }
        return emitters.computeIfAbsent(userId,
                k -> new SSEmitterWrapper)
                .start;
    }
    /** 删除失效链接 */
    private void remove{
        emitters.remove;
        log.info;
    }
   // ----------- 群发 / 单发 省略，可自行调用 wrapper.sendMessage ----------
}

public class SSEmitterWrapper {
   private static final long TIMEOUT = 6 * 60 * 60 * 1000L; // 6 小时
   private static final long HEARTBEAT_INTERVAL = 5L;      // 秒
   private final String userId;
   private final Runnable onClose;
   private final AtomicBoolean active = new AtomicBoolean;
   private final BlockingQueue retryQueue = new LinkedBlockingQueue<>;
   @Getter
   private SseEmitter emitter;
   private ScheduledFuture heartbeatTask;
   public SSEmitterWrapper{
       this.userId = uid;
       this.onClose = closeCallback;
   }
   public SseEmitter start{
       emitter = new SseEmitter;
       active.set;
       bindListener;
       scheduleHeartbeat;
       return emitter;
   }
   /** 注册错误/完成回调 */
   private void bindListener{
       emitter.onCompletion;
       emitter.onTimeout;
       emitter.onError(e -> {
           log.warn);
           close;
       });
   }
   /** 每隔 HEARTBEAT_INTERVAL 秒发送一次 “心跳” */
   private void scheduleHeartbeat{
       heartbeatTask = ThreadPoolManager.getScheduled
               .scheduleAtFixedRate->{
                   try{
                       sendInternal
                               .name)
                               .data);
                   }catch{
                       log.warn;
                       close;
                   }
               }, HEARTBEAT_INTERVAL, HEARTBEAT_INTERVAL, TimeUnit.SECONDS);
   }
   /** 真正发送消息的方法 */
   public void sendMessage{
       if  || msg == null) return;
       try{
           sendInternal
                   .id)
                   .name.value)
                   .data));
       }catch{
           // 网络波动导致发送失败 → 放入重试队列
           retryQueue.offer);
           log.info);
       }
   }
   /** 内部统一发送逻辑 */
   private void sendInternal throws IOException{
       emitter.send;
   }
   /** 定时任务，由管理类调度执行 */
   public void retryFailed{
       int size = retryQueue.size;
       for{
           RetryMessage rm = retryQueue.poll;
           if continue;
           try{
               sendInternal
                       .id)
                       .name.value)
                       .data));
               log.info);
           }catch{
               rm.retryCnt++;
               if{
                   retryQueue.offer; // 
放回队列
               }else{
                   log.warn);
               }
           }
       }
   }
   /** 清理资源并通知管理类移除映射 */
   public void close{
       if){
           if heartbeatTask.cancel;
           try{ emitter.complete; }catch{}
           onClose.run;
           log.info;
       }
   }
   /* ---------- 内部类 ---------- */
   static class RetryMessage{
      final SSEMessage msg;
      int retryCnt=0;
      RetryMessage{ this.msg=m; }
   }
}

* 小提示：上面的 `ThreadPoolManager` 是一个懒加载式线程池包装，只要调用一次 `getScheduled` 就Neng得到全局调度执行器。

SSE 属于普通 HTTP 请求，所以跨域问题Ke以直接在 Spring 配置中解决：

@Configuration
public class CorsConfig implements WebMvcConfigurer {
 @Override
 public void addCorsMappings {
     registry.addMapping
             .allowedOrigins          // 开发阶段随意放行
             .allowCredentials
             .maxAge;
 }
}

`allowCredentials` Neng让浏览器把 JSESSIONID 一起带上，实现「同一会话」的效果。前端只要确保登录后页面保持同一个 Cookie，即可在不同路由之间共享同一条 SSE 链接。

E​ventSource 用起来几乎就是「声明式」——实例化一次它就会自动尝试重新连接。下面给出一个封装好的 composable，让你在任何组件里douNeng像订阅普通状态一样使用：

// src/composables/useSse.ts
import { ref, onMounted, onUnmounted } from 'vue'
export interface MessagePayload {
  id:string,
  event:string,
  data:any
}
/**
 * 创建并管理 EventSource 实例。
 * url 必须指向后端 /sse/xxx 接口，
 * headers 中若需要携带 token，可自行
。
 */
export function useSse{
  const source = ref
  const messages = ref
  const error = ref
  const connect = =>{
     source.value = new EventSource
     source.value.onmessage = ev =>{
         messages.value.push})
     }
     source.value.addEventListener('heartbeat', ev=>{
         console.log
     })
     source.value.onerror = e=>{
         error.value = new Error
         console.warn
         // 浏览器会自动尝试重连，这里仅记录日志即可
     }
  }
  onMounted
  onUnmounted=>{
      source.value?.close
      console.log
  })
  return {messages,error,source}
}

A Vue 页面示例 —— Chat.vue 



这里故意加入了几行随意注释，让代码kan起来geng像真实项目，而不是教科书式演示。
四、部署注意点与运维经验分享 

# 长连接保活：
服务器默认超时时间设为六小时但实际生产环境常被负载均衡或 Nginx 的 proxyreadtimeout /#keepalive_timeout#​​​​​​​​​ ​‍‍‍‍‍​​‍​​‌​​​‌​​‌​​‌​​‌​​​​​​​​​​​‏‏‏‏‏‏‏‏‮‌‌‌‌‌‌‌‌‌‌‭‬‎‬‮‎⁠⁠⁠⁠⁠⁠⁠⁠⁠‎‭‬‎     **