Java Websocket 01: 原生模式 Websocket 基础通信

目录

• Java Websocket 01: 原生模式 Websocket 基础通信
  
• Java Websocket 02: 原生模式通过 Websocket 传输文件
  

Websocket 原生模式

原生模式下

• 服务端通过 @ServerEndpoint 实现其对应的 @OnOpen, @OnClose, @OnMessage, @OnError 方法
  
• 客户端创建 WebSocketClient 实现对应的 onOpen(), onClose(), onMessage(), onError()
  

演示项目

完整示例代码 https://github.com/MiltonLai/websocket-demos/tree/main/ws-demo01
目录结构

1. │   pom.xml
2. └───src
3.     ├───main
4.     │   ├───java
5.     │   │   └───com
6.     │   │       └───rockbb
7.     │   │           └───test
8.     │   │               └───wsdemo
9.     │   │                       SocketServer.java
10.     │   │                       WebSocketConfig.java
11.     │   │                       WsDemo01App.java
12.     │   └───resources
13.     │           application.yml
14.     └───test
15.         └───java
16.             └───com
17.                 └───rockbb
18.                     └───test
19.                         └───wsdemo
20.                                 SocketClient.java

复制代码

pom.xml

• 可以用 JDK11, 也可以用 JDK17
  
• 通过 Spring Boot plugin repackage, 生成 fat jar
  
• 用 Java-WebSocket 作为 client 的 websocket 实现库, 当前最新版本为 1.5.3
  

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.     <modelVersion>4.0.0</modelVersion>
7.     <groupId>com.rockbb.test</groupId>
8.     <artifactId>ws-demo01</artifactId>
9.     <packaging>jar</packaging>
10.     <version>1.0-SNAPSHOT</version>
12.     <name>WS: Demo 01</name>
14.     <properties>
15.         
16.         <project.jdk.version>17</project.jdk.version>
17.         <project.source.encoding>UTF-8</project.source.encoding>
18.         
19.         <spring-boot.version>2.7.11</spring-boot.version>
20.     </properties>
22.     <dependencyManagement>
23.         <dependencies>
24.             
25.             <dependency>
26.                 <groupId>org.springframework.boot</groupId>
27.                 <artifactId>spring-boot-dependencies</artifactId>
28.                 <version>${spring-boot.version}</version>
29.                 <type>pom</type>
30.                 <scope>import</scope>
31.             </dependency>
32.         </dependencies>
33.     </dependencyManagement>
35.     <dependencies>
36.         <dependency>
37.             <groupId>org.springframework.boot</groupId>
38.             <artifactId>spring-boot-starter-web</artifactId>
39.         </dependency>
40.         <dependency>
41.             <groupId>org.springframework.boot</groupId>
42.             <artifactId>spring-boot-starter-test</artifactId>
43.             <scope>test</scope>
44.         </dependency>
45.         <dependency>
46.             <groupId>org.springframework</groupId>
47.             <artifactId>spring-websocket</artifactId>
48.         </dependency>
49.         <dependency>
50.             <groupId>org.springframework</groupId>
51.             <artifactId>spring-messaging</artifactId>
52.         </dependency>
54.         <dependency>
55.             <groupId>org.java-websocket</groupId>
56.             <artifactId>Java-WebSocket</artifactId>
57.             <version>1.5.3</version>
58.         </dependency>
60.     </dependencies>
62.     <build>
63.         <finalName>ws-demo01</finalName>
64.         <plugins>
65.             <plugin>
66.                 <groupId>org.apache.maven.plugins</groupId>
67.                 <artifactId>maven-compiler-plugin</artifactId>
68.                 <version>3.10.1</version>
69.                 <configuration>
70.                     <source>${project.jdk.version}</source>
71.                     <target>${project.jdk.version}</target>
72.                     <encoding>${project.source.encoding}</encoding>
73.                 </configuration>
74.             </plugin>
75.             <plugin>
76.                 <groupId>org.apache.maven.plugins</groupId>
77.                 <artifactId>maven-resources-plugin</artifactId>
78.                 <version>3.3.0</version>
79.                 <configuration>
80.                     <encoding>${project.source.encoding}</encoding>
81.                 </configuration>
82.             </plugin>
83.             <plugin>
84.                 <groupId>org.springframework.boot</groupId>
85.                 <artifactId>spring-boot-maven-plugin</artifactId>
86.                 <version>${spring-boot.version}</version>
87.                 <executions>
88.                     <execution>
89.                         <goals>
90.                             <goal>repackage</goal>
91.                         </goals>
92.                     </execution>
93.                 </executions>
94.             </plugin>
95.         </plugins>
96.     </build>
97. </project>

复制代码

application.yml

设置服务端口为 8763

1. server:
2.   port: 8763
3.   tomcat:
4.     uri-encoding: UTF-8
6. spring:
7.   application:
8.     name: ws-demo01

复制代码

WsDemo01App.java

• 将 @RestController 也合并到应用入口了. 和单独拆开做一个 Controller 类是一样的
  
• '/msg' 路径用于从 server 往 client 发送消息
  

1. @RestController
2. @SpringBootApplication
3. public class WsDemo01App {
5.     public static void main(String[] args) {
6.         SpringApplication.run(WsDemo01App.class, args);
7.     }
9.     @RequestMapping("/msg")
10.     public String sendMsg(String sessionId, String msg) throws IOException {
11.         Session session = SocketServer.getSession(sessionId);
12.         SocketServer.sendMessage(session, msg);
13.         return "send " + sessionId + " : " + msg;
14.     }
15. }

复制代码

WebSocketConfig.java

必须显式声明 ServerEndpointExporter 这个 Bean 才能提供 websocket 服务

1. @Configuration
2. public class WebSocketConfig {
4.     @Bean
5.     public ServerEndpointExporter initServerEndpointExporter(){
6.         return new ServerEndpointExporter();
7.     }
8. }

复制代码

SocketServer.java

提供 websocket 服务的关键类. @ServerEndpoint 的作用类似于 RestController, 这里指定 client 访问的路径格式为 ws://host:port/websocket/server/[id],
当 client 访问使用不同的 id 时, 会对应产生不同的 SocketServer 实例

1. @Component
2. @ServerEndpoint("/websocket/server/{sessionId}")
3. public class SocketServer {
4.     private static final org.slf4j.Logger log = LoggerFactory.getLogger(SocketServer.class);
5.     private static final Map<String, Session> sessionMap = new ConcurrentHashMap<>();
7.     private String sessionId = "";
9.     @OnOpen
10.     public void onOpen(Session session, @PathParam("sessionId") String sessionId) {
11.         this.sessionId = sessionId;
12.         /* Old connection will be kicked by new connection */
13.         sessionMap.put(sessionId, session);
14.         /*
15.          * this: instance id. New instances will be created for each sessionId
16.          * sessionId: assigned from path variable
17.          * session.getId(): the actual session id (start from 0)
18.          */
19.         log.info("On open: this{} sessionId {}, actual {}", this, sessionId, session.getId());
20.     }
22.     @OnClose
23.     public void onClose() {
24.         sessionMap.remove(sessionId);
25.         log.info("On close: sessionId {}", sessionId);
26.     }
28.     @OnMessage
29.     public void onMessage(String message, Session session) {
30.         log.info("On message: sessionId {}, {}", session.getId(), message);
31.     }
33.     @OnError
34.     public void onError(Session session, Throwable error) {
35.         log.error("On error: sessionId {}, {}", session.getId(), error.getMessage());
36.     }
38.     public static void sendMessage(Session session, String message) throws IOException {
39.         session.getBasicRemote().sendText(message);
40.     }
42.     public static Session getSession(String sessionId){
43.         return sessionMap.get(sessionId);
44.     }
45. }

复制代码

关于会话对象 Session

OnOpen 会注入一个 Session 参数, 这个是实际的 Websocket Session, 其 ID 是全局唯一的, 可以唯一确定一个客户端连接. 在当前版本的实现中, 这是一个从0开始自增的整数. 如果你需要实现例如单个用户登录多个会话, 在通信中, 将消息转发给同一个用户的多个会话, 就要小心记录这些 Session 的 ID.

1. @OnOpen
2. public void onOpen(Session session, @PathParam("sessionId") String sessionId)

复制代码

关于会话意外关闭

在客户端意外停止后, 服务端会收到 OnError 消息, 可以通过这个消息管理已经关闭的会话
SocketClient.java

client 测试类, 连接后可以通过命令行向 server 发送消息

1. public class SocketClient {
3.     private static final org.slf4j.Logger log = LoggerFactory.getLogger(SocketClient.class);
5.     public static void main(String[] args) throws URISyntaxException {
7.         WebSocketClient wsClient = new WebSocketClient(
8.                 new URI("ws://127.0.0.1:8763/websocket/server/10001")) {
10.             @Override
11.             public void onOpen(ServerHandshake serverHandshake) {
12.                 log.info("On open: {}, {}", serverHandshake.getHttpStatus(), serverHandshake.getHttpStatusMessage());
13.             }
15.             @Override
16.             public void onMessage(String s) {
17.                 log.info("On message: {}", s);
18.             }
20.             @Override
21.             public void onClose(int i, String s, boolean b) {
22.                 log.info("On close: {}, {}, {}", i, s, b);
23.             }
25.             @Override
26.             public void onError(Exception e) {
27.                 log.info("On error: {}", e.getMessage());
28.             }
29.         };
31.         wsClient.connect();
32.         log.info("Connecting...");
33.         while (!ReadyState.OPEN.equals(wsClient.getReadyState())) {
34.             try {
35.                 Thread.sleep(100);
36.             } catch (InterruptedException e) {
37.                 log.error(e.getMessage(), e);
38.             }
39.         }
40.         log.info("Connected");
42.         wsClient.send("hello");
44.         Scanner scanner = new Scanner(System.in);
45.         while (scanner.hasNext()) {
46.             String line = scanner.next();
47.             wsClient.send(line);
48.         }
49.         wsClient.close();
50.     }
51. }

复制代码

代码的执行过程就是新建一个 WebSocketClient 并实现其处理消息的接口方法, 使用 10001 作为 sessionId 进行连接, 在连接成功后, 不断读取键盘输入 (System.in), 将输入的字符串发送给服务端.
运行示例

示例是一个普通的 Spring Boot jar项目, 可以通过mvn clean package进行编译, 再通过java -jar ws-demo01.jar运行, 启动后工作在8763端口
然后运行 SocketClient.java, 可以观察到服务端接收到的消息.
服务端可以通过浏览器访问 http://127.0.0.1:8763/msg?sessionId=10001&msg=123 向客户端发送消息.
结论

以上说明并演示了原生的 Websocket 实现方式, 可以尝试运行多个 SocketClient, 使用相同或不同的 server sessionId 路径, 观察通信的变化情况.

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！