带你玩转Netty（二)

最新推荐文章于 2023-05-19 11:42:37 发布
最新推荐文章于 2023-05-19 11:42:37 发布
阅读量522 收藏 1
点赞数
分类专栏： 技术总结 文章标签： Netty 应用
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lenyusun/article/details/76732186
版权

概述

上篇给大家介绍了 Netty 的基本原理，这次主要给大家讲一下具体怎么用 Netty，主要分成两个方面客户端以及服务端实现，我们将实现一个简单的 Echo 程序。

服务端

服务端的实现，主要从这几个方面考虑：
1. 最佳线程模型，实现高并发，高稳定性
2. 容错机制
3. 业务处理
4. 心跳监测

那么用Netty怎么一一实现这些呢，废话不多说，直接上代码。

public class NormalNettyServer {
    private int serverPort = 9000;
    private String serverIp = "192.168.2.102";

    public  NormalNettyServer(int port){
        serverPort = port;
    }

    public void start() throws Exception {
        // 创建Accpet线程池 (1)
        EventLoopGroup bossGroup = new NioEventLoopGroup(10);

        // 创建Work线程池
        EventLoopGroup workGroup = new NioEventLoopGroup(10);

        try{
            // 创建ServerBootstrap (2)
            ServerBootstrap b = new ServerBootstrap();
            b.group(bossGroup, workGroup).      // (3)
            channel(NioServerSocketChannel.class). //(4)
            childHandler(new ChannelInitializer<SocketChannel>() {  // 初始化处理handler (5)
                @Override
                public void initChannel(SocketChannel ch) throws Exception {
                    // 加入用户心跳监测机制 读时间超时 60s 写时间超时 10s 读写都没有超时 10s
                    ch.pipeline().addLast("timeout", new IdleStateHandler(60, 10, 10, TimeUnit.SECONDS));
                    // 加入业务处理handler
                    ch.pipeline().addLast("echo", new EchoHandler());
            }
            }).option(ChannelOption.SO_BACKLOG, 128) // (6)
                    .childOption(ChannelOption.SO_KEEPALIVE, true); 
            // Bind and start to accept incoming connections.
            ChannelFuture f = b.bind(serverIp, serverPort).sync(); // (7)
            f.channel().closeFuture().sync();
        } finally {
            // 释放资源
            workGroup.shutdownGracefully();
            bossGroup.shutdownGracefully();
        }
    }
}
  1. EventLoopGroup 是用来处理I/O操作多线程事件循环池， 我们知道Netty是基于Reactor模型的，其中一种是双线程池，这里就创建了两个线程循环池，管理10个线程，bossGroup主要用于处理accpet请求，建立连接后的处理主要是由workGroup负责。
  2. ServerBootstrap 是一个启动NIO服务的辅助启动类
  3. 注册两个线程循环池。

  4. NioServerSocketChannel这里直接引用官方说明更合适

    A ServerSocketChannel implementation which uses NIO selector based implementation to accept new connections.

  5. SocketChannel是TCP连接的网络通道，在下面两种情况会创建

    • 打开一个SocketChannel连接某台服务器。
    • 一个新连接到达ServerSocketChannel时，会创建一个SocketChannel。
      当通道建立，会调用初始化操作，将业务处理的handler加入到pipeline中。这里主要加入应用层心跳监测以及应用层业务处理
  6. 通道支持参数配置，这里配置了两个参数SO_BACKLOG, SO_KEEPALIVE,具体作用大家可以看这里
  7. 绑定host以及监听端口，返回的ChannelFuture, 由于这个过程是异步的，所有执行状态可以通过ChannelFuture中的获取，这将在客户端的实现中重点介绍。

通过以上步骤，我们就可以建立一个高效的服务，对于一个写C++的我，只能说真的很爽。言归正传，下面我们介绍一下两个handler的处理，看代码。

public class EchoHandler extends SimpleChannelInboundHandler<Object> { // (1)

    @Override
    protected void channelRead0(ChannelHandlerContext channelHandlerContext, Object o) throws Exception {
        ByteBuf buf = (ByteBuf)o; // (2)
        byte[] packet = new byte[buf.readableBytes()];
        buf.readBytes(packet);
        // pb 协议 (3)
        HelloTest.Hello hello = HelloTest.Hello.parseFrom(packet);
        System.out.println(hello.getContent().toString());
        channelHandlerContext.channel().writeAndFlush(buf);
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        // (4)
        cause.printStackTrace();
        ctx.close();
    }

    @Override
    public void channelActive(ChannelHandlerContext ctx)
            throws Exception {
        // 新连接active
        super.channelActive(ctx);
    }

    @Override
    public void channelInactive(ChannelHandlerContext ctx)
            throws Exception {
        // 连接关闭
        super.channelInactive(ctx);
    }
  1. Netty的接受数据处理Handler都是继承 SimpleChannelInboundHandler或者ChannelInboundHandlerAdapter
  2. Netty数据的收发，都采用ByteBuf
  3. 这里采用了PB协议，具体用法，这里不详细讲，大家先看看，之后会有文章介绍。因为是Echo, 所有收到的数据直接原包返回。
  4. Channel异常处理，这里可以做一些容错操作。
    public class HeartBeatHandler extends ChannelInboundHandlerAdapter {

    private ConnectionClient client;
    public HeartBeatHandler(ConnectionClient client) {
       this.client = client;
    }

    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        super.channelActive(ctx);
    }

    @Override
    public void channelInactive(ChannelHandlerContext ctx) throws Exception {
        super.channelInactive(ctx);
    }

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        super.channelRead(ctx, msg);
    }

    @Override
    public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
        if (evt instanceof IdleStateEvent) {
            IdleStateEvent event = (IdleStateEvent) evt;
            if (event.state() == IdleState.WRITER_IDLE) {
                //TODO（1） 可以做监测处理
            } else if (event.state() == IdleState.READER_IDLE) {
                // TODO(2)
            }
        }
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        super.exceptionCaught(ctx, cause);
    }
}
  1. 写数据超时，服务端已经有一段时间没有对该连接通道发送数据。
  2. 读数据超时，服务端已经有一段时间没有接受该连接通道的数据。
  3. 通过这两个，我们可以对该通道做检查，比如发送心跳指令，监测客户端是否还存在。

这就是最简单服务端实现，麻雀虽小，五脏俱全，实现了我们最开始说的几个方面的内容。按照这个顺序，我们接下来介绍客户端实现。

客户端

客户端的实现往往都会有这样几个要求：
* 断线重连
* 心跳维持
* 业务处理

接下来，我们将会用Netty来实现这些功能，由于代码比较多，下面主要截取重要函数做说明。

public boolean connect() {
    Bootstrap b = new Bootstrap(); // (1)
    final HeartBeatHandler hearthandler = new HeartBeatHandler(this);
    final ClientHandler handler = new ClientHandler(this);

    EventLoopGroup loop = new NioEventLoopGroup(); // (2)
    b.group(loop).channel(NioSocketChannel.class);
    b.handler(new ChannelInitializer<Channel>() {
        @Override
        protected void initChannel(Channel ch) throws Exception {
            ChannelPipeline pipeline = ch.pipeline();
            // idle状态处理，主要是用于与服务端发送心跳 (3)
            pipeline.addLast(new IdleStateHandler(60, 20, 0, TimeUnit.SECONDS));
            pipeline.addLast("hearthandler", hearthandler);

            // 业务处理
            pipeline.addLast("handler",  handler);
        }
    });
    b.option(ChannelOption.SO_KEEPALIVE, true);
    b.option(ChannelOption.TCP_NODELAY, true);
    ChannelFuture future = b.connect(host, port);
    future.addListener(new ConnectionListener(this)); // (4)
    return true;
}
  1. Bootstrap客户端启动辅助类，与ServerBootstrap相对。
  2. 客户端不需要处理连接请求，所有只需定义一个多线程事件循环池来处理channel事件就可以。
  3. 客户端的业务处理handler，包含心跳处理，以及业务处理。

  4. ChannelFuture添加连接情况监听，用于实现重连。

    其他的含义与服务端相同，请参考服务端说明，这里重点介绍重连机制的实现，重连主要是由两个点来触发的，一个是ChannelFuture, 一个Handler的InActive事件。

 public class ConnectionListener implements ChannelFutureListener {

    // 此处省略多行代码 .......

    @Override
    public void operationComplete(ChannelFuture future) throws Exception {
        if (!future.isSuccess()) {
            // 连接失败
            System.out.println("connect reconnect");
            this.client.reconnect(future.channel());
        } else {
            // 连接成功
            System.out.println("connect success");
            this.client.setChannel(future.channel());
        }
    }
}
public class ClientHandler extends ChannelInboundHandlerAdapter {
    // 此处省略多行代码 .......

    @Override
    public void channelInactive(ChannelHandlerContext ctx)
            throws Exception {
        // 断开连接
        System.out.println("SuperServer is disconnect " +  ctx.channel().remoteAddress().toString());
        client.reconnect(ctx.channel());
        super.channelInactive(ctx);
    }
}
public void reconnect(final Channel ch) {
    final EventLoop eventLoop = ch.eventLoop();
    eventLoop.schedule(new Runnable() {
        @Override
        public void run() {
            connect();
            System.out.println("reconnect server:" + host + ", Port:" + port);
        }
    }, 10L, TimeUnit.SECONDS);
}

以上就是具体的重连的实现过程，两个触发点，大家记住即可。另外心跳的实现与服务端类似，只不过在业务的处理有可能不同。比如 服务要考虑是否断开客户端，回收资源。而客户端要考虑的是是否要重连。

欢迎关注公众号

大朝书房
关注
专栏目录
00开篇词：带你玩转gRPC框架
做兴趣使然的Hero
01-24 1430
大家好，先做一下自我介绍我叫Barry Yan，目前是一名互联网公司的研发工程师，同时也是后端技术领域的狂热爱好者和技术博主，在GitHub、CSDN社区、51CTO博客社区、阿里云技术社区、掘金技术社区和InfoQ写作社区等都有自己的博客，原创200余篇。
springboot整合netty的正确姿势
02-22 5720
chatGPT大神帮助我整理思路
带你玩转Netty(一)
cosysun的专栏
07-23 996
netty 其实就是基于事件驱动，快速开发高并发，高可靠性的服务和客户端的一个开源框架
认真啃透，带你玩转网络开发框架中的Spring——Netty
老男孩的架构路
11-03 807
Netty是一款异步的事件驱动的网络应用程序框架，支持快速开发可维护的高性能的面向协议的服务器和客户端。Netty主要是对java 的 nio包进行的封装。
玩转Netty，从“Hello World”开始
最新发布
三分恶的博客
05-19 689
Netty官方是这么定义Netty的：Netty 是一个异步事件驱动的网络应用程序框架，用于快速开发可维护的高性能协议服务器和客户端。Netty是一个开源的、单线程模型的 Java 网络编程框架。Netty基于 NIO ，被广泛应用于各种网络应用程序开发。Netty支持多种协议，包括但不限于 HTTP、WebSocket、TCP、UDP 和 SSL/TLS 协议等。Netty 是非阻塞的，事件驱动的框架。Netty具有高性能、可扩展和易于使用的优点。
Netty 断线重连方案实现
HelloWorldBegin
05-12 2208
Netty 断线重连解决方案
netty 中ChannelOption 属性含义
weixin_30532973的博客
09-11 362
　　ChannelOption 属性介绍 　　 属性 含义 ChannelOption.SO_KEEPALIVE 该参数用于设置tcp连接，当设置该选项后，会测试连接的状态，当两个小时没有数据探测后，tcp 会自动发送一个活动探测数据 ChannelOption.ALLOCATOR 也是默认值，使用对象池，重用缓冲区 Channe...
netty-playground:玩转 Netty 的例子
06-10
网络游乐场 玩转 Netty 的例子
netty5权威指南(带书签)
09-25
玩转网络编程必备书籍。Netty5.0权威指南，国内第一本详细讲解netty的书籍，高清PDF且自带书签导航。 玩转网络编程必备书籍。Netty5.0权威指南，国内第一本详细讲解netty的书籍，高清PDF且自带书签导航。 玩转网络...
阿里资深架构师强烈推荐丨Netty源码剖析与应用
q66562636的博客
05-25 912
前言 Netty是一款基于NIO（非阻塞I/O）开发的网络框架，与传统BIO相比，它的并发性能得到了很大的提高，而且更加节省资源。Netty不仅封装了NIO操作的很多细节；在设计上还基于灵活、可扩展的事件驱动模型与高度可定制的线程模型，让Netty的应用更加灵活。作为一个被广泛使用的Java网络编程框架，Netty在互联网领域、大数据分布式计算领域、游戏行业、物联网行业等都得到了广泛的应用。很多流行的大数据框架的核心通信模块也都使用的是Netty，如Elasticsearch、HBase、Flink等。
初识Netty（二）
qq_39339965的博客
01-10 814
扑街前言：上面说了Netty的一些基本概念，本篇我们说下Netty应该如何来编写客户端和服务端。（认识到自己是菜鸟的不知道多少天，人都学麻木了的第二天）。 在编写代码之前，首先要知道Netty的事件传播是以什么方式做到的。我们目前只讨论Netty的NIO实现，而NIO是Java的同步非阻塞IO，使用了channel、buffer、selector三个核心组件来实现信息的传输，数据的具体操作是buffer，传输用的是channel。 那么结合上篇说到的Ne...
构建一个分布式的消息通知系统(Netty + SpringBoot + Dubbo )
qq_18244417的博客
07-26 953
前话之前在接商业外包的时候，遇到了一个需要服务端主动推送消息的需求，当时由于对 Netty 的不熟悉以及没有很好的理解 Netty 的 websocket，因此用了SSE去解决了这个问题，...
java 游戏断线心跳_Netty 4.0 实现心跳检测和断线重连
weixin_30546683的博客
03-07 403
一 实现心跳检测原理：当服务端每隔一段时间就会向客户端发送心跳包，客户端收到心跳包后同样也会回一个心跳包给服务端一般情况下，客户端与服务端在指定时间内没有任何读写请求，就会认为连接是idle(空闲的)的。此时，客户端需要向服务端发送心跳消息，来维持服务端与客户端的链接。那么怎么判断客户端在指定时间里没有任何读写请求呢？netty中为我们提供一个特别好用的IdleStateHandler来干这个苦差...
【netty】(2)---搭建一个简单服务器
a8892117的博客
12-05 201
netty(2)---搭建一个简单服务器 说明:本篇博客是基于学习慕课网有关视频教学。效果:当用户访问:localhost:8088 后 服务器返回 “hello netty”; 一、服务端线程模型 下面的做法是服务端监听线程和 IO 线程分离，类似于 Reactor 的多线程模型，它的工作原理图如下(盗的图）： 这里netty版本是4.1.25 <dependency&...
Netty详细讲解
大鹏知识库
10-23 1331
github代码地址：https://github.com/gudepeng/gdpNetty本教程使用的Netty版本为4.1.15.Final一、Netty详解Netty是由JBOSS提供的一个java开源框架。Netty提供异步的、事件驱动的网络应用程序框架和工具，用以快速开发高性能、高可靠性的网络服务器和客户端程序。也就是说，Netty 是一个基于NIO的客户、服务器端编程框架，使用Net...
基于netty的socket服务端触发了channelInactive方法，但实际连接没有断开的问题
weixin_34292287的博客
07-12 5911
背景： 一个中小型H5游戏，后端使用基于 netty 的socket服务 服务端 分为 分发服务器 & 业务服务器，业务服务器可负载 　　用户客户端与分发服务器连接 　　分发服务器再作为客户端与每台业务服务器连接 为了方便快速得知服务宕机的情况，我打算在服务器上做一个宕机通知 因为 分发服务器与业务服务器都处于连接状态，在连接断开时都会触发 channelIn...
ZooKeeper集群“脑裂”问题处理大全
Docker的专栏
11-13 717
本文重点讲解ZooKeeper脑裂问题的处理办法。ZooKeeper是用来协调（同步）分布式进程的服务，提供了一个简单高性能的协调内核，用户可以在此之上构建更多复杂的分布式协调功能。脑裂...
Netty从入门到精通（一）
边博磊的博客
12-23 847
Netty是一个高性能的、异步的、基于事件驱动的网络应用型框架
Netty源码解析-Channel生命周期与ChannelHandler处理方法
恐龙弟旺仔的博客
12-27 1458
前言： 在之前的文章中，我们已经熟练的使用了ChannelHandler来处理各种请求。同时也了解了各Channel的不同，后续会继续详细介绍SocketChannel和ServerSocketChannel等相关知识点。 在本文中我们来了解下Channel的生命周期（也就是一个客户端连接SocketChannel从连接完成到最后关闭经历过哪些阶段），和其触发的ChannelHandler的那些方法，以期对这两者之间有更好的理解。 1.示例准备 示例的话，我们还是使用之前的示例，在这里主要展示S
Netty：25道面试精华，带你了解高性能网络框架
Netty是一个专为高性能网络应用程序设计的异步、事件驱动的框架，它基于NIO（Non-blocking I/O）技术，旨在简化网络服务器和客户端的开发，尤其适合那些需要低延迟和高吞吐量的应用场景。以下是关于Netty的一些关键...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值