springboot2.0+websocket集成【群发消息+单
2018-09-13 本文已影响300人
兔龍
现在用springboot集成websocket变的很方便快捷了，下面简单写个小demo，实现群发消息，单对单的聊天。主要是功能，界面将就一下。
参考：
http://tech.lede.com/2017/03/08/qa/websocket+spring/
https://blog.csdn.net/mr_zhuqiang/article/details/46618197
开发工具是IDEA，2018.2.3
新建项目
默认创建springboot的方式
填写项目简介
用到的依赖包
依照上图的流程，新建一个简单的工程。
然后在pom文件中添加一些额外用到的插件。
完整的pom.xml文件：
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.example</groupId>
<artifactId>websocketdemo1</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>war</packaging>
<name>websocketdemo1</name>
<description>springboot2.0+websocket的集成,实现群发消息+单对单消息推送.</description>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.0.5.RELEASE</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
<java.version>1.8</java.version>
</properties>
<dependencies>
<!-- json工具 -->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>LATEST</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-freemarker</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-websocket</artifactId>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<optional>true</optional>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-tomcat</artifactId>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
<configuration>
<!-- 包含本地的 jar -->
<includeSystemScope>true</includeSystemScope>
<!--创建成系统服务在后台运行-->
<executable>true</executable>
</configuration>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-surefire-plugin</artifactId>
<configuration>
<!--打包的时候, 略过test, 不运行-->
<skipTests>true</skipTests>
</configuration>
</plugin>
</plugins>
</build>
</project>
1. 新建MyHandshake实现HandshakeInterceptor接口
从名字大致上就可以猜测出这个接口的含义，handshake，Interceptor。
这里主要是实现2个方法。
//握手之前干啥，常用来注册用户信息，绑定 WebSocketSession
beforeHandshake
//握手之后干啥
afterHandshake
完整的实现
package com.example.websocketdemo1.websocket;
import lombok.extern.slf4j.Slf4j;
import org.springframework.http.server.ServerHttpRequest;
import org.springframework.http.server.ServerHttpResponse;
import org.springframework.http.server.ServletServerHttpRequest;
import org.springframework.stereotype.Service;
import org.springframework.web.socket.WebSocketHandler;
import org.springframework.web.socket.server.HandshakeInterceptor;
import javax.servlet.http.HttpServletRequest;
import java.util.Map;
/**
* @author linyun
* @date 2018/9/13 下午3:12
*/
@Slf4j
@Service
public class MyHandshake implements HandshakeInterceptor {
@Override
public boolean beforeHandshake(ServerHttpRequest request, ServerHttpResponse response, WebSocketHandler webSocketHandler, Map<String, Object> attributes) throws Exception {
if (request instanceof ServletServerHttpRequest) {
HttpServletRequest servletRequest = ((ServletServerHttpRequest) request).getServletRequest();
// 从session中获取到当前登录的用户信息. 作为socket的账号信息. session的的WEBSOCKET_USERNAME信息,在用户打开页面的时候设置.
String userName = (String) servletRequest.getSession().getAttribute("WEBSOCKET_USERNAME");
attributes.put("WEBSOCKET_USERNAME", userName);
}
return true;
}
@Override
public void afterHandshake(ServerHttpRequest serverHttpRequest, ServerHttpResponse serverHttpResponse, WebSocketHandler webSocketHandler, Exception e) {
}
}
2. 新建MyHandler实现WebSocketHandler接口
主要是负责消息的分发，用户统计等。
package com.example.websocketdemo1.websocket;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.web.socket.*;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
/**
* @author linyun
* @date 2018/9/13 下午3:26
*/
@Slf4j
@Service
public class MyHandler implements WebSocketHandler {
/**
* 为了保存在线用户信息，在方法中新建一个list存储一下【实际项目依据复杂度，可以存储到数据库或者缓存】
*/
private final static List<WebSocketSession> SESSIONS = Collections.synchronizedList(new ArrayList<>());
@Override
public void afterConnectionEstablished(WebSocketSession session) throws Exception {
log.info("链接成功......");
SESSIONS.add(session);
String userName = (String) session.getAttributes().get("WEBSOCKET_USERNAME");
if (userName != null) {
JSONObject obj = new JSONObject();
// 统计一下当前登录系统的用户有多少个
obj.put("count", SESSIONS.size());
users(obj);
session.sendMessage(new TextMessage(obj.toJSONString()));
}
}
@Override
public void handleMessage(WebSocketSession session, WebSocketMessage<?> message) throws Exception {
log.info("处理要发送的消息");
JSONObject msg = JSON.parseObject(message.getPayload().toString());
JSONObject obj = new JSONObject();
if (msg.getInteger("type") == 1) {
//给所有人
obj.put("msg", msg.getString("msg"));
sendMessageToUsers(new TextMessage(obj.toJSONString()));
} else {
//给个人
String to = msg.getString("to");
obj.put("msg", msg.getString("msg"));
sendMessageToUser(to, new TextMessage(obj.toJSONString()));
}
}
@Override
public void handleTransportError(WebSocketSession session, Throwable exception) throws Exception {
if (session.isOpen()) {
session.close();
}
log.info("链接出错，关闭链接......");
SESSIONS.remove(session);
}
@Override
public void afterConnectionClosed(WebSocketSession session, CloseStatus closeStatus) throws Exception {
log.info("链接关闭......" + closeStatus.toString());
SESSIONS.remove(session);
}
@Override
public boolean supportsPartialMessages() {
return false;
}
/**
* 给所有在线用户发送消息
*
* @param message
*/
public void sendMessageToUsers(TextMessage message) {
for (WebSocketSession user : SESSIONS) {
try {
if (user.isOpen()) {
user.sendMessage(message);
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
/**
* 给某个用户发送消息
*
* @param userName
* @param message
*/
public void sendMessageToUser(String userName, TextMessage message) {
for (WebSocketSession user : SESSIONS) {
if (user.getAttributes().get("WEBSOCKET_USERNAME").equals(userName)) {
try {
if (user.isOpen()) {
user.sendMessage(message);
}
} catch (IOException e) {
e.printStackTrace();
}
break;
}
}
}
/**
* 将系统中的用户传送到前端
*
* @param obj
*/
private void users(JSONObject obj) {
List<String> userNames = new ArrayList<>();
for (WebSocketSession webSocketSession : SESSIONS) {
userNames.add((String) webSocketSession.getAttributes().get("WEBSOCKET_USERNAME"));
}
obj.put("users", userNames);
}
}
3. 实现WebSocketConfigurer接口
主要的配置文件，很简单
package com.example.websocketdemo1.websocket;
import lombok.extern.slf4j.Slf4j;
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 linyun
* @date 2018/9/13 下午3:41
*/
@Slf4j
@Configuration
@EnableWebSocket
public class WebSocketConfig implements WebSocketConfigurer {
@Autowired
private MyHandshake handshake;
@Autowired
private MyHandler handler;
/**
* 实现 WebSocketConfigurer 接口，重写 registerWebSocketHandlers 方法，这是一个核心实现方法，配置 websocket 入口，允许访问的域、注册 Handler、SockJs 支持和拦截器。
* <p>
* registry.addHandler()注册和路由的功能，当客户端发起 websocket 连接，把 /path 交给对应的 handler 处理，而不实现具体的业务逻辑，可以理解为收集和任务分发中心。
* <p>
* addInterceptors，顾名思义就是为 handler 添加拦截器，可以在调用 handler 前后加入我们自己的逻辑代码。
* <p>
* setAllowedOrigins(String[] domains),允许指定的域名或 IP (含端口号)建立长连接，如果只允许自家域名访问，这里轻松设置。如果不限时使用”*”号，如果指定了域名，则必须要以 http 或 https 开头。
*
* @param registry
*/
@Override
public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) {
//部分 支持websocket 的访问链接,允许跨域
registry.addHandler(handler, "/echo").addInterceptors(handshake).setAllowedOrigins("*");
//部分 不支持websocket的访问链接,允许跨域
registry.addHandler(handler, "/sockjs/echo").addInterceptors(handshake).setAllowedOrigins("*").withSockJS();
}
}
4. 页面模拟聊天
模拟用户登录，存储用户信息到session中。
package com.example.websocketdemo1;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import javax.servlet.http.HttpServletRequest;
/**
* @author linyun
* @date 2018/9/13 下午3:45
*/
@Controller
@RequestMapping("/socket")
public class WebSocketController {
/**
* 第一个用户
*
* @param request
* @return
*/
@RequestMapping("/chat1")
public String chat1(HttpServletRequest request) {
// 假设用户tom登录,存储到session中
request.getSession().setAttribute("WEBSOCKET_USERNAME", "tom");
return "chat1";
}
/**
* 第二个用户登录
*
* @param request
* @return
*/
@RequestMapping("/chat2")
public String chat2(HttpServletRequest request) {
// 假设用户jerry登录,存储到session中
request.getSession().setAttribute("WEBSOCKET_USERNAME", "jerry");
return "chat2";
}
/**
* 第三个用户登录
*
* @param request
* @return
*/
@RequestMapping("/chat3")
public String chat3(HttpServletRequest request) {
// 假设用户jack登录,存储到session中
request.getSession().setAttribute("WEBSOCKET_USERNAME", "jack");
return "chat3";
}
}
页面都是一样的代码，分别新建3份，chat1.html，chat2.html，chat3.html。
<!DOCTYPE html>
<html lang="en">
<head>
<title>测试websocket</title>
<meta charset="UTF-8">
<meta name="viewport"
content="width=device-width, initial-scale=1, minimum-scale=1, maximum-scale=1, user-scalable=no">
<meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1"/>
<link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/twitter-bootstrap/4.1.2/css/bootstrap.min.css">
<link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/jquery-toast-plugin/1.3.2/jquery.toast.min.css">
</head>
<body>
<div class="container">
<div class="input-group mb-3">
<div class="input-group-prepend">
<label class="input-group-text" for="inputGroupSelect01">用户</label>
</div>
<select class="custom-select" id="inputGroupSelect01">
<option selected>选择一个...</option>
</select>
</div>
<div class="input-group mb-3">
<input type="text" class="form-control">
<div class="input-group-append">
<span class="input-group-text" id="btn1">发送给所有人</span>
</div>
</div>
<div class="input-group mb-3">
<input type="text" class="form-control">
<div class="input-group-append">
<span class="input-group-text" id="btn2">发送给单人</span>
</div>
</div>
</div>
<script src="https://cdnjs.cloudflare.com/ajax/libs/jquery/1.12.4/jquery.min.js" type="text/javascript"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/twitter-bootstrap/4.1.2/js/bootstrap.min.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/jquery-toast-plugin/1.3.2/jquery.toast.min.js"></script>
<script language=javascript>
$(function () {
var websocket;
if ('WebSocket' in window) {
console.log("WebSocket");
websocket = new WebSocket("ws://localhost:8080/echo");
} else if ('MozWebSocket' in window) {
console.log("MozWebSocket");
websocket = new MozWebSocket("ws://echo");
} else {
console.log("SockJS");
websocket = new SockJS("http://127.0.0.1:8080/sockjs/echo");
}
websocket.onopen = function (evnt) {
console.log("链接服务器成功!", evnt.data);
};
websocket.onmessage = function (evnt) {
console.log('收到消息:', evnt.data);
var json = JSON.parse(evnt.data);
if (json.hasOwnProperty('users')) {
var users = json.users;
for (var i = 0; i < users.length; i++) {
$("#inputGroupSelect01").append('<option value="' + users[i] + '">' + users[i] + '</option>');
}
} else {
//打印消息
toast(json.msg, 'info')
}
};
websocket.onerror = function (evnt) {
};
websocket.onclose = function (evnt) {
console.log("与服务器断开了链接!")
}
$('#btn2').bind('click', function () {
if (websocket != null) {
//根据勾选的人数确定是群聊还是单聊
var value = $(this).parent().parent().find('input').val();
//得到选择的用户
var name = $("#inputGroupSelect01").find("option:selected").val();
console.log('选中的用户', name);
if (name === '选择一个...') {
toast('请选择一个用户', 'warning')
} else {
var object = {
to: name,
msg: value,
type: 2
};
//将object转成json字符串发送给服务端
var json = JSON.stringify(object);
websocket.send(json);
}
} else {
console.log('未与服务器链接.');
}
});
$('#btn1').bind('click', function () {
if (websocket != null) {
//根据勾选的人数确定是群聊还是单聊
var value = $(this).parent().parent().find('input').val();
var object = {
msg: value,
type: 1
};
//将object转成json字符串发送给服务端
var json = JSON.stringify(object);
websocket.send(json);
} else {
console.log('未与服务器链接.');
}
});
})
function toast(text, icon) {
$.toast({
text: text,
heading: '新消息',
icon: icon,
showHideTransition: 'slide',
allowToastClose: true,
hideAfter: 3000,
stack: 5,
position: 'top-right',
bgColor: '#444444',
textColor: '#eeeeee',
textAlign: 'left',
loader: true,
loaderBg: '#006eff'
});
}
</script>
</body>
</html>
5. 页面的支持
修改配置文件，我比较喜欢yml的。所以重命名配置文件为yml格式
application.yml
spring:
####配置 页面模板的参数，
freemarker:
charset: utf-8
suffix: .html
content-type: text/html
settings:
##格式化这个项目中，页面数字的显示，小数位数最多显示10位
number_format: 0.##########
http:
encoding:
charset: UTF-8
#### 配置静态资源的地址。html文件中，可以直接使用/static/目录
resources:
static-locations: "classpath:/"
6.测试
服务跑起来。
然后浏览器打开3个页面，分别访问：
http://localhost:8080/socket/chat1
http://localhost:8080/socket/chat2
http://localhost:8080/socket/chat3
效果如下：
查看窗口的调试模式
可以看到最先打开的页面返回的用户信息只有tom，后面的用户加入就出现了jerry和jack。
测试发送一条群消息
群消息效果
下面查看单人消息，先刷新3个页面，保证都加载了3个用户信息。发送的时候选择另外用户推送消息，另外2个人是收不到消息的。
单对单消息
完整项目 git：git@gitlab.com:tulongx/websocketdemo1.git
以上。
