SpringBoot webSocket
https://blog.csdn.net/u013565163/article/details/80659828
SpringBoot+websocket+定时任务
SpringBoot+websocket
概念
websocket:由于http协议时基于 请求-响应模型 服务端的每次响应都必须有客户端发起（浏览器）的请求。如果服务端想主动推送消息到客户端是很难满足的。
如果一定想使用http来做服务端主动推动，只能客户端不停的发起轮询请求，如果访问量很很大，这种模式会拖垮服务器。造成很大的通信开销和服务端流量压力。
使用websocket可以完成要求实时性的应用：股票的变动、天气、彩票、即时通讯、通知。
WebSocket 是web客户端和服务器之间新的通讯方式， 依然架构在HTTP协议之上。使用WebSocket连接， web应用程序可以执行实时的交互， 而不是以前的poll方式。
WebSocket是HTML5开始提供的一种在单个 TCP 连接上进行全双工通讯的协议，可以用来创建快速的更大规模的健壮的高性能实时的web应用程序。WebSocket通信协议于2011年被IETF定为标准RFC 6455，WebSocketAPI被W3C定为标准。
在WebSocket API中，浏览器和服务器只需要做一个握手的动作，然后，浏览器和服务器之间就形成了一条快速通道。两者之间就直接可以数据互相传送。
现在大概了解了websocket的概念和应用，现在我们来看看如何在springBoot中集成websocket。
配置类
创建一个配置类：
使用@Configuration注解 声明这个类为配置类。
使用@EnableWebSocket注解表明这是一个websocket配置类，我们会在这个类配置一些websocket的参数和地址。
我们的配置类实现WebSocketConfigurer接口。
重写registerWebSocketHandlers方法，
//配置指定地址：/demo的处理器，及通信允许的域名，这里使用*，表示匹配所有。
webSocketHandlerRegistry.addHandler(new WebSocketDemoHanlder(),"/demo").setAllowedOrigins("*");
/**
* @author xuelongjiang
*/
@Configuration
@EnableWebSocket
public class WebsocketConfig implements WebSocketConfigurer{
@Override
public void registerWebSocketHandlers(WebSocketHandlerRegistry webSocketHandlerRegistry) {
webSocketHandlerRegistry.addHandler(new WebSocketDemoHanlder(),"/demo").setAllowedOrigins("*");
}
}
处理器
这里我们主要绑定WebSocketSession和我们的推送目标。
如果是聊天室，则根据约定的规则，进行用户与用户，用户与聊天室的绑定。
如果是彩票，推送消息到所有的WebSocketSession。
package com.xuelongjiang.websocketdemo.websocket;
import com.alibaba.fastjson.JSONObject;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
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.util.Map;
import java.util.concurrent.ConcurrentHashMap;
/**
* @author xuelongjiang
*/
public class WebSocketDemoHanlder extends TextWebSocketHandler {
private Logger logger = LoggerFactory.getLogger(WebSocketDemoHanlder.class);
private static Map<String,WebSocketSession> userIdSessionMap = new ConcurrentHashMap();
private static Map<WebSocketSession,String> sessionUserIdMap = new ConcurrentHashMap<>();
@Override
protected void handleTextMessage(WebSocketSession session, TextMessage message) throws Exception {
String payload = message.getPayload();
logger.info("websocket请求参数payload:{}",payload);
JSONObject jsonObject = JSONObject.parseObject(payload);
String action = jsonObject.getString("action");
if("register".equals(action)){
logger.info("注册websocket连接");
String userId = jsonObject.getString("userId");
logger.info("userId:{}注册session:{}",userId,session.getId());
userIdSessionMap.put(userId,session);
sessionUserIdMap.put(session,userId);
}
}
//定时任务获取session
public static Map<String,WebSocketSession> getUserIdSessionMap(){
return userIdSessionMap;
}
@Override
public void afterConnectionEstablished(WebSocketSession session) throws Exception {
super.afterConnectionEstablished(session);
}
@Override
public void afterConnectionClosed(WebSocketSession session, CloseStatus status) throws Exception {
//连接关闭后移除
String userId = sessionUserIdMap.get(session);
userIdSessionMap.remove(userId);
logger.info("websocket session:{}关闭原因:{}",session,status);
}
}
到这里我们测试一下是否可以连接。
从上面可以看到我们已经和服务端建立了连接。
websocketSession：可以理解为http的一个会话。会话记录了这一次的通讯对象，我们可以使用seesion发送消息给客户端。
定时任务
在上面我们用一个线程安全的map,存储了userId和websocketSession的关系。现在我们用定时任务来发送消息给连接。
在springboot启动类增加注解@EnableScheduling
由于websocket和定时任务启动的时候会报错。的时候会报错。增加taskScheduler()方法。
@SpringBootApplication
@EnableScheduling
public class WebsocketdemoApplication {
public static void main(String[] args) {
SpringApplication.run(WebsocketdemoApplication.class, args);
}
/**
* 使用 websockt注解的时候，使用@EnableScheduling注解
* 启动的时候一直报错，增加这个bean 则报错解决。
* 报错信息： Unexpected use of scheduler.
*https://stackoverflow.com/questions/49343692/websocketconfigurer-and-scheduled-are-not-work-well-in-an-application
*
* @return
*/
@Bean
public TaskScheduler taskScheduler(){
ThreadPoolTaskScheduler taskScheduler = new ThreadPoolTaskScheduler();
taskScheduler.setPoolSize(10);
taskScheduler.initialize();
return taskScheduler;
}
}
定时任务
package com.xuelongjiang.websocketdemo.schedule;
import com.xuelongjiang.websocketdemo.websocket.WebSocketDemoHanlder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Service;
import org.springframework.web.socket.TextMessage;
import org.springframework.web.socket.WebSocketSession;
import java.util.Map;
/**
* 定时任务
* @author xuelongjiang
*/
@Service
public class ScheduleTask {
private Logger logger = LoggerFactory.getLogger(ScheduleTask.class);
@Scheduled(cron = "* * 0/1 * * ?")
public void sendMessage(){
String message = "你好";
Map<String,WebSocketSession> map = WebSocketDemoHanlder.getUserIdSessionMap();
WebSocketSession session = map.get("xuelongjiang");//这里用户ID的获取可以根据具体业务，这里为了更简单的演示。
if(session != null){
try {
session.sendMessage(new TextMessage(message));
}catch (Exception e){
logger.error("定时任务异常:{}",e);
}
}
}
}
websocket测试地址：http://www.blue-zero.com/WebSocket/
源码地址：https://github.com/longjiangxue/websocketDemo
---------------------
作者：我爱看明朝
来源：CSDN
原文：https://blog.csdn.net/u013565163/article/details/80659828
版权声明：本文为博主原创文章，转载请附上博文链接！
SpringMVC 使用websocket向前端实时推送信息
一、maven项目添加websocket依赖
在pom.xml中添加依赖
二、项目中添加websocket相关配置
1、创建一个WebSocket配置类（这里也可以用配置文件来实现其实），实现接口来配置Websocket请求的路径和拦截器
package com.example.websocket;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.stereotype.Component;
import org.springframework.web.socket.WebSocketHandler;
import org.springframework.web.socket.config.annotation.EnableWebSocket;
import org.springframework.web.socket.config.annotation.WebSocketConfigurer;
import org.springframework.web.socket.config.annotation.WebSocketHandlerRegistry;
@Configuration
@EnableWebSocket
public class WebSocketConfig implements WebSocketConfigurer {
@Override
public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) {
registry.addHandler(myHandler(), "/myHandler").addInterceptors(new WebSocketInterceptor()).setAllowedOrigins("*");
}
@Bean
public WebSocketHandler myHandler() {
return new MyHandler();
}
}
加个setAllowedOrigins(“*”)不然可能会报403的错误
3、创建拦截器，用来记录用户标识，便于后面向特定用户发送消息
package com.example.websocket;
import org.springframework.http.server.ServerHttpRequest;
import org.springframework.http.server.ServerHttpResponse;
import org.springframework.http.server.ServletServerHttpRequest;
import org.springframework.stereotype.Component;
import org.springframework.web.socket.WebSocketHandler;
import org.springframework.web.socket.server.HandshakeInterceptor;
import javax.servlet.http.HttpSession;
import java.util.Map;
@Component
public class WebSocketInterceptor implements HandshakeInterceptor {
@Override
public boolean beforeHandshake(ServerHttpRequest request, ServerHttpResponse response, WebSocketHandler handler, Map<String, Object> map) throws Exception {
if (request instanceof ServletServerHttpRequest) {
ServletServerHttpRequest serverHttpRequest = (ServletServerHttpRequest) request;
HttpSession session = serverHttpRequest.getServletRequest().getSession();
if (session != null) {
map.put("username", session.getAttribute("username"));
}
}
return true;
}
@Override
public void afterHandshake(ServerHttpRequest serverHttpRequest, ServerHttpResponse serverHttpResponse, WebSocketHandler webSocketHandler, Exception e) {
}
}
4、实现Websocket建立连接、发送消息、断开连接等时候的处理类。
package com.example.websocket;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Service;
import org.springframework.web.socket.CloseStatus;
import org.springframework.web.socket.TextMessage;
import org.springframework.web.socket.WebSocketMessage;
import org.springframework.web.socket.WebSocketSession;
import org.springframework.web.socket.handler.TextWebSocketHandler;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
@Service
public class MyHandler extends TextWebSocketHandler {
//在线用户列表
private static final Map<String, WebSocketSession> users;
//用户标识
private static final String CLIENT_ID = "username";
static {
users = new HashMap<String, WebSocketSession>();
}
@Override
public void afterConnectionEstablished(WebSocketSession session) throws Exception {
System.out.println("成功建立连接");
String username= getClientId(session);
System.out.println("5555"+username);
if (username != null) {
users.put(username, session);
session.sendMessage(new TextMessage("成功建立socket连接"));
System.out.println(username);
System.out.println(session);
}
}
@Override
public void handleTextMessage(WebSocketSession session, TextMessage message) {
// ...
System.out.println(message.getPayload());
WebSocketMessage message1 = new TextMessage("server:"+message);
try {
session.sendMessage(message1);
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* 发送信息给指定用户
* @param clientId
* @param message
* @return
*/
public boolean sendMessageToUser(String clientId, TextMessage message) {
if (users.get(clientId) == null) {
System.out.println("1313313");
return false;
}
WebSocketSession session = users.get(clientId);
System.out.println("sendMessage:" + session);
if (!session.isOpen()) {
System.out.println("7657");
return false;
}
try {
session.sendMessage(message);
} catch (IOException e) {
System.out.println(e);
return false;
}
return true;
}
/**
* 广播信息
* @param message
* @return
*/
public boolean sendMessageToAllUsers(TextMessage message) {
boolean allSendSuccess = true;
Set<String> clientIds = users.keySet();
WebSocketSession session = null;
for (String clientId : clientIds) {
try {
session = users.get(clientId);
if (session.isOpen()) {
session.sendMessage(message);
}
} catch (IOException e) {
e.printStackTrace();
allSendSuccess = false;
}
}
return allSendSuccess;
}
@Override
public void handleTransportError(WebSocketSession session, Throwable exception) throws Exception {
if (session.isOpen()) {
session.close();
}
System.out.println("连接出错");
users.remove(getClientId(session));
}
@Override
public void afterConnectionClosed(WebSocketSession session, CloseStatus status) throws Exception {
System.out.println("连接已关闭：" + status);
users.remove(getClientId(session));
}
@Override
public boolean supportsPartialMessages() {
return false;
}
/**
* 获取用户标识
* @param session
* @return
*/
private String getClientId(WebSocketSession session) {
try {
String clientId = (String) session.getAttributes().get(CLIENT_ID);
return clientId;
} catch (Exception e) {
return null;
}
}
}
5、controller
@Controller
public class SocketController {
@Autowired
MyHandler handler;
@RequestMapping("/login/{username}")
public @ResponseBody String login(HttpSession session, @PathVariable("username") String username) {
System.out.println("登录接口,username="+usename);
session.setAttribute("username", username);
System.out.println(session.getAttribute("username"));
return "成功";
}
@RequestMapping("/message")
public @ResponseBody String sendMessage() {
boolean flag = handler.sendMessageToAllUser(4, new TextMessage("你好"));
System.out.println(flag);
return "发送";
}
}
6、前端
//建立websocket
var ws = new WebSocket("ws://localhost:8080/你的项目名/myHandler")
---------------------
作者：HOMERUNIT
来源：CSDN
原文：https://blog.csdn.net/HOMERUNIT/article/details/80861096
版权声明：本文为博主原创文章，转载请附上博文链接！
