netty建立websocket通道

最新推荐文章于 2025-05-25 16:28:10 发布
最新推荐文章于 2025-05-25 16:28:10 发布
阅读量553 收藏 2
点赞数
CC 4.0 BY-SA版权
分类专栏： netty JAVA 文章标签： websocket http
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/woniyu123/article/details/118420425
本文档展示了如何使用Netty构建WebSocket服务器并处理客户端连接。通过引入Netty依赖，定义`LcfcSebsocketChannelHandler`处理通道事件，包括连接建立、消息处理和异常捕获。同时，配置`LcfcWebsocketChannelInitializer`初始化通道，并启动`LcfcWebsockerServerStart`来启动WebSocket服务。此外，还提供了WebSocket客户端的`WebSocketClientHandler`处理类和启动客户端的`WebsocketClient`示例。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

使用netty建立websocket通道

项目地址

1、引入maven依赖

<dependency>
			<groupId>io.netty</groupId>
			<artifactId>netty-all</artifactId>
			<version>4.1.60.Final</version>
		</dependency>

2、编写通道处理

@Slf4j
@NoArgsConstructor
public class LcfcSebsocketChannelHandler extends SimpleChannelInboundHandler<Object> {

    private static final String TOKEN="token";

    private WebsocketConfig  socketConfig;

    private WebSocketServerHandshaker handshaker;

    private WebsocketConnectLogService logService;

    public LcfcSebsocketChannelHandler(WebsocketConfig config,WebsocketConnectLogService logService){
        this.socketConfig = config;
        this.logService = logService;
    }


    @Override
    protected void channelRead0(ChannelHandlerContext ctx, Object msg) throws Exception {

        log.debug("收到消息："+msg);
        if (msg instanceof FullHttpRequest){
            //以http请求形式接入，但是走的是websocket
            handleHttpRequest(ctx, (FullHttpRequest) msg);
        }else if (msg instanceof WebSocketFrame){
            //处理websocket客户端的消息
            handlerWebSocketFrame(ctx, (WebSocketFrame) msg);
        }


    }

    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        //添加连接
//        String userId = ctx.channel().attr(WebsocketUtils.ATTRIBUTE_KEY_USER_ID).get();
        WebsocketUtils.addChannel(ctx.channel());
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        log.error("链接发生错误=",cause.getMessage());
        String userId = ctx.channel().attr(WebsocketUtils.ATTRIBUTE_KEY_USER_ID).get();
        saveConnectLog(ctx,userId,cause.getMessage(),MessageConstants.exceptionStatus.exception);
        WebsocketUtils.removeChannel(ctx.channel());
    }



    @Override
    public void channelInactive(ChannelHandlerContext ctx) throws Exception {
        //断开连接
        log.debug("客户端断开连接："+ctx.channel());
        WebsocketUtils.removeChannel(ctx.channel());
        saveConnectLog(ctx,null,"客户端断开链接");
    }

    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
        ctx.flush();
    }

    private void handlerWebSocketFrame(ChannelHandlerContext ctx, WebSocketFrame frame){
        // 判断是否关闭链路的指令
        if (frame instanceof CloseWebSocketFrame) {
            handshaker.close(ctx.channel(), (CloseWebSocketFrame) frame.retain());
            return;
        }
        // 判断是否ping消息
        if (frame instanceof PingWebSocketFrame) {
            ctx.channel().write(
                    new PongWebSocketFrame(frame.content().retain()));
            return;
        }
        // 本例程仅支持文本消息，不支持二进制消息
        if (!(frame instanceof TextWebSocketFrame)) {
            log.debug("本例程仅支持文本消息，不支持二进制消息");
            throw new UnsupportedOperationException(String.format(
                    "%s frame types not supported", frame.getClass().getName()));
        }
        // 返回应答消息
        String request = ((TextWebSocketFrame) frame).text();
        log.debug("服务端收到：" + request);
        TextWebSocketFrame tws = new TextWebSocketFrame(new Date().toString()
                + ctx.channel().id() + "：" + request);
        // 群发
//        log.info("发送消息");
//        WebsocketUtils.send2All(tws);
        // 返回【谁发的发给谁】
        // ctx.channel().writeAndFlush(tws);
    }

    /**
     * 唯一的一次http请求，用于创建websocket
     * */
    private void handleHttpRequest(ChannelHandlerContext ctx,
                                   FullHttpRequest req) {
        //要求Upgrade为websocket，过滤掉get/Post
        if (!req.decoderResult().isSuccess()
                || (!"websocket".equals(req.headers().get("Upgrade")))) {
            //若不是websocket方式，则创建BAD_REQUEST的req，返回给客户端
            saveConnectLog(ctx,null,"要求Upgrade为websocket",MessageConstants.exceptionStatus.exception);
            sendHttpResponse(ctx, req, new DefaultFullHttpResponse(
                    HttpVersion.HTTP_1_1, HttpResponseStatus.BAD_REQUEST),"非websocket请求");
            return;
        }


        String uri = req.uri();

        ConcurrentMap<String, String> paramMap = getUrlParams(uri);
        log.debug("获取uri中参数={}",paramMap);
        if (paramMap.get(TOKEN)==null){
            saveConnectLog(ctx,null,"请求参数中没有token",
                    MessageConstants.exceptionStatus.exception);
            sendHttpResponse(ctx, req, new DefaultFullHttpResponse(
                    HttpVersion.HTTP_1_1, HttpResponseStatus.BAD_REQUEST),"token不合法");
            return;
        }
        try {
           String userId =  PlatfromComponent.getInstants(socketConfig.getCheckUrl()).checkToken(paramMap.get(TOKEN));
           paramMap.put(WebsocketUtils.KEY_USER_ID,userId);
        }catch (Exception e){
            String msg = "根据token获取用户信息出错";
            log.error(msg);
            saveConnectLog(ctx,null,msg,
                    MessageConstants.exceptionStatus.exception);
            sendHttpResponse(ctx, req, new DefaultFullHttpResponse(
                    HttpVersion.HTTP_1_1,
                    HttpResponseStatus.BAD_REQUEST),msg);
            return;
        }

        WebSocketServerHandshakerFactory wsFactory = new WebSocketServerHandshakerFactory(
                "ws://"+socketConfig.getRemoteUrl()+":"+socketConfig.getPort()+"/websocket", null, false);
        handshaker = wsFactory.newHandshaker(req);
        if (handshaker == null) {
            WebSocketServerHandshakerFactory
                    .sendUnsupportedVersionResponse(ctx.channel());
        } else {
            handshaker.handshake(ctx.channel(), req);

            WebsocketUtils.setChannelParam(ctx.channel(),paramMap.get(WebsocketUtils.KEY_USER_ID));
            String ip = req.headers().get("X-real-ip");
            if (ip!=null){
                saveConnectLog(ctx,null,"链接建立成功",MessageConstants.exceptionStatus.normal,ip);
            }else {
                saveConnectLog(ctx,null,"链接建立成功");

            }
        }



    }
    /**
     * 拒绝不合法的请求，并返回错误信息
     * */
    private static void sendHttpResponse(ChannelHandlerContext ctx,
                                         FullHttpRequest req, DefaultFullHttpResponse res,String msg) {
        // 返回应答给客户端
        if (res.status().code() != 200) {
            ByteBuf buf = Unpooled.copiedBuffer(msg,
                    CharsetUtil.UTF_8);
            res.content().writeBytes(buf);
            buf.release();
        }
        ChannelFuture f = ctx.channel().writeAndFlush(res);
        // 如果是非Keep-Alive，关闭连接
        if (!isKeepAlive(req) || res.status().code() != 200) {
            f.addListener(ChannelFutureListener.CLOSE);
        }
    }


    private static ConcurrentMap<String, String> getUrlParams(String url) {
        ConcurrentMap<String, String> map = new ConcurrentHashMap<>();
        url = url.replace("?", ";");
        if (!url.contains(";")) {
            return map;
        }
        if (url.split(";").length > 0) {
            String[] arr = url.split(";")[1].split("&");
            for (String s : arr) {
                String key = s.split("=")[0];
                String value = s.split("=")[1];
                map.put(key, value);
            }
            return map;

        } else {
            return map;
        }
    }

    private void saveConnectLog(ChannelHandlerContext ctx,String userId,String msg){
        saveConnectLog(ctx,userId,msg,MessageConstants.exceptionStatus.normal,null);
    }

    private void saveConnectLog(ChannelHandlerContext ctx,String userId,String msg,Integer status){
        saveConnectLog(ctx,userId,msg,status,null);
    }

    /**
     *
     * @param ctx
     * @param userId 用户id
     * @param msg 链接描述
     * @param status 链接状态
     */
    private void saveConnectLog(ChannelHandlerContext ctx,String userId,String msg,Integer status,String clientIP){
        if (userId==null){
            userId = ctx.channel().attr(WebsocketUtils.ATTRIBUTE_KEY_USER_ID).get();
        }
        if (clientIP==null){
            InetSocketAddress insocket = (InetSocketAddress) ctx.channel().remoteAddress();
            clientIP = insocket.getAddress().getHostAddress();
        }

        WebsocketConnectLog log = WebsocketConnectLog.builder()
                .host(clientIP)
                .msg(msg)
                .userId(userId)
                .status(status)
                .time(new Date())
                .build();

        logService.save(log);
    }

}

3、配置通道初始化

@NoArgsConstructor
@AllArgsConstructor
public class LcfcWebsocketChannelInitializer extends ChannelInitializer<SocketChannel> {

    private WebsocketConfig config;

    private WebsocketConnectLogService logService;

    protected void initChannel(SocketChannel socketChannel) throws Exception {

        socketChannel.pipeline().addLast("http-codec", new HttpServerCodec());
        socketChannel.pipeline().addLast("aggregator", new HttpObjectAggregator(65536));
        socketChannel.pipeline().addLast("http-chunked", new ChunkedWriteHandler());
        socketChannel.pipeline().addLast("handler", new LcfcSebsocketChannelHandler(config,logService));
    }
}

4、启动websocket服务端

@Slf4j
@Component
public class LcfcWebsockerServerStart  implements ApplicationRunner {

    @Autowired
    WebsocketConfig config;

    @Autowired
    WebsocketConnectLogService logService;

    @Override
    public void run(ApplicationArguments args) throws Exception {

        new Thread(()->{init();}).start();
//        init();
    }
    private void init(){
        log.info("正在启动websocket服务器");
        NioEventLoopGroup boss=new NioEventLoopGroup();
        NioEventLoopGroup work=new NioEventLoopGroup();
        try {
            ServerBootstrap bootstrap=new ServerBootstrap();
            bootstrap.group(boss,work);
            bootstrap.channel(NioServerSocketChannel.class);
            bootstrap.childHandler(new LcfcWebsocketChannelInitializer(config,logService));
            Channel channel = bootstrap.bind(config.getPort()).sync().channel();
            log.info("webSocket服务器启动成功："+channel);
            channel.closeFuture().sync();
        } catch (InterruptedException e) {
            e.printStackTrace();
            log.info("运行出错："+e);
        }finally {
            boss.shutdownGracefully();
            work.shutdownGracefully();
            log.info("websocket服务器已关闭");
        }
    }

}

启动后如果看到 17:24:38.692 [Thread-32] INFO c.l.w.s.i.LcfcWebsockerServerStart - [init,41] - webSocket服务器启动成功：[id: 0x4dbe0472, L:/0:0:0:0:0:0:0:0:19999]，说明启动成功

5、websocket客户端编写

5.1 编写通道处理

public class WebSocketClientHandler extends SimpleChannelInboundHandler<Object> {

    private final WebSocketClientHandshaker handshaker;
    private ChannelPromise handshakeFuture;

    public WebSocketClientHandler(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) {
        System.out.println("WebSocket Client disconnected!");
    }

    @Override
    public void channelRead0(ChannelHandlerContext ctx, Object msg) throws Exception {
        Channel ch = ctx.channel();
        if (!handshaker.isHandshakeComplete()) {
            try {
                handshaker.finishHandshake(ch, (FullHttpResponse) msg);
                System.out.println("WebSocket Client connected!");
                handshakeFuture.setSuccess();
            } catch (WebSocketHandshakeException e) {
                System.out.println("WebSocket Client failed to connect");
                handshakeFuture.setFailure(e);
            }
            return;
        }

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

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

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
        cause.printStackTrace();
        if (!handshakeFuture.isDone()) {
            handshakeFuture.setFailure(cause);
        }
        ctx.close();
    }
}

5.2 启动客户端

public class WebsocketClient {
    static final String URL = System.getProperty("url", "ws://127.0.0.1:19999/websocket?userId=456");


    public static void main(String[] args) throws Exception {
        URI uri = new URI(URL);
        String scheme = uri.getScheme() == null ? "ws" : uri.getScheme();
        final String host = uri.getHost() == null ? "127.0.0.1" : uri.getHost();
        final int port;
        if (uri.getPort() == -1) {
            if ("ws".equalsIgnoreCase(scheme)) {
                port = 80;
            } else if ("wss".equalsIgnoreCase(scheme)) {
                port = 443;
            } else {
                port = -1;
            }
        } else {
            port = uri.getPort();
        }

        if (!"ws".equalsIgnoreCase(scheme) && !"wss".equalsIgnoreCase(scheme)) {
            System.err.println("Only WS(S) is supported.");
            return;
        }

        final boolean ssl = "wss".equalsIgnoreCase(scheme);
        final SslContext sslCtx;
        if (ssl) {
            sslCtx = SslContextBuilder.forClient()
                    .trustManager(InsecureTrustManagerFactory.INSTANCE).build();
        } else {
            sslCtx = null;
        }

        EventLoopGroup group = new NioEventLoopGroup();
        try {
            // Connect with V13 (RFC 6455 aka HyBi-17). You can change it to V08 or V00.
            // If you change it to V00, ping is not supported and remember to change
            // HttpResponseDecoder to WebSocketHttpResponseDecoder in the pipeline.
            final WebSocketClientHandler handler =
                    new WebSocketClientHandler(
                            WebSocketClientHandshakerFactory.newHandshaker(
                                    uri, WebSocketVersion.V13, null, false, new DefaultHttpHeaders()));

            Bootstrap b = new Bootstrap();
            b.group(group)
                    .channel(NioSocketChannel.class)
                    .handler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel ch) {
                            ChannelPipeline p = ch.pipeline();
                            if (sslCtx != null) {
                                p.addLast(sslCtx.newHandler(ch.alloc(), host, port));
                            }
                            p.addLast(
                                    new HttpClientCodec(),
                                    new HttpObjectAggregator(8192),
                                    handler);
                        }
                    });

            Channel ch = b.connect(uri.getHost(), port).sync().channel();
            handler.handshakeFuture().sync();

            BufferedReader console = new BufferedReader(new InputStreamReader(System.in));
            while (true) {
                String msg = console.readLine();
                if (msg == null) {
                    break;
                } else if ("bye".equals(msg.toLowerCase())) {
                    ch.writeAndFlush(new CloseWebSocketFrame());
                    ch.closeFuture().sync();
                    break;
                } else if ("ping".equals(msg.toLowerCase())) {
                    WebSocketFrame frame = new PingWebSocketFrame(Unpooled.wrappedBuffer(new byte[]{8, 1, 8, 1}));
                    ch.writeAndFlush(frame);
                } else {
                    WebSocketFrame frame = new TextWebSocketFrame(msg);
                    ch.writeAndFlush(frame);
                }
            }
        } finally {
            group.shutdownGracefully();
        }
    }

}

help文档

config

@Data
@Configuration
@ConfigurationProperties(prefix = "websocket")
public class WebsocketConfig {
    private Integer port;

    private String remoteUrl;

    private String checkUrl;

}

// 配置文件
websocket:
  port: 19999 # 占用端口
  remote-url: 127.0.0.1 远程ip
  check-url: http://10.0.0.0:19200/api/auth/oauth/check_token 验证用户token地址

websocket 工具类

public class WebsocketUtils {
    public static final String KEY_USER_ID = "userId";
    public static final AttributeKey<String> ATTRIBUTE_KEY_USER_ID = AttributeKey.valueOf(KEY_USER_ID);
    private   static ChannelGroup GlobalGroup=new DefaultChannelGroup(GlobalEventExecutor.INSTANCE);
    private  static ConcurrentMap<String, ChannelId> ChannelMap=new ConcurrentHashMap();

    public static void setChannelParam(Channel channel, String userId){
        channel.attr(ATTRIBUTE_KEY_USER_ID).setIfAbsent(userId);
    }

    public  static void addChannel(Channel channel){
        GlobalGroup.add(channel);
    }

    public  static void addChannel(Channel channel,String userId){
        setChannelParam(channel,userId);
        GlobalGroup.add(channel);
//        ChannelMap.put(userId,channel);
    }
    public static void removeChannel(Channel channel){
        GlobalGroup.remove(channel);
//        ChannelMap.remove(channel.id().asShortText());
    }
    public static  Channel findChannel(String id){
        return GlobalGroup.find(ChannelMap.get(id));
    }

    public static Boolean sendToOne(final String userId, TextWebSocketFrame tws){
        Boolean send = false;

        for (Iterator<Channel> it = GlobalGroup.stream().iterator(); it.hasNext(); ) {
            Channel x = it.next();
            String itemUserId = x.attr(ATTRIBUTE_KEY_USER_ID).get();
            if (userId.equals(itemUserId)){
                x.writeAndFlush(tws);
                send = true;
            }

        }
        return send;

    }
    public static void send2All(TextWebSocketFrame tws){
        GlobalGroup.writeAndFlush(tws);
    }
}
Netty多通道多对话管理
qq_44460210的博客
05-11 1644
这里推荐使用观察者模式（事件驱动）搭建多通道之间的交互，该模式的核心思想是基于事件和事件监听器的机制，当特定事件发生时，系统会通知已注册的监听器，并由它们来处理事件。这种方式使得程序可以更加灵活地响应用户的操作和系统的状态变化。有两种实现方式：使用ChannelId、使用ChannelHandlerContext的属性Attribute。使用ThreadLocal存储用户数据，当出现线程切换的时候，用户数据丢失。
Netty 实现 WebSocket 协议
m0_69146489的博客
04-03 1448
System.out.println(NettyServer.class + " 启动正在监听： " + cf.channel().localAddress());.channel(NioServerSocketChannel.class) // 指定使用的channel。log.info("客户端断开: 租户xx:{}", ctx.channel().id().asLongText());//以块的方式来写的处理器。
Netty(五) - 通道Channel
yangxshn的博客
01-30 1146
一、基本介绍 1）、NIO 的通道类似于流，但有些区别如下： 通道可以同时进行读写，而流只能读或者只能写 通道可以实现异步读写数据 通道可以从缓冲读数据，也可以写数据到缓冲 2）、BIO 中的 stream 是单向的，例如 FileInputStream 对象只能进行读取数据的操作，而 NIO 中的通道（Channel）是双向的，可以读操作，也可以写操作。 3）、Channel 在 NIO 中是一个接口 public interface Channel extends Closeable 4）、常用的
Netty实现WebSocket服务端与客户端交互技巧总结
最新发布
weixin_36364707的博客
05-25 888
WebSocket是一种在单个TCP连接上进行全双工通信的协议。与传统HTTP轮询不同，WebSocket允许服务器主动向客户端发送消息，大幅提升了实时通信的效率。它通过升级HTTP协议的方式建立长连接，实现了真正的双向通信。
Netty 中的通道和反应器
Songbl_的博客
09-23 566
EventLoopGroup、channel
Netty学习 2、通道（Channel）
大树
11-11 1193
通道（Channel） 一、通道（Channel） 通道（Channel）是NIO用来传输数据的。和流类似，只不过有很大的区别 区别： ​ 通道用来传输的是数据块，也就是Buffer。而流用来传输字节的 ​ 通道可以同时进行读写，而流只能读或者只能写 ​ 通道可以实现异步读写数据 ​ 通道可以从缓冲读数据，也可以写数据到缓冲 二、常用的通道类 类名 作用 FileChannel 用于文件的数据读写 DatagramChannel 用于UDP的数据读写 ServerSocketCh
Spring+Netty+WebSocket实例
12-06
3. **Netty服务器**：创建一个Netty服务器，配置WebSocket服务器通道处理器，处理WebSocket的连接请求和数据帧。 4. **Spring与Netty的集成**：通过Spring的`WebSocketMessageBrokerConfigurer`接口，将Spring的...
使用 netty 实现 websocket 通信
qq_73609596的博客
12-28 1514
这里推荐使用**netty框架**来实现websocket，首先netty是**nio**基于事件驱动的**多路复用框架**，使用单线程或少量线程处理大量的并发连接；其次，netty提供了**丰富的功能和组件**，可以灵活的构建自定义的网络应用。它具有强大的编解码器和处理器，可以轻松处理复杂的协议和数据模式。同时，Netty的扩展性也很好，可以根据需要**添加自定义组件**，例如我们可以用netty的pipeline方便的进行前后置的处理，可以用netty的心跳处理器来检查连接的状态等。
WebSocket——netty实现websocket编码
m0_53926113的博客
02-03 1721
在本篇博客中，我们通过一步步搭建和配置 Netty 实现 WebSocket 的服务器端，成功实现了 WebSocket 消息的收发和处理。这里，我将简要总结一下整个过程和实现的关键点。1. WebSocket 和 Netty 的优势WebSocket是一种常用于浏览器和服务器之间的双向通信协议，它通过一个持久的连接，使得数据可以在客户端和服务器之间实时地双向传输。相比于传统的 HTTP 请求，WebSocket 更加高效，适用于实时聊天、在线游戏等需要实时数据交互的场景。Netty。
netty-websocket-demo:一个简单的netty实现的websocket
05-18
在本文中，我们将深入探讨如何使用 Netty 实现 WebSocket 协议，这是一个基于 TCP 的低延迟、全双工通信协议，广泛应用于实时数据传输，如在线聊天、股票行情更新等场景。 首先，我们需要理解 WebSocket 协议的基本...
使用Netty搭建WebSocket服务器，可修改单包大小限制
03-21
WebSocket是一种在客户端和服务器之间建立持久连接的协议，它提供了双向通信能力，使得服务器和客户端可以实时、高效地交换数据。在开发WebSocket服务时，我们可能会遇到数据包大小的限制问题，这会影响到大文件或者...
netty 通道接口定义
Donald_Draper的专栏
09-10 503
Netty学习之NIO---通道Channel（一）
Crazer_cy的博客
08-21 3853
一、关于通道的简单概述： 通道主要用于源节点和目标节点的连接，channel本身不存储数据，需要配合缓冲区进行数据的传输。 二、获取通道的主要途径： 1.Java针对支持通道的类提供了getChannel()方法； 2.在JDK1.7中的NIO.2，针对各个通道提供了静态方法open()； 3.在JDK1.7中的NIO.2,的Files工具类中提供了newByteChannel()方法；
使用netty 4.1.x 手写一个简单的websocket服务端
qq_26782095的博客
08-03 361
使用netty 4.1.x 手写一个简单的websocket服务端
基于Springboot用Netty实现WebSocket及用户身份校验
linbeiwo的博客
07-21 3570
基于Springboot用Netty实现WebSocket及用户身份校验
3.Netty中Channel通道概述
locklws的专栏
11-07 580
当一个请求从链式的首端发出时，会沿着链的路径依次传递给每一个节点对象，直至有对象处理这个请求为止。Channel（管道）是 Java NIO 的一个基本抽象，代表了一个连接到如硬件设备、文件、网络 socket 等实体的开放连接，或者是一个能够完成一种或多种不同的。中的所有的处理器都有机会处理它，因此，对于入栈的请求，全部从头节点开始往后传播，一直传播到尾节点(来到尾节点的msg会被释放掉)。责任链模式的重点在这个 "链"上，由一条链去处理相似的请求，在链中决定谁来处理这个请求，并返回相应的结果。
Netty 实现 一个端口同时接收 socket 和 webSocket 连接
NRGAGA的专栏
06-22 6941
项目是在 Springboot 集成 Netty 的基础上开发。 参考文章： 1、SpringBoot 整合 Netty 实现Socket：https://www.cnblogs.com/guoyuchuan/p/9581283.html 2、Netty 实现 webSocket：https://www.cnblogs.com/miller-zou/p/7002070.html 3、同时实现...
maven netty 配置_springboot2.3手册：5分钟用Netty搭建高性能异步WebSocket服务
weixin_39957647的博客
11-26 231
互联网应用架构：专注编程教学，架构，JAVA，Python，微服务，机器学习等领域，欢迎关注，一起学习。断更快两个月了，6月份工作忙到飞起，7月份家里又有事，已经累到躺下就想睡觉的程度了。现在我们做WebSocket服务，很多时候都是会整合Netty作为服务器，但是有个问题，就是发现网上的整合起来，比较繁琐，各种配置，各种对应，最关键是千篇一律的网文，看得好辛苦了，今天咱们来介绍一个开源...
基于Netty实现WebSocket客户端
u013771019的专栏
05-25 3151
握手事件是在自定义的Handler中实现的，这里为了方便使用CountDownLatch，使用了匿名内部类SimpleChannelInboundHandler的方式。这里我们不手动进行握手，由Netty通过WebSocketClientProtocolHandler进行握手，但是我们要知道何时握手完成了。测试的时候，我们可以看到，当客户端发送ping的时候，服务端会自动回pong，这个是有Netty实现的服务端自带的心跳机制。】，测试用的WebSocket服务端也是用Netty实现的，参考【
Netty实现WebSocket通讯技术详解
标题：“websocket.zip”与描述“websocket netty 通讯 java”以及标签“websocket netty 通讯 java”表明了该压缩文件内很可能包含关于WebSocket和Netty在Java中的应用的相关资料或代码。WebSocket是一种网络通信...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

woniyu123

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

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

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

打赏作者

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

抵扣说明：

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

余额充值