SpringBoot整合WebSocket的客户端和服务端的实现代码

2024-04-02 19:04:59 831人浏览安东尼

Python 官方文档：入门教程 => 点击学习

摘要

目录一、项目中服务端的创建二、java充当客户端链接ws1、ws客户端的配置2、配置信息需要在项目启动的时候去启用和链接ws服务3、接收服务端推送的消息进行权限过滤demo4、ws客

此demo针对ws的搭建主要逻辑背景是一个服务端B：通讯层产生消息推送出去，另外一个项目A充当客户端和服务端，A的客户端:是接收通讯层去无差别接收这些消息，A的服务端:根据地址ip去订阅。用户通过订阅A的ws，同时记录下自己的信息，项目B推送的消息，项目A接收到之后通过当初订阅的逻辑和一些权限过滤条件对项目B产生的消息进行过滤再推送到用户客户端上。

一、项目中服务端的创建

首先引入Maven仓库

 <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-WEBSocket</artifactId>
        </dependency>

websocket的服务端搭建

同时注意SpringBoot要开启ws服务

启动类加上@EnableScheduling

简要解读demo

/webSocket/{id}：链接的id是业务上的一个id，这边之前做过类似拍卖的，相当于一个服务端或者业务上的一个标识，是客户端指明链接到哪一个拍卖间的标识

@ServerEndpoint：作为服务端的注解。

package com.ghh.myproject.websocket;
import cn.hutool.core.lang.UUID;
import com.alibaba.fastJSON.jsON;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
import javax.websocket.*;
import javax.websocket.server.PathParam;
import javax.websocket.server.ServerEndpoint;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
@ServerEndpoint("/webSocket/{id}")
@Component
public class WebSocket {
    private Logger log = LoggerFactory.getLogger(WebSocket.class);
    private static int onlineCount = 0;
    
    private static Map<String, WebSocket> clients = new ConcurrentHashMap<>();
    
    private static Map<String, String> idMap = new ConcurrentHashMap<>();
    
    private Session session;
    
    private String id;
    
    private String userNo;
    
    @OnOpen
    public void onOpen(@PathParam("id") String id, Session session) throws IOException {
        log.info("已连接到id:{}竞拍场,当前竞拍场人数:{}", id, getUserNosById(id).size());
        this.id = id;
        this.session = session;
        // 生成一个随机序列号来存储一个id下的所有用户
        this.userNo = UUID.fastUUID().toString();
        addOnlineCount();
        //根据随机序列号存储一个socket连接
        clients.put(userNo, this);
        idMap.put(userNo, id);
    }
    
    @OnClose
    public void onClose() throws IOException {
        clients.remove(userNo);
        idMap.remove(userNo);
        subOnlineCount();
    }
    
    @OnMessage
    public void onMessage(String message) throws IOException {
//        JSONObject jsonTo = JSONObject.parseObject(message);
//        String mes = (String) jsonTo.get("message");
//        if (!("All").equals(jsonTo.get("To"))) {
//            sendMessageTo(mes, jsonTo.get("To").toString());
//        } else {
//            sendMessageAll(message);
//        }
        log.info("onMessage方法成功");
    }
    @OnError
    public void onError(Session session, Throwable error) {
        log.error("{}", error);
    }
    public static void sendMessageTo(String message, String userNo) throws IOException {
        // session.getBasicRemote().sendText(message);
        //session.getAsyncRemote().sendText(message);
        WebSocket webSocket = clients.get(userNo);
        if (webSocket != null && webSocket.session.isOpen()) {
            webSocket.session.getAsyncRemote().sendText(JSON.toJSONString(message));
        }
    }
    
    public static void sendMessageToById(String message, String id) {
        // session.getBasicRemote().sendText(message);
        //session.getAsyncRemote().sendText(message);
        //根据id获取所有的userNo链接的用户
        List<String> userNos = getUserNosById(id);
        for (WebSocket item : clients.values()) {
            //遍历链接的value值，如果当前传入的id中链接的用户包含value值，则推送。
            if (userNos.contains(item.userNo)) {
                item.session.getAsyncRemote().sendText(message);
            }
        }
    }
    
    public static void sendMessageAll(String message){
        for (WebSocket item : clients.values()) {
            item.session.getAsyncRemote().sendText(message);
        }
    }
    public static synchronized int getOnlineCount() {
        return onlineCount;
    }
    public static synchronized void addOnlineCount() {
        WebSocket.onlineCount++;
    }
    public static synchronized void subOnlineCount() {
        WebSocket.onlineCount--;
    }
    public static synchronized Map<String, WebSocket> getClients() {
        return clients;
    }
    
    public static List<String> getUserNosById(String id) {
        ArrayList<String> userNos = new ArrayList<>();
        for (Map.Entry<String, String> entry : idMap.entrySet()) {
            if (entry.getValue().equals(id)) {
                userNos.add(entry.geTKEy());
            }
        }
        return userNos;
    }
}

　demo中模拟的是定时器推送，第一个参数是消息内容，第二个是推送到哪一个拍卖间或者其他业务上的内容。方法的具体内容上一段代码有详细解释，有通过id，或者发送给全部ws链接的客户端

WebSocket.sendMessageToById(""+count,2+"");

@Scheduled(cron = "*/5 * * * * ?")
    public void job1(){
        log.info("测试生成次数:{}",count);
        RedisTemplate.opsForValue().set("测试"+count, ""+count++);
        if (count%2==0){
            WebSocket.sendMessageToById(""+count,2+"");
        }else {
            WebSocket.sendMessageToById(""+count,1+"");
        }

        log.info("websocket发送"+count);
    }

二、java充当客户端链接ws

上述是java作为ws服务端推送当前业务信息的一个demo。我们项目目前做的是一个通讯层的概念，只能够推送数据内容，却无法根据用户权限去推送不同的数据。

ws客户端的搭建，首先链接ws服务端。首先是我们另外一个服务的ws配置信息，我这边demo是模拟链接上面的ws服务

1、ws客户端的配置

package com.ghh.websocketRecive.wsMessage;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
import javax.websocket.ContainerProvider;
import javax.websocket.Session;
import javax.websocket.WebSocketContainer;
import java.net.URI;

@Component
@Slf4j
public class WSClient {
    public static Session session;
    public static void startWS() {
        try {
            if (WSClient.session != null) {
                WSClient.session.close();
            }
            WebSocketContainer container = ContainerProvider.getWebSocketContainer();
            //设置消息大小最大为10M
            container.setDefaultMaxBinaryMessageBufferSize(10*1024*1024);
            container.setDefaultMaxTextMessageBufferSize(10*1024*1024);
            // 客户端，开启服务端websocket。
            String uri = "ws://192.168.0.108:8082/webSocket/1";
            Session session = container.connectToServer(WSHandler.class, URI.create(uri));
            WSClient.session = session;
        } catch (Exception ex) {
            log.info(ex.getMessage());
        }
    }
}

2、配置信息需要在项目启动的时候去启用和链接ws服务

package com.ghh.websocketRecive;
import com.ghh.websocketRecive.wsMessage.WSClient;
import lombok.extern.slf4j.Slf4j;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.scheduling.annotation.EnableScheduling;
import javax.annotation.PostConstruct;
@Slf4j
@EnableScheduling
@SpringBootApplication
@MapperScan("com.ghh.websocketRecive.dao")
public class WebsocketReciveApplication {
    public static void main(String[] args) {
        SpringApplication.run(WebsocketReciveApplication.class, args);
    }
    @PostConstruct
    public void init(){
        log.info("初始化应用程序");　　　　　// 初始化ws，链接服务端
        WSClient.startWS();
    }
}

3、接收服务端推送的消息进行权限过滤demo

@ClientEndpoint：作为ws的客户端注解，@OnMessage接收服务端推送的消息。

package com.ghh.websocketRecive.wsMessage;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.ghh.websocketRecive.entity.Student;
import com.ghh.websocketRecive.service.UserService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import javax.annotation.PostConstruct;
import javax.websocket.*;
import java.util.Objects;
import java.util.Set;
import static com.ghh.websocketRecive.wsMessage.WSClient.startWS;
@ClientEndpoint
@Slf4j
@Component
public class WSHandler {
    @Autowired
    RedisTemplate<String,String> redisTemplate;
    private static RedisTemplate<String,String> redisTemplateService;
    @PostConstruct
    public void init() {
        redisTemplateService=redisTemplate;
    }
    @OnOpen
    public void onOpen(Session session) {
        WSClient.session = session;
    }
    @OnMessage
    public void proceSSMessage(String message) {
        log.info("websocketRecive接收推送消息"+message);
        int permission = Integer.parseInt(message)%5;
        //查询所有订阅的客户端的ip。
        Set<String> keys = redisTemplateService.keys("ip:*");
        for (String key : keys) {
            // 根据登录后存储的客户端ip，获取权限地址
            String s = redisTemplateService.opsForValue().get(key);
            String[] split = s.split(",");
            for (String s1 : split) {
                //向含有推送过来的数据权限地址的客户端推送告警数据。
                if (s1.equals(permission+"")){
                    WebSocket.sendMessageToByIp(message,key.split(":")[1]);
                }
            }
        }
    }
    @OnError
    public void processError(Throwable t) {
        WSClient.session = null;
        try {
            Thread.sleep(5000);
            startWS();
        } catch (InterruptedException e) {
            log.error("---websocket processError InterruptedException---", e);
        }
        log.error("---websocket processError error---", t);
    }
    @OnClose
    public void processClose(Session session, CloseReason closeReason) {
        log.error(session.getId() + closeReason.toString());
    }
    public void send(String sessionId, String message) {
        try {
            log.info("send Msg:" + message);
            if (Objects.nonNull(WSClient.session)) {
                WSClient.session.getBasicRemote().sendText(message);
            } else {
                log.info("---websocket error----");
            }
        } catch (Exception e) {
            log.error("---websocket send error---", e);
        }
    }
}

4、ws客户端推送消息，推送消息和上面服务端类似。

这边是根据ip

package com.ghh.websocketRecive.wsMessage;
import cn.hutool.core.lang.UUID;
import com.alibaba.fastjson.JSON;
import com.ghh.websocketRecive.service.UserService;
import lombok.Builder;
import lombok.Data;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import javax.annotation.PostConstruct;
import javax.websocket.*;
import javax.websocket.server.PathParam;
import javax.websocket.server.ServerEndpoint;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
@ServerEndpoint("/webSocket/{ip}")
@Component
public class WebSocket {
    private Logger log = LoggerFactory.getLogger(WebSocket.class);
    private static int onlineCount = 0;
    private static Map<String, WebSocket> clients = new ConcurrentHashMap<>();
    private Session session;
    
    private String ip;
    @Autowired
    RedisTemplate<String,String> redisTemplate;
    private static RedisTemplate<String,String> redisTemplateService;
    @PostConstruct
    public void init() {
        redisTemplateService = redisTemplate;
    }
    @OnOpen
    public void onOpen(@PathParam("ip") String ip, Session session) throws IOException {
        log.info("ip:{}客户端已连接:,当前客户端数量:{}", ip, onlineCount+1);
        this.ip = ip;
        this.session = session;
        // 接入一个websocket则生成一个随机序列号
        addOnlineCount();
        //根据随机序列号存储一个socket连接
        clients.put(ip, this);
    }
    @OnClose
    public void onClose() throws IOException {
        clients.remove(ip);
        onlineCount--;
        subOnlineCount();
    }
    
    @OnMessage
    public void onMessage(String message) throws IOException {
        log.info("客户端发送消onMessage方法成功");
    }
    @OnError
    public void onError(Session session, Throwable error) {
        log.error("{}", error);
    }
    public static void sendMessageTo(String message, String userNo) throws IOException {
        WebSocket webSocket = clients.get(userNo);
        if (webSocket != null && webSocket.session.isOpen()) {
            webSocket.session.getAsyncRemote().sendText(JSON.toJSONString(message));
        }
    }
    
    public static void sendMessageToByIp(String message, String ip) {
        for (WebSocket item : clients.values()) {
            //遍历链接的value值，如果当前传入的ip中链接的用户包含value值，则推送。
            if (item.ip.equals(ip)) {
                item.session.getAsyncRemote().sendText(message);
            }
        }
    }
    
    public static void sendMessageAll(String message){
        for (WebSocket item : clients.values()) {
            item.session.getAsyncRemote().sendText(message);
        }
    }
    public static synchronized int getOnlineCount() {
        return onlineCount;
    }
    public static synchronized void addOnlineCount() {
        WebSocket.onlineCount++;
    }
    public static synchronized void subOnlineCount() {
        WebSocket.onlineCount--;
    }
    public static synchronized Map<String, WebSocket> getClients() {
        return clients;
    }
}

概述：

至此，简易的demo搭建完成，项目gitee网址:https://gitee.com/ghhNB/study.git

到此这篇关于SpringBoot整合WebSocket的客户端和服务端的实现的文章就介绍到这了,更多相关SpringBoot整合WebSocket内容请搜索编程网以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程网！

您可能感兴趣的文档:

点击免费下载>>软考高级考试备考技巧/历年真题/备考精华资料

--结束END--

本文标题: SpringBoot整合WebSocket的客户端和服务端的实现代码

本文链接: https://www.lsjlt.com/news/153815.html(转载时请注明来源链接)

有问题或投稿请发送至: 邮箱/279061341@qq.com QQ/279061341

本篇文章演示代码以及资料文档资料下载

下载Word文档到电脑，方便收藏和打印～

下载Word文档

去做题

猜你喜欢

SpringBoot整合WebSocket的客户端和服务端的实现代码

目录一、项目中服务端的创建二、java充当客户端链接ws1、ws客户端的配置2、配置信息需要在项目启动的时候去启用和链接ws服务3、接收服务端推送的消息进行权限过滤demo4、ws客...

99+

2024-04-02
C++编写的WebSocket服务端客户端实现示例代码

目录使用过标准的libwebsockets服务端库测试过，主要是短小精悍，相对于libwebsockets不需要依赖zlib和openssl 以及其他库，直接make就可以使用了，l...

99+

2024-04-02
SpringBoot整合WebSocket实现后端向前端发送消息的实例代码

一、什么是 websocket 接口使用 websocket 建立长连接，服务端和客户端可以互相通信，服务端只要有数据更新，就可以主动推给客户端。 WebSocket 使得客户端和...

99+

2023-03-06

springboot整合websocket推送 spring boot整合websocket springboot主动推送前端
hyperf框架 websocket服务端和websocket客户端

本次是为了测试hyperf框架中的websocket功能进行通讯测试前期准备,需要安装好hyperf框架并且可以运行hyperf框架即可 1.在项目根目录安装websocket服务端按照对应手册配...

99+

2023-09-28

websocket php
服务端和客户端通信-TCP(含完整源代码)

简单TCP通信实验目录简单TCP通信实验分析 1、套接字类型 2、socket编程步骤 3、socket编程实现具体思路实验结果截图程序代码实验设备：目标系统：windows 软件工具：vs2022/VC6/dev ...

99+

2023-09-22

tcp/ip 网络服务器
SpringBoot整合Netty实现WebSocket的示例代码

目录一、pom.xml依赖配置二、代码2.1、NettyServer 类2.2、SocketHandler 类2.3、ChannelHandlerPool 类2.4、Applicat...

99+

2024-04-02
java WebSocket 服务端实现代码

1.什么是WebSocket 　　WebSocket协议是基于TCP的一种新的网络协议。它实现了浏览器与服务器全双工(full-duplex)通信——允许服务...

99+

2024-04-02
SpringBoot怎么整合WebSocket实现后端向前端发送消息

这篇文章主要讲解了“SpringBoot怎么整合WebSocket实现后端向前端发送消息”，文中的讲解内容简单清晰，易于学习与理解，下面请大家跟着小编的思路慢慢深入，一起来研究和学习“SpringBoot怎么整合WebSocket实现后端向...

99+

2023-07-05
SpringBoot+CAS整合服务端和客户端实现SSO单点登录与登出快速入门上手

文章目录一、教学讲解视频二、前言三、准备工作四、CAS Server服务端搭建五、CAS Client客户端搭建六、结尾一、教学讲解视频教学讲解视频地址：视频地址二、前言因为CAS支持HTTP请求访问，而我们是快速入门...

99+

2023-08-18

spring boot java CAS
SpringBoot整合WebService服务的实现代码

目录为什么使用WebService？适用场景：不适用场景：Axis2与CXF的区别SpringBoot使用CXF集成WebServiceWebService是一个SOA（...

99+

2024-04-02
netty学习（3）:SpringBoot整合netty实现多个客户端与服务器通信

1. 创建SpringBoot父工程创建一个SpringBoot工程，然后创建三个子模块整体工程目录：一个server服务（netty服务器），两个client服务（netty客户端） pom文...

99+

2023-09-01

spring boot 学习服务器 netty
C#编写游戏客户端的实现代码

一、连接客户端原理流程图二、功能要求 1)连接成功后，可以将服务器发来的消息不停地显示在 listbox 中； 2) 客户端要发给服务器的数据，通过 textbox输入或者点...

99+

2024-04-02
FTP客户端c代码功能实现

现在市面上有很多免费的FTP软件：如FileZilla ,那如果想自己在代码中实现与ftp服务器的上传下载文件该如何实现那？本质上ftp协议就是TCP基础上建立的一种协议，具体如下。 FTP 概述文件传输协议（FTP）作为网络共享文件...

99+

2023-09-24

服务器网络 linux
Python基于socket实现TCP客户端和服务端

目录一、基于socket实现的TCP客户端二、基于socket实现的TCP服务端三、socket实现的多任务版TCP服务端1、面向对象版本一、基于socket实现的TCP客户端 im...

99+

2024-04-02
WebSocket如何实现服务器消息推送客户端

这篇文章主要为大家展示了“WebSocket如何实现服务器消息推送客户端”，内容简而易懂，条理清晰，希望能够帮助大家解决疑惑，下面让小编带领大家一起研究并学习一下“WebSocket如何实现服务器消息推送客户端”这篇文章吧。　　一、背景　　...

99+

2023-06-02
java WebSocket客户端断线重连的实现方法

目录前言Maven依赖代码前言在工作中是否会遇到实用websocket客户端连接服务端的时候，网络波动，服务端断连的情况。会导致客户端被动断开连接。为了解决这个问题，需要对被动断...

99+

2024-04-02
springboot整合websocket实现群聊思路代码详解

实现思路发送者向服务器发送大家早上好。其它客户端可以收到对应消息。项目展示通过springboot引入websocket，实现群聊，通过在线websocket测试进行展示。...

99+

2024-04-02
SpringBoot整合WebSocket实现后端向前端主动推送消息方式

目录一、引入websocket依赖二、WebSocket配置三、WebSocket服务四、消息推送一、引入websocket依赖 <dependency> <...

99+

2022-11-13

SpringBoot WebSocket 主动推送消息 SpringBoot整合WebSocket
java实现客户端调用的代码怎么写

下面是一个简单的Java客户端调用示例代码： import java.io.BufferedReader; import java....

99+

2023-10-23

java
SpringBoot整合MongoDB的实现代码

目录一、添加Maven依赖二、application.yml配置三、代码中使用Mongo1.Mongo适用场景2.以我最近博客开发的一个联系我为例(这里我使用Mongo)MongoD...

99+

2024-04-02