• Long-Polling, WebSocket, SSE 傻傻分不清楚

    大多数人都知道 HTTP1.0 不支持长连接，知道 HTTP1.1 支持长连接，这是业界的一个常识。 这样的描述导致了一些不做网络底层开发的开发者都下意识的认为 HTTP1.1 是一个可以建立长连接的的协议。 长连接是存在于网络层的一种连接状态，而实现它则需要在传输层进行开发，因为它是基于对真实数据的收发，需要在底层进行管控。

    所谓 HTTP1.1 及以上支持长连接，并不是 HTTP1.1 可以建立长连接，而是它支持以请求头的方式进行长连接发起（并且要求客户端与服务端都要具备 ‘Keep-Alive: true’ ）。

    • 短连接： 所谓短连接，及连接只保持在数据传输过程，请求发起，连接建立，数据返回，连接关闭。它适用于一些实时数据请求，配合轮询来进行新旧数据的更替。
    • 长连接： 长连接便是在连接发起后，在请求关闭连接前客户端与服务端都保持连接，实质是保持这个通信管道，之后便可以对其进行复用。 它适用于涉及消息推送，请求频繁的场景（直播，流媒体）。连接建立后，在该连接下的所有请求都可以重用这个长连接管道，避免了频繁了连接请求，提升了效率。
    • 短轮询： 所谓轮询，即是在一个循环周期内不断发起请求来得到数据的机制。只要有请求的的地方，都可以实现轮询，譬如各种事件驱动模型。它的长短是在于某次请求的返回周期。短轮询指的是在循环周期内，不断发起请求，每一次请求都立即返回结果，根据新旧数据对比决定是否使用这个结果。
    • 长轮询： 而长轮询及是在请求的过程中，若是服务器端数据并没有更新，那么则将这个连接挂起，直到服务器推送新的数据，再返回，然后再进入循环周期。长短轮询的理想实现都应当基于长连接，否则若是循环周期太短，那么服务器的荷载会相当重。

    1. Polling

    Polling 技术被大多数 Ajax 应用使用，基本原理：客户端不停轮询服务端获取数据，如果没有数据也会返回一个空响应。

    • 客户端打开一个链接，使用 http 协议请求服务器端数据；
    • 客户端周期性的发送请求获取数据；
    • 服务器端响应请求，并返回一个响应；
    • 客户端周期性重复以上三步；

    轮询的问题在于客户端需要不停的请求服务端，导致一个结果就是很多请求的响应都是空的，导致大量 http 的无用开销。

    2. Long-Polling

    这是传统轮询技术的一种变体，允许服务器推送数据可用时向客户提供信息。使用长轮询，客户端与正常轮询一样从服务器请求信息，但使用期望服务器可能不会立即响应。这就是为什么这种技术有时被称为“挂起 GET”。

    • 如果服务端没有可用数据，服务端就挂起该请求直到有可用数据；
    • 一旦服务器端游可用数据，响应发送给客户端。客户端立即重新连接服务端，等待下次响应。

    Long-Polling 的生命周期如下：

    • 客户端发起一个 http 请求等待响应；
    • 服务端挂起请求直到有可用数据或者链接时间超时；
    • 当服务端有可用数据后发送数据给客户端；
    • 客户端通常会立即发送一个新的长轮询请求接收响应或在暂停后允许可接受的延迟期；
    • 客户端发现长链接超时后发起重新连接。

    下边我们自己动手来实践一下:

    我们先建立一个父级项目，方便我们后续操作：

    1. <?xml version="1.0" encoding="UTF-8"?>
    2. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    3.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    4.     <modelVersion>4.0.0</modelVersion>
    5.  
    6.     <groupId>com.hupun</groupId>
    7.     <artifactId>WebMessage</artifactId>
    8.     <packaging>pom</packaging>
    9.     <version>0.0.1-SNAPSHOT</version>
    10.     
    11.     <name>WebMessage</name>
    12.     <description>Demo project for Spring Boot</description>
    13.  
    14.     <modules>
    15.         <module>demo-longpolling</module>
    16.         <module>demo-serversent</module>
    17.         <module>demo-websocket</module>
    18.     </modules>
    19.  
    20.     <properties>
    21.         <java.version>1.8</java.version>
    22.     </properties>
    23.  
    24.     <parent>
    25.         <groupId>org.springframework.boot</groupId>
    26.         <artifactId>spring-boot-starter-parent</artifactId>
    27.         <version>2.7.2</version>
    28.         <relativePath/> <!-- lookup parent from repository -->
    29.     </parent>
    30.  
    31.     <dependencies>
    32.         <dependency>
    33.             <groupId>org.springframework.boot</groupId>
    34.             <artifactId>spring-boot-starter-test</artifactId>
    35.             <scope>test</scope>
    36.         </dependency>
    37.     </dependencies>
    38.  
    39.     <build>
    40.         <plugins>
    41.             <plugin>
    42.                 <groupId>org.springframework.boot</groupId>
    43.                 <artifactId>spring-boot-maven-plugin</artifactId>
    44.             </plugin>
    45.         </plugins>
    46.     </build>
    47.  
    48. </project>
    49. 复制代码

    接下来我们搭建一个 spring-web 服务:

    1. <?xml version="1.0" encoding="UTF-8"?>
    2. <project xmlns="http://maven.apache.org/POM/4.0.0"
    3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    5.     <parent>
    6.         <artifactId>WebMessage</artifactId>
    7.         <groupId>com.hupun</groupId>
    8.         <version>0.0.1-SNAPSHOT</version>
    9.     </parent>
    10.     <modelVersion>4.0.0</modelVersion>
    11.  
    12.     <artifactId>demo-longpolling</artifactId>
    13.  
    14.     <properties>
    15.         <maven.compiler.source>8</maven.compiler.source>
    16.         <maven.compiler.target>8</maven.compiler.target>
    17.     </properties>
    18.  
    19.     <dependencies>
    20.         <dependency>
    21.             <groupId>org.springframework.boot</groupId>
    22.             <artifactId>spring-boot-starter-web</artifactId>
    23.         </dependency>
    24.         <dependency>
    25.             <groupId>org.projectlombok</groupId>
    26.             <artifactId>lombok</artifactId>
    27.         </dependency>
    28.     </dependencies>
    29.  
    30. </project>
    31. 复制代码

    LongPollingApplication.java

    1. import org.springframework.boot.SpringApplication;
    2. import org.springframework.boot.autoconfigure.SpringBootApplication;
    3.  
    4. @SpringBootApplication
    5. public class LongPollingApplication {
    6.  
    7.     public static void main(String[] args) {
    8.         SpringApplication.run(LongPollingApplication.class, args);
    9.     }
    10.  
    11. }
    12. 复制代码

    LongPollingServer.java

    1. import lombok.extern.slf4j.Slf4j;
    2. import org.springframework.util.ConcurrentReferenceHashMap;
    3. import org.springframework.web.bind.annotation.GetMapping;
    4. import org.springframework.web.bind.annotation.RestController;
    5. import org.springframework.web.context.request.async.DeferredResult;
    6.  
    7. import java.util.Map;
    8.  
    9. @Slf4j
    10. @RestController
    11. public class LongPollingServer {
    12.  
    13.     // 存放所有请求的返回值
    14.     private static final Map<String, DeferredResult<String>>
    15.             resultMap = new ConcurrentReferenceHashMap<>();
    16.  
    17.     /**
    18.      * 请求连接
    19.      *
    20.      * @param id
    21.      * @return
    22.      */
    23.     @GetMapping("/longPolling")
    24.     public DeferredResult<String> longPolling(String id) {
    25.         // 超时时间设置为300秒
    26.         DeferredResult<String> deferredResult = new DeferredResult<>(300 * 1000L);
    27.         resultMap.put(id, deferredResult);
    28.         log.info("收到" + resultMap.size() + "个请求未处理...");
    29.         deferredResult.onCompletion(() -> {
    30.             resultMap.remove(id);
    31.             log.info("还剩" + resultMap.size() + "个请求未响应...");
    32.         });
    33.         return deferredResult;
    34.     }
    35.  
    36.     /**
    37.      * 模拟服务端处理完成
    38.      */
    39.     @GetMapping("/returnValue")
    40.     public void returnValue() {
    41.         for (String key : resultMap.keySet()) {
    42.             resultMap.get(key).setResult("id: " + key + " is ok");
    43.         }
    44.     }
    45.  
    46. }
    47. 复制代码

    启动项目，我们准备两个浏览器，分别请求：

    1. http://localhost:8080/longPolling?id=001
    2. http://localhost:8080/longPolling?id=002
    3. 复制代码

    接下来我们通过请求来模拟服务端处理完毕：

    1. http://localhost:8080/returnValue
    2. 复制代码

    3. WebSocket

    WebSocket 是在 TCP 之上建立了一个全双工通信通道，客户端跟服务器端可以在任何时刻发起通信。客户端通过 websocket 握手建立连接，一旦成功建立连接，客户端跟服务端可以在任何时候双向通信。 Websocket 协议使客户端与服务器端以低开销，近乎实时的方式通信。这可以通过提供标准化的服务器在不被客户端询问的情况下向浏览器发送内容的方式并允许在保持连接的同时来回传递消息。

    下边我们自己动手来实践一下:

    接下来我们搭建一个 spring-websocket 服务:

    1. <?xml version="1.0" encoding="UTF-8"?>
    2. <project xmlns="http://maven.apache.org/POM/4.0.0"
    3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    5.     <parent>
    6.         <artifactId>WebMessage</artifactId>
    7.         <groupId>com.hupun</groupId>
    8.         <version>0.0.1-SNAPSHOT</version>
    9.     </parent>
    10.     <modelVersion>4.0.0</modelVersion>
    11.  
    12.     <artifactId>demo-websocket</artifactId>
    13.  
    14.     <properties>
    15.         <maven.compiler.source>8</maven.compiler.source>
    16.         <maven.compiler.target>8</maven.compiler.target>
    17.     </properties>
    18.  
    19.     <dependencies>
    20.         <dependency>
    21.             <groupId>org.springframework.boot</groupId>
    22.             <artifactId>spring-boot-starter-websocket</artifactId>
    23.         </dependency>
    24.         <dependency>
    25.             <groupId>org.projectlombok</groupId>
    26.             <artifactId>lombok</artifactId>
    27.         </dependency>
    28.         <dependency>
    29.             <groupId>com.alibaba</groupId>
    30.             <artifactId>fastjson</artifactId>
    31.             <version>1.2.76</version>
    32.         </dependency>
    33.     </dependencies>
    34.  
    35. </project>
    36. 复制代码

    WebSocketApplication.java

    1. import org.springframework.boot.SpringApplication;
    2. import org.springframework.boot.autoconfigure.SpringBootApplication;
    3.  
    4. @SpringBootApplication
    5. public class WebSocketApplication {
    6.  
    7.     public static void main(String[] args) {
    8.         SpringApplication.run(WebSocketApplication.class, args);
    9.     }
    10.  
    11. }
    12. 复制代码

    WebSocketConfig.java

    1. import org.springframework.context.annotation.Bean;
    2. import org.springframework.context.annotation.Configuration;
    3. import org.springframework.web.socket.server.standard.ServerEndpointExporter;
    4.  
    5. @Configuration
    6. public class WebSocketConfig {
    7.  
    8.     @Bean
    9.     public ServerEndpointExporter serverEndpointExporter() {
    10.         return new ServerEndpointExporter();
    11.     }
    12.  
    13. }
    14. 复制代码

    WebSocketServer.java

    1. import lombok.extern.slf4j.Slf4j;
    2. import org.springframework.stereotype.Component;
    3.  
    4. import javax.websocket.*;
    5. import javax.websocket.server.ServerEndpoint;
    6. import java.util.Map;
    7. import java.util.concurrent.ConcurrentHashMap;
    8.  
    9. @Slf4j
    10. @Component
    11. @ServerEndpoint(value = "/websocket")
    12. public class WebSocketServer {
    13.  
    14.     // 存放所有在线的客户端
    15.     private static final Map<String, Session> clients = new ConcurrentHashMap<>();
    16.  
    17.     @OnOpen
    18.     public void onOpen(Session session) {
    19.         clients.put(session.getId(), session);
    20.         log.info("连接加入: {}, 当前在线人数为: {}", session.getId(), clients.size());
    21.     }
    22.  
    23.     @OnClose
    24.     public void onClose(Session session) {
    25.         clients.remove(session.getId());
    26.         log.info("连接关闭: {}, 当前在线人数为: {}", session.getId(), clients.size());
    27.     }
    28.  
    29.     @OnMessage
    30.     public void onMessage(String message, Session session) {
    31.         log.info("收到消息: {}, 客户端ID: {}", message, session.getId());
    32.         sendMessage(session.getId(), "服务端收到消息: " + message);
    33.     }
    34.  
    35.     @OnError
    36.     public void onError(Session session, Throwable error) {
    37.         log.error("发生错误" + (null == session ? "" : ", 客户端ID: " + session.getId()));
    38.         error.printStackTrace();
    39.     }
    40.  
    41.     /**
    42.      * 发送消息给指定客户端
    43.      */
    44.     public static void sendMessage(String sessionId, String message) {
    45.         try {
    46.             Session session = clients.get(sessionId);
    47.             if (session != null) {
    48.                 session.getBasicRemote().sendText(message);
    49.                 log.info("发送消息: {}, 客户端ID: {}", message, sessionId);
    50.             }
    51.         } catch (Exception e) {
    52.             log.error("发送消息失败: {}, 客户端ID: {}", message, sessionId, e);
    53.         }
    54.     }
    55.  
    56.     /**
    57.      * 发送消息给全部客户端
    58.      */
    59.     public static void sendMessageToAll(String message) {
    60.         clients.forEach((sessionId, client) -> sendMessage(sessionId, message));
    61.     }
    62.  
    63. }
    64. 复制代码

    我们在 idea 里边安装一个 web-socket 插件，来测试下：

    输出地址，我们能发现成功连接：

    1. ws://localhost:8080/websocket
    2. 复制代码

    接下来我们来发送下消息报文，测试下通信结果：

    4. Server-Sent Events

    SSE 是一种通过 HTTP 为 Web 应用程序提供与从服务器到客户端的事件流的异步通信的技术。服务器可以向客户端发送非定向消息/事件，并且可以异步更新客户端。几乎所有浏览器都支持 SSE，除了 Internet Explorer。服务器发送事件 (SSE) 使服务器能够将消息从服务器发送到客户端，而无需任何轮询或长轮询。

    下边我们自己动手来实践一下:

    接下来我们搭建一个 spring-web 服务:

    1. <?xml version="1.0" encoding="UTF-8"?>
    2. <project xmlns="http://maven.apache.org/POM/4.0.0"
    3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    5.     <parent>
    6.         <artifactId>WebMessage</artifactId>
    7.         <groupId>com.hupun</groupId>
    8.         <version>0.0.1-SNAPSHOT</version>
    9.     </parent>
    10.     <modelVersion>4.0.0</modelVersion>
    11.  
    12.     <artifactId>demo-serversent</artifactId>
    13.  
    14.     <properties>
    15.         <maven.compiler.source>8</maven.compiler.source>
    16.         <maven.compiler.target>8</maven.compiler.target>
    17.     </properties>
    18.  
    19.     <dependencies>
    20.         <dependency>
    21.             <groupId>org.springframework.boot</groupId>
    22.             <artifactId>spring-boot-starter-web</artifactId>
    23.         </dependency>
    24.         <dependency>
    25.             <groupId>org.projectlombok</groupId>
    26.             <artifactId>lombok</artifactId>
    27.         </dependency>
    28.     </dependencies>
    29.  
    30. </project>
    31. 复制代码

    ServerSentApplication.java

    1. import org.springframework.boot.SpringApplication;
    2. import org.springframework.boot.autoconfigure.SpringBootApplication;
    3.  
    4. @SpringBootApplication
    5. public class ServerSentApplication {
    6.  
    7.     public static void main(String[] args) {
    8.         SpringApplication.run(ServerSentApplication.class, args);
    9.     }
    10.  
    11. }
    12. 复制代码

    ServerSentServer.java

    1. import lombok.extern.slf4j.Slf4j;
    2. import org.springframework.http.MediaType;
    3. import org.springframework.util.ConcurrentReferenceHashMap;
    4. import org.springframework.web.bind.annotation.GetMapping;
    5. import org.springframework.web.bind.annotation.RestController;
    6. import org.springframework.web.servlet.mvc.method.annotation.SseEmitter;
    7.  
    8. import java.util.Map;
    9.  
    10. @Slf4j
    11. @RestController
    12. public class ServerSentServer {
    13.  
    14.     // 存放所有请求的发送器
    15.     private static final Map<String, SseEmitter> subscribeMap = new ConcurrentReferenceHashMap<>();
    16.  
    17.     /**
    18.      * 请求连接
    19.      *
    20.      * @param id
    21.      * @return
    22.      */
    23.     @GetMapping(value = "/subscribe", produces = MediaType.TEXT_EVENT_STREAM_VALUE)
    24.     public SseEmitter subscribe(String id) {
    25.         // 超时时间设置为300秒
    26.         SseEmitter sseEmitter = new SseEmitter(300 * 1000L);
    27.         sseEmitter.onTimeout(() -> log.info("连接已超时..."));
    28.         sseEmitter.onCompletion(() -> log.info("连接已结束..."));
    29.         subscribeMap.put(id, sseEmitter);
    30.         return sseEmitter;
    31.     }
    32.  
    33.     /**
    34.      * 模拟服务端发送消息
    35.      *
    36.      * @param id
    37.      * @param message
    38.      */
    39.     @GetMapping("/send")
    40.     public String send(String id, String message) {
    41.         try {
    42.             subscribeMap.get(id).send(message);
    43.         } catch (Exception e) {
    44.             e.printStackTrace();
    45.         }
    46.         return "id: " + id + "message: " + message + " is ok";
    47.     }
    48.  
    49. }
    50. 复制代码

    启动项目，我们准备两个浏览器，其中一个请求：

    1. http://localhost:8080/subscribe?id=001
    2. 复制代码

    打开另一个浏览器，连续输入信息：

    1. http://localhost:8080/send?id=001&message=Hello
    2. http://localhost:8080/send?id=001&message=This is Jackey
    3. http://localhost:8080/send?id=001&message=Thank you
    4. 复制代码

    等到连接超时，我们将会看到日志：

  • 相关阅读:
    mysql 随笔
    阿里最新产，SpringCloud 微服务核心技术全解手册 Github 星标 50k
    从 Pulsar Client 的原理到它的监控面板
    Java基础面试题
    Java 修饰符 private、default、protected、public 的应用实例 (方法)
    03 卷积操作图片
    Javascript知识【JS方法和事件&正则&JS注册案例】
    论道金陵 | 原生数字浪潮来袭，如何乘势而上？
    分布式数据库（笔记）
    Redis学习笔记9
  • 原文地址：https://blog.csdn.net/m0_71777195/article/details/126437962