Shulou(Shulou.com)06/02 Report--

This article mainly introduces how to integrate springboot websocket, has a certain reference value, interested friends can refer to, I hope you can learn a lot after reading this article, the following let the editor take you to understand it.

1. Original annotation

Pom.xml

Org.springframework.boot spring-boot-starter-websocket

WebSocketConfig

/ * blog.coder4j.cn * * Copyright (C) 2016-2019 All Rights Reserved. * * / package cn.coder4j.study.example.websocket.config;import org.springframework.context.annotation.Bean;import org.springframework.context.annotation.Configuration;import org.springframework.web.socket.config.annotation.EnableWebSocket;import org.springframework.web.socket.server.standard.ServerEndpointExporter;/** * @ author buhao * @ version WebSocketConfig.java, v 2019-10-18 15:45 buhao * / @ Configuration@EnableWebSocketpublic class WebSocketConfig {@ Bean public ServerEndpointExporter serverEndpoint () {return new ServerEndpointExporter () }}

Description:

This configuration class is very simple. By configuring spring boot, you can scan the following comments about websocket.

WsServerEndpoint#

/ * blog.coder4j.cn * * Copyright (C) 2016-2019 All Rights Reserved. * * / package cn.coder4j.study.example.websocket.ws;import org.springframework.stereotype.Component;import javax.websocket.OnClose;import javax.websocket.OnMessage;import javax.websocket.OnOpen;import javax.websocket.Session;import javax.websocket.server.ServerEndpoint;import java.io.IOException;import java.util.HashMap;import java.util.Map / * @ author buhao * @ version WsServerEndpoint.java, v 2019-10-18 16:06 buhao * / @ ServerEndpoint ("/ myWs") @ Componentpublic class WsServerEndpoint {/ * connected successfully * * @ param session * / @ OnOpen public void onOpen (Session session) {System.out.println ("connected successfully") } / * * connection closed * * @ param session * / @ OnClose public void onClose (Session session) {System.out.println ("connection closed");} / * * received message * * @ param text * / @ OnMessage public String onMsg (String text) throws IOException {return "servet send:" + text;}}

Description

Here are a few notes to note. The first is that their packages are all under * * javax.websocket * *. It is not provided by spring, but comes with jdk. Here are their specific roles.

@ ServerEndpoint

Through this spring boot, you can know the path of your exposed ws application, which is a bit similar to the @ RequestMapping we often use. For example, if your startup port is 8080 and the value of this annotation is ws, then we can connect to your application through ws://127.0.0.1:8080/ws.

@ OnOpen

This annotated method will be triggered when websocket successfully establishes the connection. Note that it has a Session parameter.

@ OnClose

This annotated method is triggered when the connection established by websocket is disconnected. Note that it has a Session parameter.

@ OnMessage

When the client sends a message to the server, it triggers the annotation modification method, which has a String input parameter indicating the value passed by the client.

@ OnError

This annotated method is triggered when an exception occurs when websocket establishes a connection. Note that it has a Session parameter.

Another point is how the server sends a message to the client. The server must send the message through the Session class mentioned above, usually in the @ OnOpen method. When the connection is successful, the value,key that stores the session in Map is the user ID corresponding to session. When it is to be sent, the session is obtained through key and then sent. Here, you can send a message to the client through session.getBasicRemote_ (). SendText (_).

2. Spring encapsulation

Pom.xml

Org.springframework.boot spring-boot-starter-websocket

HttpAuthHandler

/ * blog.coder4j.cn * * Copyright (C) 2016-2019 All Rights Reserved. * * / package cn.coder4j.study.example.websocket.handler;import cn.coder4j.study.example.websocket.config.WsSessionManager;import org.springframework.stereotype.Component;import org.springframework.web.socket.CloseStatus;import org.springframework.web.socket.TextMessage;import org.springframework.web.socket.WebSocketSession;import org.springframework.web.socket.handler.TextWebSocketHandler;import java.time.LocalDateTime / * @ author buhao * @ version MyWSHandler.java, v 2019-10-17 17:10 buhao * / @ Componentpublic class HttpAuthHandler extends TextWebSocketHandler {/ * socket Establishment success event * * @ param session * @ throws Exception * / @ Override public void afterConnectionEstablished (WebSocketSession session) throws Exception {Object token = session.getAttributes () .get ("token") If (token! = null) {/ / user connection succeeded and put into online user cache WsSessionManager.add (token.toString (), session);} else {throw new RuntimeException ("user login has expired!") }} / * receive message event * * @ param session * @ param message * @ throws Exception * / @ Override protected void handleTextMessage (WebSocketSession session, TextMessage message) throws Exception {/ / get the message String payload = message.getPayload (); Object token = session.getAttributes (). Get ("token") System.out.println ("server received" + payload sent by "+ token +"); session.sendMessage ("server sent to" + token + "message" + payload + "" + LocalDateTime.now () .toString () } / * socket disconnects * * @ param session * @ param status * @ throws Exception * / @ Override public void afterConnectionClosed (WebSocketSession session, CloseStatus status) throws Exception {Object token = session.getAttributes () .get ("token") If (token! = null) {/ / user exits and removes cache WsSessionManager.remove (token.toString ());}

Description

Events of websocket can be handled by inheriting the TextWebSocketHandler class and overriding the corresponding methods, which can be linked with the annotations of the native annotations

The afterConnectionEstablished method is triggered after a successful socket connection, which is the same as the @ OnOpen function in the native annotation.

The * * afterConnectionClosed * * method is triggered after the socket connection is closed, which is the same as the @ OnClose function in the native annotation.

The * * handleTextMessage * * method is triggered when the client sends a message, which is the same as the @ OnMessage function in the native annotation.

WsSessionManager

/ * blog.coder4j.cn * * Copyright (C) 2016-2019 All Rights Reserved. * * / package cn.coder4j.study.example.websocket.config;import lombok.extern.slf4j.Slf4j;import org.springframework.web.socket.WebSocketSession;import java.io.IOException;import java.util.concurrent.ConcurrentHashMap;/** * @ author buhao * @ version WsSessionManager.java, v 2019-10-22 10:24 buhao * / @ Slf4jpublic class WsSessionManager {/ * Save the connection to the session * / private static ConcurrentHashMap SESSION_POOL = new ConcurrentHashMap () / * add session * * @ param key * / public static void add (String key, WebSocketSession session) {/ / add session SESSION_POOL.put (key, session) } / * deleting session will return the deleted session * * @ param key * @ return * / public static WebSocketSession remove (String key) {/ / delete session return SESSION_POOL.remove (key) } / * delete and close the connection synchronously * * @ param key * / public static void removeAndClose (String key) {WebSocketSession session = remove (key); if (session! = null) {try {/ / close the connection session.close () } catch (IOException e) {/ / todo: turn off exception handling e.printStackTrace () Get session * * @ param key * @ return * / public static WebSocketSession get (String key) {/ / get session return SESSION_POOL.get (key);}}

Description

Here, a session pool is simply implemented through * * ConcurrentHashMap * *, which is used to store the session of the logged-in web socket. As mentioned earlier, the server must go through this session to send messages to the client.

MyInterceptor

/ * blog.coder4j.cn * * Copyright (C) 2016-2019 All Rights Reserved. * * / package cn.coder4j.study.example.websocket.interceptor;import cn.hutool.core.util.StrUtil;import cn.hutool.http.HttpUtil;import org.springframework.http.server.ServerHttpRequest;import org.springframework.http.server.ServerHttpResponse;import org.springframework.stereotype.Component;import org.springframework.web.socket.WebSocketHandler;import org.springframework.web.socket.server.HandshakeInterceptor;import java.util.HashMap;import java.util.Map / * @ author buhao * @ version MyInterceptor.java, v 2019-10-17 19:21 buhao * / @ Componentpublic class MyInterceptor implements HandshakeInterceptor {/ * before shaking hands * * @ param request * @ param response * @ param wsHandler * @ return * @ throws Exception * / @ Override public boolean beforeHandshake (ServerHttpRequest request, ServerHttpResponse response, WebSocketHandler wsHandler Map attributes) throws Exception {System.out.println ("handshake begins") / / get the request parameter HashMap paramMap = HttpUtil.decodeParamMap (request.getURI (). GetQuery (), "utf-8"); String uid = paramMap.get ("token"); if (StrUtil.isNotBlank (uid)) {/ / put into the attribute field attributes.put ("token", uid) System.out.println ("user token" + uid + "handshake successful!") ; return true;} System.out.println ("user login is invalid"); return false } / * after handshake * * @ param request * @ param response * @ param wsHandler * @ param exception * / @ Override public void afterHandshake (ServerHttpRequest request, ServerHttpResponse response, WebSocketHandler wsHandler, Exception exception) {System.out.println ("handshake complete");}}

Description

Define the handshake interceptor by implementing the HandshakeInterceptor interface. Note that this is different from the above Handler event. Here is the event of establishing a handshake, which is divided into before and after the handshake, while the Handler event is to establish a socket connection based on a successful handshake. So if you put authentication in this step, relatively speaking, it will save the most server resources. It mainly has two methods: beforeHandshake and * * afterHandshake * *. As the name implies, one is triggered before the handshake and the other after the handshake.

WebSocketConfig

/ * blog.coder4j.cn * * Copyright (C) 2016-2019 All Rights Reserved. * * / package cn.coder4j.study.example.websocket.config;import cn.coder4j.study.example.websocket.handler.HttpAuthHandler;import cn.coder4j.study.example.websocket.interceptor.MyInterceptor;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.context.annotation.Configuration;import org.springframework.web.socket.config.annotation.EnableWebSocket;import org.springframework.web.socket.config.annotation.WebSocketConfigurer;import org.springframework.web.socket.config.annotation.WebSocketHandlerRegistry / * @ author buhao * @ version WebSocketConfig.java, v 2019-10-17 15:43 buhao * / @ Configuration@EnableWebSocketpublic class WebSocketConfig implements WebSocketConfigurer {@ Autowired private HttpAuthHandler httpAuthHandler; @ Autowired private MyInterceptor myInterceptor; @ Override public void registerWebSocketHandlers (WebSocketHandlerRegistry registry) {registry .addHandler (httpAuthHandler, "myWS") .addInterceptors (myInterceptor) .setAllowedOrigins ("*");}}

Description

Configure websocket by implementing the WebSocketConfigurer class and overriding the corresponding methods. We mainly cover the registerWebSocketHandlers method. Configure by setting different parameters to WebSocketHandlerRegistry. The * * addHandler method adds the handler processing class of the ws we wrote above, and the second parameter is the ws path you exposed. AddInterceptors adds the handshake filter we wrote. SetAllowedOrigins ("*") * * this disables cross-domain verification for local debugging. It is recommended to enable it online.

3. TIO

Pom.xml

Org.t-io tio-websocket-spring-boot-starter 3.5.5.v20191010-RELEASE

Application.xml

Tio: websocket: server: port: 8989

Description

Only the startup port of ws is configured here, and there are many configurations that can be found through the link at the end.

MyHandler

/ * blog.coder4j.cn * * Copyright (C) 2016-2019 All Rights Reserved. * * / package cn.coder4j.study.example.websocket.handler;import org.springframework.stereotype.Component;import org.tio.core.ChannelContext;import org.tio.http.common.HttpRequest;import org.tio.http.common.HttpResponse;import org.tio.websocket.common.WsRequest;import org.tio.websocket.server.handler.IWsMsgHandler / * @ author buhao * @ version MyHandler.java, v 2019-10-21 14:39 buhao * / @ Componentpublic class MyHandler implements IWsMsgHandler {/ * handshake * * @ param httpRequest * @ param httpResponse * @ param channelContext * @ return * @ throws Exception * / @ Override public HttpResponse handshake (HttpRequest httpRequest, HttpResponse httpResponse, ChannelContext channelContext) throws Exception {return httpResponse } / * * handshake succeeded * * @ param httpRequest * @ param httpResponse * @ param channelContext * @ throws Exception * / @ Override public void onAfterHandshaked (HttpRequest httpRequest, HttpResponse httpResponse, ChannelContext channelContext) throws Exception {System.out.println ("handshake succeeded") } / * receive binaries * * @ param wsRequest * @ param bytes * @ param channelContext * @ return * @ throws Exception * / @ Override public Object onBytes (WsRequest wsRequest, byte [] bytes, ChannelContext channelContext) throws Exception {return null } / * disconnect * * @ param wsRequest * @ param bytes * @ param channelContext * @ return * @ throws Exception * / @ Override public Object onClose (WsRequest wsRequest, byte [] bytes, ChannelContext channelContext) throws Exception {System.out.println ("close connection"); return null } / * * receive messages * * @ param wsRequest * @ param s * @ param channelContext * @ return * @ throws Exception * / @ Override public Object onText (WsRequest wsRequest, String s, ChannelContext channelContext) throws Exception {System.out.println ("receive text messages:" + s); return "success";}}

Description

This is very similar to the handler in the previous example, which also handles events by implementing the interface override method. The interface is IWsMsgHandler, and its method functions are as follows

Handshake

Triggered during a handshake

OnAfterHandshaked

Triggered after a successful handshake

OnBytes

The client sends a binary message trigger

OnClose

Triggered when the client closes the connection

OnText

The client sends a text message to trigger

StudyWebsocketExampleApplication

/ * blog.coder4j.cn * * Copyright (C) 2016-2019 All Rights Reserved. * * / package cn.coder4j.study.example.websocket;import org.springframework.boot.SpringApplication;import org.springframework.boot.autoconfigure.SpringBootApplication;import org.tio.websocket.starter.EnableTioWebSocketServer;@SpringBootApplication@EnableTioWebSocketServerpublic class StudyWebsocketExampleApplication {public static void main (String [] args) {SpringApplication.run (StudyWebsocketExampleApplication.class, args);}}

Description

The name of this class is not important, it is actually your spring boot startup class, just remember to add the @ EnableTioWebSocketServer annotation

STOMP

Pom.xml

Org.springframework.boot spring-boot-starter-websocket

WebSocketConfig

/ * blog.coder4j.cn * * Copyright (C) 2016-2019 All Rights Reserved. * * / package cn.coder4j.study.example.websocket.config;import org.springframework.context.annotation.Configuration;import org.springframework.messaging.simp.config.MessageBrokerRegistry;import org.springframework.web.socket.config.annotation.EnableWebSocketMessageBroker;import org.springframework.web.socket.config.annotation.StompEndpointRegistry;import org.springframework.web.socket.config.annotation.WebSocketMessageBrokerConfigurer / * @ author buhao * @ version WebSocketConfig.java, v 2019-10-21 16:32 buhao * / @ Configuration@EnableWebSocketMessageBrokerpublic class WebSocketConfig implements WebSocketMessageBrokerConfigurer {@ Override public void registerStompEndpoints (StompEndpointRegistry registry) {/ / configure the client attempt connection address registry.addEndpoint ("/ ws") .setAllowedOrigins ("*") .withSockJS () } @ Override public void configureMessageBroker (MessageBrokerRegistry registry) {/ / set the broadcast node registry.enableSimpleBroker ("/ topic", "/ user"); / / the prefix registry.setApplicationDestinationPrefixes ("/ app") is required for the client to send messages to the server; / / specify the prefix / user/ registry.setUserDestinationPrefix ("/ user/") that the user sends ("/ user/");}}

Description

Configure and annotate stomp by implementing the WebSocketMessageBrokerConfigurer interface and adding @ EnableWebSocketMessageBroker.

It overrides the registerStompEndpoints method to set the path to the exposed stomp, and other cross-domain, client-side settings.

Override the * * configureMessageBroker * * method to configure the node.

The broadcast node configured by * * enableSimpleBroker * *, that is, the node where the server sends messages and the client subscribes to receive messages.

Override the * * setApplicationDestinationPrefixes * * method and set the node on which the client sends messages to the server.

Override the setUserDestinationPrefix method and set the node for one-to-one communication.

WSController

/ * blog.coder4j.cn * * Copyright (C) 2016-2019 All Rights Reserved. * * / package cn.coder4j.study.example.websocket.controller;import cn.coder4j.study.example.websocket.model.RequestMessage;import cn.coder4j.study.example.websocket.model.ResponseMessage;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.messaging.handler.annotation.MessageMapping;import org.springframework.messaging.handler.annotation.SendTo;import org.springframework.messaging.simp.SimpMessagingTemplate;import org.springframework.stereotype.Controller;import org.springframework.web.bind.annotation.GetMapping;import org.springframework.web.bind.annotation.ResponseBody / * @ author buhao * @ version WSController.java, v 2019-10-21 17:22 buhao * / @ Controllerpublic class WSController {@ Autowired private SimpMessagingTemplate simpMessagingTemplate; @ MessageMapping ("/ hello") @ SendTo ("/ topic/hello") public ResponseMessage hello (RequestMessage requestMessage) {System.out.println ("receive message:" + requestMessage); return new ResponseMessage ("server receives your message:" + requestMessage) } @ GetMapping ("/ sendMsgByUser") public @ ResponseBody Object sendMsgByUser (String token, String msg) {simpMessagingTemplate.convertAndSendToUser (token, "/ msg", msg); return "success";} @ GetMapping ("/ sendMsgByAll") public @ ResponseBody Object sendMsgByAll (String msg) {simpMessagingTemplate.convertAndSend ("/ topic", msg); return "success" @ GetMapping ("/ test") public String test () {return "test-stomp.html";}}

Description

Expose the node path through @ MessageMapping, which is a bit like @ RequestMapping. Note that although hello is written here, the real address of our client call is * * / app/hello. Because we configured registry.setApplicationDestinationPrefixes ("/ app") * * in the config above.

The @ SendTo annotation sends the content of the return value to the client that subscribes to / topic/hello, similar to the @ SendToUser except that it sends an one-to-one communication to the client. These two annotations are generally responsive, and if the server actively sends a message, it can be sent through the convertAndSend method of the simpMessagingTemplate class. Note simpMessagingTemplate.convertAndSendToUser (token, "/ msg", msg), contact the registry.setUserDestinationPrefix we configured above ("/ user/"), where the client subscribes to / user/ {token} / msg, make no mistake.

Problems with Session sharing

A problem repeatedly mentioned above is that if the server wants to actively send messages to the client, it must use session. What we all know is that session is not cross-jvm. If there are multiple servers, in the case of a http request, we can share this problem by putting session into the caching middleware, which can be solved through several spring session configurations. But web socket can't. His session is not serializable, and of course it's not designed to embarrass you, but because of the difference between http and web socket requests.

At present, the simplest solution found on the Internet is to subscribe to the broadcast through redis. The main code is similar to the second way. You need to put a map locally to save the requested session. In other words, each server will keep the session connected to it locally. Then the place where the message is sent needs to be modified, not directly as it is now, but through the subscription mechanism of redis. When the server wants to send a message, you broadcast the message through redis, all subscribed servers will receive the message, and then try to send it locally. In the end, it is certain that only the one with this corresponding user session can be sent.

How to choose

If you are using tio, it is recommended to use tio integration. Because it has implemented a lot of functions, including the session sharing through redis mentioned above, you only need to add a few configurations. But tio is a semi-open source, and documentation is free of charge. If you don't use it, forget him.

If your business requirements are flexible, the first two are recommended, and the second form of Spring encapsulation is recommended.

If it is only a simple two-way communication between the server, the form of stomp is recommended because it is easier to standardize.

Thank you for reading this article carefully. I hope the article "how to integrate springboot into websocket" shared by the editor will be helpful to everyone. At the same time, I also hope that you will support us and pay attention to the industry information channel. More related knowledge is waiting for you to learn!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.