九、Netty核心技术之模块分析

BootStrap、ServerBootstrap

介绍

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

常见的方法有

• public ServerBootStap group(EventLoopGroup parentGroup,EventLoopGroup childGroup),该方法用于服务器端，用来设置两个EventLoop
• public B group(EventLoopGroup),该方法用于客户端，用来设置一个EventLoopGroup
• public B channel(Class<? extends C>channelClass),该方法用来设置一个服务器端的通道实现
• public B option(ChannelOptionoption,T value)用来给serverChannel添加配置
• public serverBootStrap childOption(ChannelOption childOption ,T value),用来给接收到的通道添加配置
• public ServerBootStrap childHandler(ChannelHandler childHandler)该方法用来设置业务处理类（自定义的handler）
• public ChannelFuture bind(int inetPort) 该方法用于服务器端，用来设置占用的端口号
• public ChannelFuture connect(String inetHost,int inetPort)该方法用于客户端，用来连接服务器端

• Future、ChannelFuture

  介绍

  Netty中所有IO操作都是异步的，不能立刻得知消息是否被正确处理，但是可以过一会等它执行完成或者直接注册一个监听，具体的实现就是通过Future和ChannelFutures,他们可以注册一个监听，当操作执行成功或失败时监听会自动触发注册的监听事件

  常见的方法

  

  

  channel

  1、Netty网络通信的组件，能够用于执行网络的IO操作
  2、通过Channel可获得当前网络连接的通道状态
  3、通过Channel可获得网络连接的配置参数（例如接收缓冲区大小）
  4、Channel提供异步的网络IO操作（如建立连接、读写、绑定端口），异步调用意味着任何IO调用都将立即返回，并且不保证在调用结束时所请求的IO操作已完成
  5、调用立即返回一个ChannelFuture实例，通过注册监听器到ChannelFuture上，可以IO操作成功、失败、或取消时回调通知调用方

  Selector

• Netty 基于Selector对象实现IO多路复用，通过Selector一个线程可以监听多个连接的Channel事件
• 当向一个Selector中注册Channel后，Selector内部的机制就可以自动不断地查询(Select）这些注册的Channel是否有已就绪的IO事件（例如可读，可写，网络连接完成等），这样程序就可以很简单地使用一个线程高效的管理多个channel

• ChannelHandler及其实现类

• ChannelHandler是一个接口，处理IO事件或拦截IO操作，将其转发到其ChannelPipeline(业务处理链）中的下一个处理程序。
• ChannelHandler 本身并没有提供很多方法，因为这个接口有许多的方法需要实现，方便使用期间，可以继承它的子类 
• ChannelPipeline提供了ChannelHandler链的容器。以客户端应用程序为例，如果事件的运动方向是从客户端到服务端的，那么我们称这些事件是为出站的，即客户端发送服务端的数据会通过pipeline中的一系列ChannelOutBoundHandler,并被这些Handler处理，反之称为入站

• Pipeline和ChannelPipeline💥

  ChannelPipeline 是一个重点

• ChannelPipeline是一个Handler的集合，它负责处理和拦截inbound或者outbound的事件和操作，相当于一个贯穿Netty的链。（也可以这样理解：ChannelPipeline是保存ChannelHandler的list,用于处理或拦截Channel的入站事件和出站事件）
• ChannelPipeline 实现了一种高级形式的拦截过滤器模式，使用户可以完全控制事件的处理方式，以及Channel中的各个的ChannelHandler如何相互交互
• 在Netty中每个Channel都有且仅有一个ChannelPipeline与之对应，他们的组成关系如下图所示； 

• 1、一个channel包含了一个ChannelPipeline,而ChannelPipeline中又维护了一个由ChannelHandlerContext组成的双向链表，并且每个ChannelHandlerContext中又关联着一个ChannelHandler
  2、入站事件和出站事件在一个双向链表中，入站事件会从链表head往后传递到最后一个入站的handler,出站事件会从链表tail往前传递到最前一个出站的handler,两种类型的handler互补干扰

  ChannelHandlerContext

  • 保存Channel相关的所有上下文信息，同事关联一个ChannelHandler对象
  • 即ChannelHandlerContext中包含一个具体的事件处理器ChannelHandler,同时ChannelHandlerContext中也绑定了对应的pipeline和channel的信息，方便对ChannelHandler进行调用

  常用方法

  ChannelFuture close() 关闭通道
  ChannelOutboundinvoker flush() 刷新
  ChannelFuture writeAndFlush(Object msg) 将数据写到ChannelPipeline中当前ChannelHandler的下一个ChannelHandler开始处理（出站）

  EventLoopGroup 和其实现类 NioEventLoopGroup

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

  
  4) 常用方法
  public NioEventLoopGroup()，构造方法
  public Future<?> shutdownGracefully()，断开连接，关闭线程

  Unpooled 类

  1. Netty 提供一个专门用来操作缓冲区(即 Netty 的数据容器)的工具类
  2. 常用方法如下所示
     
     3）案例实例：

  package com.netty.MoKuan;
  
  import io.netty.buffer.ByteBuf;
  import io.netty.buffer.Unpooled;
  public class NettyByteBuf01 {
      public static void main(String[] args) {
  //创建一个 ByteBuf
  //说明
  //1. 创建 对象，该对象包含一个数组 arr , 是一个 byte[10]
  //2. 在 netty 的 buffer 中，不需要使用 flip 进行反转
  // 底层维护了 readerindex 和 writerIndex
  //3. 通过 readerindex 和 writerIndex 和 capacity， 将 buffer 分成三个区域
  // 0---readerindex 已经读取的区域
  // readerindex---writerIndex ， 可读的区域
  // writerIndex -- capacity, 可写的区域
          ByteBuf buffer = Unpooled.buffer(10);
          for(int i = 0; i < 10; i++) {
              buffer.writeByte(i);
          }
          System.out.println("capacity=" + buffer.capacity());//10
  //输出
  // for(int i = 0; i<buffer.capacity(); i++) {
  // System.out.println(buffer.getByte(i));
  // }
          for(int i = 0; i < buffer.capacity(); i++) {
              System.out.println(buffer.readByte());
          }
          System.out.println("执行完毕");
      }
  }
  

  示例2：

  package com.netty.MoKuan;
  
  import io.netty.buffer.ByteBuf;
  import io.netty.buffer.Unpooled;
  
  import java.nio.charset.Charset;
  
  public class NettyByteBuf01 {
      public static void main(String[] args) {
  //创建 ByteBuf
          ByteBuf byteBuf = Unpooled.copiedBuffer("hello,world!", Charset.forName("utf-8"));
  //使用相关的方法
       
          if(byteBuf.hasArray()) { // true
              byte[] content = byteBuf.array();
  //将 content 转成字符串
              System.out.println(new String(content, Charset.forName("utf-8")));
              System.out.println("byteBuf=" + byteBuf);
              System.out.println(byteBuf.arrayOffset()); // 0
              System.out.println(byteBuf.readerIndex()); // 0
              System.out.println(byteBuf.writerIndex()); // 12
              System.out.println(byteBuf.capacity()); // 36
  //System.out.println(byteBuf.readByte()); //
              System.out.println(byteBuf.getByte(0)); // 104
              int len = byteBuf.readableBytes(); //可读的字节数 12
              System.out.println("len=" + len);
  //使用 for 取出各个字节
              for(int i = 0; i < len; i++) {
                  System.out.println((char) byteBuf.getByte(i));
              }
  //按照某个范围读取
             
              System.out.println(byteBuf.getCharSequence(0, 4, Charset.forName("utf-8")));
              System.out.println(byteBuf.getCharSequence(4, 6, Charset.forName("utf-8")));
          }
      }
  }
  

  💥推荐阅读💥

  上一篇：八、Netty核心技术之HTTP服务实例

  下一篇：十、Netty核心技术之Netty心跳机制