传统@ServerEndpoint方式开发WebSocket应用和SpringBoot构建WebSocket应用程序

vlambda
2021-02-10

传统@ServerEndpoint方式开发WebSocket应用和SpringBoot构建WebSocket应用程序

小Hub领读：

通过websocket的两种使用方式，让你更加深入理解用法。很多人不懂websocket怎么辨别是谁发送过来的，文中说到实现WebSocketConfigurer接口，定义拦截器可以绑定用户信息，还有其他很多，细细品，对比看比较好！

对了，看完记得点个[ 在看 ]支持一下哈。

https://www.skypyb.com/2019/02/jishu/java/813/

WebSocket 一次握手就可以使客户端和服务端建立长连接，并进行双向数据传输。

由于其双向传输特性，服务端可主动向客户端发送信息，实时性很高。

而与 HTTP 协议比起来 WebSocket 协议每次数据传输的头信息都较小，节约带宽。

在获取实时数据这方面时，那是比 ajax 轮询方式高到不知道哪去了。

在 SpringBoot 架构下进行 WebSocket 服务开发的话, 首先还是要导入这个

就算是使用 Tomcat 7 的 @ServerEndpoint 进行 WebSocket 开发, 也得导。不然在 SpringBoot 环境下会有 bug。

普通 java web 应用开发 WebSocket 就不需要了,@ServerEndpoint 直接用就行。

 
   
   
 
  
    
    
  compile('org.springframework.boot:spring-boot-starter-websocket:2.0.4.RELEASE')

maven 仓库: spring-boot-starter-websocket

这是使用 @ServerEndpoint 进行的传统 WebSocket 开发:

由于我是在 SpringBoot 环境, 所以得先写个能扫描 @ServerEndpoint 的配置, 不然在客户端连接的时候会一直连不上。不是在 SpringBoot 下开发的可以跳过这一环节。

ServerEndpointExporter 这个类偏偏还是 spring-boot-starter-websocket 提供的。所以必须要导入这个依赖。

 
   
   
 
  
    
    
  package com.skypyb.websocket;
  
    
    
  

  
    
    
  import org.springframework.context.annotation.Bean;
  
    
    
  import org.springframework.context.annotation.Configuration;
  
    
    
  import org.springframework.web.socket.server.standard.ServerEndpointExporter;
  
    
    
  

  
    
    
  @Configuration
  
    
    
  public class WebSocketConfigOne {
  
    
    
  

  
    
    
   /**
  
    
    
   * 这个bean会自动注册使用了@ServerEndpoint注解声明的对象
  
    
    
   * 没有的话会报404
  
    
    
   *
  
    
    
   * @return
  
    
    
   */
  
    
    
   @Bean
  
    
    
   public ServerEndpointExporter serverEndpointExporter() {
  
    
    
  

  
    
    
   return new ServerEndpointExporter();
  
    
    
   }
  
    
    
  }

在类层次上, 还得加上 @Component 注解才行。普通 java web 项目不用加。

这个方式开发的 WebSocket 服务器，每个连接加入都会为该连接新建一个服务器对象绑定。

 
   
   
 
  
    
    
  package com.skypyb.websocket;
  
    
    
  

  
    
    
  import org.springframework.stereotype.Component;
  
    
    
  

  
    
    
  import javax.websocket.*;
  
    
    
  import javax.websocket.server.ServerEndpoint;
  
    
    
  import java.io.IOException;
  
    
    
  import java.util.concurrent.CopyOnWriteArraySet;
  
    
    
  

  
    
    
  /**
  
    
    
   * @ServerEndpoint 该注解可以将类定义成一个WebSocket服务器端，
  
    
    
   * @OnOpen 表示有浏览器链接过来的时候被调用
  
    
    
   * @OnClose 表示浏览器发出关闭请求的时候被调用
  
    
    
   * @OnMessage 表示浏览器发消息的时候被调用
  
    
    
   * @OnError 表示报错了
  
    
    
   */
  
    
    
  @ServerEndpoint("/ws/serverOne")
  
    
    
  @Component
  
    
    
  public class WebSocketServerOne {
  
    
    
  

  
    
    
   //concurrent包下线程安全的Set
  
    
    
   private static final CopyOnWriteArraySet<WebSocketServerOne> SESSIONS = new CopyOnWriteArraySet<>();
  
    
    
  

  
    
    
   private Session session;
  
    
    
  

  
    
    
   @OnOpen
  
    
    
   public void onOpen(Session session) {
  
    
    
   this.session = session;
  
    
    
   SESSIONS.add(this);
  
    
    
   System.out.println(String.format("成功建立连接~ 当前总连接数为:%s", SESSIONS.size()));
  
    
    
   System.out.println(this);
  
    
    
   }
  
    
    
  

  
    
    
   @OnClose
  
    
    
   public void onClose() {
  
    
    
   SESSIONS.remove(this);
  
    
    
   System.out.println(String.format("成功关闭连接~ 当前总连接数为:%s", SESSIONS.size()));
  
    
    
   }
  
    
    
  

  
    
    
   @OnMessage
  
    
    
   public void onMessage(String message, Session session) {
  
    
    
   System.out.println(message);
  
    
    
   }
  
    
    
  

  
    
    
   @OnError
  
    
    
   public void onError(Session session, Throwable error) {
  
    
    
   System.out.println("发生错误");
  
    
    
   error.printStackTrace();
  
    
    
   }
  
    
    
  

  
    
    
   /**
  
    
    
   * 指定发消息
  
    
    
   *
  
    
    
   * @param message
  
    
    
   */
  
    
    
   public void sendMessage(String message) {
  
    
    
   try {
  
    
    
   this.session.getBasicRemote().sendText(message);
  
    
    
   } catch (IOException e) {
  
    
    
   e.printStackTrace();
  
    
    
   }
  
    
    
   }
  
    
    
  

  
    
    
   /**
  
    
    
   * 群发消息
  
    
    
   *
  
    
    
   * @param message
  
    
    
   */
  
    
    
   public static void fanoutMessage(String message) {
  
    
    
   SESSIONS.forEach(ws -> ws.sendMessage(message));
  
    
    
   }
  
    
    
  

  
    
    
  }

这时，一个传统的 WebSocket 应用就开发完毕了。由于我是在 SpringBoot 下开发的，所以有一些调整。

启动应用后搞个普通的 html 页面直接本地打开就可以试验是否能够连接上了。

 
   
   
 
  
    
    
  <!DOCTYPE html>
  
    
    
  <html lang="en">
  
    
    
  <head>
  
    
    
   <meta charset="UTF-8">
  
    
    
   <title>webSocket</title>
  
    
    
   <style type="text/css">
  
    
    
  

  
    
    
   </style>
  
    
    
  </head>
  
    
    
  <body>
  
    
    
  <h1>WebSocket Demo.</h1>
  
    
    
  <h1>WebSocket Demo..</h1>
  
    
    
  <h1>WebSocket Demo...</h1>
  
    
    
  <input type="button" onclick="websocket.send('666666666')" value="点我发消息"/>
  
    
    
  </body>
  
    
    
  <script type="application/javascript">
  
    
    
  

  
    
    
   var websocket = {
  
    
    
   send: function (str) {
  
    
    
  

  
    
    
   }
  
    
    
   };
  
    
    
  

  
    
    
   window.onload = function () {
  
    
    
   if (!'WebSocket' in window) return;
  
    
    
   webSocketInit();
  
    
    
   };
  
    
    
  

  
    
    
   function webSocketInit() {
  
    
    
   websocket = new WebSocket("ws://127.0.0.1:8080/ws/serverOne");
  
    
    
  

  
    
    
   //成功建立连接
  
    
    
   websocket.onopen = function () {
  
    
    
   websocket.send("成功连接到服务器");
  
    
    
   };
  
    
    
  

  
    
    
   //接收到消息
  
    
    
   websocket.onmessage = function (event) {
  
    
    
   console.log(event.data)
  
    
    
   };
  
    
    
  

  
    
    
   //连接发生错误
  
    
    
   websocket.onerror = function () {
  
    
    
   alert("WebSocket连接发生错误");
  
    
    
   };
  
    
    
  

  
    
    
   //连接关闭
  
    
    
   websocket.onclose = function () {
  
    
    
   alert("WebSocket连接关闭");
  
    
    
   };
  
    
    
  

  
    
    
   //监听窗口关闭事件，当窗口关闭时，主动关闭websocket连接
  
    
    
   window.onbeforeunload = function () {
  
    
    
   websocket.close()
  
    
    
   };
  
    
    
   }
  
    
    
  

  
    
    
  

  
    
    
  </script>
  
    
    
  </html>

不过… 我既然都导入了 spring-boot-starter-websocket 依赖，自然最好还是用 SprinBoot 推荐的方法比较好。

这是使用 SpringBoot 的形式构建 WebSocket 应用程序:

这是核心配置类。实现 WebSocketConfigurer 接口实现它提供的注册方法。

这个方法就厉害了, 可以配置 websocket 入口，允许访问的域、注册 Handler、定义拦截器等等等等。

@EnableWebSocket 用于开启注解接收和发送消息

 
   
   
 
  
    
    
  package com.skypyb.springboot_websocket;
  
    
    
  

  
    
    
  import org.springframework.context.annotation.Configuration;
  
    
    
  import org.springframework.http.server.ServerHttpRequest;
  
    
    
  import org.springframework.http.server.ServerHttpResponse;
  
    
    
  import org.springframework.http.server.ServletServerHttpRequest;
  
    
    
  import org.springframework.web.socket.WebSocketHandler;
  
    
    
  import org.springframework.web.socket.config.annotation.EnableWebSocket;
  
    
    
  import org.springframework.web.socket.config.annotation.WebSocketConfigurer;
  
    
    
  import org.springframework.web.socket.config.annotation.WebSocketHandlerRegistry;
  
    
    
  import org.springframework.web.socket.server.HandshakeInterceptor;
  
    
    
  

  
    
    
  import java.util.Map;
  
    
    
  

  
    
    
  @Configuration
  
    
    
  @EnableWebSocket
  
    
    
  public class WebSocketConfigTwo implements WebSocketConfigurer {
  
    
    
  

  
    
    
  

  
    
    
   @Override
  
    
    
   public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) {
  
    
    
   registry.addHandler(new MyWebSocketHandler(), "/ws/serverTwo")//设置连接路径和处理
  
    
    
   .setAllowedOrigins("*")
  
    
    
   .addInterceptors(new MyWebSocketInterceptor());//设置拦截器
  
    
    
   }
  
    
    
  

  
    
    
   /**
  
    
    
   * 自定义拦截器拦截WebSocket请求
  
    
    
   */
  
    
    
   class MyWebSocketInterceptor implements HandshakeInterceptor {
  
    
    
  

  
    
    
   //前置拦截一般用来注册用户信息，绑定 WebSocketSession
  
    
    
   @Override
  
    
    
   public boolean beforeHandshake(ServerHttpRequest request, ServerHttpResponse response,
  
    
    
   WebSocketHandler wsHandler, Map<String, Object> attributes) throws Exception {
  
    
    
   System.out.println("前置拦截~~");
  
    
    
  

  
    
    
   if (!(request instanceof ServletServerHttpRequest)) return true;
  
    
    
  

  
    
    
  // HttpServletRequest servletRequest = ((ServletServerHttpRequest) request).getServletRequest();
  
    
    
  // String userName = (String) servletRequest.getSession().getAttribute("userName");
  
    
    
   String userName = "Koishipyb";
  
    
    
   attributes.put("userName", userName);
  
    
    
  

  
    
    
   return true;
  
    
    
   }
  
    
    
  

  
    
    
   @Override
  
    
    
   public void afterHandshake(ServerHttpRequest request, ServerHttpResponse response,
  
    
    
   WebSocketHandler wsHandler, Exception exception) {
  
    
    
   System.out.println("后置拦截~~");
  
    
    
   }
  
    
    
   }
  
    
    
  }

关于他这个拦截器, 是非常重要的，最好还是设置一个。他可以在连接进入到 Handler 处理时进行一些操作。

比如从 session 中拿出用户登陆信息作为唯一标识符等等…

我把我的拦截器实现写成内部类了，反正也没多少东西。这个配置注册的处理器和拦截器，都是只有一个的，无论你多少连接进来，都是用相同的对象处理。

那么就不好用传统的 WebSocket 开发那样用个集合类容器来存了。用前置拦截设置进去的某些唯一标识作为 key，session 作为 value 用键值对映射类容器来存储连接是比较好的方案。

推荐阅读：

这是我实现的处理器, 也是 WebSocket 开发的核心:

需要实现 WebSocketHandler 接口, 该接口提供了五个方法。

1、afterConnectionEstablished(): 建立新的 socket 连接后回调的方法。
2、handleMessage(): 接收客户端发送的 Socket。
3、handleTransportError(): 连接出错时，回调的方法。
4、afterConnectionClosed(): 连接关闭时，回调的方法。
5、supportsPartialMessages(): 这个是 WebSocketHandler 是否处理部分消息，没什么卵用返回 false 就完事了。

 
   
   
 
  
    
    
  package com.skypyb.springboot_websocket;
  
    
    
  

  
    
    
  import org.springframework.web.socket.*;
  
    
    
  

  
    
    
  import java.io.IOException;
  
    
    
  import java.util.Map;
  
    
    
  import java.util.concurrent.ConcurrentHashMap;
  
    
    
  

  
    
    
  public class MyWebSocketHandler implements WebSocketHandler {
  
    
    
  

  
    
    
   private static final Map<String, WebSocketSession> SESSIONS = new ConcurrentHashMap<>();
  
    
    
  

  
    
    
   @Override
  
    
    
   public void afterConnectionEstablished(WebSocketSession session) throws Exception {
  
    
    
   String userName = session.getAttributes().get("userName").toString();
  
    
    
   SESSIONS.put(userName, session);
  
    
    
   System.out.println(String.format("成功建立连接~ userName: %s", userName));
  
    
    
   }
  
    
    
  

  
    
    
   @Override
  
    
    
   public void handleMessage(WebSocketSession session, WebSocketMessage<?> message) throws Exception {
  
    
    
   String msg = message.getPayload().toString();
  
    
    
   System.out.println(msg);
  
    
    
   }
  
    
    
  

  
    
    
   @Override
  
    
    
   public void handleTransportError(WebSocketSession session, Throwable exception) throws Exception {
  
    
    
   System.out.println("连接出错");
  
    
    
   if (session.isOpen()) {
  
    
    
   session.close();
  
    
    
   }
  
    
    
   }
  
    
    
  

  
    
    
   @Override
  
    
    
   public void afterConnectionClosed(WebSocketSession session, CloseStatus closeStatus) throws Exception {
  
    
    
   System.out.println("连接已关闭,status:" + closeStatus);
  
    
    
   }
  
    
    
  

  
    
    
   @Override
  
    
    
   public boolean supportsPartialMessages() {
  
    
    
   return false;
  
    
    
   }
  
    
    
  

  
    
    
   /**
  
    
    
   * 指定发消息
  
    
    
   *
  
    
    
   * @param message
  
    
    
   */
  
    
    
   public static void sendMessage(String userName, String message) {
  
    
    
   WebSocketSession webSocketSession = SESSIONS.get(userName);
  
    
    
   if (webSocketSession == null || !webSocketSession.isOpen()) return;
  
    
    
  

  
    
    
   try {
  
    
    
   webSocketSession.sendMessage(new TextMessage(message));
  
    
    
   } catch (IOException e) {
  
    
    
   e.printStackTrace();
  
    
    
   }
  
    
    
   }
  
    
    
  

  
    
    
   /**
  
    
    
   * 群发消息
  
    
    
   *
  
    
    
   * @param message
  
    
    
   */
  
    
    
   public static void fanoutMessage(String message) {
  
    
    
   SESSIONS.keySet().forEach(us -> sendMessage(us, message));
  
    
    
   }
  
    
    
  

  
    
    
  }

（完）

MarkerHub文章索引：（点击阅读原文直达）

https://github.com/MarkerHub/JavaIndex

【推荐阅读】

好文！必须点赞

vlambda博客
学习文章列表