Netty核心组件

骑猪看日落 2021-09-18 07:28 465阅读 0赞

# Bootstrap、ServerBootstrap #

Bootstrap 意思是引导，一个 Netty 应用通常由一个 Bootstrap 开始，主要作用是配置整个 Netty 程序，串联各个组件，Netty 中 Bootstrap 类是客户端程序的启动引导类，ServerBootstrap 是服务端启动引导类。

## 简版 ##

**Netty的引导类，配置Netty程序，串联各个组件。**

## 客户端code ##

Bootstrap bootstrap = new Bootstrap()
                        .group(eventExecutors)
                        .channel(NioSocketChannel.class)
                        .handler(new ChannelInitializer<SocketChannel>() {
                            @Override
                            protected void initChannel(SocketChannel ch) throws Exception {
                                ChannelPipeline pipeline = ch.pipeline();
                                //加入Handler
                                pipeline.addLast("decoder", new StringDecoder());
                                pipeline.addLast("encoder", new StringEncoder());
                                pipeline.addLast(new GroupChatClientHandler());
                            }
                        });

## 服务端code ##

// Bootstrap 类是客户端程序的启动引导类，ServerBootstrap 是服务端启动引导类
                ServerBootstrap serverBootstrap = new ServerBootstrap();
                serverBootstrap.group(bossGroup,workerGroup)
                        //Netty 网络通信的组件，能够用于执行网络 I/O 操作。 选择哪种channel 异步的服务器端 TCP Socket 连接
                        .channel(NioServerSocketChannel.class)
                        //ChannelOption.SO_BACKLOG 对应 TCP/IP 协议 listen 函数中的 backlog 参数，用来初始化服务器可连接队列大小。
                        //服务端处理客户端连接请求是顺序处理的，所以同一时间只能处理一个客户端连接。多个客户端来的时候，服务端将不能处理的客户端连接请求放在队列中等待处理，backlog 参数指定了队列的大小。
                        //Socket参数，服务端接受连接的队列长度，如果队列已满，客户端连接将被拒绝。默认值，Windows为200，其他为128。
                        .option(ChannelOption.SO_BACKLOG,128)
                        //Netty中的option主要是设置的ServerChannel的一些选项，而childOption主要是设置的ServerChannel的子Channel的选项。
                        //SO_KEEPALIVE 连接保活，默认值为False。启用该功能时，TCP会主动探测空闲连接的有效性。可以将此功能视为TCP的心跳机制，需要注意的是：默认的心跳间隔是7200s即2小时。Netty默认关闭该功能。
                        .childOption(ChannelOption.SO_KEEPALIVE, true)
                        //定义worker
                        .childHandler(new ChannelInitializer<SocketChannel>() {
                            @Override
                            protected void initChannel(SocketChannel socketChannel) throws Exception {
                                ChannelPipeline pipeline = socketChannel.pipeline();
                                pipeline.addLast("decoder",new StringDecoder());
                                pipeline.addLast("encoder",new StringEncoder());
                                pipeline.addLast(new GroupChatServerHandler());
                            }
                        });

# Future、ChannelFuture #

Netty 中所有的 IO 操作都是异步的，不能立刻得知消息是否被正确处理。

但是可以过一会等它执行完成或者直接注册一个监听，具体的实现就是通过 Future 和 ChannelFutures，他们可以注册一个监听，当操作执行成功或失败时监听会自动触发注册的监听事件。

## 简版 ##

Netty中所有IO操作都是异步的，为了监听操作是否执行成功，通过ChannelFuture注册监听，当IO操作执行完毕后会触发该监听事件。

## code ##

ChannelFuture sync()ChannelFuture sync()

等待异步操作执行完

ChannelFuture channelFuture = bootstrap.connect(host, port);
    ChannelFuture channelFuture = channelFuture.sync();

返回当前正在进行 IO 操作的通道

Channel channel = channelFuture.channel();

addListener

添加io一步操作之后的监听事件

final ChannelFuture f = ctx.writeAndFlush(time);
      f.addListener(new ChannelFutureListener() {
           @Override
           public void operationComplete(ChannelFuture future) {
                ctx.close();
        }
    });

# Channel #

*  Netty 网络通信的组件，能够用于执行网络 I/O 操作。
 *  通过Channel 可获得当前网络连接的通道的状态
 *  通过Channel 可获得 网络连接的配置参数 （例如接收缓冲区大小）
 *  **Channel 提供异步的网络 I/O 操作**(如建立连接，读写，绑定端口)，异步调用意味着任何 I/O 调用都将立即返回，并且不保证在调用结束时所请求的 I/O 操作已完成
 *  调用立即返回一个 ChannelFuture 实例，通过注册监听器到 ChannelFuture 上，可以 I/O 操作成功、失败或取消时回调通知调用方
 *  支持关联 I/O 操作与对应的处理程序
 *  不同协议、不同的阻塞类型的连接都有不同的 Channel 类型与之对应
 *  **比较常用的Channel接口实现类是NioServerSocketChannel（服务端）和NioSocketChannel（客户端），这两个 Channel 可以和 BIO 编程模型中的ServerSocket以及Socket两个概念对应上。Netty 的 Channel 接口所提供的 API，大大地降低了直接使用 Socket 类的复杂性。**

## 简版 ##

Channel 接口是 Netty 对网络操作抽象类，它除了包括基本的 I/O 操作，如 bind()、connect()、read()、write() 等。

## code ##

异步的客户端 TCP Socket 连接。

Bootstrap bootstrap = new Bootstrap()
                        .group(eventExecutors)
                        .channel(NioSocketChannel.class);

异步的服务器端 TCP Socket 连接

serverBootstrap.group(bossGroup,workerGroup)
                        //Netty 网络通信的组件，能够用于执行网络 I/O 操作。 选择哪种channel 异步的服务器端 TCP Socket 连接
                        .channel(NioServerSocketChannel.class);

io操作

//得到channel
    Channel channel = channelFuture.channel();
    System.out.println("--------" + channel.localAddress() + "---------");
    //客户端需要输入信息，创建一个扫描器
    Scanner scanner = new Scanner(System.in);
    while (scanner.hasNextLine()){
        String msg = scanner.nextLine();
        //通过channel发送到服务器端
        channel.writeAndFlush(msg + "\r\n");
    
        System.out.println("异步执行了");
    }

# ChannelHandler #

*  ChannelHandler 是一个接口，处理 I/O 事件或拦截 I/O 操作，并将其转发到其 ChannelPipeline(业务处理链)中的下一个处理程序。
 *  ChannelHandler 本身并没有提供很多方法，因为这个接口有许多的方法需要实现，方便使用期间，可以继承它的子类
 *  我们经常需要自定义一个 Handler 类去继承 ChannelInboundHandlerAdapter，然后通过重写相应方法实现业务逻辑，我们接下来看看一般都需要重写哪些方法

## 简版 ##

ChannelHandler 是消息的**具体处理器**。他负责处理读写操作、客户端连接等事情。

## code ##

netty组件添加具体处理io的handler

// Bootstrap 类是客户端程序的启动引导类，ServerBootstrap 是服务端启动引导类
                ServerBootstrap serverBootstrap = new ServerBootstrap();
                serverBootstrap.group(bossGroup,workerGroup)
                        .channel(NioServerSocketChannel.class)
                        .option(ChannelOption.SO_BACKLOG,128)
                        .childOption(ChannelOption.SO_KEEPALIVE, true)
                        .childHandler(new ChannelInitializer<SocketChannel>() {
                            @Override
                            protected void initChannel(SocketChannel socketChannel) throws Exception {
                                ChannelPipeline pipeline = socketChannel.pipeline();
                                pipeline.addLast("decoder",new StringDecoder());
                                pipeline.addLast("encoder",new StringEncoder());
                                pipeline.addLast(new GroupChatServerHandler());
                            }
                        });

自定义一个 Handler 类去继承 ChannelInboundHandlerAdapte（入栈）

public class ChannelInboundHandlerAdapter extends ChannelHandlerAdapter implements ChannelInboundHandler {
    
        //通道注册事件
        @Skip
        @Override
        public void channelRegistered(ChannelHandlerContext ctx) throws Exception {
            ctx.fireChannelRegistered();
        }
    
        //通道取消注册事件
        @Skip
        @Override
        public void channelUnregistered(ChannelHandlerContext ctx) throws Exception {
            ctx.fireChannelUnregistered();
        }
    
        //通道就绪事件
        @Skip
        @Override
        public void channelActive(ChannelHandlerContext ctx) throws Exception {
            ctx.fireChannelActive();
        }
    
        /**
         * Calls {@link ChannelHandlerContext#fireChannelInactive()} to forward
         * to the next {@link ChannelInboundHandler} in the {@link ChannelPipeline}.
         *
         * Sub-classes may override this method to change behavior.
         */
        @Skip
        @Override
        public void channelInactive(ChannelHandlerContext ctx) throws Exception {
            ctx.fireChannelInactive();
        }
    
        //通道读取数据事件
        @Skip
        @Override
        public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
            ctx.fireChannelRead(msg);
        }
    
        //通道数据读取完毕事件
        @Skip
        @Override
        public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
            ctx.fireChannelReadComplete();
        }
    
        /**
         * Calls {@link ChannelHandlerContext#fireUserEventTriggered(Object)} to forward
         * to the next {@link ChannelInboundHandler} in the {@link ChannelPipeline}.
         *
         * Sub-classes may override this method to change behavior.
         */
        @Skip
        @Override
        public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
            ctx.fireUserEventTriggered(evt);
        }
    
        /**
         * Calls {@link ChannelHandlerContext#fireChannelWritabilityChanged()} to forward
         * to the next {@link ChannelInboundHandler} in the {@link ChannelPipeline}.
         *
         * Sub-classes may override this method to change behavior.
         */
        @Skip
        @Override
        public void channelWritabilityChanged(ChannelHandlerContext ctx) throws Exception {
            ctx.fireChannelWritabilityChanged();
        }
    
        //通道发生异常事件
        @Skip
        @Override
        @SuppressWarnings("deprecation")
        public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause)
                throws Exception {
            ctx.fireExceptionCaught(cause);
        }
    }

## notice ##

### channelHandler的实现类和子类 ###

![18721752-5ba6d75fa7d3a6e9.png][]

image.png

**处理器**

ChannelInboundHandler 用于处理入站 I/O 事件。

ChannelOutboundHandler 用于处理出站 I/O 操作。

**适配器**

ChannelInboundHandlerAdapter 用于处理入站 I/O 事件。

ChannelOutboundHandlerAdapter 用于处理出站 I/O 操作。

ChannelDuplexHandler 用于处理入站和出站事件。

# ChannelPipeline #

*  ChannelPipeline 是一个 Handler 的集合，它负责处理和拦截 inbound 或者 outbound 的事件和操作，相当于一个贯穿 Netty 的链。(也可以这样理解：ChannelPipeline 是 保存 ChannelHandler 的 List，用于处理或拦截 Channel 的入站事件和出站操作)
 *  ChannelPipeline 实现了一种高级形式的拦截过滤器模式，使用户可以完全控制事件的处理方式，以及 Channel 中各个的 ChannelHandler 如何相互交互
 *  一个 Channel 包含了一个 ChannelPipeline，而 ChannelPipeline 中又维护了一个由 ChannelHandlerContext 组成的双向链表，并且每个 ChannelHandlerContext 中又关联着一个 ChannelHandler
 *  入站事件和出站事件在一个双向链表中，入站事件会从链表 head 往后传递到最后一个入站的 handler，出站事件会从链表 tail 往前传递到最前一个出站的 handler，两种类型的 handler 互不干扰
 *  在 Netty 中每个 Channel 都有且仅有一个 ChannelPipeline 与之对应，它们的组成关系如下

![18721752-ac44d8ff84059efd.png][]

image.png

## 简版 ##

ChannelPipeline 为 ChannelHandler 的链（双向链表），提供了一个容器并定义了用于沿着链传播入站和出站事件流的 API 。当 Channel 被创建时，它会被自动地分配到它专属的 ChannelPipeline。

**ChannelPipeline是一个存储ChannelHandler的容器，数据结构为双向链表。**

## code ##

ChannelPipeline addLast(ChannelHandler… handlers)

把一个业务处理类（handler）添加到链中的最后一个位置

serverBootstrap.group(bossGroup,workerGroup)
                        .channel(NioServerSocketChannel.class)
                        .option(ChannelOption.SO_BACKLOG,128)
                        .childOption(ChannelOption.SO_KEEPALIVE, true)
                        .childHandler(new ChannelInitializer<SocketChannel>() {
                            @Override
                            protected void initChannel(SocketChannel socketChannel) throws Exception {
                                ChannelPipeline pipeline = socketChannel.pipeline();
                                pipeline.addLast("decoder",new StringDecoder());
                                pipeline.addLast("encoder",new StringEncoder());
                                pipeline.addLast(new GroupChatServerHandler());
                            }
                        });

# ChannelOption #

Netty 在创建 Channel 实例后,一般都需要设置 ChannelOption 参数

## code ##

配置连接服务端的队列数量

// Bootstrap 类是客户端程序的启动引导类，ServerBootstrap 是服务端启动引导类
                ServerBootstrap serverBootstrap = new ServerBootstrap();
                serverBootstrap.group(bossGroup,workerGroup)
                        .channel(NioServerSocketChannel.class)
                        //ChannelOption.SO_BACKLOG 对应 TCP/IP 协议 listen 函数中的 backlog 参数，用来初始化服务器可连接队列大小。
                        //服务端处理客户端连接请求是顺序处理的，所以同一时间只能处理一个客户端连接。多个客户端来的时候，服务端将不能处理的客户端连接请求放在队列中等待处理，backlog 参数指定了队列的大小。
                        //Socket参数，服务端接受连接的队列长度，如果队列已满，客户端连接将被拒绝。默认值，Windows为200，其他为128。
                        .option(ChannelOption.SO_BACKLOG,128)
                        //Netty中的option主要是设置的ServerChannel的一些选项，而childOption主要是设置的ServerChannel的子Channel的选项。
                        //SO_KEEPALIVE 连接保活，默认值为False。启用该功能时，TCP会主动探测空闲连接的有效性。可以将此功能视为TCP的心跳机制，需要注意的是：默认的心跳间隔是7200s即2小时。Netty默认关闭该功能。
                        .childOption(ChannelOption.SO_KEEPALIVE, true)
                       );

## notice ##

### Channel配置参数 ###

通用参数

CONNECT_TIMEOUT_MILLIS :
      Netty参数，连接超时毫秒数，默认值30000毫秒即30秒。
    MAX_MESSAGES_PER_READ
      Netty参数，一次Loop读取的最大消息数，对于ServerChannel或者NioByteChannel，默认值为16，其他Channel默认值为1。默认值这样设置，是因为：ServerChannel需要接受足够多的连接，保证大吞吐量，NioByteChannel可以减少不必要的系统调用select。
    WRITE_SPIN_COUNT
      Netty参数，一个Loop写操作执行的最大次数，默认值为16。也就是说，对于大数据量的写操作至多进行16次，如果16次仍没有全部写完数据，此时会提交一个新的写任务给EventLoop，任务将在下次调度继续执行。这样，其他的写请求才能被响应不会因为单个大数据量写请求而耽误。
    ALLOCATOR
      Netty参数，ByteBuf的分配器，默认值为ByteBufAllocator.DEFAULT，4.0版本为UnpooledByteBufAllocator，4.1版本为PooledByteBufAllocator。该值也可以使用系统参数io.netty.allocator.type配置，使用字符串值："unpooled"，"pooled"。
    RCVBUF_ALLOCATOR
      Netty参数，用于Channel分配接受Buffer的分配器，默认值为AdaptiveRecvByteBufAllocator.DEFAULT，是一个自适应的接受缓冲区分配器，能根据接受到的数据自动调节大小。可选值为FixedRecvByteBufAllocator，固定大小的接受缓冲区分配器。
    AUTO_READ
      Netty参数，自动读取，默认值为True。Netty只在必要的时候才设置关心相应的I/O事件。对于读操作，需要调用channel.read()设置关心的I/O事件为OP_READ，这样若有数据到达才能读取以供用户处理。该值为True时，每次读操作完毕后会自动调用channel.read()，从而有数据到达便能读取；否则，需要用户手动调用channel.read()。需要注意的是：当调用config.setAutoRead(boolean)方法时，如果状态由false变为true，将会调用channel.read()方法读取数据；由true变为false，将调用config.autoReadCleared()方法终止数据读取。
    WRITE_BUFFER_HIGH_WATER_MARK
      Netty参数，写高水位标记，默认值64KB。如果Netty的写缓冲区中的字节超过该值，Channel的isWritable()返回False。
    WRITE_BUFFER_LOW_WATER_MARK
      Netty参数，写低水位标记，默认值32KB。当Netty的写缓冲区中的字节超过高水位之后若下降到低水位，则Channel的isWritable()返回True。写高低水位标记使用户可以控制写入数据速度，从而实现流量控制。推荐做法是：每次调用channl.write(msg)方法首先调用channel.isWritable()判断是否可写。
    MESSAGE_SIZE_ESTIMATOR
      Netty参数，消息大小估算器，默认为DefaultMessageSizeEstimator.DEFAULT。估算ByteBuf、ByteBufHolder和FileRegion的大小，其中ByteBuf和ByteBufHolder为实际大小，FileRegion估算值为0。该值估算的字节数在计算水位时使用，FileRegion为0可知FileRegion不影响高低水位。
    SINGLE_EVENTEXECUTOR_PER_GROUP
      Netty参数，单线程执行ChannelPipeline中的事件，默认值为True。该值控制执行ChannelPipeline中执行ChannelHandler的线程。如果为Trye，整个pipeline由一个线程执行，这样不需要进行线程切换以及线程同步，是Netty4的推荐做法；如果为False，ChannelHandler中的处理过程会由Group中的不同线程执行。

SocketChannel参数

SO_RCVBUF
      Socket参数，TCP数据接收缓冲区大小。该缓冲区即TCP接收滑动窗口，linux操作系统可使用命令：cat /proc/sys/net/ipv4/tcp_rmem查询其大小。一般情况下，该值可由用户在任意时刻设置，但当设置值超过64KB时，需要在连接到远端之前设置。
    SO_SNDBUF
      Socket参数，TCP数据发送缓冲区大小。该缓冲区即TCP发送滑动窗口，linux操作系统可使用命令：cat /proc/sys/net/ipv4/tcp_smem查询其大小。
    TCP_NODELAY
      TCP参数，立即发送数据，默认值为Ture（Netty默认为True而操作系统默认为False）。该值设置Nagle算法的启用，改算法将小的碎片数据连接成更大的报文来最小化所发送的报文的数量，如果需要发送一些较小的报文，则需要禁用该算法。Netty默认禁用该算法，从而最小化报文传输延时。
    SO_KEEPALIVE
      Socket参数，连接保活，默认值为False。启用该功能时，TCP会主动探测空闲连接的有效性。可以将此功能视为TCP的心跳机制，需要注意的是：默认的心跳间隔是7200s即2小时。Netty默认关闭该功能。
    SO_REUSEADDR
      Socket参数，地址复用，默认值False。有四种情况可以使用：(1).当有一个有相同本地地址和端口的socket1处于TIME_WAIT状态时，而你希望启动的程序的socket2要占用该地址和端口，比如重启服务且保持先前端口。(2).有多块网卡或用IP Alias技术的机器在同一端口启动多个进程，但每个进程绑定的本地IP地址不能相同。(3).单个进程绑定相同的端口到多个socket上，但每个socket绑定的ip地址不同。(4).完全相同的地址和端口的重复绑定。但这只用于UDP的多播，不用于TCP。
    SO_LINGER
      Socket参数，关闭Socket的延迟时间，默认值为-1，表示禁用该功能。-1表示socket.close()方法立即返回，但OS底层会将发送缓冲区全部发送到对端。0表示socket.close()方法立即返回，OS放弃发送缓冲区的数据直接向对端发送RST包，对端收到复位错误。非0整数值表示调用socket.close()方法的线程被阻塞直到延迟时间到或发送缓冲区中的数据发送完毕，若超时，则对端会收到复位错误。
    IP_TOS
      IP参数，设置IP头部的Type-of-Service字段，用于描述IP包的优先级和QoS选项。
    ALLOW_HALF_CLOSURE
      Netty参数，一个连接的远端关闭时本地端是否关闭，默认值为False。值为False时，连接自动关闭；为True时，触发ChannelInboundHandler的userEventTriggered()方法，事件为ChannelInputShutdownEvent。

ServerSocketChannel参数

SO_BROADCAST: Socket参数，设置广播模式。
     
    SO_RCVBUF: 已说明
     
    SO_SNDBUF:已说明
     
    SO_REUSEADDR:已说明
     
    IP_MULTICAST_LOOP_DISABLED:
      对应IP参数IP_MULTICAST_LOOP，设置本地回环接口的多播功能。由于IP_MULTICAST_LOOP返回True表示关闭，所以Netty加上后缀_DISABLED防止歧义。
     
    IP_MULTICAST_ADDR:
      对应IP参数IP_MULTICAST_IF，设置对应地址的网卡为多播模式。
     
    IP_MULTICAST_IF:
      对应IP参数IP_MULTICAST_IF2，同上但支持IPV6。
     
    IP_MULTICAST_TTL:
      IP参数，多播数据报的time-to-live即存活跳数。
     
    IP_TOS:
      已说明
     
    DATAGRAM_CHANNEL_ACTIVE_ON_REGISTRATION:
      Netty参数，DatagramChannel注册的EventLoop即表示已激活。

## EventLoopGroup和其实现类NioEventLoopGroup ##

*  EventLoopGroup是一组 EventLoop的抽象，Netty为了更好的利用多核 CPU资源，一般会有多个 EventLoop同时工作，每个 EventLoop维护着一个 Selector 实例。
 *  EventLoopGroup 提供 next 接口，可以从组里面按照一定规则获取其中一个 EventLoop来处理任务。在 Netty 服务器端编程中，我们一般都需要提供两个 EventLoopGroup，例如：BossEventLoopGroup 和WorkerEventLoopGroup。
 *  通常一个服务端口即一个 ServerSocketChannel对应一个Selector 和一个EventLoop线程。BossEventLoop 负责接收客户端的连接并将 SocketChannel 交给 WorkerEventLoopGroup 来进行 IO 处理，如下图所示

![18721752-99b273d61f5b911d.png][]

image.png

*  BossEventLoopGroup 通常是一个单线程的 EventLoop，EventLoop 维护着一个注册了ServerSocketChannel 的 Selector 实例BossEventLoop 不断轮询 Selector 将连接事件分离出来
 *  通常是 OP\_ACCEPT 事件，然后将接收到的 SocketChannel 交给 WorkerEventLoopGroup
 *  WorkerEventLoopGroup 会由 next 选择其中一个 EventLoop来将这个 SocketChannel 注册到其维护的 Selector 并对其后续的 IO 事件进行处理

## 简版 ##

EventLoopGroup是一组 EventLoop(事件循环)的抽象，EventLoop 的主要作用实际就是负责监听网络事件并调用事件处理器进行相关 I/O 操作的处理。

Channel 为 Netty 网络操作(读写等操作)抽象类，EventLoop 负责处理注册到其上的Channel 处理 I/O 操作，两者配合参与 I/O 操作。

## code ##

服务端 bossGroup&workerGroup

//bossGroup 用于接收连接
    NioEventLoopGroup bossGroup = new NioEventLoopGroup(1);
    //workerGroup 用于具体的处理
    NioEventLoopGroup workerGroup = new NioEventLoopGroup();
    ServerBootstrap serverBootstrap = new ServerBootstrap();
    serverBootstrap.group(bossGroup,workerGroup)

客户端

NioEventLoopGroup eventExecutors = new NioEventLoopGroup();
    Bootstrap bootstrap = new Bootstrap()
        .group(eventExecutors)

public Future<?> shutdownGracefully()  
断开连接，关闭线程

finally {
        eventExecutors.shutdownGracefully();
    }

[18721752-5ba6d75fa7d3a6e9.png]: /images/20210918/086a4b3b084b4c809ca0f8de0e87fda7.png
[18721752-ac44d8ff84059efd.png]: /images/20210918/6b42722ea0ce4ff184330990a6de129f.png
[18721752-99b273d61f5b911d.png]: /images/20210918/629465dddbf7459195e07ec4031e67f7.png