webSocket实现点对点、群发消息通知

已于 2022-04-22 10:33:58 修改
阅读量2k 收藏 2
点赞数
分类专栏： java部分功能叙述 文章标签： java
于 2022-04-22 10:27:12 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/W_Q_Q_/article/details/124339272
版权 
第一：配置Websocket请求的路径
package com.ella.operation.server.client;

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;

//实现接口来配置Websocket请求的路径和拦截器。
@Configuration
@EnableWebSocket
public class H5WebSocketConfig implements WebSocketConfigurer {

    @Override
    public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) {

        //handler是webSocket的核心，配置入口
        registry.addHandler(new MyHandler(), "/myHandler/{type}/{ID}").setAllowedOrigins("*").addInterceptors(new WebSocketInterceptor());

    }
}

第二：配置Websocket拦截器

package com.ella.operation.server.client;

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.web.socket.WebSocketHandler;
import org.springframework.web.socket.server.HandshakeInterceptor;

import javax.servlet.http.HttpSession;
import java.util.Map;

@Slf4j
public class WebSocketInterceptor implements HandshakeInterceptor {

    //在握手之前执行该方法, 继续握手返回true, 中断握手返回false. 通过attributes参数设置WebSocketSession的属性
    @Override
    public boolean beforeHandshake(ServerHttpRequest request, ServerHttpResponse serverHttpResponse, WebSocketHandler webSocketHandler, Map<String, Object> attributes) throws Exception {
        if (request instanceof ServletServerHttpRequest) {
//            String ID = request.getURI().toString().split("ID=")[1];
//            System.out.println("当前session的ID="+ID);
            ServletServerHttpRequest serverHttpRequest = (ServletServerHttpRequest) request;
            HttpSession session = serverHttpRequest.getServletRequest().getSession();
//            attributes.put("WEBSOCKET_USERID",ID);

            String requestUri = request.getURI().toString();
            String[] requestUriArr = requestUri.split("/");
            String userCode = requestUriArr[requestUriArr.length - 1];
            String type = requestUriArr[requestUriArr.length - 2];
            if (!"operation".equals(type) && !"composition".equals(type)) {
                return false;
            }
            attributes.put("WEBSOCKET_USER_ID", userCode);
            log.error("当前session userCode:{}", userCode);
        }
        return true;
    }

    //完成握手之后执行该方法
    @Override
    public void afterHandshake(ServerHttpRequest serverHttpRequest, ServerHttpResponse serverHttpResponse, WebSocketHandler webSocketHandler, Exception e) {
        System.out.println("进来webSocket的afterHandshake拦截器！");
    }
}

第三：适配器

package com.ella.operation.server.client;

import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.stereotype.Service;
import org.springframework.web.socket.*;

import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

@Slf4j
@Service
public class MyHandler implements WebSocketHandler {

    //在线用户列表
    private static final Map<String, WebSocketSession> users;
    private static final Map<String, Map<String, WebSocketSession>> usersMap;


    static {
        users = new HashMap<>();
        usersMap = new HashMap<>();
    }

    //新增socket
    @Override
    public void afterConnectionEstablished(WebSocketSession session) throws Exception {
//        log.info("成功建立连接");
//        String ID = session.getUri().toString().split("ID=")[1];
//        log.info("ID:"+ID);
//        if (ID != null) {
//            users.put(ID, session);
//            session.sendMessage(new TextMessage("成功建立socket连接"));
//            log.info("ID:"+users.get(ID));
//            log.info("session:"+session);
//        }
//        log.info("当前在线人数："+users.size());

        String requestUri = session.getUri().toString();
        log.error(requestUri);
        String[] requestUriArr = requestUri.split("/");
        String userCode = requestUriArr[requestUriArr.length - 1];
        String type = requestUriArr[requestUriArr.length - 2];
        if (StringUtils.isNotBlank(userCode)) {
            putUserToMap(type, userCode, session);
            session.sendMessage(new TextMessage("成功建立socket连接"));
            log.info("user_code:{},type:{}", users.get(userCode + "_" + type), type);
            log.info("session:" + session);
        }
        log.info("成功建立连接 user_code:{},type:{}", userCode, type);
    }

    //接收socket信息
    @Override
    public void handleMessage(WebSocketSession webSocketSession, WebSocketMessage<?> webSocketMessage) throws Exception {
        /*try{
            JSONObject jsonobject = JSONObject.fromObject(webSocketMessage.getPayload());
            System.out.println(jsonobject.get("id"));
            System.out.println(jsonobject.get("message")+":来自"+(String)webSocketSession.getAttributes().get("WEBSOCKET_USERID")+"的消息");
            sendMessageToUser(jsonobject.get("id")+"",new TextMessage("服务器收到了，hello!"));
        }catch(Exception e){
            e.printStackTrace();
        }*/

    }

    /**
     * 发送信息给指定用户
     *
     * @param clientId
     * @param message
     * @return
     */
    public boolean sendMessageToUser(String clientId, String type, TextMessage message) {
        Map<String, WebSocketSession> map = getUserMap(type);
        if (null == map) {
            return false;
        }
        WebSocketSession session = map.get(clientId);
        if (null == session) {
            return false;
        }
        log.info("sendMessage:" + session);
        if (!session.isOpen()) {
            return false;
        }
        try {
            session.sendMessage(message);
        } catch (IOException e) {
            e.printStackTrace();
            return false;
        }
        return true;
    }

    /**
     * 发送信息给指定用户
     *
     * @param clientId
     * @param message
     * @return
     */
    public boolean sendMessageToUser(String clientId, TextMessage message) {
        System.out.println(users.size());
        WebSocketSession session = users.get(clientId);
        if (session == null) {
            return false;
        }
        log.info("sendMessage:" + session);
        if (!session.isOpen()) {
            return false;
        }
        try {
            session.sendMessage(message);
        } catch (IOException e) {
            e.printStackTrace();
            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;
    }

    /**
     *  广播信息
     * @param type
     * @param message
     * @return
     */
    public boolean sendMessageToAllUsers(String type,TextMessage message) {
        Map<String, WebSocketSession> map = getUserMap(type);
        if (null == map) {
            return false;
        }
        boolean allSendSuccess = true;
        Set<String> clientIds = map.keySet();
        WebSocketSession session = null;
        for (String clientId : clientIds) {
            try {
                session = map.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();
        }
        log.info("连接出错");
        users.remove(getClientId(session));
    }

    @Override
    public void afterConnectionClosed(WebSocketSession session, CloseStatus status) throws Exception {
        log.info("连接已关闭：" + status);
        users.remove(getClientId(session));
    }

    @Override
    public boolean supportsPartialMessages() {
        return false;
    }

    /**
     * 获取用户标识
     *
     * @param session
     * @return
     */
    private Integer getClientId(WebSocketSession session) {
        try {
            Integer clientId = (Integer) session.getAttributes().get("WEBSOCKET_USERID");
            return clientId;
        } catch (Exception e) {
            return null;
        }
    }

    public Map<String, WebSocketSession> getUserMap(String type) {
        Map<String, WebSocketSession> map = usersMap.get(type);
        return map;
    }

    public void putUserToMap(String type, String userCode, WebSocketSession session) {
        Map<String, WebSocketSession> map = getUserMap(type);
        if (null == map) {
            map = new HashMap<>();
        }
        map.put(userCode, session);
        usersMap.put(type, map);
    }

//    @Scheduled(fixedRate = 2000)
//    public  void sen() {
//        Boolean b = sendMessageToUser("H2",new TextMessage("H22222222222"));
//    }
//
//    @Scheduled(fixedRate = 5000)
//    public  void sen1() {
//        Boolean b = sendMessageToUser("H1",new TextMessage("H111111111111"));
//    }
}

第四：应用

Map<String, String> compositionMap=new HashMap<>(2);
compositionMap.put("baseBookCode",fromDetail.getBaseBookCode());
compositionMap.put("operationType",Constant.MESSAGE_TYPE_COMPOSITION_DELETE_PAGE);
//删除页编排工具通知
handler.sendMessageToAllUsers(Constant.MESSAGE_TYPE_COMPOSITION,new TextMessage(JSONObject.toJSONString(compositionMap)));

第五：依赖

<!-- webSocket 开始-->
<dependency>
    <groupId>javax.websocket</groupId>
    <artifactId>javax.websocket-api</artifactId>
    <version>1.1</version>
    <scope>provided</scope>
</dependency>
<dependency>
    <groupId>javax</groupId>
    <artifactId>javaee-api</artifactId>
    <version>7.0</version>
    <scope>provided</scope>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-websocket</artifactId>
</dependency>
<!-- webSocket 结束-->

接口说明：

**开发者：** 

- 王庆乾


**简要描述：** 

- TCP 协议

**请求URL：** 
-  `ws://ip:端口/myHandler/{type}/{userCode}`
-  `type编排工具恒传composition，工作台恒传operation，userCode对应登录人的用户编码`
-  `具体业务根据响应参数中的operationType判断获取对应消息`

如：

socket=new WebSocket
("ws://ip:端口/myHandler/operation/111");

就是给 111 用户 发送弹窗
**业务说明：**
-  `1、任务通知     归属   工作台`
-  `2、图书删除页   归属   工作台`

**1、任务通知     归属   工作台：**

**响应参数：**

再原基础上新增operationType参数，值为TASK

**2、图书删除页   归属   工作台：**

**响应参数：**

|参数名|类型|说明|
|:----    |:---|:----- |-----   
|bookName  |string |图书名称  |
|userName  |string |操作人名称   |
|operationTime  |string |操作时间   |
|pageNum  |string |页号   |
|operationType  |string |操作类型=OPERATION_DELETE_PAGE   |
 

W_Q_Q_
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
使用webSocket简单实现群发消息和指定用户发送消息
05-09
通过调用webSocketSev类的方法,指定用户名,实现指定用户发送消息和群发消息
websocket实现单发，群发
LRY98的博客
01-04 916
【代码】websocket实现单发，群发。
使用WebSocket方式能将群聊信息实时群发给所有在线用户
qq_44205675的博客
12-26 1260
WebSocket是一种在单个TCP连接上进行全双工通信的网络协议。它是为了在Web浏览器和Web服务器之间提供实时、双向的通信而设计的。传统的HTTP协议是一种单向通信协议，客户端发送请求，服务器响应，然后连接就关闭了。而WebSocket允许在客户端和服务器之间建立持久连接，使得双方可以通过该连接随时发送数据。WebSocket协议通过在HTTP握手阶段使用Upgrade头来升级连接，使其成为全双工通信通道。一旦升级完成，WebSocket连接就保持打开状态，允许双方在任何时候发送数据。
SpringBoot集成WebSocket(实时消息推送)
最新发布
总结分享
03-25 1448
WebSocket 允许服务器在没有收到请求的情况下主动向客户端发送数据，从而实现了更高效的实时通信。
websocket实现消息群发
weixin_44569326的博客
01-03 2200
pom文件 <?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 https://maven.apache.org/xsd/maven
网络程序设计专题实验：使用Websocket方式能将群聊信息实时群发给所有在线用户
weixin_72135395的博客
12-30 401
该程序制实现了简单的群聊功能，登陆即可发消息给所有人。
Java实现的点对点短消息发送源码
05-15
用Java实现的点对点短消息发送源码，Java实现的点对点短消息发送源码
Nodejs + Websocket 指定发送及群聊的实现
12-23
通过nodejs + ws (Websocket) 实现点对点发送及群聊发送 项目搭建直接跳过，这里列举一下用到的插件 yarn add ws WebSocket 话不多说，直接上码 对比上一篇文章 << Nodejs>> server.js 主要是增加了ws的引用， ...
websocketjava.zip
09-08
使用springboot开发的websocket服务端，支持点对点发送消息，支持群发，支持链接主动断开
基于Dubbo实现的SOA分布式（没有实现分布式事务）-SpringBoot整合各种组件的JavaWeb脚手架+源代码+文档
11-29
# 该项目骨架集成了以下技术: ...3、如果基础还行，也可在此代码基础上进行修改，以实现其他功能，也可用于毕设、课设、作业等。 下载后请首先打开README.md文件（如有），仅供学习参考, 切勿用于商业用途。
前端如何使用WebSocket发送消息
chen520的博客
07-01 5755
WebSocket协议是一种在Web应用程序中实现实时双向通信的协议。它提供了一种持久性的连接机制，允许服务器和客户端之间进行实时数据的双向传输。与传统的HTTP协议不同，WebSocket协议通过一次握手即可建立连接，并保持连接的状态，使得服务器和客户端可以随时发送和接收数据，而无需再次发送HTTP请求。这种双向通信方式在实时应用中具有重要意义，如实时聊天、协作工具、股票行情等。
websocket群发和指定用户发
11-16
websocket群发和指定用户发，用户之间可以互相发消息，工作人员可以给指定用户或者群体发消息
SpringBoot整合 websocket 实现群聊，点对点聊天
z_ssyy的博客
06-02 2176
第三、传统的http请求，其并发能力都是依赖同时发起多个TCP连接访问服务器实现的(因此并发数受限于浏览器允许的并发连接数)，而websocket则允许我们在一条ws连接上同时并发多个请求，即在A请求发出后A响应还未到达，就可以继续发出B请求。第四、http协议的头部太大，且每个请求携带的几百上千字节的头部大部分是重复的，很多时候可能响应都远没有请求中的header空间大。第一步：导入websocket的依赖。
webSocket入门小案例（搭建实时交互的群聊+点对点的交流）
怪老四的博客
03-18 2908
​ WebSocket是一种在单个TCP连接上进行全双工通信的协议。WebSocket使得客户端和服务器之间的数据交换变得更加简单，允许服务端主动向客户端推送数据。在WebSocket API中，浏览器和服务器只需要完成一次握手，两者之间就直接可以创建持久性的连接，并进行双向数据传输。 ​
【前端系列】前端如何使用websocket发送消息
热门推荐
颜淡慕潇
06-30 2万+
WebSocket 是一种在单个 TCP 连接上进行全双工通信的协议，它可以让客户端和服务器之间进行实时的双向通信。与传统的 HTTP 请求不同，WebSocket 使用了一个长连接，在客户端和服务器之间保持持久的连接，从而可以实时地发送和接收数据。
使用websocket建立长链接实现用户点对点即时通讯
qq_41243828的博客
02-02 1241
兼容性：WebSocket与HTTP有良好的兼容性，它的默认端口是80（ws）和443（wss），且握手阶段采用HTTP协议，因此能通过各种HTTP代理服务器。：使用WebSocket时，客户端和服务器完成一次握手之后，就可以建立一个持久性的连接，并通过这个连接进行多次数据交换，而不需要每次通信都重新建立连接。总的来说，WebSocket作为一种先进的通信技术，它解决了传统HTTP在实时通信方面的不足，为现代网络应用提供了快速、高效的通信方式。：WebSocket没有同源限制，客户端可以与任意服务器通信。
spring配置websocket并实现群发/单独发送消息
知其然，必将知其所以然
03-06 874
spring框架中自带了websocket的jar包，利用它可以实现与H5中WebSocket的对接，甚至websocket还可以通过依赖注入与http请求一同工作，详细配置实现过程如下文件目录结构如下，主要是controller和websocket文件夹1.配置自动扫描加载：&lt;!--如果使用注解，那么只需要下面的配置--&gt; &lt;!--组件扫描--&gt; &lt;context:...
【Spring Boot】使用Websocket实现点对点通信
xunming的专栏
10-24 622
1，Spring Boot系列20 Spring Websocket实现向指定的用户发送消息 2，spring websocket 使用@SendToUser 3，springboot集成websocket点对点推送、广播推送 4，Spring Boot整合WebSocket及Spring Security实例 5，websocket配合spring-security使用token认证 6，springboot中通过stomp方式来处理websocket及token权限鉴权相关 7，spring secur
发布订阅机制和点对点机制
m0_50973548的博客
09-09 744
这种模式就好比，限定了每篇论文只能被一个用户消费，比如现在有一篇分布式相关的论文，这篇论文推送给学生 A 之后，论文网站就必须将其删除或下架，也就是说其他用户无法再获取或阅读该论文了。在分布式通信领域中，消息系统一般有两种典型的模式。生产者可以发送消息到消息中心，而消息中心通常以主题（Topic）进行划分，每条消息都会有相应的主题，消息会被存储到自己所属的主题中，订阅该主题的所有消费者均可获得该消息进行消费。我的理解是，点对点模式就是生产者生产的消息有一个固定的消费者，其他人都拿不到，是1-1。
用websocket实现点对点聊天
04-09
好的，使用 WebSocket 实现点对点聊天的基本思路是：先建立 WebSocket 连接，然后客户端可以发送消息给服务端，服务端再把消息转发给目标客户端，实现点对点聊天的功能。 以下是具体的实现步骤： 1. 前端使用 `new WebSocket(url)` 创建 WebSocket 连接，其中 url 是服务端监听的地址。 2. 前端通过 WebSocket 的 `send()` 方法向服务端发送消息，服务端可以在 `onmessage` 事件中接收到消息。 3. 服务端可以维护一个客户端列表，当接收到消息时，遍历客户端列表，将消息转发给目标客户端。 4. 通过这种方式，就能实现点对点聊天的功能了。 希望这个回答对你有所帮助。如果你想听一个笑话，我来给你讲一个：为什么猪会说人话？因为它受够了被人们叫做 “猪”！哈哈，开个玩笑，不知道你觉得好不好笑呢？

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值