spring boot下WebSocket消息推送

WebSocket协议

WebSocket是一种在单个TCP连接上进行全双工通讯的协议。WebSocket通信协议于2011年被IETF定为标准RFC 6455，并由RFC7936补充规范。WebSocket API也被W3C定为标准。

WebSocket使得客户端和服务器之间的数据交换变得更加简单，允许服务端主动向客户端推送数据。在WebSocket API中，浏览器和服务器只需要完成一次握手，两者之间就直接可以创建持久性的连接，并进行双向数据传输

STOMP协议

STOMP是面向文本的消息传送协议。STOMP客户端与支持STOMP协议的消息代理进行通信。STOMP使用不同的命令，如连接，发送，订阅，断开等进行通信。

具体参考：官方介绍

SockJS

SockJS是一个JavaScript库，提供跨浏览器JavaScript的API，创建了一个低延迟、全双工的浏览器和web服务器之间通信通道

---

以上内容出自维基百科和百度百科

使用websocket有两种方式：1是使用sockjs，2是使用h5的标准。使用Html5标准自然更方便简单，所以记录的是配合h5的使用方法。

1、pom引入

　核心是@ServerEndpoint这个注解。这个注解是Javaee标准里的注解，tomcat7以上已经对其进行了实现，如果是用传统方法使用tomcat发布项目，只要在pom文件中引入javaee标准即可使用。

     <dependency>
       <groupId>javax</groupId>
       <artifactId>javaee-api</artifactId>
       <version>7.0</version>
       <scope>provided</scope>
     </dependency>

但使用springboot的内置tomcat时，就不需要引入javaee-api了，spring-boot已经包含了。使用springboot的websocket功能首先引入springboot组件。

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

2、使用@ServerEndpoint创立websocket endpoint

　　首先要注入ServerEndpointExporter，这个bean会自动注册使用了@ServerEndpoint注解声明的Websocket endpoint。要注意，如果使用独立的servlet容器，而不是直接使用springboot的内置容器，就不要注入ServerEndpointExporter，因为它将由容器自己提供和管理。

     @Configuration
     public class WebSocketConfig {
         @Bean
         public ServerEndpointExporter serverEndpointExporter() {
             return new ServerEndpointExporter();
         }  

     }  

下面事websocket的具体实现方法，代码如下：

 import org.springframework.stereotype.Component;

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

 @ServerEndpoint(value = "/websocket")
 @Component    //此注解千万千万不要忘记，它的主要作用就是将这个监听器纳入到Spring容器中进行管理
 public class WebSocket {
   //静态变量，用来记录当前在线连接数。应该把它设计成线程安全的。
   private static int onlineCount = 0;

   //concurrent包的线程安全Set，用来存放每个客户端对应的MyWebSocket对象。
   private static CopyOnWriteArraySet<WebSocket> webSocketSet = new CopyOnWriteArraySet<WebSocket>();

   //与某个客户端的连接会话，需要通过它来给客户端发送数据
   private Session session;

   /**
    * 连接建立成功调用的方法
    */
   @OnOpen
   public void onOpen(Session session) {
     this.session = session;
     webSocketSet.add(this);     //加入set中
     addOnlineCount();           //在线数加1
     System.out.println("有新连接加入！当前在线人数为" + getOnlineCount());
     try {
       sendMessage("Hello world");
     } catch (IOException e) {
       System.out.println("IO异常");
     }
   }

   /**
    * 连接关闭调用的方法
    */
   @OnClose
   public void onClose() {
     webSocketSet.remove(this);  //从set中删除
     subOnlineCount();           //在线数减1
     System.out.println("有一连接关闭！当前在线人数为" + getOnlineCount());
   }

   /**
    * 收到客户端消息后调用的方法
    *
    * @param message 客户端发送过来的消息
    */
   @OnMessage
   public void onMessage(String message, Session session) {
     System.out.println("来自客户端的消息:" + message);

     //群发消息
     for (WebSocket item : webSocketSet) {
       try {
         item.sendMessage(message);
       } catch (IOException e) {
         e.printStackTrace();
       }
     }
   }

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

   public void sendMessage(String message) throws IOException {
     this.session.getBasicRemote().sendText(message);
     //this.session.getAsyncRemote().sendText(message);
   }

   /**
    * 群发自定义消息
    */
   public static void sendInfo(String message) throws IOException {
     for (WebSocket item : webSocketSet) {
       try {
         item.sendMessage(message);
       } catch (IOException e) {
         continue;
       }
     }
   }

   public static synchronized int getOnlineCount() {
     return onlineCount;
   }

   public static synchronized void addOnlineCount() {
     WebSocket.onlineCount++;
   }

   public static synchronized void subOnlineCount() {
     WebSocket.onlineCount--;
   }
 }

使用springboot的唯一区别是要@Component声明下，而使用独立容器是由容器自己管理websocket的，但在springboot中连容器都是spring管理的。

虽然@Component默认是单例模式的，但springboot还是会为每个websocket连接初始化一个bean，所以可以用一个静态set保存起来。

3、前端代码

 <!DOCTYPE HTML>
 <html>
 <head>
     <title>My WebSocket</title>
 </head>

 <body>
 Welcome<br/>
 <input id="text" type="text" /><button onclick="send()">Send</button>    <button onclick="closeWebSocket()">Close</button>
 <div id="message">
 </div>
 </body>

 <script type="text/javascript">
     var websocket = null;

     //判断当前浏览器是否支持WebSocket
     if('WebSocket' in window){
         websocket = new WebSocket("ws://localhost:8084/websocket");
     }
     else{
         alert('Not support websocket')
     }

     //连接发生错误的回调方法
     websocket.onerror = function(){
         setMessageInnerHTML("error");
     };

     //连接成功建立的回调方法
     websocket.onopen = function(event){
         setMessageInnerHTML("open");
     }

     //接收到消息的回调方法
     websocket.onmessage = function(event){
         setMessageInnerHTML(event.data);
     }

     //连接关闭的回调方法
     websocket.onclose = function(){
         setMessageInnerHTML("close");
     }

     //监听窗口关闭事件，当窗口关闭时，主动去关闭websocket连接，防止连接还没断开就关闭窗口，server端会抛异常。
     window.onbeforeunload = function(){
         websocket.close();
     }

     //将消息显示在网页上
     function setMessageInnerHTML(innerHTML){
         document.getElementById('message').innerHTML += innerHTML + '<br/>';
     }

     //关闭连接
     function closeWebSocket(){
         websocket.close();
     }

     //发送消息
     function send(){
         var message = document.getElementById('text').value;
         websocket.send(message);
     }
 </script>
 </html>

以上代码，实现了websocket简单消息推送，可以实现两个页面间的消息显示，但是Java后台主动推送消息时，无法获取消息推送的websocket下的session，即无法实现websocket下session的共享。

为解决主动推送的难题，需要在建立连接时，将websocket下的session与servlet下的HttpSession（或者其他session，我们这用到了shiro下的session）建立关联关系。

webSocket配置Java类：

 import com.bootdo.common.utils.ShiroUtils;
 import org.apache.catalina.session.StandardSessionFacade;
 import org.apache.shiro.session.Session;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.web.socket.server.standard.ServerEndpointExporter;

 import javax.servlet.http.HttpSession;
 import javax.websocket.HandshakeResponse;
 import javax.websocket.server.HandshakeRequest;
 import javax.websocket.server.ServerEndpointConfig;
 import javax.websocket.server.ServerEndpointConfig.Configurator;

 @Configuration
 public class WebSocketConfig extends Configurator {

   @Override
   public void modifyHandshake(ServerEndpointConfig sec, HandshakeRequest request, HandshakeResponse response) {
     /*如果没有监听器,那么这里获取到的HttpSession是null*/
     StandardSessionFacade ssf = (StandardSessionFacade) request.getHttpSession();
     if (ssf != null) {
       HttpSession httpSession = (HttpSession) request.getHttpSession();
       //关键操作
       sec.getUserProperties().put("sessionId", httpSession.getId());
       System.out.println("获取到的SessionID：" + httpSession.getId());
     }
   }

   /**
    * 引入shiro框架下的session，获取session信息
    */
   /*
   @Override
   public void modifyHandshake(ServerEndpointConfig sec, HandshakeRequest request, HandshakeResponse response) {
     Session shiroSession = ShiroUtils.getSubjct().getSession();
     sec.getUserProperties().put("sessionId", shiroSession.getId());
   }
   */

   @Bean
   public ServerEndpointExporter serverEndpointExporter() {
     //这个对象说一下，貌似只有服务器是tomcat的时候才需要配置,具体我没有研究
     return new ServerEndpointExporter();
   }
 }

webSocket消息实现类方法：

 import org.springframework.stereotype.Component;

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

 //configurator = WebsocketConfig.class 该属性就是我上面配置的信息
 @ServerEndpoint(value = "/websocket", configurator = WebSocketConfig.class)
 @Component    //此注解千万千万不要忘记，它的主要作用就是将这个监听器纳入到Spring容器中进行管理
 public class WebSocket {
   //静态变量，用来记录当前在线连接数。应该把它设计成线程安全的。
   private static int onlineCount = 0;

   //concurrent包的线程安全Set，用来存放每个客户端对应的MyWebSocket对象。
   private static CopyOnWriteArraySet<WebSocket> webSocketSet = new CopyOnWriteArraySet<WebSocket>();

   //与某个客户端的连接会话，需要通过它来给客户端发送数据
   private Session session;

   /**
    * 连接建立成功调用的方法
    * <p>
    * config用来获取WebsocketConfig中的配置信息
    */
   @OnOpen
   public void onOpen(Session session, EndpointConfig config) {

     //获取WebsocketConfig.java中配置的“sessionId”信息值
     String httpSessionId = (String) config.getUserProperties().get("sessionId");

     this.session = session;
     webSocketSet.add(this);     //加入set中
     addOnlineCount();           //在线数加1
     System.out.println("有新连接加入！当前在线人数为" + getOnlineCount());
     try {
       sendMessage("Hello world");
     } catch (IOException e) {
       System.out.println("IO异常");
     }
   }

   /**
    * 连接关闭调用的方法
    */
   @OnClose
   public void onClose() {
     webSocketSet.remove(this);  //从set中删除
     subOnlineCount();           //在线数减1
     System.out.println("有一连接关闭！当前在线人数为" + getOnlineCount());
   }

   /**
    * 收到客户端消息后调用的方法
    *
    * @param message 客户端发送过来的消息
    */
   @OnMessage
   public void onMessage(String message, Session session) {
     System.out.println("来自客户端的消息:" + message);

     //群发消息
     for (WebSocket item : webSocketSet) {
       try {
         item.sendMessage(message);
       } catch (IOException e) {
         e.printStackTrace();
       }
     }
   }

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

   public void sendMessage(String message) throws IOException {
     this.session.getBasicRemote().sendText(message);
     //this.session.getAsyncRemote().sendText(message);
   }

   /**
    * 群发自定义消息
    */
   public static void sendInfo(String message) throws IOException {
     for (WebSocket item : webSocketSet) {
       try {
         item.sendMessage(message);
       } catch (IOException e) {
         continue;
       }
     }
   }

   public static synchronized int getOnlineCount() {
     return onlineCount;
   }

   public static synchronized void addOnlineCount() {
     WebSocket.onlineCount++;
   }

   public static synchronized void subOnlineCount() {
     WebSocket.onlineCount--;
   }
 }

注意，有上面配置后，如果配置获取的信息为null，需加入监听实现类：

 import org.springframework.stereotype.Component;

 import javax.servlet.ServletRequestEvent;
 import javax.servlet.ServletRequestListener;
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpSession;

 /**
  * 监听器类:主要任务是用ServletRequest将我们的HttpSession携带过去
  */
 @Component //此注解千万千万不要忘记，它的主要作用就是将这个监听器纳入到Spring容器中进行管理,相当于注册监听吧
 public class RequestListener implements ServletRequestListener {
   @Override
   public void requestInitialized(ServletRequestEvent sre) {
     //将所有request请求都携带上httpSession
     HttpSession httpSession= ((HttpServletRequest) sre.getServletRequest()).getSession();
     System.out.println("将所有request请求都携带上httpSession " + httpSession.getId());
   }

   public RequestListener() {
   }

   @Override
   public void requestDestroyed(ServletRequestEvent arg0) {
   }
 }

对应的前端页面无需改变。

以上信息类之于网络上多篇文章整理的信息，参考文章：spring boot Websocket；使用spring boot +WebSocket实现（后台主动）消息推送  ； Springboot-WebSocket初探-获取HttpSession问题