websocket @ServerEndpoint(value = "/websocket/{ip}")詳解

WebSocket是JavaEE7新支持的：

    Javax.websocket.server包含注解，類，接口用於創建和配置服務端點

    Javax.websocket包則包含服務端點和客戶斷電公用的注解，類，接口，異常

    創建一個編程式的端點，需要繼承Endpoint類，重寫它的方法。

    創建一個注解式的端點，將自己的寫的類以及類中的一些方法用前面提到的包中的注解裝飾（@EndPoint，@OnOpen等等）。

編程式注解示例：

1. @Component
2. @ServerEndpoint(value = "/websocket/{ip}")
3. public class MyWebSocket {
4.  
5. private static final Logger log = LoggerFactory.getLogger(MyWebSocket.class);
6.  
7. // 靜態變量，用來記錄當前在線連接數。應該把它設計成線程安全的。
8. private static int onlineCount = 0;
9.  
10. // concurrent包的線程安全Map，用來存放每個客戶端對應的MyWebSocket對象。
11. private static ConcurrentHashMap<String, MyWebSocket> webSocketMap = new ConcurrentHashMap<String, MyWebSocket>();
12.  
13. // 與某個客戶端的連接會話，需要通過它來給客戶端發送數據
14. private Session session;
15.  
16. private String ip; // 客戶端ip
17. public static final String ACTION_PRINT_ORDER = "printOrder";
18. public static final String ACTION_SHOW_PRINT_EXPORT = "showPrintExport";
19.  
20. /**
21. * 連接建立成功調用的方法
22. */
23. @OnOpen
24. public void onOpen(Session session, @PathParam("ip") String ip) {
25. this.session = session;
26. this.ip = ip;
27. webSocketMap.put(ip, this);
28. addOnlineCount(); // 在線數加1
29. // System.out.println("有新連接加入！當前在線人數為" + getOnlineCount());
30. log.info( "有新連接加入,ip:{}！當前在線人數為:{}", ip, getOnlineCount());
31. ExportService es = BeanUtils.getBean(ExportService.class);
32. List<String> list = es.listExportCodesByPrintIp(ip);
33. ResponseData<String> rd = new ResponseData<String>();
34. rd.setAction(MyWebSocket.ACTION_SHOW_PRINT_EXPORT);
35. rd.setList(list);
36. sendObject(rd);
37. }
38.  
39. /**
40. * 連接關閉調用的方法
41. */
42. @OnClose
43. public void onClose(@PathParam("ip") String ip) {
44. webSocketMap.remove(ip); // 從set中刪除
45. // Map<String, String> map = session.getPathParameters();
46. // webSocketMap.remove(map.get("ip"));
47. subOnlineCount(); // 在線數減1
48. // System.out.println("有一連接關閉！當前在線人數為" + getOnlineCount());
49. log.info( "websocket關閉，IP：{},當前在線人數為:{}", ip, getOnlineCount());
50. }
51.  
52. /**
53. * 收到客戶端消息后調用的方法
54. *
55. * @param message
56. * 客戶端發送過來的消息
57. */
58. @OnMessage
59. public void onMessage(String message, Session session) {
60. // System.out.println("來自客戶端的消息:" + message);
61. log.debug( "websocket來自客戶端的消息:{}", message);
62. OrderService os = BeanUtils.getBean(OrderService.class);
63. OrderVo ov = os.getOrderDetailByOrderNo(message);
64. // System.out.println(ov);
65. ResponseData<OrderVo> rd = new ResponseData<OrderVo>();
66. ArrayList<OrderVo> list = new ArrayList<OrderVo>();
67. list.add(ov);
68. rd.setAction(MyWebSocket.ACTION_PRINT_ORDER);
69. rd.setList(list);
70. sendObject(rd);
71. // log.info("推送打印信息完成，單號：{}", ov.getOrderNo());
72. }
73.  
74. /**
75. * 發生錯誤時調用
76. */
77. @OnError
78. public void onError(Session session, Throwable error) {
79. // System.out.println("發生錯誤");
80. log.error( "webSocket發生錯誤！IP：{}", ip);
81. error.printStackTrace();
82. }
83.  
84. /**
85. * 像當前客戶端發送消息
86. *
87. * @param message
88. * 字符串消息
89. * @throws IOException
90. */
91. public void sendMessage(String message) {
92. try {
93. this.session.getBasicRemote().sendText(message);
94. // this.session.getAsyncRemote().sendText(message);
95. } catch (IOException e) {
96. e.printStackTrace();
97. log.error( "發送數據錯誤，ip:{},msg：{}", ip, message);
98. }
99. }
100.  
101. /**
102. * 向當前客戶端發送對象
103. *
104. * @param obj
105. * 所發送對象
106. * @throws IOException
107. */
108. public void sendObject(Object obj) {
109. ObjectMapper mapper = new ObjectMapper();
110. mapper.setSerializationInclusion(Include.NON_NULL);
111. String s = null;
112. try {
113. s = mapper.writeValueAsString(obj);
114. } catch (JsonProcessingException e) {
115. e.printStackTrace();
116. log.error( "轉json錯誤！{}", obj);
117. }
118. this.sendMessage(s);
119. }
120.  
121. /**
122. * 群發自定義消息
123. */
124. public static void sendInfo(String message) {
125. for (Entry<String, MyWebSocket> entry : webSocketMap.entrySet()) {
126. MyWebSocket value = entry.getValue();
127. value.sendMessage(message);
128. }
129. }
130.  
131. public static synchronized int getOnlineCount() {
132. return onlineCount;
133. }
134.  
135. public static synchronized void addOnlineCount() {
136. MyWebSocket.onlineCount++;
137. }
138.  
139. public static synchronized void subOnlineCount() {
140. MyWebSocket.onlineCount--;
141. }
142.  
143. public static ConcurrentHashMap<String, MyWebSocket> getWebSocketMap() {
144. return webSocketMap;
145. }
146.  
147. }

當創建好一個（服務）端點之后，將它以一個指定的URI發布到應用當中，這樣遠程客戶端就能連接上它了。

Websocket（服務）端點以URI表述，有如下的訪問方式：

ws://host:port/path?query

wss://host:port/path?query

注解詳解：

@ServerEndPoint：

    RequiredElements :

        Value: URI映射

    OptionalElemens：

        subprotocols：

        decoders：解碼器

        encoders：編碼器

        configurator

建立連接相關：

Annotation	Event	Example
OnOpen	Connection opened	@OnOpen Public void open(Sessionsession, EndpointConfig conf) { }
OnMessage	Message received	@OnMessage public void message(Sessionsession, String msg) { }
OnError	Connection error	@OnError public void error(Sessionsession, Throwable error) { }
OnClose	Connection closed	@OnClose public void close(Sessionsession, CloseReason reason) { }

Session代表着服務端點與遠程客戶端點的一次會話。

容器會為每一個連接創建一個EndPoint的實例，需要利用實例變量來保存一些狀態信息。

Session.getUserProperties提供了一個可編輯的map來保存properties，

例如，下面的端點在收到文本消息時，將前一次收到的消息回復給其他的端點

1. @ServerEndpoint("/delayedecho")
2.  
3. public class DelayedEchoEndpoint
4.  
5. {
6.  
7. @OnOpen
8.  
9. public void open(Sessionsession)
10.  
11. {
12.  
13. session.getUserProperties().put( "previousMsg", "");
14.  
15. }
16.  
17.  
18.  
19. @OnMessage
20.  
21. public void message(Session session, Stringmsg)
22.  
23. {
24.  
25.  
26.  
27. String prev= (String) session.getUserProperties().get( "previousMsg");
28.  
29.  
30.  
31. session.getUserProperties().put( "previousMsg",msg);
32.  
33. try {
34.  
35. session.getBasicRemote().sendText(prev);
36.  
37.  
38.  
39. } catch (IOException e){ ... }
40.  
41. }
42.  
43. }

發送、接收消息：

Websocketendpoint能夠發送和接收文本、二進制消息，另外，也可以發送ping幀和接收pong 幀

發送消息：

Obtain the Session object from theconnection.

從連接中獲得Session對象

Session對象是endPoint中那些被注解標注的方法中可得到的參數

當你的message作為另外的消息的響應

在@OnMessage標注的方法中，有session對象接收message

如果你必須主動發送message，需要在標注了@OnOpen的方法中將session對象作為實例變量保存

這樣，你可以再其他方法中得到該session對象

1.Use the Session object to obtain aRemote Endpoint object.

通過Session對象獲得Remoteendpoint對象

2.Use the RemoteEndpoint object to sendmessages to the peer.

利用RemoteEndpoint對象來發送message

代碼示例：

@ServerEndpoint("/echoall")

public class EchoAllEndpoint

{

@OnMessage

public void onMessage(Session session, Stringmsg)

{

try {

for (Session sess :session.getOpenSessions())

{

if (sess.isOpen())

sess.getBasicRemote().sendText(msg);

}

} catch (IOExceptione) { ... }

}

}

接收消息

OnMessage注解指定方法來處理接收的messages

在一個端點類中，至多可以為三個方法標注@OnMessage注解

消息類型分別為：text、binary、pong。

 

我們查看一下ServerEndpoint類源碼：

1. @Retention(value = RetentionPolicy.RUNTIME)
2. @Target(value = {ElementType.TYPE})
3. public @interface ServerEndpoint {
4.  
5. public String value();
6.  
7. public String[] subprotocols() default {};
8.  
9. public Class<? extends Decoder>[] decoders() default {};
10.  
11. public Class<? extends Encoder>[] encoders() default {};
12.  
13. public Class<? extends ServerEndpointConfig.Configurator> configurator() default ServerEndpointConfig.Configurator.class;

Encoders and Decoders（編碼器和解碼器）：

WebSocket Api 提供了encoders 和 decoders用於 Websocket Messages 與傳統java 類型之間的轉換

An encoder takes a Java object and produces a representation that can be transmitted as a WebSocket message;

編碼器輸入java對象，生成一種表現形式，能夠被轉換成Websocket message

for example, encoders typically produce JSON, XML, or binary representations.

例如：編碼器通常生成json、XML、二進制三種表現形式

A decoder performs the reverse function; it reads a WebSocket message and creates a Java object.

解碼器執行相反的方法，它讀入Websocket消息，然后輸出java對象

編碼器編碼：

looks for an encoder that matches your type and uses it to convert the object to a WebSocket message.

利用RemoteEndpoint.Basic 或者RemoteEndpoint.Async的sendObject(Object data)方法將對象作為消息發送，容器尋找一個符合此對象的編碼器，

利用此編碼器將此對象轉換成Websocket message

代碼示例：可以指定為自己的一個消息對象

1. package com.zlxls.information;
2.  
3. import com.alibaba.fastjson.JSON;
4. import com.common.model.SocketMsg;
5. import javax.websocket.EncodeException;
6. import javax.websocket.Encoder;
7. import javax.websocket.EndpointConfig;
8.  
9. /**
10. * 配置WebSocket解碼器，用於發送請求的時候可以發送Object對象，實則是json數據
11. * sendObject()
12. * @ClassNmae：ServerEncoder
13. * @author zlx-雄雄
14. * @date 2017-11-3 15:47:13
15. *
16. */
17. public class ServerEncoder implements Encoder.Text<SocketMsg> {
18.  
19. @Override
20. public void destroy() {
21. // TODO Auto-generated method stub
22.  
23. }
24.  
25. @Override
26. public void init(EndpointConfig arg0) {
27. // TODO Auto-generated method stub
28.  
29. }
30.  
31. @Override
32. public String encode(SocketMsg socketMsg) throws EncodeException {
33. try {
34. return JSON.toJSONString(socketMsg);
35. } catch (Exception e) {
36. // TODO Auto-generated catch block
37. e.printStackTrace();
38. return "";
39. }
40. }
41.  
42. }

Then, add the encodersparameter to the ServerEndpointannotation as follows:

@ServerEndpoint(

value = "/myendpoint",

encoders = { ServerEncoder.class, ServerEncoder1.class }

)

解碼器解碼：

Decoder.Binary<T>for binary messages

These interfaces specify the willDecode and decode methods.

the container calls the method annotated with @OnMessage that takes your custom Java type as a parameter if this method exists.

1. package com.zlxls.information;
2.  
3. import com.common.model.SocketMsg;
4. import javax.websocket.DecodeException;
5. import javax.websocket.Decoder;
6. import javax.websocket.EndpointConfig;
7. /**
8. * 解碼器執，它讀入Websocket消息，然后輸出java對象
9. * @ClassNmae：ServerDecoder
10. * @author zlx-雄雄
11. * @date 2017-11-11 9:12:09
12. *
13. */
14. public class ServerDecoder implements Decoder.Text<SocketMsg>{
15.  
16. @Override
17. public void init(EndpointConfig ec){}
18.  
19. @Override
20. public void destroy(){}
21.  
22. @Override
23. public SocketMsg decode(String string) throws DecodeException{
24. // Read message...
25. return new SocketMsg();
26. }
27.  
28. @Override
29. public boolean willDecode(String string){
30. // Determine if the message can be converted into either a
31. // MessageA object or a MessageB object...
32. return false;
33. }
34. }

Then, add the decoderparameter to the ServerEndpointannotation as follows:

@ServerEndpoint(

value = "/myendpoint",

encoders = { ServerEncoder.class, ServerEncoder1.class },

decoders = {ServerDecoder.class }

)

處理錯誤：

To designate a method that handles errors in an annotated WebSocket endpoint, decorate it with @OnError:

1. /**
2. * 發生錯誤是調用方法
3. * @param t
4. * @throws Throwable
5. */
6. @OnError
7. public void onError(Throwable t) throws Throwable {
8. System.out.println( "錯誤: " + t.toString());
9. }

為一個注解式的端點指定一個處理error的方法，為此方法加上@OnError注解：

This method is invoked when there are connection problems, runtime errors from message handlers, or conversion errors when decoding messages.

 

當出現連接錯誤，運行時錯誤或者解碼時轉換錯誤，該方法才會被調用

指定端點配置類：

The Java API for WebSocket enables you to configure how the container creates server endpoint instances.

Websocket的api允許配置容器合適創建server endpoint 實例

You can provide custom endpoint configuration logic to:

Access the details of the initial HTTP request for a WebSocket connection

Perform custom checks on the OriginHTTP header

Modify the WebSocket handshake response

Choose a WebSocket subprotocol from those requested by the client

Control the instantiation and initialization of endpoint instances

To provide custom endpoint configuration logic, you extend the ServerEndpointConfig.Configurator class and override some of its methods.

繼承ServerEndpointConfig.Configurator 類並重寫一些方法，來完成custom endpoint configuration 的邏輯代碼

In the endpoint class, you specify the configurator class using the configurator parameter of the ServerEndpoint annotation.

代碼示例：

1. package com.zlxls.information;
2.  
3. import javax.servlet.http.HttpSession;
4. import javax.websocket.HandshakeResponse;
5. import javax.websocket.server.HandshakeRequest;
6. import javax.websocket.server.ServerEndpointConfig;
7. import javax.websocket.server.ServerEndpointConfig.Configurator;
8. /**
9. * 由於websocket的協議與Http協議是不同的，
10. * 所以造成了無法直接拿到session。
11. * 但是問題總是要解決的，不然這個websocket協議所用的場景也就沒了
12. * 重寫modifyHandshake，HandshakeRequest request可以獲取httpSession
13. * @ClassNmae：GetHttpSessionConfigurator
14. * @author zlx-雄雄
15. * @date 2017-11-3 15:47:13
16. *
17. */
18. public class GetHttpSessionConfigurator extends Configurator{
19. @Override
20. public void modifyHandshake(ServerEndpointConfig sec,HandshakeRequest request, HandshakeResponse response) {
21.  
22. HttpSession httpSession=(HttpSession) request.getHttpSession();
23.  
24. sec.getUserProperties().put(HttpSession.class.getName(),httpSession);
25.  
26. }
27. }

1. @OnOpen
2. public void open(Session s, EndpointConfig conf){
3.  
4. HandshakeRequest req = (HandshakeRequest) conf.getUserProperties().get( "sessionKey");
5.  
6. }

@ServerEndpoint(

value = "/myendpoint",

configurator=GetHttpSessionConfigurator.class

)

不過要特別說一句：

HandshakeRequest req = (HandshakeRequest) conf.getUserProperties().get("sessionKey");  目前獲取到的是空值。會報錯：java.lang.NullPointerException，這個錯誤信息，大家最熟悉不過了。

原因是：請求頭里面並沒有把相關的信息帶上

這里就需要實現一個監聽，作用很明顯：將所有request請求都攜帶上httpSession，這樣就可以正常訪問了

說明：注解非常簡單可以直接使用注解@WebListener，也可以再web.xml配置監聽

1. package com.zlxls.information;
2.  
3. import javax.servlet.ServletRequestEvent;
4. import javax.servlet.ServletRequestListener;
5. import javax.servlet.annotation.WebListener;
6. import javax.servlet.http.HttpServletRequest;
7.  
8. /**
9. * http://www.cnblogs.com/zhuxiaojie/p/6238826.html
10. * 配置監聽器，將所有request請求都攜帶上httpSession
11. * 用於webSocket取Session
12. * @ClassNmae：RequestListener
13. * @author zlx-雄雄
14. * @date 2017-11-4 11:27:33
15. *
16. */
17. @WebListener
18. public class RequestListener implements ServletRequestListener {
19. @Override
20. public void requestInitialized(ServletRequestEvent sre) {
21.  
22. //將所有request請求都攜帶上httpSession
23. ((HttpServletRequest) sre.getServletRequest()).getSession();
24.  
25. }
26. public RequestListener() {}
27.  
28. @Override
29. public void requestDestroyed(ServletRequestEvent arg0) {}
30. }
31.