基于Netty模拟大量WebSocket客户端

最新推荐文章于 2024-07-09 18:00:22 发布
最新推荐文章于 2024-07-09 18:00:22 发布
阅读量1k 收藏 3
点赞数
分类专栏： Java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dyj095/article/details/127714472
版权

基于Netty模拟大量WebSocket客户端

目录

一、概述

前段时间需要写一个模拟大量客户端的程序来对服务器做压力测试，选用了Netty做为通信框架，通信协议采用了WebSocket，根据官方下载的源码和Demo写完后发现连接几十个连接后就无法继续获取新的Socket通道了，后来经过各种尝试后发现是EventLoopGroup用法不正确导致的，正确用法是所有的Socket连接共用一个EventLoopGroup就可以正常模拟大量的客户端连接了。

二、错误用法演示

文中所有代码主要参照Netty官方源码中netty-netty-4.1.84.Final/example/src/main/java/io/netty/example/http/websocketx/client/

1、启动类

public class Simulator {
    public static void start() {
        String serverIp = "127.0.0.1";
        int serverPort = 8005;
        for (int i = 0; i < 10000; i++) {
            WebSocketConnector client = new WebSocketConnector(serverIp,serverPort);
            client.doConnect();
        }
    }
}

2、WebSocket连接类

import io.netty.bootstrap.Bootstrap;
import io.netty.channel.*;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioSocketChannel;
import io.netty.handler.codec.http.DefaultHttpHeaders;
import io.netty.handler.codec.http.HttpClientCodec;
import io.netty.handler.codec.http.HttpObjectAggregator;
import io.netty.handler.codec.http.websocketx.WebSocketClientHandshakerFactory;
import io.netty.handler.codec.http.websocketx.WebSocketVersion;
import io.netty.handler.stream.ChunkedWriteHandler;
import lombok.extern.slf4j.Slf4j;

import java.net.URI;

/**
 * WebSocket协议类型的模拟客户端连接器类
 *
 * @author duyanjun
 * @since 2022/10/13 杜燕军 新建
 */
@Slf4j
public class WebSocketConnector {
    // 服务器ip
    protected String serverIp;
    // 服务器通信端口
    protected int serverSocketPort;
    // 网络通道
    private Channel channel;

    /**
     * WebSocket协议类型的模拟客户端连接器构造方法
     *
     * @param serverIp
     * @param serverSocketPort
     */
    public WebSocketConnector(String serverIp,int serverSocketPort) {
        this.serverIp = serverIp;
        this.serverSocketPort = serverSocketPort;
    }

    public void doConnect() {
        try {
            String URL = "ws://"+ this.serverIp + ":" + this.serverSocketPort + "/";
            URI uri = new URI(URL);
            final WebSocketIoHandler handler =
                    new WebSocketIoHandler(
                            WebSocketClientHandshakerFactory.newHandshaker(
                                    uri, WebSocketVersion.V13, null, true, new DefaultHttpHeaders()));
            EventLoopGroup group = new NioEventLoopGroup();
            Bootstrap bootstrap = new Bootstrap();
            bootstrap.group(group).channel(NioSocketChannel.class)
                    //.option(ChannelOption.TCP_NODELAY, true)
                    .option(ChannelOption.SO_KEEPALIVE,true)
                    .handler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {
                            ChannelPipeline pipeline = ch.pipeline();
                            // 添加一个http的编解码器
                            pipeline.addLast(new HttpClientCodec());
                            // 添加一个用于支持大数据流的支持
                            pipeline.addLast(new ChunkedWriteHandler());
                            // 添加一个聚合器，这个聚合器主要是将HttpMessage聚合成FullHttpRequest/Response
                            pipeline.addLast(new HttpObjectAggregator(1024 * 64));
                            pipeline.addLast(handler);
                        }
                    });
            try {
                synchronized (bootstrap) {
                    final ChannelFuture future = bootstrap.connect(this.serverIp, this.serverSocketPort).sync();
                    this.channel = future.channel();
                }
            } catch (InterruptedException e) {
                log.error("连接服务失败.......................uri:" + uri.toString(),e);
            }catch (Exception e) {
                log.error("连接服务失败.......................uri:" + uri.toString(),e);
            }
        } catch (Exception e) {
            log.error("连接服务失败.......................",e);
        } finally {
        }
    }

    public void disConnect() {
        this.channel.close();
    }
  • 问题代码主要在上述代码中 EventLoopGroup group = new NioEventLoopGroup() 这样使用后就导致每个WebSocket连接会创建一个新的EventLoopGroup对象,导致无法创建大量的客户端连接；
  • 正确用法应该是将EventLoopGroup提到WebSocketConnector类的上层，由WebSocketConnector对象的创建者维护一个公共的EventLoopGroup对象，所有WebSocketConnector对象共享一个EventLoopGroup对象；

3、IO数据处理类


import io.netty.channel.*;
import io.netty.handler.codec.http.FullHttpResponse;
import io.netty.handler.codec.http.websocketx.*;
import io.netty.handler.timeout.IdleState;
import io.netty.handler.timeout.IdleStateEvent;
import io.netty.util.CharsetUtil;
import lombok.extern.slf4j.Slf4j;

/**
 * WebSocket协议类型的模拟客户端IO处理器类
 *
 * @author duyanjun
 * @since 2022/10/13 杜燕军 新建
 */
@Slf4j
public class WebSocketIoHandler extends SimpleChannelInboundHandler<Object> {

    private final WebSocketClientHandshaker handShaker;

    private ChannelPromise handshakeFuture;

    public WebSocketIoHandler(WebSocketClientHandshaker handShaker) {
        this.handShaker = handShaker;
    }

    public ChannelFuture handshakeFuture() {
        return handshakeFuture;
    }

    @Override
    public void handlerAdded(ChannelHandlerContext ctx) {
        handshakeFuture = ctx.newPromise();
    }

    @Override
    public void channelActive(ChannelHandlerContext ctx) {
        handShaker.handshake(ctx.channel());
    }

    @Override
    public void channelInactive(ChannelHandlerContext ctx) {
        ctx.close();
        try {
            super.channelInactive(ctx);
        } catch (Exception e) {
            log.error("channelInactive 异常.", e);
        }
        log.warn("WebSocket链路与服务器连接已断开.");
    }

    @Override
    public void channelRead0(ChannelHandlerContext ctx, Object msg) throws Exception {
        Channel ch = ctx.channel();
        if (!handShaker.isHandshakeComplete()) {
            try {
                handShaker.finishHandshake(ch, (FullHttpResponse) msg);
                handshakeFuture.setSuccess();
                log.info("WebSocket握手成功，可以传输数据了.");
                // 数据一定要封装成WebSocketFrame才能发达
                String data = "Hello";
                WebSocketFrame frame = new TextWebSocketFrame(data);
                ch.writeAndFlush(frame);
            } catch (WebSocketHandshakeException e) {
                log.warn("WebSocket Client failed to connect");
                handshakeFuture.setFailure(e);
            }
            return;
        }

        if (msg instanceof FullHttpResponse) {
            FullHttpResponse response = (FullHttpResponse) msg;
            throw new IllegalStateException(
                    "Unexpected FullHttpResponse (getStatus=" + response.status() +
                            ", content=" + response.content().toString(CharsetUtil.UTF_8) + ')');
        }

        WebSocketFrame frame = (WebSocketFrame) msg;
        if (frame instanceof TextWebSocketFrame) {
            TextWebSocketFrame textFrame = (TextWebSocketFrame) frame;
            String s = textFrame.text();
            log.info("WebSocket Client received message: " + s);
        } else if (frame instanceof PongWebSocketFrame) {
            log.info("WebSocket Client received pong");
        } else if (frame instanceof CloseWebSocketFrame) {
            log.info("WebSocket Client received closing");
            ch.close();
        }
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        log.error("WebSocket链路由于发生异常,与服务器连接已断开.", cause);
        if (!handshakeFuture.isDone()) {
            handshakeFuture.setFailure(cause);
        }
        ctx.close();
        super.exceptionCaught(ctx, cause);
    }

    @Override
    public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
        if (evt instanceof IdleStateEvent) {
            IdleStateEvent event = (IdleStateEvent) evt;
            // 如果写通道处于空闲状态,就发送心跳命令
            if (IdleState.WRITER_IDLE.equals(event.state()) || IdleState.READER_IDLE.equals(event.state())) {
                // 发送心跳数据
            }
        } else {
            super.userEventTriggered(ctx, evt);
        }
    }
}

三、正确用法演示

1、启动类

import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;

public class Simulator {
    public static void start() {
        String serverIp = "127.0.0.1";
        int serverPort = 8005;
        EventLoopGroup group = new NioEventLoopGroup();
        for (int i = 0; i < 10000; i++) {
            WebSocketConnector client = new WebSocketConnector(serverIp,serverPort,group);
            client.doConnect();
        }
    }
}

2、WebSocket连接类

import io.netty.bootstrap.Bootstrap;
import io.netty.channel.*;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioSocketChannel;
import io.netty.handler.codec.http.DefaultHttpHeaders;
import io.netty.handler.codec.http.HttpClientCodec;
import io.netty.handler.codec.http.HttpObjectAggregator;
import io.netty.handler.codec.http.websocketx.WebSocketClientHandshakerFactory;
import io.netty.handler.codec.http.websocketx.WebSocketVersion;
import io.netty.handler.stream.ChunkedWriteHandler;
import lombok.extern.slf4j.Slf4j;

import java.net.URI;

/**
 * WebSocket协议类型的模拟客户端连接器类
 *
 * @author duyanjun
 * @since 2022/10/13 杜燕军 新建
 */
@Slf4j
public class WebSocketConnector {
    // 服务器ip
    protected String serverIp;
    // 服务器通信端口
    protected int serverSocketPort;
    // 事件循环线程池
    protected EventLoopGroup group;
    // 网络通道
    private Channel channel;

    /**
     * WebSocket协议类型的模拟客户端连接器构造方法
     *
     * @param serverIp
     * @param serverSocketPort
     * @param group
     */
    public WebSocketConnector(String serverIp,int serverSocketPort,EventLoopGroup group) {
        this.serverIp = serverIp;
        this.serverSocketPort = serverSocketPort;
        this.group = group;
    }

    public void doConnect() {
        try {
            String URL = "ws://"+ this.serverIp + ":" + this.serverSocketPort + "/";
            URI uri = new URI(URL);
            final WebSocketIoHandler handler =
                    new WebSocketIoHandler(
                            WebSocketClientHandshakerFactory.newHandshaker(
                                    uri, WebSocketVersion.V13, null, true, new DefaultHttpHeaders()));
            Bootstrap bootstrap = new Bootstrap();
            bootstrap.group(group).channel(NioSocketChannel.class)
                    //.option(ChannelOption.TCP_NODELAY, true)
                    .option(ChannelOption.SO_KEEPALIVE,true)
                    .handler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {
                            ChannelPipeline pipeline = ch.pipeline();
                            // 添加一个http的编解码器
                            pipeline.addLast(new HttpClientCodec());
                            // 添加一个用于支持大数据流的支持
                            pipeline.addLast(new ChunkedWriteHandler());
                            // 添加一个聚合器，这个聚合器主要是将HttpMessage聚合成FullHttpRequest/Response
                            pipeline.addLast(new HttpObjectAggregator(1024 * 64));
                            pipeline.addLast(handler);
                        }
                    });
            try {
                synchronized (bootstrap) {
                    final ChannelFuture future = bootstrap.connect(this.serverIp, this.serverSocketPort).sync();
                    this.channel = future.channel();
                }
            } catch (InterruptedException e) {
                log.error("连接服务失败.......................uri:" + uri.toString(),e);
            }catch (Exception e) {
                log.error("连接服务失败.......................uri:" + uri.toString(),e);
            }
        } catch (Exception e) {
            log.error("连接服务失败.......................",e);
        } finally {
        }

    }

    public void disConnect() {
        this.channel.close();
    }
}

3、IO数据处理类

// Io数据处理类WebSocketIoHandler.java没有变化，使用二、错误用法演示->3、IO数据处理类中所示代码即可
老杜095
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Netty 模拟百万连接
everyok的博客
12-06 3383
  我们知道单机的端口最多65536，除去系统使用的端口， 留给程序使用的也就6万个端口， 在需要对单机做长连接压力测试的时候，如果要测60W的长连接并发，就得找10台机器，而一般情况下我们并没有这么多的空闲机器去做这种规模的测试，那如何用两台机器模拟百万连接呢？对于TCP的连接，系统用一个4四元组来唯一标识：{server ip, server port...
基于Netty的WebSocket
dzyls的笔记
11-24 261
WebSocket Http是无状态的，浏览器每次请求，都是创建一个新连接，传输完毕即断开。双方并不能感知对方的状态。 而WebSocket是长连接，一次TCP握手，即可建立持久性的连接，并且双方能感知到对方的状态。 核心代码： // 因为基于http，所以要添加http编码和解码器 pipeline.addLast(new HttpServerCodec()); // 以块的方式写，添加Chu...
Springboot+Netty搭建TCP客户端-多客户端
热门推荐
蚂蚁舞
07-04 1万+
之前搭建了一个Springboot+Netty服务端的应用，既然有服务端，自然也有客户端的应用，现在搭建一个Springboot+Netty客户端的应用Demo程序，使用多客户端和服务端联调交互进行测试。
websocket推送消息，模拟推送
最新发布
在职可交流前端开发，包括：web端、uniapp等，欢迎指教。
07-09 802
MQTT.js 是一个功能强大的 MQTT 客户端库，支持在 Node.js 和浏览器中使用。下面是一个简单的示例，展示如何在浏览器中使用 MQTT over WebSocket。通过将 MQTT 与 WebSocket 结合使用，可以在 Web 应用中实现高效、实时的消息传输，特别适用于需要实时数据更新的应用场景。MQTT 的发布/订阅模式与 WebSocket 的双向通信特性相结合。简化了初始化一个MQTT对象的代码书写。
netty学习（3）:SpringBoot整合netty实现多个客户端与服务器通信
weixin_42774617的博客
07-03 5712
整体工程目录：一个server服务（netty服务器），两个client服务（netty客户端）pom文件引入netty依赖，springboot依赖。创建一个SpringBoot工程，然后创建三个子模块。然后按照相同的方法创建client2。
WebSocket学习
orchidofocean的博客
02-25 1011
从搜索引擎搜索资料：https://www.runoob.com/html/html5-websocket.html WebSocket 是 HTML5 开始提供的一种在单个 TCP 连接上进行全双工通讯的协议。WebSocket 使得客户端和服务器之间的数据交换变得更加简单，允许服务端主动向客户端推送数据。在 WebSocket API 中，浏览器和服务器只需要完成一次握手，两者之间就直接可以...
Netty系列3：多客户端实现
qq_37596793的博客
10-24 298
暂时未实现
netty-实现websocket
AmbroseLe
07-08 1665
netty介绍 netty是一个高性能、事件驱动、异步非阻塞的 IO java 开源框架，由Jboss提供，建立tcp等底层连接。基于netty可以建立高性能的http服务器，快速开发，高性能高可靠的网络服务器和客户端程序，支持http、websocket、tcp、udp等。很多高性能的项目，把他作为socket底层的通信基础。 netty是基于nio的客户服务端、服务端编程框架。使用netty可以快速的开发出简单的一个网络应用，netty相当简化的和流线化了网络应用的开发过程 稳定性和伸缩性 使用
spring boot + netty websocket
10-23
在测试方面，由于WebSocket是基于TCP的，所以普通的HTTP测试工具可能无法很好地模拟WebSocket通信。这里我们可以使用一些专门的WebSocket测试工具，如`ws`命令行工具，或者在代码中使用`WebSocketClient`进行测试。 ...
nettyWebSocket.rar
12-19
客户端则需要配置WebSocket客户端解码器，以便正确解析服务器发送的数据。 3. **Pom.xml**：这是Maven项目的配置文件，包含项目依赖。在这里，应该列出了Netty库和其他可能的依赖，如WebSocket的相关库，如`netty-...
spring+websocketdemo
11-29
3. **WebSocket客户端**：在前端，可以使用JavaScript的WebSocket API或者库（如Stomp.js、sockjs-client）来建立WebSocket连接，订阅和发送消息。例如，通过`new WebSocket('ws://localhost:8080/ws')`创建连接，...
互联网实时聊天系统 (Spring + Netty + Websocket).zip
04-01
存储设备：如硬盘、固态硬盘 (SSD)、光盘驱动器等，用于长期保存大量的程序和数据。 输入/输出设备：如键盘、鼠标、显示器、打印机、扫描仪、摄像头等，实现人与计算机之间的交互以及数据的输入和输出。 主板：...
cheshuo：:jack-o-lantern:轻量级的游戏服务器框架。 基于Springboot和Netty。 使用ProtoBuf作为客户端和服务器之间的通信
02-04
车硕一个轻量级的游戏服务器框架，基于Springboot和Netty，使用Protobuf作为客户端和服务器之间的通信。功能逐步完善中... :face_blowing_a_kiss:目前支持协议： TCP协议Websocket项目依赖：名称为链接JDK1.8 Java...
基于netty实现多个客户端和服务端进行通信
华安小书童的博客
03-03 5225
在netty的实际使用中，会经常有多个客户端和服务器进行连接的情况。另外，由于netty的客户端和服务端是进行的长连接，所以也需要客户端和服务端进行心跳的传递，今天学习完这块内容后，跟着视频写了个demo。大致就是多个客户端与服务端建立连接之后，服务端已广播的形式给客户端发送消息。 下面先写服务端相关代码 自定义的处理器 package cn.zxw.netty.third_chat.server...
做个小工具-WebSocket客户端
nightingale1985的博客
12-07 1234
调试助手，websocket
netty开2个端口实现socket连接和websocket连接
m0_62690910的博客
08-17 989
netty+springboot开2个端口实现socket连接和websocket连接---个人记录
Netty整合WebSocket实现服务器和浏览器通信
冰冰的博客
12-10 486
对于netty也学了一会，本章内容，是根据视频所学，写的，大家可参考 可直接copy运行，进行参考 1.前端部分 <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Title</title> </head> &...
十一、Netty 通过 WebSocket 编程实现服务器和客户端长连接
猿小许的博客
11-09 678
一、 什么是Websocket? 1、websocket技术应用场景 使用java技术快速学习一个简单的在线聊天室系统，该系统具备很强的扩展性，可以根据业务需要，制作在线客服系统、web版的微信、QQ即时通信系统等，使用较为流行的技术，采用积木式的编程思路。 web领域的实时推送技术，也被称为Realtime技术，这种技术要达到的目的是绕过用户不需要刷新浏览器就可以获得实时更新。他有着广泛的应用前景，比如在线聊天室，在线客服系统、评论系统、WebIM等。 2、websocket协议概述 webSocket
【网络编程】一文搞定Netty，打造单机百万连接测试！
互联网小阿祥
11-03 3276
一文搞定Netty，打造单机百万连接测试！
基于springboot+netty封装websocket客户端生成代码发给我
05-26
很抱歉，作为一名AI语言模型，我无法生成代码。不过我可以给你提供一些参考资料，希望能对你有所帮助。 首先，你需要在Spring Boot项目中引入Netty和WebSocket的依赖，例如： ```xml <dependency> <groupId>io.netty</groupId> <artifactId>netty-all</artifactId> <version>4.1.22.Final</version> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-websocket</artifactId> </dependency> ``` 然后，你可以编写一个WebSocket客户端类，例如： ```java @Component public class WebSocketClient { private final WebSocketClientHandshaker handshaker; private WebSocketChannel channel; public WebSocketClient(@Value("${websocket.url}") String url) throws Exception { URI uri = new URI(url); handshaker = WebSocketClientHandshakerFactory.newHandshaker(uri, WebSocketVersion.V13, null, true, new DefaultHttpHeaders()); } public void connect() throws Exception { Bootstrap bootstrap = new Bootstrap(); EventLoopGroup group = new NioEventLoopGroup(); try { bootstrap.group(group) .channel(NioSocketChannel.class) .handler(new WebSocketClientInitializer(handshaker)); ChannelFuture future = bootstrap.connect(handshaker.uri().getHost(), handshaker.uri().getPort()).sync(); channel = ((WebSocketClientHandler) future.channel().pipeline().last()).getChannel(); handshaker.handshake(channel).sync(); } catch (InterruptedException e) { e.printStackTrace(); } finally { group.shutdownGracefully(); } } public void send(String message) { WebSocketFrame frame = new TextWebSocketFrame(message); channel.writeAndFlush(frame); } public void close() { channel.close(); } } ``` 其中，WebSocketClientInitializer是用于初始化Netty的WebSocket客户端的，例如： ```java public class WebSocketClientInitializer extends ChannelInitializer<SocketChannel> { private final WebSocketClientHandshaker handshaker; public WebSocketClientInitializer(WebSocketClientHandshaker handshaker) { this.handshaker = handshaker; } @Override protected void initChannel(SocketChannel channel) throws Exception { channel.pipeline() .addLast(new HttpClientCodec()) .addLast(new HttpObjectAggregator(8192)) .addLast(new WebSocketClientHandler(handshaker)); } } ``` 最后，你可以在Spring Boot的控制器中使用WebSocketClient来与WebSocket服务器进行通信，例如： ```java @RestController public class WebSocketController { @Autowired private WebSocketClient webSocketClient; @PostMapping("/send") public void send(@RequestBody String message) { webSocketClient.send(message); } } ``` 这样你就可以使用Spring Boot和Netty来实现WebSocket客户端了。希望对你有所帮助。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

老杜095

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

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

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

打赏作者

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

抵扣说明：

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

余额充值