NIO 的类库和 API 繁杂，使用麻烦：需要熟练掌握Selector、 ServerSocketChannel、 SocketChannel、 ByteBuffer等。 开发工作量和难度都非常大： 例如客户端面临断线重连、 网络闪断、心跳处理、半包读写、 网络拥塞和异常流的处理等等。
Netty 对 JDK 自带的 NIO 的 API 进行了良好的封装，解决了上述问题。且Netty拥有高性能、吞吐量更高，延迟更低，减少资源消耗，最小化不必要的内存复制等优点。

NIO具体特点及用法可以参考《I/O多路复用原理》

Netty使用场景：
在分布式系统中，各个节点之间需要远程服务调用，高性能的 RPC 框架必不可少，Netty 作为异步高性能的通信框架，往往作为基础通信组件被这些 RPC 框架使用。典型的应用有：阿里分布式服务框架 Dubbo 的 RPC 框架使用 Dubbo 协议进行节点间通信，Dubbo 协议默认使用 Netty 作为基础通信组件，用于实现。各进程节点之间的内部通信。Rocketmq底层也是用的Netty作为基础通信组件。

Netty通讯实示例

服务端代码示例:

  1. public class NettyServer {
  3.     public static void main(String[] args) throws Exception {
  5.         // 创建两个线程组bossGroup和workerGroup, 含有的子线程NioEventLoop的个数默认为cpu核数的两倍
  6.         // bossGroup只是处理连接请求 ,真正的和客户端业务处理，会交给workerGroup完成
  7.         EventLoopGroup bossGroup = new NioEventLoopGroup(1);
  8.         EventLoopGroup workerGroup = new NioEventLoopGroup(8);
  9.         try {
  10.             // 创建服务器端的启动对象
  11.             ServerBootstrap bootstrap = new ServerBootstrap();
  12.             // 使用链式编程来配置参数
  13.             bootstrap.group(bossGroup, workerGroup) //设置两个线程组
  14.                     // 使用NioServerSocketChannel作为服务器的通道实现
  15.                     .channel(NioServerSocketChannel.class)
  16.                     // 初始化服务器连接队列大小，服务端处理客户端连接请求是顺序处理的,所以同一时间只能处理一个客户端连接。
  17.                     // 多个客户端同时来的时候,服务端将不能处理的客户端连接请求放在队列中等待处理
  18.                     .option(ChannelOption.SO_BACKLOG, 1024)
  19.                     //创建通道初始化对象，设置初始化参数，在SocketChannel建立起来之前执行
  20.                     .childHandler(new ChannelInitializer<SocketChannel>() {
  22.                         @Override
  23.                         protected void initChannel(SocketChannel ch) throws Exception {
  24.                             //对workerGroup的SocketChannel设置处理器
  25.                             ch.pipeline().addLast(new NettyServerHandler());
  26.                         }
  27.                     });
  28.             System.out.println("netty server start。。");
  29.             // 绑定一个端口并且同步, 生成了一个ChannelFuture异步对象，通过isDone()等方法可以判断异步事件的执行情况
  30.             // 启动服务器(并绑定端口)，bind是异步操作，sync()方法是等待异步操作执行完毕
  31.             ChannelFuture cf = bootstrap.bind(9000).sync();
  32.             // 等待服务端监听端口关闭，closeFuture是异步操作
  33.             // 通过sync方法同步等待通道关闭处理完毕，这里会阻塞等待通道关闭完成，内部调用的是Object的wait()方法
  34.             cf.channel().closeFuture().sync();
  35.         } finally {
  36.             bossGroup.shutdownGracefully();
  37.             workerGroup.shutdownGracefully();
  38.         }
  39.     }
  40. }
  41. ---------------------------------------------------------------------
  42. /**
  43.  * 自定义Handler需要继承netty规定好的某个HandlerAdapter(规范)
  44.  */
  45. public class NettyServerHandler extends ChannelInboundHandlerAdapter {
  47.     /**
  48.      * 当客户端连接服务器完成就会触发该方法
  49.      *
  50.      * @param ctx
  51.      * @throws Exception
  52.      */
  53.     @Override
  54.     public void channelActive(ChannelHandlerContext ctx) {
  55.         System.out.println("客户端连接通道建立完成");
  56.     }
  58.     /**
  59.      * 读取客户端发送的数据
  60.      *
  61.      * @param ctx 上下文对象, 含有通道channel，管道pipeline
  62.      * @param msg 就是客户端发送的数据
  63.      * @throws Exception
  64.      */
  65.     @Override
  66.     public void channelRead(ChannelHandlerContext ctx, Object msg) {
  67.         //Channel channel = ctx.channel();
  68.         //ChannelPipeline pipeline = ctx.pipeline(); //本质是一个双向链接, 出站入站
  69.         //将 msg 转成一个 ByteBuf，类似NIO 的 ByteBuffer
  70.         ByteBuf buf = (ByteBuf) msg;
  71.         System.out.println("收到客户端的消息:" + buf.toString(CharsetUtil.UTF_8));
  72.     }
  74.     /**
  75.      * 数据读取完毕处理方法
  76.      *
  77.      * @param ctx
  78.      * @throws Exception
  79.      */
  80.     @Override
  81.     public void channelReadComplete(ChannelHandlerContext ctx) {
  82.         ByteBuf buf = Unpooled.copiedBuffer("HelloClient".getBytes(CharsetUtil.UTF_8));
  83.         ctx.writeAndFlush(buf);
  84.     }
  86.     /**
  87.      * 处理异常, 一般是需要关闭通道
  88.      *
  89.      * @param ctx
  90.      * @param cause
  91.      * @throws Exception
  92.      */
  93.     @Override
  94.     public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
  95.         ctx.close();
  96.     }
  97. }

客户端代码：

  1. public class NettyClient {
  2.     public static void main(String[] args) throws Exception {
  3.         //客户端需要一个事件循环组
  4.         EventLoopGroup group = new NioEventLoopGroup();
  5.         try {
  6.             //创建客户端启动对象
  7.             //注意客户端使用的不是ServerBootstrap而是Bootstrap
  8.             Bootstrap bootstrap = new Bootstrap();
  9.             //设置相关参数
  10.             bootstrap.group(group) //设置线程组
  11.                     .channel(NioSocketChannel.class) // 使用NioSocketChannel作为客户端的通道实现
  12.                     .handler(new ChannelInitializer<SocketChannel>() {
  13.                         @Override
  14.                         protected void initChannel(SocketChannel ch) throws Exception {
  15.                             //加入处理器
  16.                             ch.pipeline().addLast(new NettyClientHandler());
  17.                         }
  18.                     });
  20.             System.out.println("netty client start。。");
  21.             //启动客户端去连接服务器端
  22.             ChannelFuture cf = bootstrap.connect("127.0.0.1", 9000).sync();
  23.             //对通道关闭进行监听
  24.             cf.channel().closeFuture().sync();
  25.         } finally {
  26.             group.shutdownGracefully();
  27.         }
  28.     }
  29. }
  30. ----------------------------------------------
  31. public class NettyClientHandler extends ChannelInboundHandlerAdapter {
  33.     /**
  34.      * 当客户端连接服务器完成就会触发该方法
  35.      *
  36.      * @param ctx
  37.      * @throws Exception
  38.      */
  39.     @Override
  40.     public void channelActive(ChannelHandlerContext ctx) {
  41.         ByteBuf buf = Unpooled.copiedBuffer("HelloServer".getBytes(CharsetUtil.UTF_8));
  42.         ctx.writeAndFlush(buf);
  43.     }
  45.     //当通道有读取事件时会触发，即服务端发送数据给客户端
  46.     @Override
  47.     public void channelRead(ChannelHandlerContext ctx, Object msg) {
  48.         ByteBuf buf = (ByteBuf) msg;
  49.         System.out.println("收到服务端的消息:" + buf.toString(CharsetUtil.UTF_8));
  50.     }
  52.     @Override
  53.     public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
  54.         cause.printStackTrace();
  55.         ctx.close();
  56.     }
  57. }

看完以上代码，我们可以发现很多写法都是Netty规定好了，我们只需要编写专注于业务处理的Handler。这也是Netty框架的一大特点，让你的业务逻辑从网络基础应用编码中分离出来，让你可以专注业务的开发，而不需写一大堆类似NIO的网络处理操作。

Netty模块组件

NioEventLoopGroup

相当于一个事件循环线程组, 这个组中含有多个事件循环线程，每一个事件循环线程是NioEventLoop，NioEventLoopGroup主要管理 eventLoop 的生命周期，可以理解为一个线程池，内部维护了一组线程，每个线程负责处理多个 Channel 上的事件，而一个 Channel 只对应于一个线程。

NioEventLoop

每个NioEventLoop都有一个selector , 用于监听注册在其上的socketChannel的网络通讯，NioEventLoop 中维护了一个任务队列，支持异步提交执行任务，线程启动时会调用 NioEventLoop 的 run 方法，执行 I/O 任务和非 I/O 任务：

  • I/O 任务：即 selectionKey 中 ready 的事件，如 accept、connect、read、write 等，由 processSelectedKeys() 方法触发
  • 非 IO 任务：添加到 taskQueue 中的任务，如 register0，由 runAllTasks() 方法触发

BootStrap、ServerBootStrap

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

Future、ChannelFuture

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

ChannelHandler

ChannelHandler 是一个接口，处理 I/O 事件或拦截 I/O 操作，并将其转发到其ChannelPipeline中的下一个处理程序。 ChannelHandler 本身并没有提供很多方法，因为这个接口有许多的方法需要实现，方便使用期间，可以继承它的子类：

  • ChannelInboundHandler 用于处理入站 I/O 事件
  • ChannelOutboundHandler 用于处理出站 I/O 操作

ChannelHandlerContext

保存 Channel 相关的所有上下文信息，同时关联一个 ChannelHandler 对象。

ChannelPipeline

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

Netty线程模型

Netty线程模型是基于主从Reactor模型演变而来

Reactor模型相关特点可以阅读《Reactor线程模型》

微信截图_20210726145701.png

  • BossGroup：专门负责接收客户端的连接
  • workerGroup：专门负责网络的读写（BossGroup和WorkerGroup类型都是NioEventLoopGroup ）
  • 每个BossGroup 中 NioEventLoop 内部循环执行的步骤
    • 处理accept事件 , 与client 建立连接 , 生成 NioSocketChannel
    • 将NioSocketChannel注册到某个workerGroup 的 NioEventLoop上的selector
    • 处理任务队列的任务 ， 即runAllTasks
  • 每个workerGroup 中 NioEventLoop线程循环执行的步骤
    • 轮询注册到自己selector上的所有NioSocketChannel 的read, write事件
    • 处理 I/O 事件， 即read , write 事件， 在对应NioSocketChannel 处理业务
    • runAllTasks处理任务队列TaskQueue的任务 ，一些耗时的业务处理一般可以放入TaskQueue中慢慢处理，这样不影响数据在 pipeline 中的流动处理
  • 每个 NioEventLoop 处理 NioSocketChannel 业务时，会使用 pipeline，管道中维护了很多 handler 处理器用来处理 channel 中的数据