一、Netty简介
Netty是由JBOSS提供的一个java开源框架，现为 Github上的独立项目。Netty提供异步的、事件驱动的网络应用程序框架和工具，用以快速开发高性能、高可靠性的网络服务器和客户端程序。
也就是说，Netty 是一个基于NIO的客户、服务器端的编程框架，使用Netty 可以确保你快速和简单的开发出一个网络应用，例如实现了某种协议的客户、服务端应用。Netty相当于简化和流线化了网络应用的编程开发过程，例如：基于TCP和UDP的socket服务开发。
“快速”和“简单”并不用产生维护性或性能上的问题。Netty 是一个吸收了多种协议（包括FTP、SMTP、HTTP等各种二进制文本协议）的实现经验，并经过相当精心设计的项目。最终，Netty 成功的找到了一种方式，在保证易于开发的同时还保证了其应用的性能，稳定性和伸缩性
1.1 Netty的特点
- 设计优雅
适用于各种传输类型的统一API - 阻塞和非阻塞Socket
基于灵活且可扩展的事件模型，可以清晰地分离关注点
高度可定制的线程模型 - 单线程，一个或多个线程池
真正的无连接数据报套接字支持（自3.1起） - 使用方便
详细记录的Javadoc，用户指南和示例
没有其他依赖项，JDK 5（Netty 3.x）或6（Netty 4.x）就足够了 - 高性能
吞吐量更高，延迟更低
减少资源消耗
最小化不必要的内存复制 - 安全
完整的SSL / TLS和StartTLS支持 - 社区活跃，不断更新
社区活跃，版本迭代周期短，发现的BUG可以被及时修复，同时，更多的新功能会被加入
1.2 Netty常见使用场景
- 互联网行业
在分布式系统中，各个节点之间需要远程服务调用，高性能的RPC框架必不可少，Netty作为异步高新能的通信框架,往往作为基础通信组件被这些RPC框架使用。
典型的应用有：阿里分布式服务框架Dubbo的RPC框架使用Dubbo协议进行节点间通信，Dubbo协议默认使用Netty作为基础通信组件，用于实现各进程节点之间的内部通信。 - 游戏行业
无论是手游服务端还是大型的网络游戏，Java语言得到了越来越广泛的应用。Netty作为高性能的基础通信组件，它本身提供了TCP/UDP和HTTP协议栈。
非常方便定制和开发私有协议栈，账号登录服务器，地图服务器之间可以方便的通过Netty进行高性能的通信 - 大数据领域
经典的Hadoop的高性能通信和序列化组件Avro的RPC框架，默认采用Netty进行跨界点通信，它的Netty Service基于Netty框架二次封装实现
二、Netty高性能设计
2.1 Netty线程模型
Netty主要基于主从Reactors多线程模型（参考：【Linux】IO的线程模型）（如下图）做了一定的修改，其中主从Reactor多线程模型有多个Reactor：MainReactor和SubReactor：
- MainReactor负责客户端的连接请求，并将请求转交给SubReactor
- SubReactor负责相应通道的IO读写请求
- 非IO请求（具体逻辑处理）的任务则会直接写入队列，等待worker threads进行处理
这里引用Doug Lee大神的Reactor介绍：Scalable IO in Java里面关于主从Reactor多线程模型的图
虽然Netty的线程模型基于主从Reactor多线程，借用了MainReactor和SubReactor的结构，但是实际实现上，SubReactor和Worker线程在同一个线程池中：
1 EventLoopGroup bossGroup = new NioEventLoopGroup(); 2 EventLoopGroup workerGroup = new NioEventLoopGroup(); 3 ServerBootstrap server = new ServerBootstrap(); 4 server.group(bossGroup, workerGroup).channel(NioServerSocketChannel.class)
上面代码中的bossGroup 和workerGroup是Bootstrap构造方法中传入的两个对象，这两个group均是线程池
- bossGroup线程池则只是在bind某个端口后，获得其中一个线程作为MainReactor，专门处理端口的accept事件，每个端口对应一个boss线程
- workerGroup线程池会被各个SubReactor和worker线程充分利用
2.2 异步处理
异步的概念和同步相对。当一个异步过程调用发出后，调用者不能立刻得到结果。实际处理这个调用的部件在完成后，通过状态、通知和回调来通知调用者。
Netty中的I/O操作是异步的，包括bind、write、connect等操作会简单的返回一个ChannelFuture，调用者并不能立刻获得结果，通过Future-Listener机制，用户可以方便的主动获取或者通过通知机制获得IO操作结果。
当future对象刚刚创建时，处于非完成状态，调用者可以通过返回的ChannelFuture来获取操作执行的状态，注册监听函数来执行完成后的操作，常见有如下：
- 通过isDone方法来判断当前操作是否完成
- 通过isSuccess方法来判断已完成的当前操作是否成功
- 通过getCause方法来获取已完成的当前操作失败的原因
- 通过isCancelled方法来判断已完成的当前操作是否被取消
- 通过addListener方法来注册监听器，当操作已完成(isDone方法返回完成)，将会通知指定的监听器；如果future对象已完成，则理解通知指定的监听器
例如下面的代码中绑定端口是异步操作，当绑定操作处理完，将会调用相应的监听器处理逻辑
1 serverBootstrap.bind(port).addListener(future -> { 2 if (future.isSuccess()) { 3 System.out.println(new Date() + ": 端口[" + port + "]绑定成功!"); 4 } else { 5 System.err.println("端口[" + port + "]绑定失败!"); 6 } 7 });
三、Netty架构设计
前面介绍完Netty相关一些理论介绍，下面从功能特性、模块组件、运作过程来介绍Netty的架构设计3.1 功能特性
- 传输服务
支持BIO和NIO - 容器集成
支持OSGI、JBossMC、Spring、Guice容器 - 协议支持
HTTP、Protobuf、二进制、文本、WebSocket等一系列常见协议都支持。
还支持通过实行编码解码逻辑来实现自定义协议 - Core核心
可扩展事件模型、通用通信API、支持零拷贝的ByteBuf缓冲对象
3.2 模块组件
Bootstrap、ServerBootstrap
Bootstrap意思是引导，一个Netty应用通常由一个Bootstrap开始，主要作用是配置整个Netty程序，串联各个组件，Netty中Bootstrap类是客户端程序的启动引导类，ServerBootstrap是服务端启动引导类。
Future、ChannelFuture
Channel
Netty网络通信的组件，能够用于执行网络I/O操作。
Channel为用户提供：
- 当前网络连接的通道的状态（例如是否打开？是否已连接？）
- 网络连接的配置参数 （例如接收缓冲区大小）
- 提供异步的网络I/O操作(如建立连接，读写，绑定端口)，异步调用意味着任何I/O调用都将立即返回，并且不保证在调用结束时所请求的I/O操作已完成。调用立即返回一个ChannelFuture实例，通过注册监听器到ChannelFuture上，可以I/O操作成功、失败或取消时回调通知调用方。
- 支持关联I/O操作与对应的处理程序
不同协议、不同的阻塞类型的连接都有不同的 Channel 类型与之对应，下面是一些常用的 Channel 类型
- NioSocketChannel，异步的客户端 TCP Socket 连接
- NioServerSocketChannel，异步的服务器端 TCP Socket 连接
- NioDatagramChannel，异步的 UDP 连接
- NioSctpChannel，异步的客户端 Sctp 连接
- NioSctpServerChannel，异步的 Sctp 服务器端连接
这些通道涵盖了 UDP 和 TCP网络 IO以及文件 IO.
Selector
NioEventLoop
NioEventLoop中维护了一个线程和任务队列，支持异步提交执行任务，线程启动时会调用NioEventLoop的run方法，执行I/O任务和非I/O任务：
- I/O任务
即selectionKey中ready的事件，如accept、connect、read、write等，由processSelectedKeys方法触发。 - 非IO任务
添加到taskQueue中的任务，如register0、bind0等任务，由runAllTasks方法触发。
两种任务的执行时间比由变量ioRatio控制，默认为50，则表示允许非IO任务执行的时间与IO任务的执行时间相等。
NioEventLoopGroup
NioEventLoopGroup，主要管理eventLoop的生命周期，可以理解为一个线程池，内部维护了一组线程，每个线程(NioEventLoop)负责处理多个Channel上的事件，而一个Channel只对应于一个线程。
ChannelHandler
ChannelHandler是一个接口，处理I/O事件或拦截I/O操作，并将其转发到其ChannelPipeline(业务处理链)中的下一个处理程序。
ChannelHandler本身并没有提供很多方法，因为这个接口有许多的方法需要实现，方便使用期间，可以继承它的子类：
- ChannelInboundHandler用于处理入站I/O事件
- ChannelOutboundHandler用于处理出站I/O操作
或者使用以下适配器类：
- ChannelInboundHandlerAdapter用于处理入站I/O事件
- ChannelOutboundHandlerAdapter用于处理出站I/O操作
- ChannelDuplexHandler用于处理入站和出站事件
ChannelHandlerContext
保存Channel相关的所有上下文信息，同时关联一个ChannelHandler对象
ChannelPipline
保存ChannelHandler的List，用于处理或拦截Channel的入站事件和出站操作。 ChannelPipeline实现了一种高级形式的拦截过滤器模式，使用户可以完全控制事件的处理方式，以及Channel中各个的ChannelHandler如何相互交互。
下图引用Netty的Javadoc4.1中ChannelPipline的说明，描述了ChannelPipeline中ChannelHandler通常如何处理I/O事件。 I/O事件由ChannelInboundHandler或ChannelOutboundHandler处理，并通过调用ChannelHandlerContext中定义的事件传播方法（例如ChannelHandlerContext.fireChannelRead（Object）和ChannelOutboundInvoker.write（Object））转发到其最近的处理程序。
1 I/O Request 2 via Channel or 3 ChannelHandlerContext 4 | 5 +---------------------------------------------------+---------------+ 6 | ChannelPipeline | | 7 | |/ | 8 | +---------------------+ +-----------+----------+ | 9 | | Inbound Handler N | | Outbound Handler 1 | | 10 | +----------+----------+ +-----------+----------+ | 11 | /| | | 12 | | |/ | 13 | +----------+----------+ +-----------+----------+ | 14 | | Inbound Handler N-1 | | Outbound Handler 2 | | 15 | +----------+----------+ +-----------+----------+ | 16 | /| . | 17 | . . | 18 | ChannelHandlerContext.fireIN_EVT() ChannelHandlerContext.OUT_EVT()| 19 | [ method call] [method call] | 20 | . . | 21 | . |/ | 22 | +----------+----------+ +-----------+----------+ | 23 | | Inbound Handler 2 | | Outbound Handler M-1 | | 24 | +----------+----------+ +-----------+----------+ | 25 | /| | | 26 | | |/ | 27 | +----------+----------+ +-----------+----------+ | 28 | | Inbound Handler 1 | | Outbound Handler M | | 29 | +----------+----------+ +-----------+----------+ | 30 | /| | | 31 +---------------+-----------------------------------+---------------+ 32 | |/ 33 +---------------+-----------------------------------+---------------+ 34 | | | | 35 | [ Socket.read() ] [ Socket.write() ] | 36 | | 37 | Netty Internal I/O Threads (Transport Implementation) | 38 +-------------------------------------------------------------------+
入站事件由自下而上方向的入站处理程序处理，如图左侧所示。 入站Handler处理程序通常处理由图底部的I/O线程生成的入站数据。 通常通过实际输入操作（例如SocketChannel.read（ByteBuffer））从远程读取入站数据。
出站事件由上下方向处理，如图右侧所示。 出站Handler处理程序通常会生成或转换出站传输，例如write请求。 I/O线程通常执行实际的输出操作，例如SocketChannel.write（ByteBuffer）。
在 Netty 中每个 Channel 都有且仅有一个 ChannelPipeline 与之对应, 它们的组成关系如下:
四、工作原理架构
初始化并启动Netty服务端过程如下：1 public static void main(String[] args) { 2 // 创建mainReactor 3 NioEventLoopGroup boosGroup = new NioEventLoopGroup(); 4 // 创建工作线程组 5 NioEventLoopGroup workerGroup = new NioEventLoopGroup(); 6 7 final ServerBootstrap serverBootstrap = new ServerBootstrap(); 8 serverBootstrap 9 // 组装NioEventLoopGroup 10 .group(boosGroup, workerGroup) 11 // 设置channel类型为NIO类型 12 .channel(NioServerSocketChannel.class) 13 // 设置连接配置参数 14 .option(ChannelOption.SO_BACKLOG, 1024) 15 .childOption(ChannelOption.SO_KEEPALIVE, true) 16 .childOption(ChannelOption.TCP_NODELAY, true) 17 // 配置入站、出站事件handler 18 .childHandler(new ChannelInitializer<NioSocketChannel>() { 19 @Override 20 protected void initChannel(NioSocketChannel ch) { 21 // 配置入站、出站事件channel 22 ch.pipeline().addLast(...); 23 ch.pipeline().addLast(...); 24 } 25 }); 26 27 // 绑定端口 28 int port = 8080; 29 serverBootstrap.bind(port).addListener(future -> { 30 if (future.isSuccess()) { 31 System.out.println(new Date() + ": 端口[" + port + "]绑定成功!"); 32 } else { 33 System.err.println("端口[" + port + "]绑定失败!"); 34 } 35 }); 36 }
- 基本过程如下：
- 1 初始化创建2个NioEventLoopGroup，其中boosGroup用于Accetpt连接建立事件并分发请求， workerGroup用于处理I/O读写事件和业务逻辑
- 2 基于ServerBootstrap(服务端启动引导类)，配置EventLoopGroup、Channel类型，连接参数、配置入站、出站事件handler
- 3 绑定端口，开始工作
结合上面的介绍的Netty Reactor模型，介绍服务端Netty的工作架构图：
server端包含1个Boss NioEventLoopGroup和1个Worker NioEventLoopGroup，NioEventLoopGroup相当于1个事件循环组，这个组里包含多个事件循环NioEventLoop，每个NioEventLoop包含1个selector和1个事件循环线程。
每个Boss NioEventLoop循环执行的任务包含3步：
- 1 轮询accept事件
- 2 处理accept I/O事件，与Client建立连接，生成NioSocketChannel，并将NioSocketChannel注册到某个Worker NioEventLoop的Selector上
- 3 处理任务队列中的任务，runAllTasks。任务队列中的任务包括用户调用eventloop.execute或schedule执行的任务，或者其它线程提交到该eventloop的任务
每个Worker NioEventLoop循环执行的任务包含3步：
- 1 轮询read、write事件
- 2 处理I/O事件，即read、write事件，在NioSocketChannel可读、可写事件发生时进行处理
- 3 处理任务队列中的任务，runAllTasks
其中任务队列中的task有3种典型使用场景
- 1 用户程序自定义的普通任务
1 ctx.channel().eventLoop().execute(new Runnable() { 2 @Override 3 public void run() { 4 //... 5 } 6 });
-
2 非当前reactor线程调用channel的各种方法
例如在推送系统的业务线程里面，根据用户的标识，找到对应的channel引用，然后调用write类方法向该用户推送消息，就会进入到这种场景。最终的write会提交到任务队列中后被异步消费。 -
3 用户自定义定时任务
1 ctx.channel().eventLoop().schedule(new Runnable() { 2 @Override 3 public void run() { 4 5 } 6 }, 60, TimeUnit.SECONDS);
五、总结
现在稳定推荐使用的主流版本还是Netty4，Netty5 中使用了 ForkJoinPool，增加了代码的复杂度，但是对性能的改善却不明显，所以这个版本不推荐使用，官网也没有提供下载链接。
Netty 入门门槛相对较高，其实是因为这方面的资料较少，并不是因为他有多难，大家其实都可以像搞透 Spring 一样搞透 Netty。在学习之前，建议先理解透整个框架原理结构，运行过程，可以少走很多弯路。
链接：https://www.jianshu.com/p/6681bfa36c4f
来源：简书
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。