springboot中使用websocket

最新推荐文章于 2025-09-05 19:25:19 发布

weixin_34273046

最新推荐文章于 2025-09-05 19:25:19 发布

阅读量111

点赞数

CC 4.0 BY-SA版权

文章标签：网络 java 前端 ViewUI

原文链接：https://my.oschina.net/hnqingping1255/blog/1862711

本文介绍如何在SpringBoot项目中配置并使用WebSocket，包括引入依赖、编写消息处理器、配置WebSocket及拦截器等内容。

2019独角兽企业重金招聘Python工程师标准>>>

websocket在即时通信方面非常好用，性能也是很高的。在不用考虑兼容性的情况下，应该被大量使用的。

如果要在springboot中使用websocket，那是很简单了，因为前人已经帮我们做好了基础的工作，只要引入相关的jar和做一些配置就可以了。

首先引入包：

compile 'org.springframework.boot:spring-boot-starter-websocket'

再来看消息处理器

import java.util.concurrent.ConcurrentHashMap;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
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;

/**
 * 
 */
@Component
public class SpringWebSocketHandler extends TextWebSocketHandler {
	
	/**
	 * 用Map存储，key用userid
	 */
	private static final ConcurrentHashMap<String,WebSocketSession> users;
	
	private static final Logger logger = LoggerFactory.getLogger(SpringWebSocketHandler.class);
	
	static {
		users = new ConcurrentHashMap<String,WebSocketSession>();
	}

	public SpringWebSocketHandler() {
	}

	/**
	 * 连接成功时候，会触发页面上onopen方法
	 */
	public void afterConnectionEstablished(WebSocketSession session) throws Exception {
		String key=session.getAttributes().get("WEBSOCKET_USERNAME")+"";
		logger.info("WebSocket连接成功，username:{}",key);
		users.put(key,session);
		// 这块会实现自己业务，比如，当用户登录后，会把离线消息推送给用户
		// TextMessage returnMessage = new TextMessage("你将收到的离线");
		// session.sendMessage(returnMessage);
	}

	/**
	 * 关闭连接时触发
	 */
	public void afterConnectionClosed(WebSocketSession session, CloseStatus closeStatus) throws Exception {
		String username =  session.getAttributes().get("WEBSOCKET_USERNAME")+"";
		logger.info("用户{}已退出！",username);
		users.remove(username);
	}

	/**
	 * js调用websocket.send时候，会调用该方法
	 */
	@Override
	protected void handleTextMessage(WebSocketSession session, TextMessage message) throws Exception {
		super.handleTextMessage(session, message);
	}

	public void handleTransportError(WebSocketSession session, Throwable exception) throws Exception {
		if (session.isOpen()) {
			session.close();
		}
		logger.warn("连接异常，关闭通道");
		String username =  session.getAttributes().get("WEBSOCKET_USERNAME")+"";
		users.remove(username);
	}

	public boolean supportsPartialMessages() {
		return false;
	}

	/**
	 * 给某个用户发送消息
	 *
	 * @param userName
	 * @param message
	 */
	public void sendMessageToUser(String userName, TextMessage message) {
		WebSocketSession user=users.get(userName);
		if(user==null) {
			logger.error("用户{}不在线，推送失败",userName);
			return;
		}
		try {
			if (user.isOpen()) {
				user.sendMessage(message);
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	/**
	 * 给所有在线用户发送消息
	 *
	 * @param message
	 */
	public void sendMessageToUsers(TextMessage message) {
		for (WebSocketSession user : users.values()) {
			try {
				if (user.isOpen()) {
					user.sendMessage(message);
				}
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
	}

}

然后就是配置了，有两段

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.socket.server.standard.ServerEndpointExporter;

@Configuration
public class WebSocketConfig {

    @Bean
    public ServerEndpointExporter serverEndpointExporter() {
        return new ServerEndpointExporter();
    }
}

然后是配置webconfig

import java.util.HashMap;
import java.util.Map;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import org.springframework.web.context.request.async.TimeoutCallableProcessingInterceptor;
import org.springframework.web.servlet.config.annotation.AsyncSupportConfigurer;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.ViewControllerRegistry;
import org.springframework.web.servlet.config.annotation.ViewResolverRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;
import org.springframework.web.socket.config.annotation.EnableWebSocket;
import org.springframework.web.socket.config.annotation.WebSocketConfigurer;
import org.springframework.web.socket.config.annotation.WebSocketHandlerRegistry;
import org.springframework.web.socket.handler.TextWebSocketHandler;
import org.thymeleaf.spring4.view.ThymeleafViewResolver;


/**
 */
@Configuration
@EnableWebSocket
public class WebConfig extends WebMvcConfigurerAdapter implements WebSocketConfigurer{
	
   //其它方法略

    /**
     * websocket支持
     */
    @Override
    public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) {
		registry.addHandler(webSocketHandler(), "/websocket2/socketServer")
				.addInterceptors(new SpringWebSocketHandlerInterceptor());
		registry.addHandler(webSocketHandler(), "/sockjs2/socketServer")
				.addInterceptors(new SpringWebSocketHandlerInterceptor()).withSockJS();
	}
    

    /**
     * 异步web支持
     */
    @Override
    public void configureAsyncSupport(final AsyncSupportConfigurer configurer) {
        configurer.setDefaultTimeout(60 * 1000L);
        configurer.registerCallableInterceptors(timeoutInterceptor());
        configurer.setTaskExecutor(executor);
    }
    

	@Bean
	public TextWebSocketHandler webSocketHandler() {
		return new SpringWebSocketHandler();
	}
}

最后再配置一个身份识别的拦截器

import java.util.Map;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.http.server.ServerHttpRequest;
import org.springframework.http.server.ServerHttpResponse;
import org.springframework.http.server.ServletServerHttpRequest;
import org.springframework.web.socket.WebSocketHandler;
import org.springframework.web.socket.server.support.HttpSessionHandshakeInterceptor;


/**
 * WebSocket拦截器<br>
 * 给session中放入身份信息(employeeId/admin/token)，如果没有找到此人的登陆信息，则返回403
 */
public class SpringWebSocketHandlerInterceptor extends HttpSessionHandshakeInterceptor {
  
	private static final Logger logger=LoggerFactory.getLogger(SpringWebSocketHandlerInterceptor.class);
	
	@Override
    public boolean beforeHandshake(ServerHttpRequest request, ServerHttpResponse response, WebSocketHandler wsHandler,
            Map<String, Object> attributes) throws Exception {
        if (request instanceof ServletServerHttpRequest) {
            ServletServerHttpRequest servletRequest = (ServletServerHttpRequest) request;
            String adminToken=CookieUtil.getAdminTokenFromCookie(servletRequest.getServletRequest());
            logger.info("cookie请求{}",adminToken);
            attributes.put("WEBSOCKET_USERNAME",adminToken);
        }
        return super.beforeHandshake(request, response, wsHandler, attributes);
    }
    
    @Override
    public void afterHandshake(ServerHttpRequest request, ServerHttpResponse response, WebSocketHandler wsHandler,
            Exception ex) {
        super.afterHandshake(request, response, wsHandler, ex);
    }
}

至此，后台的配置就做完了。前端的代码，网上有很多，这里就不贴了，大家自己找找吧。

转载于:https://my.oschina.net/hnqingping1255/blog/1862711