日常记录：springboot 给websocket 添加拦截、认证（二）

已于 2022-09-02 18:58:58 修改
阅读量4.8k 收藏 13
点赞数 4
分类专栏： 日常问题 文章标签： websocket 网络协议 spring boot
于 2022-09-02 17:49:30 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_16430873/article/details/126667606
版权

前言

上一章的websocket拦截和这次讲的不同，这次是stomp协议广播消息的拦截。

一、配置拦截

这次是由AbstractWebSocketMessageBrokerConfigurer抽象类里面一个configureClientInboundChannel方法，添加拦截器。

自定义WebSocketEmptyLogInterceptor拦截器，覆盖ChannelInterceptorAdapter接口preSend方法。ChannelInterceptorAdapter是ChannelInterceptor的适配器，覆盖preSend，在发送前认证token即可。

package com.sakyoka.test.systemconfig.interceptor;

import org.apache.commons.lang3.StringUtils;
import org.springframework.messaging.Message;
import org.springframework.messaging.MessageChannel;
import org.springframework.messaging.simp.stomp.StompCommand;
import org.springframework.messaging.simp.stomp.StompHeaderAccessor;
import org.springframework.messaging.support.ChannelInterceptorAdapter;
import org.springframework.messaging.support.MessageHeaderAccessor;
import org.springframework.stereotype.Component;

import com.sakyoka.test.utils.JwtTokenUtils;

import lombok.extern.log4j.Log4j;

/**
 * 
 * 描述：stomp websocket 拦截器
 * @author sakyoka
 * @date 2022年9月2日 下午5:27:12
 */
@Component
@Log4j
public class WebSocketEmptyLogInterceptor extends ChannelInterceptorAdapter{

    @Override
    public Message<?> preSend(Message<?> message, MessageChannel channel) {
    	final StompHeaderAccessor accessor = 
    			MessageHeaderAccessor.getAccessor(message, StompHeaderAccessor.class);
    	//连接
    	if (StompCommand.CONNECT.equals(accessor.getCommand())) {
        	String token = accessor.getFirstNativeHeader("token");
    		if (StringUtils.isBlank(token)){
    			log.info("token is null");
    			throw new RuntimeException("token is null");
    		}
    		
    		//判断token有效性
    		boolean tokenValid = JwtTokenUtils.tokenValid(token);
    		if (!tokenValid){
    			log.info("invalid token");
    			throw new RuntimeException("invalid token");
    		}
    	}
    	return message;
    }
}

在第一次连接时候，从头部信息获取token值，这里是从header获取，对应前端需要传到header。

注册WebSocketEmptyLogInterceptor拦截器，在configureClientInboundChannel的setInterceptors添加

package com.sakyoka.test.systemconfig.socket;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.messaging.simp.config.ChannelRegistration;
import org.springframework.messaging.simp.config.MessageBrokerRegistry;
import org.springframework.web.socket.config.annotation.AbstractWebSocketMessageBrokerConfigurer;
import org.springframework.web.socket.config.annotation.EnableWebSocket;
import org.springframework.web.socket.config.annotation.EnableWebSocketMessageBroker;
import org.springframework.web.socket.config.annotation.StompEndpointRegistry;
import org.springframework.web.socket.config.annotation.WebSocketConfigurer;
import org.springframework.web.socket.config.annotation.WebSocketHandlerRegistry;
import org.springframework.web.socket.server.standard.ServerEndpointExporter;

import com.sakyoka.test.systemconfig.interceptor.WebSocketEmptyLogInterceptor;
import com.sakyoka.test.systemconfig.interceptor.WebSocketReadLogInterceptor;
import com.sakyoka.test.webscoketlog.websocket.TokenWebSocketHandler;

/**
 * 
 * 描述：开启WebSocket、注册ServerEndpointExporter实例、开启STOMP协议来传输基于代理
 * @author sakyoka
 * @date 2022年8月14日 2022
 */
@Configuration
@EnableWebSocket
@EnableWebSocketMessageBroker
public class WebSocketConfig extends AbstractWebSocketMessageBrokerConfigurer implements WebSocketConfigurer{

	@Autowired
	WebSocketReadLogInterceptor webSocketReadLogInterceptor;
	
	@Autowired
	WebSocketEmptyLogInterceptor webSocketEmptyLogInterceptor;
	
	@Autowired
	TokenWebSocketHandler tokenWebSocketHandler;
	
    @Bean
    public ServerEndpointExporter serverEndpointExporter() {
        return new ServerEndpointExporter();
    }
    
	@Override
	public void registerStompEndpoints(StompEndpointRegistry registry) {
		//添加一个stomp协议的endpoint
		registry.addEndpoint("/server").withSockJS();
	}
	
	@Override
	public void configureMessageBroker(MessageBrokerRegistry registry) {
		//添加一个topic代理节点
		registry.enableSimpleBroker("/topic");
	}
	
	@Override
	public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) {
		
		// /ws/websocket/log 路径就是前端要访问的路径 类似@ServerEndpoint("/websocket/log")
		//添加处理器、添加拦截地址、添加拦截器
		registry.addHandler(tokenWebSocketHandler, "/ws/websocket/log")
		        .setAllowedOrigins("*")
		        .addInterceptors(webSocketReadLogInterceptor);
		
		/* use configureClientInboundChannel interceptors
		 * 放弃addHandler方式， 目前测试这种使广播订阅地址失效 
		*/
//		registry.addHandler(new TextSocketHandler(), "/server/**")
//				.addInterceptors(webSocketInterceptor)
//				.setAllowedOrigins("*")  
//		        .withSockJS();
	}
	
	@Override
	public void configureClientInboundChannel(ChannelRegistration registration) {
		//添加路由拦截，判断请求头是否带上token、token是否有效
		registration.setInterceptors(webSocketEmptyLogInterceptor);
	}
}

二、页面添加header

页面代码

<%@ page contentType="text/html; charset=UTF-8" %>
<!DOCTYPE html>
<html>
<head> 
    <title>jarLog</title>
	<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
	<meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1" />
	<meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1, user-scalable=no">
	<meta name="renderer" content="webkit">
    <jsp:include page="/WEB-INF/views/common/commonstatic.jsp" flush="true" />
    <!-- socketjs插件 -->
    <script type="text/javascript" src="${root}/components/socketjs/sockjs.js"></script>
    <script type="text/javascript" src="${root}/components/socketjs/stomp.js"></script>
    <!-- jquery菜单 -->
    <link rel="stylesheet" type="text/css" href="${root}/components/jquery/jquery.contextMenu.css"/>
    <script type="text/javascript" src="${root}/components/jquery/jquery.contextMenu.js"></script>
</head>
<body>
<div style="background-color:black;width:99%; height:500px; padding: 10px" id="console-parent">
    <div id="console" style="width:99%; height:95%; color:white;overflow-y: auto; overflow-x:hidden;"></div>
</div>
</body>
<script type="text/javascript" src="${root}/js/console.js"></script>
<script type="text/javascript" src="${root}/js/console-websocket.js"></script>
<script type="text/javascript" src="${root}/js/console-websocket-stomp.js"></script>
<script type="text/javascript">
//已在登录时候设置到缓存里面
var token = localStorage.getItem("token");
//var port = window.location.port;//如果经过代理？这个经过网关是网关的端口
//var port = "${pageContext.request.serverPort}";//这个才是后端端口
var jarWebSocket;
var jarConsole;
//jarId根据实际定义传过来，现在只有本系统的日志打印可以定义为system，其它jar的可以定义一个uuid关联标识
var jarId = "system";
//@ServerEndpoint("/log")
var wsurl = 'ws://'+ ip +':'+ port + root +'/ws/websocket/log?jarId=' + jarId + "&token=" token;
//registry.addEndpoint("/server").withSockJS();
var serverurl = 'http://'+ ip +':'+ port + root + '/server';
$(function(){
	//添加console-parent内容变化,调整滚动条位置，自动滚动最下面
	$("#console").bind("DOMNodeInserted",function(e){
	 	var height = $(this).prop("scrollHeight");
	 	$(this).animate({scrollTop: height}, 10);		
	});
	
	registerConsoleLogSocket();
	
	registerEmptyLogSocket();
	
	addRightClickListener();
});

/**
 * 注册控制台打印的socket事件
 */
function registerConsoleLogSocket(){
	jarConsole = new JarConsole();
	jarConsole.load('console');
    jarWebSocket= new JarWebSocket({
		url: wsurl,
		//获取后台返回信息
		onmessage: function(event){
			jarConsole.fill(event.data);
		}
	
	}).addEventListener();
}

/**
 * 注册清空日志的socket事件,采用消息订阅形式
 */
function registerEmptyLogSocket(){
	new StompSocketDefine({
		serverUrl: serverurl,
		//这里添加token
		headers: {token: token},
		subscribes: [{
			subscribeUrl: '/topic/emptylog',
			onmessage: function(res){
				//后端通知需要重新连接
				if (res.body == jarId && jarWebSocket.isConnect()){
					jarWebSocket.close();
					jarWebSocket.reset().reconnect();	
				}
			}
		}]
	}).connect();
}

/**
 * 添加右键菜单
 */
function addRightClickListener(){
	var items = {
	         "clear": {
	        	 name: "清空控制台信息", 
	        	 callback: function(){
	        		 jarConsole.clear();
	          }},
	         'emptyLog': {
	        	 name: "清空日志文件内容",
	        	 callback: function(){
	        		 var url = root + '/log/emptylog';
	        		 $.get(url, {jarId: jarId}, function(res){
	        			 console.log("emptylog result >>> " + res);
	        		 });
	        	 }
	         }
    };
	
	//右键菜单
    $.contextMenu({
        selector: '#console', 
        events:{preShow: function(){}},
        items: items
    });	
}
</script>
</html>

在registerEmptyLogSocket的订阅方法参数上添加headers,追加token值。

对应改造console-websocket-stomp.js，添加headers传值

/**
 * add by sakyoka 2022-08-26
 * stomp协议的scoket
 * 
 */
var StompSocketDefine = function(config){
	
	/**配置数据对象 */
	config = config || {};
	/**server 地址*/
	var serverUrl = config.serverUrl;
	/**订阅信息集合*/
	var subscribes = config.subscribes || [];
	/**创建socket*/
	var socket = new SockJS(serverUrl);
	/**使用stomp协议*/
	var stompClient = Stomp.over(socket);
	/**是否自动重连 */
	var autoConnect = config.autoConnect || true;
	/**判断是否主动关闭*/
	var driving = false; 
	/** 尝试重新连接次数*/
	var defaultFailTryConnTimes = config.failTryConnTimes || 5;
	/**尝试累加次数 */
	var tryConnTimes = 0;
	/**是否连接中 */
	var isConnect = false;
	var _this = this;
	/** headers对象*/
	var headers = config.headers || {};
	
	/**
	 * 恢复初始状态值
	 */
	this.reset = function(){
		autoConnect = config.autoConnect || true;
		driving = false; 
		defaultFailTryConnTimes = config.failTryConnTimes || 5;
		tryConnTimes = 0;
		isConnect = false;
	}
	
	/**
	 * 获取client
	 */
	this.getStompClient = function(){
		return stompClient;	
	}
	
	/**
	 * 断开连接
	 */
	this.disconnect = function(){
		driving = true;
		if (stompClient != undefined){
			stompClient.disconnect();
		}
		return this;
	}
	
	/**
	 * 连接
	 */
	this.connect = function(){
		
		/**
		 * 链接服务
		 */
		stompClient.connect(headers, function(frame){
			isConnect = true;
			driving = false;
			tryConnTimes = 0;
			console.log("stomp socket link state: "+ frame);
			/**
			 * 遍历订阅地址
			 */
			for (var i in subscribes){
				var subscribeObject = subscribes[i];
				var subscribeUrl = subscribeObject.subscribeUrl;
				var onmessage = subscribeObject.onmessage;
				stompClient.subscribe(subscribeUrl, function(res){
					if (onmessage){
						onmessage(res);
					}
				});
			}
			
		}, function(){	
			isConnect = false;
			console.log('stomp socket link error');
			if (isConnect === false 
			         && autoConnect === true 
			         && driving === false){
				if (defaultFailTryConnTimes > tryConnTimes){
					_this.tryToConnect();
				}
			}
		});	
		
		return this;
	}
	
	/**
	 * 尝试连接
	 */
	this.tryToConnect = function(){
		console.log('stomp socket try to connect...');
		socket = new SockJS(serverUrl);
		stompClient = Stomp.over(socket);
	    var _tryToConnect = function (){
		
			tryConnTimes += 1;
			if (defaultFailTryConnTimes < tryConnTimes){
				console.log('stomp socket try to connect times is more than max times:' + tryConnTimes);
				return ;
			}
			
			if (isConnect === true){
				return ;
			}
			
			_this.connect();
			
			setTimeout(function(){
				_tryToConnect();
		    }, 3000);
		}
		
		_tryToConnect();
	}
	
	/**
	 * 刷新页面前把连接关掉
	 */
	window.onbeforeunload = function(){
		
		driving = true;
		
		if (stompClient != undefined){
			stompClient.disconnect();
		}
	}
}

ok，测试

三、测试

带token,可以发现有传token,连接正常

 不带token，发现有异常信息，连接失败

 ok，拦截成功了。

附件

​​​​​​​springboot+websocket消息广播接口拦截-Java文档类资源-CSDN下载

拓展

springboot集成websocket 实时输出日志到浏览器(一)_sakyoka的博客-CSDN博客_websocket实时显示日志

springboot集成websocket 清空日志后消息广播通知前端重新连接（二）_sakyoka的博客-CSDN博客

springboot 集成JWT 登录验证_sakyoka的博客-CSDN博客

日常记录：springboot 给websocket 添加拦截、认证（一）_sakyoka的博客-CSDN博客

sakyoka
关注
  • 4
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
springboot-websocket:SpringBoot整合WebSocket
05-26
springboot-websocket SpringBoot整合WebSocket
X-IM:springboot,websocket,Protobuf，LayIM 等构建的实时通讯项目
05-02
X-IM springBoot2,websocket,Protobuf,LayIM,thymeleaf 等构建的即时通讯项目，为开发者快速打造自己的即时通讯！！！ 开发模块 单聊，群聊 LayIm实时通讯 开发这可以先通简单的单聊开始，配合doc目录下的X-IM及时通信项目开发文档-version1.0.docx 快速了解X-IM的项目的数据流程。熟悉整个流程后，读者可以根据自己的业务需求快速完成自己的实时通信! 技术栈 springBoot2.0.3 netty4.0 websocket mybatis thymeleaf 项目截图 1 首页（index.html） 2 单聊页面（chat.html） 在chrome和360流量器中分别打开 注意同一个流量器打开算是一个用户，因为单聊页面使用session来识别用户的，所以同一个流量器里面 的多个单聊页面会共享一个session，但是能
JWT实现websocket的token登录拦截认证
weixin_58775072的博客
12-16 1489
关于websocket的请求必须登录，实现websocket需要登录后才可使用，不登录不能建立连接。后台spring security配置添加websocket的请求可以匿名访问，关于websocket的请求不要认证就可以随意访问，去除匿名访问后，前端在与websocket建立链接无法在请求头里直接加入Authorization token信息，任何关于websocket的请求都无法通过token认证。
【Spring实战项目】SpringBoot3整合WebSocket+拦截器实现登录验证！从原理到实战
最新发布
终于等到你啦~欢迎来到我的知识空间 这里是苏泽的成神之路
04-03 2004
WebSocket是基于TCP协议的一种网络协议，它实现了浏览器与服务器全双工通信，支持客户端和服务端之间相互发送信息。在有WebSocket之前，如果服务端数据发生了改变，客户端想知道的话，只能采用定时轮询的方式去服务端获取，这种方式很大程度上增大了服务器端的压力，有了WebSocket之后，如果服务端数据发生改变，可以立即通知客户端，客户端就不用轮询去换取，降低了服务器的压力。目前主流的浏览器都已经支持WebSocket协议了。
springboot-websocket:基于springboot的websocket示例demo
05-10
springboot-websocket 基于springboot的websocket示例demo
springboot + jwt + websocket + 拦截
09-02
springboot + jwt + websocket + 拦截
SpringBoot对WebSocket添加拦截器——自定义注解
weixin_52707625的博客
06-20 1259
对WebSocket添加拦截器，并自定义注解
Spring Boot——AbstractWebSocketMessageBrokerConfigurer已过时解决方案
无限迭代中......
04-12 5122
问题描述 Spring Boot2.0及以上版本，编译器显示AbstractWebSocketMessageBrokerConfigurer已过时。 官方文档 https://docs.spring.io/spring/docs/5.1.3.RELEASE/spring-framework-reference/web.html#websocket-server 解决方案 实现WebSo...
springboot集成webSocket实现网络实时通讯
static_coder的博客
08-04 3309
1、前言 在很多业务场景中，对实时数据要求比较高，我们就不能采用轮训拉取的方式来获取数据了。就可以采用websocket的长链接的形式，实时有服务端或者客户端推送数据，已达到数据的实时展示。 2、websocket简介 SpringBoot官方推荐的基于STOMP实现，STOMP：即Simple Text Orientated Messaging Protocol，它是一个简单的文本消息传输协议，属于 WebSocket 的子协议， 提供了一个可互操作的连接格式，允许STOMP客户端与任意...
springboot整合webSocket：鉴权，心跳检测，wss请求，nginx配置、集群部署
qq_35683545的博客
07-07 5182
从nginx配置看，进行了负载均衡，服务进行了集群部署，项目部署在多台机器上，如此，当一个客户端用户和一台机器建立了链接，客户端自然是不会再去和其他机器建立连接，同时一般建立连接成功时，还会断开旧的连接，这样就不能和新的机器建立连接。其中要监听listen 80端口，尤其注意的是要注意这下面2个配置必须加上，否则建立连接成功立刻就会断掉。注意，使用wss调用需要在nginx配置ssl证书，否则部署到服务器是无法建立websocket连接的。收到客户端发送到服务器发给接收者的消息时，
Spring boot3简单实现websocket（拦截器，跨域，服务端发送）
lingxiaoNo1的博客
04-11 3033
/
springboot + websocket 消息广播接口拦截
09-02
springboot + websocket 消息广播接口拦截
Spring WebSocket实现实时通信，构建高可靠的实时交互系统
BXA
05-15 2013
Spring WebSocket是基于WebSocket协议的一个开源框架，它使得开发人员可以更加方便地建立实时通信机制，以推送消息和数据并实时更新通信系统中的状态。Spring WebSocket被广泛应用于社交网站、电子商务、在线游戏等WEB应用程序中，以实现实时通信和即时响应。Spring WebSocket的一个显著优势是它提供了很好的可扩展性，通过底层的WebSocket协议，开发人员可以轻松地在服务器与客户端之间构建一个实时通信的渠道，同时实现跨平台和跨应用程序的通信。
WebSocket深入浅出
Java编程基础
03-23 319
1、websocket简介 简介： websocket介绍、使用场景分享、学习课程需要什么基础 笔记: websocket介绍： WebSocket协议是基于TCP的一种新的网络协议。它实现了浏览器与服务器全双工(full-duplex)通信——允许服务器主动发送信息给客户端 websocket使用场景分享 如弹幕，网页聊天系统，实时监控，股票行情推送等 学习课程需要什么基础: ja...
EIP——Spring Integration4.3使用篇
xiayutai1的博客
11-23 8331
1前言 1-1兼容Java版本 1-2兼容 Spring 框架的版本 1-3代码约定 1-4目标和原则 2主要组件 2-1Message 消息 2-2Message Channel 消息通道 2-3 Message Endpoint 消息终端 3消息端点的分类 3-1 Transformer 转换器 3-2 Filter 过滤器 3-3Router 路由 3-4 Splitter分解器 3-5
WebSocket简介及与SpringBoot框架的集成
qgnczmnmn的博客
03-17 963
文章目录1. 概述2. WebSocket的诞生的背景、运行机制和抓包分析2.1. Websocket诞生的背景2.2. WebSocket 运行机制2.3. WebSocket抓包分析3. WebSocket 的应用场景、服务端和浏览器的版本要求3.1. 使用websocket的场景3.2. 服务端和浏览器的版本要求4. Spring 内嵌的简单消息代理 和 消息流程图4.1. Simple Broker4.2. 消息流程图5. 在Spring boot中集成websocket，并介绍stomp、sock
websocket 频道拦截器 介绍和使用
小哇
03-26 2217
项目的完整地址https://blog.csdn.net/qq_41712271/article/details/115252151?spm=1001.2014.3001.5501 本项目注释代码不多，更详细的注释，可看些项目，以下只列出核心代码https://blog.csdn.net/qq_41712271/article/details/115217344?spm=1001.2014.3001.5502 1 先创建 http握手 拦截器 HttpHandShakeIntecepter，因为一.
Spring Boot 拦截器
菜鸡的博客
05-16 1566
Spring Boot 拦截器是 AOP 的一种实现，专门拦截对控制层的请求，主要应用于判断用户权限，拦截webSocket请求。SpringBoot中的拦截器实现和spring mvc中是一样的，它的大致流程是，先自己定义一个拦截器类，并将这个类实现一个类，或者是继承，都可以实现拦截器的定义。然后将自己定义的拦截器注入到适配器中，也有两种方式，一种是实现接口，一种是继承。
SpringBoot-Websocket
文天大人
07-10 1228
怀念二抱三抱
springboot整合websocket，websocket的拦截器和消息处理器及websocket实现类怎么写
12-11
以下是在Spring Boot项目中整合WebSocket的步骤，包括拦截器、消息处理器和WebSocket实现类的编写： 1. 添加依赖 在pom.xml文件中添加以下依赖： ```xml <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-websocket</artifactId> </dependency> ``` 2. 编写WebSocket配置类 创建一个WebSocketConfig类，用于配置WebSocket相关的内容，包括注册WebSocket处理器、拦截器等。 ```java @Configuration @EnableWebSocket public class WebSocketConfig implements WebSocketConfigurer { @Autowired private MyWebSocketHandler myWebSocketHandler; @Autowired private MyHandshakeInterceptor myHandshakeInterceptor; @Override public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) { registry.addHandler(myWebSocketHandler, "/websocket") .addInterceptors(myHandshakeInterceptor); } } ``` 在这个配置类中，我们注册了一个WebSocket处理器和一个握手拦截器。WebSocket处理器用于处理WebSocket连接和消息，握手拦截器用于拦截WebSocket连接请求并进行一些处理。 3. 编写WebSocket处理器 创建一个WebSocket处理器类，用于处理WebSocket连接和消息。 ```java @Component public class MyWebSocketHandler extends TextWebSocketHandler { private static final Logger logger = LoggerFactory.getLogger(MyWebSocketHandler.class); private static final Map<String, WebSocketSession> sessions = new ConcurrentHashMap<>(); @Override public void afterConnectionEstablished(WebSocketSession session) throws Exception { logger.info("WebSocket连接建立成功：{}", session.getId()); sessions.put(session.getId(), session); } @Override protected void handleTextMessage(WebSocketSession session, TextMessage message) throws Exception { logger.info("收到消息：{}", message.getPayload()); // 处理消息 } @Override public void afterConnectionClosed(WebSocketSession session, CloseStatus status) throws Exception { logger.info("WebSocket连接关闭：{}，状态：{}", session.getId(), status); sessions.remove(session.getId()); } public static void sendMessage(String sessionId, String message) throws IOException { WebSocketSession session = sessions.get(sessionId); if (session != null && session.isOpen()) { session.sendMessage(new TextMessage(message)); } } } ``` 在这个处理器类中，我们重写了WebSocket处理器的三个方法：afterConnectionEstablished、handleTextMessage和afterConnectionClosed。afterConnectionEstablished方法在WebSocket连接建立成功后被调用，handleTextMessage方法用于处理收到的消息，afterConnectionClosed方法在WebSocket连接关闭后被调用。 4. 编写握手拦截器 创建一个握手拦截器类，用于拦截WebSocket连接请求并进行一些处理。 ```java @Component public class MyHandshakeInterceptor implements HandshakeInterceptor { private static final Logger logger = LoggerFactory.getLogger(MyHandshakeInterceptor.class); @Override public boolean beforeHandshake(ServerHttpRequest request, ServerHttpResponse response, WebSocketHandler wsHandler, Map<String, Object> attributes) throws Exception { logger.info("WebSocket握手拦截器：beforeHandshake"); // 进行一些处理 return true; } @Override public void afterHandshake(ServerHttpRequest request, ServerHttpResponse response, WebSocketHandler wsHandler, Exception exception) { logger.info("WebSocket握手拦截器：afterHandshake"); } } ``` 在这个握手拦截器类中，我们重写了握手拦截器的两个方法：beforeHandshake和afterHandshake。beforeHandshake方法在WebSocket连接请求到达服务器端时被调用，afterHandshake方法在WebSocket连接握手成功后被调用。 5. 编写WebSocket实现类 创建一个WebSocket实现类，用于实现WebSocket的具体业务逻辑。 ```java @Controller public class MyWebSocketController { @MessageMapping("/hello") @SendTo("/topic/greetings") public String greeting(String message) throws Exception { Thread.sleep(1000); // 模拟处理时间 return "Hello, " + message + "!"; } } ``` 在这个WebSocket实现类中，我们使用了@MessageMapping注解来指定处理消息的路径，使用@SendTo注解来指定返回消息的路径。 6. 测试WebSocket连接 在客户端中，可以使用JavaScript代码来测试WebSocket连接： ```javascript var socket = new WebSocket("ws://localhost:8080/websocket"); socket.onopen = function(event) { console.log("WebSocket连接已建立"); socket.send("Hello, WebSocket!"); }; socket.onmessage = function(event) { console.log("收到消息：" + event.data); }; socket.onclose = function(event) { console.log("WebSocket连接已关闭"); }; ``` 以上就是在Spring Boot项目中整合WebSocket的步骤，包括拦截器、消息处理器和WebSocket实现类的编写。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值