SpringBoot中使用Netty开发WebSocket服务-netty-websocket-spring-boot-starter开源项目使用与改造多线程群发消息

于 2024-07-31 15:05:27 发布
阅读量527 收藏 7
点赞数 5
分类专栏： 开发者资源分享 文章标签： spring boot websocket 开源
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/BADAO_LIUMANG_QIZHI/article/details/140823433
版权

 场景

SpringBoot+Vue整合WebSocket实现前后端消息推送：

SpringBoot+Vue整合WebSocket实现前后端消息推送_霸道流氓气质的博客-CSDN博客

SpringCloud(若依微服务版为例)集成WebSocket实现前后端的消息推送：

SpringCloud(若依微服务版为例)集成WebSocket实现前后端的消息推送_springcloud +websocket 后端到前端推送_霸道流氓气质的博客-CSDN博客

若依前后端分离版手把手教你本地搭建环境并运行项目：

若依前后端分离版手把手教你本地搭建环境并运行项目_前后端分离项目本地运行_霸道流氓气质的博客-CSDN博客

在上面的基础上，使用websocket仍有不足，比如可能出现如下问题

Nginx代理websocket配置(解决websocket异常断开连接tcp连接不断问题)：

Nginx代理websocket配置(解决websocket异常断开连接tcp连接不断问题)_nginx配置websocker连接_霸道流氓气质的博客-CSDN博客

另外如果业务场景中需要高频定时任务通过websocket给多个客户端发动消息，

则短时间内需要使用多线程/自定义线程池实现群发消息功能。

关于自定义线程池相关可参考如下

Java中创建线程的方式以及线程池创建的方式、推荐使用ThreadPoolExecutor以及示例：

Java中创建线程的方式以及线程池创建的方式、推荐使用ThreadPoolExecutor以及示例_霸道流氓气质的博客-CSDN博客

Java中线程的常用操作-后台线程、自定义线程工厂ThreadFactpry、join加入一个线程、线程异常捕获：

Java中线程的常用操作-后台线程、自定义线程工厂ThreadFactpry、join加入一个线程、线程异常捕获_霸道流氓气质的博客-CSDN博客

注：

博客：
霸道流氓气质的博客_CSDN博客-C#,架构之路,SpringBoot领域博主

实现

1、netty-websocket-spring-boot-starter与若依集成websocket

本项目帮助你在spring-boot中使用Netty来开发WebSocket服务器，并像spring-websocket的注解开发一样简单。

仓库地址：

netty-websocket-spring-boot-starter: 轻量级、高性能的WebSocket框架

https://github.com/YeautyYE/netty-websocket-spring-boot-starter/blob/master/README_zh.md

除了此开源项目之外，这里还基于若依开源项目框架中基于websocket的插件集成

插件集成 | RuoYi

2、项目中添加依赖

        <dependency>
            <groupId>org.yeauty</groupId>
            <artifactId>netty-websocket-spring-boot-starter</artifactId>
            <version>0.12.0</version>
        </dependency>

然后集合以上两个开源框架的示例代码新建如下类

3、其中WebSocketServer类为端点类，实现代码

package com.badao.demo.websocket;

import io.netty.handler.codec.http.HttpHeaders;
import io.netty.handler.timeout.IdleStateEvent;
import lombok.extern.slf4j.Slf4j;
import org.yeauty.annotation.*;
import org.yeauty.pojo.Session;

import java.io.IOException;
import java.util.concurrent.Semaphore;

@ServerEndpoint(path = "/websocket/{userName}", port = "${ws.port}", readerIdleTimeSeconds = "${ws.readerIdleTimeSeconds}", writerIdleTimeSeconds = "${ws.writerIdleTimeSeconds}", allIdleTimeSeconds = "${ws.allIdleTimeSeconds}")
@Slf4j
public class WebSocketServer {

    /**
     * 默认最多允许同时在线人数 200
     */
    public static int socketMaxOnlineCount = 200;

    private static final Semaphore socketSemaphore = new Semaphore(socketMaxOnlineCount);

    @OnOpen
    public void onOpen(Session session, HttpHeaders headers, @PathVariable String userName) {
        boolean semaphoreFlag = false;
        // 尝试获取信号量
        semaphoreFlag = SemaphoreUtils.tryAcquire(socketSemaphore);
        if (!semaphoreFlag) {
            // 未获取到信号量
            log.error("\n 当前人数 - {} , 限制人数：{} ", WebSocketUsers.getUsers().size(), socketMaxOnlineCount);
            WebSocketUsers.sendMessageToUserByText(session, "当前人数：" + WebSocketUsers.getUsers().size() + " 限制人数：" + socketMaxOnlineCount);
            session.close();
        } else {
            // 添加用户
            WebSocketUsers.sendMessageToUserByText(session, "连接成功");
            WebSocketUsers.put(userName, session);
            log.warn("\n 用户：{} 连接后 , 当前人数 : {}", userName, WebSocketUsers.getUsers().size());
        }
    }

    @OnClose
    public void onClose(Session session, @PathVariable String userName) throws IOException {
        // 移除用户
        WebSocketUsers.remove(userName);
        log.warn("\n 用户：{} 关闭后 , 当前人数 : {}", userName, WebSocketUsers.getUsers().size());
        // 获取到信号量则需释放
        SemaphoreUtils.release(socketSemaphore);
    }

    @OnError
    public void onError(Session session, @PathVariable String userName, Throwable exception) {
        if (session.isOpen()) {
            // 关闭连接
            session.close();
        }
        log.warn("\n 连接异常 - {}", userName);
        log.warn("\n 异常信息 - {}", exception);
        // 移出用户
        WebSocketUsers.remove(userName);
        // 获取到信号量则需释放
        SemaphoreUtils.release(socketSemaphore);
    }

    @OnMessage
    public void onMessage(Session session, String message) {
        WebSocketUsers.sendMessageToUserByText(session, message);
    }

    @OnBinary
    public void onBinary(Session session, byte[] bytes) {
        for (byte b : bytes) {
            System.out.println(b);
        }
        session.sendBinary(bytes);
    }

    @OnEvent
    public void onEvent(@PathVariable String userName, Session session, Object evt) {
        if (evt instanceof IdleStateEvent) {
            IdleStateEvent idleStateEvent = (IdleStateEvent) evt;
            switch (idleStateEvent.state()) {
                case READER_IDLE:
                    log.error("user-{} Read timeout！", userName);
                    session.close();
                    break;
                case WRITER_IDLE:
                    log.error("user-{} Write timeout！", userName);
                    session.close();
                    break;
                case ALL_IDLE:
                    log.error("user-{} All timeout！", userName);
                    session.close();
                    break;
                default:
                    break;
            }
        }
    }
}

注意这里的注解@ServerEndpoint是org.yeauty路径下的，别引用错了包。

在端点类上加上@ServerEndpoint注解，并在相应的方法上加上

@BeforeHandshake、@OnOpen、@OnClose、@OnError、@OnMessage、@OnBinary、@OnEvent注解。

注解说明：

@ServerEndpoint

当ServerEndpointExporter类通过Spring配置进行声明并被使用，它将会去扫描带有@ServerEndpoint注解的类

被注解的类将被注册成为一个WebSocket端点 所有的配置项都在这个注解的属性中 ( 如:@ServerEndpoint("/ws") )

@BeforeHandshake

当有新的连接进入时，对该方法进行回调 注入参数的类型:Session、HttpHeaders...

@OnOpen

当有新的WebSocket连接完成时，对该方法进行回调 注入参数的类型:Session、HttpHeaders...

@OnClose

当有WebSocket连接关闭时，对该方法进行回调 注入参数的类型:Session

@OnError

当有WebSocket抛出异常时，对该方法进行回调 注入参数的类型:Session、Throwable

@OnMessage

当接收到字符串消息时，对该方法进行回调 注入参数的类型:Session、String

@OnBinary

当接收到二进制消息时，对该方法进行回调 注入参数的类型:Session、byte[]

@OnEvent

当接收到Netty的事件时，对该方法进行回调 注入参数的类型:Session、Object

配置说明

所有的配置项都在这个注解的属性中。

属性默认值说明
path"/"WebSocket的path,也可以用value来设置
host"0.0.0.0"WebSocket的host,"0.0.0.0"即是所有本地地址
port80WebSocket绑定端口号。如果为0，则使用随机端口(端口获取可见 多端点服务)
bossLoopGroupThreads0bossEventLoopGroup的线程数
workerLoopGroupThreads0workerEventLoopGroup的线程数
useCompressionHandlerfalse是否添加WebSocketServerCompressionHandler到pipeline
optionConnectTimeoutMillis30000与Netty的ChannelOption.CONNECT_TIMEOUT_MILLIS一致
optionSoBacklog128与Netty的ChannelOption.SO_BACKLOG一致
childOptionWriteSpinCount16与Netty的ChannelOption.WRITE_SPIN_COUNT一致
childOptionWriteBufferHighWaterMark64*1024与Netty的ChannelOption.WRITE_BUFFER_HIGH_WATER_MARK一致,但实际上是使用ChannelOption.WRITE_BUFFER_WATER_MARK
childOptionWriteBufferLowWaterMark32*1024与Netty的ChannelOption.WRITE_BUFFER_LOW_WATER_MARK一致,但实际上是使用 ChannelOption.WRITE_BUFFER_WATER_MARK
childOptionSoRcvbuf-1(即未设置)与Netty的ChannelOption.SO_RCVBUF一致
childOptionSoSndbuf-1(即未设置)与Netty的ChannelOption.SO_SNDBUF一致
childOptionTcpNodelaytrue与Netty的ChannelOption.TCP_NODELAY一致
childOptionSoKeepalivefalse与Netty的ChannelOption.SO_KEEPALIVE一致
childOptionSoLinger-1与Netty的ChannelOption.SO_LINGER一致
childOptionAllowHalfClosurefalse与Netty的ChannelOption.ALLOW_HALF_CLOSURE一致
readerIdleTimeSeconds0与IdleStateHandler中的readerIdleTimeSeconds一致，并且当它不为0时，将在pipeline中添加IdleStateHandler
writerIdleTimeSeconds0与IdleStateHandler中的writerIdleTimeSeconds一致，并且当它不为0时，将在pipeline中添加IdleStateHandler
allIdleTimeSeconds0与IdleStateHandler中的allIdleTimeSeconds一致，并且当它不为0时，将在pipeline中添加IdleStateHandler
maxFramePayloadLength65536最大允许帧载荷长度
useEventExecutorGrouptrue是否使用另一个线程池来执行耗时的同步业务逻辑
eventExecutorGroupThreads16eventExecutorGroup的线程数
sslKeyPassword""(即未设置)与spring-boot的server.ssl.key-password一致
sslKeyStore""(即未设置)与spring-boot的server.ssl.key-store一致
sslKeyStorePassword""(即未设置)与spring-boot的server.ssl.key-store-password一致
sslKeyStoreType""(即未设置)与spring-boot的server.ssl.key-store-type一致
sslTrustStore""(即未设置)与spring-boot的server.ssl.trust-store一致
sslTrustStorePassword""(即未设置)与spring-boot的server.ssl.trust-store-password一致
sslTrustStoreType""(即未设置)与spring-boot的server.ssl.trust-store-type一致
corsOrigins{}(即未设置)与spring-boot的@CrossOrigin#origins一致
corsAllowCredentials""(即未设置)与spring-boot的@CrossOrigin#allowCredentials一致

且这里的配置可以在yml中进行配置。

需要在application.yml中添加如下配置项

ws:
  # websocket 端口
  port: 8071
  # websocket 读超时
  readerIdleTimeSeconds: 10
  # websocket 写超时
  writerIdleTimeSeconds: 10
  # websocket 所有信道超时
  allIdleTimeSeconds: 15

4、注意上面的信号量相关处理封装的工具类

package com.badao.demo.websocket;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.concurrent.Semaphore;

/**
 * 信号量相关处理
 */
public class SemaphoreUtils {
    /**
     * SemaphoreUtils 日志控制器
     */
    private static final Logger LOGGER = LoggerFactory.getLogger(SemaphoreUtils.class);

    /**
     * 获取信号量
     *
     * @param semaphore
     * @return
     */
    public static boolean tryAcquire(Semaphore semaphore) {
        boolean flag = false;

        try {
            flag = semaphore.tryAcquire(1);
        } catch (Exception e) {
            LOGGER.error("获取信号量异常", e);
        }

        return flag;
    }

    /**
     * 释放信号量
     *
     * @param semaphore
     */
    public static void release(Semaphore semaphore) {

        try {
            semaphore.release();
        } catch (Exception e) {
            LOGGER.error("释放信号量异常", e);
        }
    }
}

5、存储用户信息的WebSocketUsers类实现

package com.badao.demo.websocket;

import com.badao.demo.config.MyThreadFactory;
import lombok.extern.slf4j.Slf4j;
import org.yeauty.pojo.Session;

import java.util.Collection;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.*;


@Slf4j
public class WebSocketUsers {

    private static final ThreadPoolExecutor pool = new ThreadPoolExecutor(10,WebSocketServer.socketMaxOnlineCount,10, TimeUnit.SECONDS,new ArrayBlockingQueue<>(1000),new MyThreadFactory("websocket-"));


    /**
     * 用户集
     */
    private static Map<String, Session> USERS = new ConcurrentHashMap<String, Session>();

    /**
     * 存储用户
     *
     * @param key     唯一键
     * @param session 用户信息
     */
    public static void put(String key, Session session) {
        USERS.put(key, session);
    }

    /**
     * 移除用户
     *
     * @param session 用户信息
     * @return 移除结果
     */
    public static boolean remove(Session session) {
        String key = null;
        boolean flag = USERS.containsValue(session);
        if (flag) {
            Set<Map.Entry<String, Session>> entries = USERS.entrySet();
            for (Map.Entry<String, Session> entry : entries) {
                Session value = entry.getValue();
                if (value.equals(session)) {
                    key = entry.getKey();
                    break;
                }
            }
        } else {
            return true;
        }
        return remove(key);
    }

    /**
     * 移出用户
     *
     * @param key 键
     */
    public static boolean remove(String key) {
        Session remove = USERS.remove(key);
        if (remove != null) {
            remove.close();
            boolean containsValue = USERS.containsValue(remove);
            log.warn("\n 移出结果 - {}", containsValue ? "失败" : "成功");
            return containsValue;
        } else {
            return true;
        }
    }

    /**
     * 获取在线用户列表
     *
     * @return 返回用户集合
     */
    public static Map<String, Session> getUsers() {
        return USERS;
    }

    /**
     * 群发消息文本消息
     *
     * @param message 消息内容
     */
    public static void sendMessageToUsersByText(String message) {
        Collection<Session> values = USERS.values();
        for (Session value : values) {
            pool.submit(() -> {
                synchronized (value) {
                    value.sendText(message);
                }
            });
        }
    }

    /**
     * 发送文本消息
     *
     * @param session 自己的用户名
     * @param message 消息内容
     */
    public static void sendMessageToUserByText(Session session, String message) {
        if (session != null) {
            session.sendText(message);
        } else {
            log.info("\n[你已离线]");
        }
    }
}

这里用的线程池相关概念参考上面博客，附自定义线程工厂MyThreadFactory实现

package com.badao.demo.config;

import java.util.concurrent.ThreadFactory;
import java.util.concurrent.atomic.AtomicInteger;

public class MyThreadFactory implements ThreadFactory {

    private static final AtomicInteger poolNumber = new AtomicInteger(1);
    private final ThreadGroup group;
    private final AtomicInteger threadNumber = new AtomicInteger(1);
    private final String namePrefix;

    public MyThreadFactory(String threadName) {
        SecurityManager s = System.getSecurityManager();
        group = (s !=null)?s.getThreadGroup():Thread.currentThread().getThreadGroup();
        if(threadName == null || threadName.isEmpty()){
            threadName = "pool";
        }
        namePrefix = threadName + poolNumber.getAndIncrement()+"-thread-";
    }

    @Override
    public Thread newThread(Runnable r) {
        Thread t = new Thread(group,r,namePrefix+threadNumber.getAndIncrement(),0);
        if(t.isDaemon()){
            t.setDaemon(false);
        }
        if(t.getPriority()!= Thread.NORM_PRIORITY){
            t.setPriority(Thread.NORM_PRIORITY);
        }
        return t;
    }
}

这里定义了线程名前缀。

6、又新建了一个Controller目的是为了获取当前所有的用户，因为前面限制了只能允许最多200用户

package com.badao.demo.websocket;


import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/websocket")
public class WebsocketController  {

    @GetMapping("/total")
    public String websocketTotal(){
        return WebSocketUsers.getUsers().keySet().toString();
    }

}

7、启动项目并使用websocket客户端工具进行测试

源码下载：

https://download.csdn.net/download/BADAO_LIUMANG_QIZHI/88912442

霸道流氓气质
关注
  • 5
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
websocket系列:基于netty-websocket-spring-boot-starter轻松实现高性能websocket
弹指天下
02-23 9106
基于netty-websocket-spring-boot-starter轻松实现高性能websocket
netty-spring-boot-starter:Netty与Spring Boot集成
03-19
netty-spring-boot-starter 基于Netty的Spring Boot Starter工程。 介绍 支持TCP长连接消息转发到Spring容器 支持自定义消息枚举类（ CommandController ， CommandMapping ） 支持自定义通信协议解析（ ProtocolProcessor ） 支持不同系统事件通知机制（ EventHandler ） 用例 使用SpringMVC中RestController的CommandController和GetMapping的CommandMapping进行消息定义，系统会自动将其注册进系统里 @CommandController public class SimpleCommand { @Autowired private SimpleService simpleService; @Comm
Netty Websocket SpringBoot Starter
最新发布
Myth的博客
07-13 273
添加依赖</</</</</</</</</基础配置自定义连接处理类实现存储扩展 com.github.kuangcp.websocket.store.CacheDao实现认证扩展 com.github.kuangcp.websocket.store.UserDao。
netty-websocket-spring-boot-starter基于netty的轻量级的高性能socket服务器
NICVSY的博客
01-25 6968
netty 老生常谈，干啥的？一个网络通信协议框架，自己可以各种自定义，具体的，网上一捞一大把。两大特性：NIO和零拷贝。 netty-websocket-spring-boot-starter 版本约定：0.9.5 基于此版演绎的，因为每个版本有轻微区别 官方文档： 直达网站https://gitee.com/Yeauty/netty-websocket-spring-boot-starter 这是个开源的框架。通过它，我们可以像spring-boot-starter-websocket一样使用注解进行开
SpringBoot 整合 Netty + Websocket
Mistra的博客
09-07 5876
最近项目中需要用到长连接服务，特地整合Netty+Websocket。我们系统需要给用户主动推送订单消息，还有强制用户下线的功能也需要长连接来推送消息 一、准备工作 Netty的介绍就看这里：https://www.jianshu.com/p/b9f3f6a16911 必须要理解到一些基础概念，什么是BIO，NIO，AIO，什么是多路复用，什么是Channel(相当于一个连接)，什么是管道等等概...
Springboot整合Netty提供WebSocket服务
wl_Honest的博客
10-09 1466
昨天重温Netty学习视频，发现Netty还能够提供WebSocket服务，刚好前段时间做了个WebSocket服务的接口，感觉做的不是很好，特地查了一下如何用Springboot整合Netty提供WebSocket服务。经过网上的搜查和昨天视频学习的现学现用，整理出此篇文章记录如何用WebSocket接口定时发送消息。
Spring-boot集成Netty做websocket服务端
Lance
06-21 6332
Springboot集成netty4.1.12做为websocket服务端，
SpringBoot中使用Netty开发WebSocket服务改造多线程群发消息示例代码
03-05
SpringBoot中使用Netty开发WebSocket服务改造多线程群发消息示例代码: https://blog.csdn.net/BADAO_LIUMANG_QIZHI/article/details/131681393
netty-websocket.zip
08-12
标题中的"Netty-WebSocket.zip"表明这是一个与Netty框架和WebSocket协议相关的项目或示例代码。Netty是一个高性能、异步事件驱动的网络应用程序框架，用于快速开发可维护的高性能协议服务器和客户端。而WebSocket是...
springboot-netty-websocket
08-31
标题“springboot-netty-websocket”表明我们正在讨论一个基于Spring Boot和Netty实现WebSocket通信的项目或教程。WebSocket是一种在客户端和服务器之间建立长连接的协议，它提供了双向通信能力，即服务器和客户端都...
Spring Boot 整合 Netty + WebSocket 实时消息推送
03-14
在"Spring Boot 整合 Netty + WebSocket 实时消息推送"项目中，我们主要关注以下几个核心知识点： 1. **Spring Boot集成WebSocket**：Spring Boot提供了Spring WebSocket模块，可以方便地集成WebSocket功能。通过...
Springboot中使用netty 实现 WebSocket 服务
蒯厅博客
11-06 3014
Springboot中使用netty 实现 WebSocket 服务
WebSocket | Netty netty-websocket-spring-boot-starter
苏老师的博客
09-23 1872
本文讲述 基于springboot + netty 实现websocket服务端搭建。 使用springboot 集成 netty-websocket-spring-boot-starter 来实现websocket
【项目实战】基于netty-websocket-spring-boot-starter实现WebSocket服务器长链接处理
本本本添哥
03-09 2695
项目中需要建立客户端与服务端之间的长链接，首先就考虑用WebSocket，再来SpringBoot原来整合WebSocket方式并不高效，因此找到了netty-websocket-spring-boot-starter 这款脚手架，它能让我们在SpringBoot中使用Netty来开发WebSocket服务器，并像spring-websocket的注解开发一样简单。
SpringBoot2+Netty+WebSocket(netty实现websocket）
A初夏1的博客
06-30 5338
##### 一、SpringBoot2+Netty+WebSocket(netty实现websocket，支持URL参数) 原文链接: https://zhengkai.blog.csdn.net/article/details/91552993 思路： 用netty实现 后台的 websocket 相当于前端利用websocket协议 后端用netty实现复杂的业务逻辑 <dependency> <groupId>io.netty</groupId> &lt
SpringBoot 整合 Netty 实现 WebSocket
MR.骑士道
05-11 7158
SpringBoot 整合 Netty 实现 WebSocket
SpringBoot项目整合WebSocket+netty实现前后端双向通信（同时支持前端webSocket和socket协议哦）
小米吃辣椒的博客
07-03 7638
最近做了一个硬件设备通信项目，需求是这样，前端使用webSocket向后端进行tcp协议的通信，后端netty服务端收到数据后，将数据发往socket客户端，客户端收到数据之后需要进行响应数据显示到前端页面供用户进行实时监控。
## springboot 集成基于netty的websocket 详解##
ew15988的博客
11-11 998
1、WebSocket简介WebSocket协议是基于TCP的一种新的网络协议。它实现了浏览器与服务器全双工(full-duplex)通信——允许服务器主动发送信息给客户端。双全工通信：全双工通信又称为双向同时通信，即通信的双方可以同时发送和接收信息的信息交互方式。半双工通信：数据传输指数据可以在一个信号载体的两个方向上传输，但是不能同时传输。
netty-websocket-spring-boot-starter使用案例
06-01
netty-websocket-spring-boot-starter是一个基于Netty实现的WebSocket框架，可以方便地在Spring Boot应用中集成WebSocket功能。使用该框架可以快速构建实时通信、消息推送等功能。 下面是一个使用netty-websocket-spring-boot-starter的简单案例： 1. 在pom.xml中添加依赖： ```xml <dependency> <groupId>com.github.wujiuye</groupId> <artifactId>netty-websocket-spring-boot-starter</artifactId> <version>1.0.0.RELEASE</version> </dependency> ``` 2. 编写WebSocket处理器 ```java @ServerEndpoint("/websocket/{userId}") @Component public class WebSocketHandler { private static final Logger logger = LoggerFactory.getLogger(WebSocketHandler.class); private Session session; private String userId; @OnOpen public void onOpen(Session session, @PathParam("userId") String userId) { this.session = session; this.userId = userId; logger.info("WebSocket连接建立，userId: {}", userId); } @OnMessage public void onMessage(String message) { logger.info("收到来自客户端的消息：{}", message); sendMessage("服务端已收到消息：" + message); } @OnClose public void onClose() { logger.info("WebSocket连接关闭，userId: {}", userId); } @OnError public void onError(Throwable t) { logger.error("WebSocket连接异常，userId: {}", userId, t); } public void sendMessage(String message) { try { this.session.getBasicRemote().sendText(message); } catch (IOException e) { logger.error("发送WebSocket消息失败，userId: {}", userId, e); } } } ``` 3. 配置WebSocket 在配置类中添加@EnableWebSocket注解，启用WebSocket功能，同时，也可以配置WebSocket的一些参数，例如端口号、路径等。 ```java @Configuration @EnableWebSocket public class WebSocketConfig implements WebSocketConfigurer { @Autowired private WebSocketHandler webSocketHandler; @Override public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) { registry.addHandler(webSocketHandler, "/websocket/{userId}") .setAllowedOrigins("*"); } } ``` 4. 测试WebSocket 使用浏览器或WebSocket客户端连接WebSocket服务端，例如：ws://localhost:8080/websocket/123，其中123为userId。 以上就是一个简单的netty-websocket-spring-boot-starter使用案例。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

霸道流氓气质

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值