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标准即可使用。
1 <dependency> 2 <groupId>javax</groupId> 3 <artifactId>javaee-api</artifactId> 4 <version>7.0</version> 5 <scope>provided</scope> 6 </dependency>
但使用springboot的内置tomcat时，就不需要引入javaee-api了，spring-boot已经包含了。使用springboot的websocket功能首先引入springboot组件。
1 <dependency> 2 <groupId>org.springframework.boot</groupId> 3 <artifactId>spring-boot-starter-websocket</artifactId> 4 </dependency>
2、使用@ServerEndpoint创立websocket endpoint
首先要注入ServerEndpointExporter，这个bean会自动注册使用了@ServerEndpoint注解声明的Websocket endpoint。要注意，如果使用独立的servlet容器，而不是直接使用springboot的内置容器，就不要注入ServerEndpointExporter，因为它将由容器自己提供和管理。
1 @Configuration
2 public class WebSocketConfig {
3 @Bean
4 public ServerEndpointExporter serverEndpointExporter() {
5 return new ServerEndpointExporter();
6 }
7
8 }
下面事websocket的具体实现方法，代码如下：
1 import org.springframework.stereotype.Component;
2
3 import javax.websocket.*;
4 import javax.websocket.server.ServerEndpoint;
5 import java.io.IOException;
6 import java.util.concurrent.CopyOnWriteArraySet;
7
8 @ServerEndpoint(value = "/websocket")
9 @Component //此注解千万千万不要忘记，它的主要作用就是将这个监听器纳入到Spring容器中进行管理
10 public class WebSocket {
11 //静态变量，用来记录当前在线连接数。应该把它设计成线程安全的。
12 private static int onlineCount = 0;
13
14 //concurrent包的线程安全Set，用来存放每个客户端对应的MyWebSocket对象。
15 private static CopyOnWriteArraySet<WebSocket> webSocketSet = new CopyOnWriteArraySet<WebSocket>();
16
17 //与某个客户端的连接会话，需要通过它来给客户端发送数据
18 private Session session;
19
20 /**
21 * 连接建立成功调用的方法
22 */
23 @OnOpen
24 public void onOpen(Session session) {
25 this.session = session;
26 webSocketSet.add(this); //加入set中
27 addOnlineCount(); //在线数加1
28 System.out.println("有新连接加入！当前在线人数为" + getOnlineCount());
29 try {
30 sendMessage("Hello world");
31 } catch (IOException e) {
32 System.out.println("IO异常");
33 }
34 }
35
36 /**
37 * 连接关闭调用的方法
38 */
39 @OnClose
40 public void onClose() {
41 webSocketSet.remove(this); //从set中删除
42 subOnlineCount(); //在线数减1
43 System.out.println("有一连接关闭！当前在线人数为" + getOnlineCount());
44 }
45
46 /**
47 * 收到客户端消息后调用的方法
48 *
49 * @param message 客户端发送过来的消息
50 */
51 @OnMessage
52 public void onMessage(String message, Session session) {
53 System.out.println("来自客户端的消息:" + message);
54
55 //群发消息
56 for (WebSocket item : webSocketSet) {
57 try {
58 item.sendMessage(message);
59 } catch (IOException e) {
60 e.printStackTrace();
61 }
62 }
63 }
64
65 /**
66 * 发生错误时调用
67 */
68 @OnError
69 public void onError(Session session, Throwable error) {
70 System.out.println("发生错误");
71 error.printStackTrace();
72 }
73
74
75 public void sendMessage(String message) throws IOException {
76 this.session.getBasicRemote().sendText(message);
77 //this.session.getAsyncRemote().sendText(message);
78 }
79
80
81 /**
82 * 群发自定义消息
83 */
84 public static void sendInfo(String message) throws IOException {
85 for (WebSocket item : webSocketSet) {
86 try {
87 item.sendMessage(message);
88 } catch (IOException e) {
89 continue;
90 }
91 }
92 }
93
94 public static synchronized int getOnlineCount() {
95 return onlineCount;
96 }
97
98 public static synchronized void addOnlineCount() {
99 WebSocket.onlineCount++;
100 }
101
102 public static synchronized void subOnlineCount() {
103 WebSocket.onlineCount--;
104 }
105 }
使用springboot的唯一区别是要@Component声明下，而使用独立容器是由容器自己管理websocket的，但在springboot中连容器都是spring管理的。
虽然@Component默认是单例模式的，但springboot还是会为每个websocket连接初始化一个bean，所以可以用一个静态set保存起来。
3、前端代码
1 <!DOCTYPE HTML>
2 <html>
3 <head>
4 <title>My WebSocket</title>
5 </head>
6
7 <body>
8 Welcome<br/>
9 <input id="text" type="text" /><button onclick="send()">Send</button> <button onclick="closeWebSocket()">Close</button>
10 <div id="message">
11 </div>
12 </body>
13
14 <script type="text/javascript">
15 var websocket = null;
16
17 //判断当前浏览器是否支持WebSocket
18 if('WebSocket' in window){
19 websocket = new WebSocket("ws://localhost:8084/websocket");
20 }
21 else{
22 alert('Not support websocket')
23 }
24
25 //连接发生错误的回调方法
26 websocket.onerror = function(){
27 setMessageInnerHTML("error");
28 };
29
30 //连接成功建立的回调方法
31 websocket.onopen = function(event){
32 setMessageInnerHTML("open");
33 }
34
35 //接收到消息的回调方法
36 websocket.onmessage = function(event){
37 setMessageInnerHTML(event.data);
38 }
39
40 //连接关闭的回调方法
41 websocket.onclose = function(){
42 setMessageInnerHTML("close");
43 }
44
45 //监听窗口关闭事件，当窗口关闭时，主动去关闭websocket连接，防止连接还没断开就关闭窗口，server端会抛异常。
46 window.onbeforeunload = function(){
47 websocket.close();
48 }
49
50 //将消息显示在网页上
51 function setMessageInnerHTML(innerHTML){
52 document.getElementById('message').innerHTML += innerHTML + '<br/>';
53 }
54
55 //关闭连接
56 function closeWebSocket(){
57 websocket.close();
58 }
59
60 //发送消息
61 function send(){
62 var message = document.getElementById('text').value;
63 websocket.send(message);
64 }
65 </script>
66 </html>
以上代码，实现了websocket简单消息推送，可以实现两个页面间的消息显示，但是Java后台主动推送消息时，无法获取消息推送的websocket下的session，即无法实现websocket下session的共享。
为解决主动推送的难题，需要在建立连接时，将websocket下的session与servlet下的HttpSession（或者其他session，我们这用到了shiro下的session）建立关联关系。
webSocket配置Java类：
1 import com.bootdo.common.utils.ShiroUtils;
2 import org.apache.catalina.session.StandardSessionFacade;
3 import org.apache.shiro.session.Session;
4 import org.springframework.context.annotation.Bean;
5 import org.springframework.context.annotation.Configuration;
6 import org.springframework.web.socket.server.standard.ServerEndpointExporter;
7
8 import javax.servlet.http.HttpSession;
9 import javax.websocket.HandshakeResponse;
10 import javax.websocket.server.HandshakeRequest;
11 import javax.websocket.server.ServerEndpointConfig;
12 import javax.websocket.server.ServerEndpointConfig.Configurator;
13
14 @Configuration
15 public class WebSocketConfig extends Configurator {
16
17 @Override
18 public void modifyHandshake(ServerEndpointConfig sec, HandshakeRequest request, HandshakeResponse response) {
19 /*如果没有监听器,那么这里获取到的HttpSession是null*/
20 StandardSessionFacade ssf = (StandardSessionFacade) request.getHttpSession();
21 if (ssf != null) {
22 HttpSession httpSession = (HttpSession) request.getHttpSession();
23 //关键操作
24 sec.getUserProperties().put("sessionId", httpSession.getId());
25 System.out.println("获取到的SessionID：" + httpSession.getId());
26 }
27 }
28
29 /**
30 * 引入shiro框架下的session，获取session信息
31 */
32 /*
33 @Override
34 public void modifyHandshake(ServerEndpointConfig sec, HandshakeRequest request, HandshakeResponse response) {
35 Session shiroSession = ShiroUtils.getSubjct().getSession();
36 sec.getUserProperties().put("sessionId", shiroSession.getId());
37 }
38 */
39
40 @Bean
41 public ServerEndpointExporter serverEndpointExporter() {
42 //这个对象说一下，貌似只有服务器是tomcat的时候才需要配置,具体我没有研究
43 return new ServerEndpointExporter();
44 }
45 }
webSocket消息实现类方法：
1 import org.springframework.stereotype.Component;
2
3 import javax.websocket.*;
4 import javax.websocket.server.ServerEndpoint;
5 import java.io.IOException;
6 import java.util.concurrent.CopyOnWriteArraySet;
7
8 //configurator = WebsocketConfig.class 该属性就是我上面配置的信息
9 @ServerEndpoint(value = "/websocket", configurator = WebSocketConfig.class)
10 @Component //此注解千万千万不要忘记，它的主要作用就是将这个监听器纳入到Spring容器中进行管理
11 public class WebSocket {
12 //静态变量，用来记录当前在线连接数。应该把它设计成线程安全的。
13 private static int onlineCount = 0;
14
15 //concurrent包的线程安全Set，用来存放每个客户端对应的MyWebSocket对象。
16 private static CopyOnWriteArraySet<WebSocket> webSocketSet = new CopyOnWriteArraySet<WebSocket>();
17
18 //与某个客户端的连接会话，需要通过它来给客户端发送数据
19 private Session session;
20
21 /**
22 * 连接建立成功调用的方法
23 * <p>
24 * config用来获取WebsocketConfig中的配置信息
25 */
26 @OnOpen
27 public void onOpen(Session session, EndpointConfig config) {
28
29 //获取WebsocketConfig.java中配置的“sessionId”信息值
30 String httpSessionId = (String) config.getUserProperties().get("sessionId");
31
32 this.session = session;
33 webSocketSet.add(this); //加入set中
34 addOnlineCount(); //在线数加1
35 System.out.println("有新连接加入！当前在线人数为" + getOnlineCount());
36 try {
37 sendMessage("Hello world");
38 } catch (IOException e) {
39 System.out.println("IO异常");
40 }
41 }
42
43 /**
44 * 连接关闭调用的方法
45 */
46 @OnClose
47 public void onClose() {
48 webSocketSet.remove(this); //从set中删除
49 subOnlineCount(); //在线数减1
50 System.out.println("有一连接关闭！当前在线人数为" + getOnlineCount());
51 }
52
53 /**
54 * 收到客户端消息后调用的方法
55 *
56 * @param message 客户端发送过来的消息
57 */
58 @OnMessage
59 public void onMessage(String message, Session session) {
60 System.out.println("来自客户端的消息:" + message);
61
62 //群发消息
63 for (WebSocket item : webSocketSet) {
64 try {
65 item.sendMessage(message);
66 } catch (IOException e) {
67 e.printStackTrace();
68 }
69 }
70 }
71
72 /**
73 * 发生错误时调用
74 */
75 @OnError
76 public void onError(Session session, Throwable error) {
77 System.out.println("发生错误");
78 error.printStackTrace();
79 }
80
81
82 public void sendMessage(String message) throws IOException {
83 this.session.getBasicRemote().sendText(message);
84 //this.session.getAsyncRemote().sendText(message);
85 }
86
87
88 /**
89 * 群发自定义消息
90 */
91 public static void sendInfo(String message) throws IOException {
92 for (WebSocket item : webSocketSet) {
93 try {
94 item.sendMessage(message);
95 } catch (IOException e) {
96 continue;
97 }
98 }
99 }
100
101 public static synchronized int getOnlineCount() {
102 return onlineCount;
103 }
104
105 public static synchronized void addOnlineCount() {
106 WebSocket.onlineCount++;
107 }
108
109 public static synchronized void subOnlineCount() {
110 WebSocket.onlineCount--;
111 }
112 }
注意，有上面配置后，如果配置获取的信息为null，需加入监听实现类：
1 import org.springframework.stereotype.Component;
2
3 import javax.servlet.ServletRequestEvent;
4 import javax.servlet.ServletRequestListener;
5 import javax.servlet.http.HttpServletRequest;
6 import javax.servlet.http.HttpSession;
7
8 /**
9 * 监听器类:主要任务是用ServletRequest将我们的HttpSession携带过去
10 */
11 @Component //此注解千万千万不要忘记，它的主要作用就是将这个监听器纳入到Spring容器中进行管理,相当于注册监听吧
12 public class RequestListener implements ServletRequestListener {
13 @Override
14 public void requestInitialized(ServletRequestEvent sre) {
15 //将所有request请求都携带上httpSession
16 HttpSession httpSession= ((HttpServletRequest) sre.getServletRequest()).getSession();
17 System.out.println("将所有request请求都携带上httpSession " + httpSession.getId());
18 }
19
20 public RequestListener() {
21 }
22
23 @Override
24 public void requestDestroyed(ServletRequestEvent arg0) {
25 }
26 }
对应的前端页面无需改变。
