【websocket】springboot集成websocket的四种⽅式
集成 websocket 的四种⽅案
1. 原⽣注解
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-websocket</artifactId>
</dependency>
WebSocketConfig
/*
* *
*  * der4j
*  * Copyright (C) 2016-2019 All Rights Reserved.
*
*/
fig;
import t.annotation.Bean;
import t.annotation.Configuration;
import org.springframework.fig.annotation.EnableWebSocket;
import org.springframework.web.socket.server.standard.ServerEndpointExporter;
/**
* @author buhao
* @version WebSocketConfig.java, v 0.1 2019-10-18 15:45 buhao
*/
@Configuration
@EnableWebSocket
public class WebSocketConfig {
@Bean
public ServerEndpointExporter serverEndpoint() {
return new ServerEndpointExporter();
}
}
说明：
这个配置类很简单，通过这个配置 spring boot 才能去扫描后⾯的关于 websocket 的注解
WsServerEndpoint
/*
* *
*  * der4j
*  * Copyright (C) 2016-2019 All Rights Reserved.
*
*/
ample.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 0.1 2019-10-18 16:06 buhao
*/
@ServerEndpoint("/myWs")
@Component
public class WsServerEndpoint {
/
**
* 连接成功
*
* @param session
*/
@OnOpen
public void onOpen(Session session) {
System.out.println("连接成功");
}
/**
* 连接关闭
*
* @param session
*/
@OnClose
public void onClose(Session session) {
System.out.println("连接关闭");
}
/**
* 接收到消息
*
* @param text
*/
@OnMessage
public String onMsg(String text) throws IOException {
return "servet 发送：" + text;
}
}
说明
这⾥有⼏个注解需要注意⼀下，⾸先是他们的包都在 **javax.websocket **下。并不是 spring 提供的，⽽ jdk ⾃带的，下⾯是他们的具体作⽤。
@ServerEndpoint
通过这个 spring boot 就可以知道你暴露出去的 ws 应⽤的路径，有点类似我们经常⽤的@RequestMapping。⽐如你的启动端⼝是8080，⽽这个注解的值是ws，那我们就可以通过
ws://127.0.0.1:8080/ws 来连接你的应⽤
@OnOpen
当 websocket 建⽴连接成功后会触发这个注解修饰的⽅法，注意它有⼀个 Session 参数
@OnClose
当 websocket 建⽴的连接断开后会触发这个注解修饰的⽅法，注意它有⼀个 Session 参数
@OnMessage
当客户端发送消息到服务端时，会触发这个注解修改的⽅法，它有⼀个 String ⼊参表明客户端传⼊的值
@OnError
当 websocket 建⽴连接时出现异常会触发这个注解修饰的⽅法，注意它有⼀个 Session 参数
另外⼀点就是服务端如何发送消息给客户端，服务端发送消息必须通过上⾯说的 Session 类，通常是在@OnOpen ⽅法中，当连接成功后把 session 存⼊ Map 的 value，key 是与 session 对应的⽤户标识，当要发送的时候通过 key 获得 session 再发送，这⾥可以通过 BasicRemote_().sendText(_)
来对客户端发送消息。
2. Spring封装
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-websocket</artifactId>
</dependency>
HttpAuthHandler
/*
* *
*  * der4j
*  * Copyright (C) 2016-2019 All Rights Reserved.
*
*/
ample.websocket.handler;
fig.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;
/
**
websocket和socket* @author buhao
* @version MyWSHandler.java, v 0.1 2019-10-17 17:10 buhao
*/
@Component
public class HttpAuthHandler extends TextWebSocketHandler {
/**
* socket 建⽴成功事件
*
* @param session
* @throws Exception
*/
@Override
public void afterConnectionEstablished(WebSocketSession session) throws Exception {
Object token = Attributes().get("token");
if (token != null) {
// ⽤户连接成功，放⼊在线⽤户缓存
WsSessionManager.String(), session);
} else {
throw new RuntimeException("⽤户登录已经失效!");
}
}
/
**
* 接收消息事件
*
* @param session
* @param message
* @throws Exception
*/
@Override
protected void handleTextMessage(WebSocketSession session, TextMessage message) throws Exception {
// 获得客户端传来的消息
String payload = Payload();
Object token = Attributes().get("token");
System.out.println("server 接收到 " + token + " 发送的 " + payload);
session.sendMessage(new TextMessage("server 发送给 " + token + " 消息 " + payload + " " + w().toString()));
}
/**
* socket 断开连接时
*
* @param session
* @param status
* @throws Exception
*/
@Override
public void afterConnectionClosed(WebSocketSession session, CloseStatus status) throws Exception {
Object token = Attributes().get("token");
if (token != null) {
// ⽤户退出，移除缓存
}
}
}
说明
通过继承 TextWebSocketHandler 类并覆盖相应⽅法，可以对 websocket 的事件进⾏处理，这⾥可以同原⽣注解的那⼏个注解连起来看
afterConnectionEstablished ⽅法是在 socket 连接成功后被触发，同原⽣注解⾥的 @OnOpen 功能
**afterConnectionClosed  **⽅法是在 socket 连接关闭后被触发，同原⽣注解⾥的 @OnClose 功能
**handleTextMessage **⽅法是在客户端发送信息时触发，同原⽣注解⾥的 @OnMessage 功能
WsSessionManager
/*
* *
*  * der4j
*  * Copyright (C) 2016-2019 All Rights Reserved.
*
*/
fig;
slf4j.Slf4j;
import org.springframework.web.socket.WebSocketSession;
import java.io.IOException;
import urrent.ConcurrentHashMap;
/**
* @author buhao
* @version WsSessionManager.java, v 0.1 2019-10-22 10:24 buhao
*/
@Slf4j
public class WsSessionManager {
/
**
* 保存连接 session 的地⽅
*/
private static ConcurrentHashMap<String, WebSocketSession> SESSION_POOL = new ConcurrentHashMap<>();
/**
* 添加 session
*
* @param key
*/
public static void add(String key, WebSocketSession session) {
// 添加 session
SESSION_POOL.put(key, session);
}
/**
* 删除 session，会返回删除的 session
*
* @param key
* @return
*/
public static WebSocketSession remove(String key) {
// 删除 session
return ve(key);
}
/**
* 删除并同步关闭连接
*
* @param key
*/
public static void removeAndClose(String key) {
WebSocketSession session = remove(key);
if (session != null) {
try {
// 关闭连接
session.close();
} catch (IOException e) {
// todo: 关闭出现异常处理
e.printStackTrace();
}
}
}
/**
* 获得 session
*
* @param key
* @return
*/
public static WebSocketSession get(String key) {
// 获得 session
return (key);
}
}
说明
这⾥简单通过 **ConcurrentHashMap **来实现了⼀个 session 池，⽤来保存已经登录的 web socket 的  session。前⽂提过，服务端发送消息给客户端必须要通过这个 session。MyInterceptor
/*
* *
*  * der4j
*  * Copyright (C) 2016-2019 All Rights Reserved.
*
*/
ample.websocket.interceptor;
import 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 0.1 2019-10-17 19:21 buhao
*/
@Component
public class MyInterceptor implements HandshakeInterceptor {
/**
* 握⼿前
*
* @param request
* @param response
* @param wsHandler
* @param attributes
* @return
* @throws Exception
*/
@Override
public boolean beforeHandshake(ServerHttpRequest request, ServerHttpResponse response, WebSocketHandler wsHandler, Map<String, Object> attributes) throws Exception {
System.out.println("握⼿开始");
// 获得请求参数
HashMap<String, String> paramMap = HttpUtil.URI().getQuery(), "utf-8");
String uid = ("token");
if (StrUtil.isNotBlank(uid)) {
// 放⼊属性域
attributes.put("token", uid);
System.out.println("⽤户 token " + uid + " 握⼿成功！");
return true;
}
System.out.println("⽤户登录已失效");
return false;
}
/**
* 握⼿后
*
* @param request
* @param response
* @param wsHandler
* @param exception
*/
@Override
public void afterHandshake(ServerHttpRequest request, ServerHttpResponse response, WebSocketHandler wsHandler, Exception exception) {
System.out.println("握⼿完成");
}
}
说明
通过实现 HandshakeInterceptor 接⼝来定义握⼿，注意这⾥与上⾯ Handler 的事件是不同的，这⾥是建⽴握⼿时的事件，分为握⼿前与握⼿后，⽽  Handler 的事件是在握⼿成功后的基础上建⽴socket 的连接。所以在如果把认证放在这个步骤相对来说最节省服务器资源。它主要有两个⽅法 beforeHandshake 与 **afterHandshake **，顾名思义⼀个在握⼿前触发，⼀个在握⼿后触发。WebSocketConfig
/*
* *
*  * der4j
*  * Copyright (C) 2016-2019 All Rights Reserved.
*
*/
fig;
ample.websocket.handler.HttpAuthHandler;
ample.websocket.interceptor.MyInterceptor;
import org.springframework.beans.factory.annotation.Autowired;
import t.annotation.Configuration;
import org.springframework.fig.annotation.EnableWebSocket;
import org.springframework.fig.annotation.WebSocketConfigurer;
import org.springframework.fig.annotation.WebSocketHandlerRegistry;
/**
* @author buhao
* @version WebSocketConfig.java, v 0.1 2019-10-17 15:43 buhao
*/
@Configuration
@EnableWebSocket
public 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("*");
}
}
说明
通过实现 WebSocketConfigurer 类并覆盖相应的⽅法进⾏ websocket 的配置。我们主要覆盖 registerWebSocketHandlers 这个⽅法。通过向 WebSocketHandlerRegistry 设置不同参数来进⾏配置。其中 **addHandler ⽅法添加我们上⾯的写的 ws 的  handler 处理类，第⼆个参数是你暴露出的 ws 路径。addInterceptors 添加我们写的握⼿过滤器。setAllowedOrigins("*") **这个是关闭跨域校验，⽅便本地调试，线上推荐打开。
3. TIO
<dependency>
<groupId>org.t-io</groupId>
<artifactId>tio-websocket-spring-boot-starter</artifactId>
<version>3.5.5.v20191010-RELEASE</version>
</dependency>
tio:
websocket:
server:
port: 8989
说明
这⾥只配置了 ws 的启动端⼝，还有很多配置，可以通过结尾给的链接去寻
MyHandler
/*
* *
*  * der4j
*  * Copyright (C) 2016-2019 All Rights Reserved.
*
*/
ample.websocket.handler;
import org.springframework.stereotype.Component;
import ChannelContext;
import org.tio.httpmon.HttpRequest;
import org.tio.httpmon.HttpResponse;
import org.tio.websocketmon.WsRequest;
import org.tio.websocket.server.handler.IWsMsgHandler;
/**
* @author buhao
* @version MyHandler.java, v 0.1 2019-10-21 14:39 buhao
*/
@Component
public class MyHandler implements IWsMsgHandler {
/**
* 握⼿
*
* @param httpRequest
* @param httpResponse
* @param channelContext
* @return
* @throws Exception
*/
@Override
public HttpResponse handshake(HttpRequest httpRequest, HttpResponse httpResponse, ChannelContext channelContext) throws Exception {        return httpResponse;
}
/**
* 握⼿成功
*
* @param httpRequest
* @param httpResponse
* @param channelContext
* @throws Exception
*/
@Override
public void onAfterHandshaked(HttpRequest httpRequest, HttpResponse httpResponse, ChannelContext channelContext) throws Exception {        System.out.println("握⼿成功");
}
/**
* 接收⼆进制⽂件
*
* @param wsRequest
* @param bytes
* @param channelContext
* @return
* @throws Exception
*/
@Override
public Object onBytes(WsRequest wsRequest, byte[] bytes, ChannelContext channelContext) throws Exception {
return null;
}
/**
* 断开连接
*
* @param wsRequest
* @param bytes
* @param channelContext
* @return
* @throws Exception
*/
@Override
public Object onClose(WsRequest wsRequest, byte[] bytes, ChannelContext channelContext) throws Exception {
System.out.println("关闭连接");
return null;
}
/**
* 接收消息
*
* @param wsRequest
* @param s
* @param channelContext
* @return
* @throws Exception
*/
@Override
public Object onText(WsRequest wsRequest, String s, ChannelContext channelContext) throws Exception {
System.out.println("接收⽂本消息:" + s);
return "success";
}
}
说明
这个同上个例⼦中的 handler 很像，也是通过实现接⼝覆盖⽅法来进⾏事件处理，实现的接⼝是IWsMsgHandler，它的⽅法功能如下
handshake
在握⼿的时候触发
onAfterHandshaked
在握⼿成功后触发
onBytes
客户端发送⼆进制消息触发
onClose
客户端关闭连接时触发
onText
客户端发送⽂本消息触发
StudyWebsocketExampleApplication
/*
* *
*  * der4j
*  * Copyright (C) 2016-2019 All Rights Reserved.
*
*/
ample.websocket;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.tio.websocket.starter.EnableTioWebSocketServer;

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。