史上最通俗 Netty 入门长文：基本介绍、环境搭建、动手实战
原作者江成军，原题“还在被 Java NIO 虐？该试试 Netty 了”，收录时有修订和改动。
1、阅读对象
本文适合对 Netty 一无所知的 Java NIO 网络编程新手阅读，为了做到这一点，内容从最基本介绍到开发环境的配置，再到第一个 Demo 代码的编写，事无巨细都用详细的图文进行了说明。
所以本文这对于新手来说帮助很大，但对于老司机来说，就没有必要了。老司机请绕道哦。
PS：是的，用 Java 写 IM、消息推送的话，基本上都是用的 Netty，所以如果你想用 Java 做即时通讯这类系统，学习 Netty 肯定没错。
2、本文作者
江成军：工信部信息系统项目管理师，全栈工程师，多年丰富的 JavaWEB 平台、PC 端软件、移动端 APP 开发及培训经验，擅长把复杂的事情搞简单。
3、基本常识
在了解 Netty 之前，我们非常有必要简要了解一下 Java 网络编程模型的基本常识，具体说也就是 BIO、NIO 和 AIO 这 3 个技术概念。
BIO、NIO 和 AIO 这三个概念分别对应三种通讯模型：阻塞、非阻塞、非阻塞异步，具体这里就不详细写了。网上好多博客说 Netty 对应 NIO，准确来说，应该是既可以是 NIO，也可以是 AIO，就看你怎么实现。
这三个概念的区别如下：
1）BIO：一个连接一个线程，客户端有连接请求时服务器端就需要启动一个线程进行处理,线程开销大。
2）NIO：一个请求一个线程，客户端发送的连接请求会注册到多路复用器上，多路复用器轮询到该连接有 I/O 请求时才启动一个线程进行处理；
3）AIO：一个有效请求一个线程，客户端的 I/O 请求都是由 OS 先完成了再通知服务器应用去启动线程进行处理。
通俗地概括一下就是：
1）BIO 是面向流的，NIO 是面向缓冲区的；
2）BIO 的各种流是阻塞的，而 NIO 是非阻塞的；
3）BIO 的 Stream 是单向的，而 NIO 的 channel 是双向的。
NIO 的的显著特点：事件驱动模型、单线程处理多任务、非阻塞 I/O，I/O 读写不再阻塞，而是返回 0、基于 block 的传输比基于流的传输更高效、更高级的 IO 函数 zero-copy、IO 多路复用大大提高了 Java 网络应用的可伸缩性和实用性。基于 Reactor 线程模型。
限于篇幅原因，这里没办法深入展开话题，想深入了解的，可以继续阅读这几篇：
3）《史上最强Java NIO入门：担心从入门到放弃的，请读这篇！》（* 推荐必读）。
4、认识 Netty
4.1 基本介绍
Netty 是一个 Java NIO 技术的开源异步事件驱动的网络编程框架，用于快速开发可维护的高性能协议服务器和客户端。
往通俗了讲，可以将 Netty 理解为：一个将 Java NIO 进行了大量封装，并大大降低 Java NIO 使用难度和上手门槛的超牛逼框架。
PS：Netty 的官网是 https://netty.io/，可以随时下载到最新的 Netty 源码，以及各种 API 文档和开发指南。
4.2 技术特征
Netty 的优点，概括一下就是：
1）使用简单；
2）功能强大；
3）性能强悍。
Netty 的特点：
1）高并发：基于 NIO（Nonblocking IO，非阻塞 IO）开发，对比于 BIO（Blocking I/O，阻塞 IO），他的并发性能得到了很大提高；
2）传输快：传输依赖于零拷贝特性，尽量减少不必要的内存拷贝，实现了更高效率的传输；
3）封装好：封装了 NIO 操作的很多细节，提供了易于使用调用接口。
Netty 的优势：
1）使用简单：封装了 NIO 的很多细节，使用更简单；
2）功能强大：预置了多种编解码功能，支持多种主流协议；
3）扩展性强：可以通过 ChannelHandler 对通信框架进行灵活地扩展；
4）性能优异：通过与其他业界主流的 NIO 框架对比，Netty 的综合性能最优；
5）运行稳定：Netty 修复了已经发现的所有 NIO 的 bug，让开发人员可以专注于业务本身；
6）社区活跃：Netty 是活跃的开源项目，版本迭代周期短，bug 修复速度快。
Netty 高性能表现在哪些方面？
1）IO 线程模型：同步非阻塞，用最少的资源做更多的事；
2）内存零拷贝：尽量减少不必要的内存拷贝，实现了更高效率的传输；
3）内存池设计：申请的内存可以重用，主要指直接内存。内部实现是用一颗二叉查找树管理内存分配情况；
4）串形化处理读写：避免使用锁带来的性能开销；
5）高性能序列化协议：支持 protobuf 等高性能序列化协议。
限于篇幅，Netty 的详细特征就不展开了，有兴趣的可以读一读《新手入门：目前为止最透彻的的Netty高性能原理和框架架构解析》。
5、Netty 的作者
个人而言，了解一项技术，比较喜欢扒一下它的作者情况，不是八卦，只是个人习惯，希望对所使用的技术了解地更多更全面而已。
5.1 Netty 的创始人
Netty 的创始人是韩国人 Trustin Lee，80 年出生，8 岁起在 MSX 迷你计算机上编写 BASIC 程序，爱好游戏编程以及使用汇编、C 和 C++解决编程问题，1998 年获得韩国信息奥林匹克竞赛铜牌。
就读于韩国 Yonsei 大学计算机系期间，曾为多家公司编写高性能网络应用以及少量的 web 程序，毕业后，就职于 Arreo 通讯公司，该公司为韩国最大的移动短信提供商之一。
他现在韩国 line 公司工作（据他个人博客显示，他以于 2020 年 8 月底从 Line 离职了，具体博文 点这里），早前应用较多的 Mina 也是这牛人的作品。
▲ Trustin Lee 本尊
Trustin Lee 大神的其它信息：
他的个人博客：https://t.motd.kr/
他的 Github：https://github.com/trustin
5.2 Netty 现任 Leader
Netty 目前的项目 leader 是德国人 Norman Maurer（之前在 Redhat，全职开发 Netty）,也是《Netty in Action》的作者，目前是苹果公司高级工程师。
▲ Norman maurer 本尊
Norman maurer 大神的其它信息：
他的个人博客：http://normanmaurer.me/
他的 Github：https://github.com/normanmaurer
最后，附上两位大神的同框图：
6、Netty 能做什么？
学技能都是为了能够应用到实际工作中去，谁也不是为了学而学、弄着玩不是，那么 Netty 能做什么呢？
主要是在两个方面。
一方面：现在物联网的应用无处不在，大量的项目都牵涉到应用传感器和服务器端的数据通信，Netty 作为基础通信组件、能够轻松解决之前有较高门槛的通信系统开发，你不用再为如何解析各类简单、或复杂的通讯协议而薅头发了，有过这方面开发经验的程序员会有更深刻、或者说刻骨铭心的体会。
另一方面：现在互联网系统讲究的都是高并发、分布式、微服务，各类消息满天飞（是的，IM 系统、消息推送系统就是其中的典型），Netty 在这类架构里面的应用可谓是如鱼得水，如果你对当前的各种应用服务器不爽，那么完全可以基于 Netty 来实现自己的 HTTP 服务器、FTP 服务器、UDP 服务器、RPC 服务器、WebSocket 服务器、Redis 的 Proxy 服务器、MySQL 的 Proxy 服务器等等。
7、掌握 Netty 有什么好处？
直接的好处是：能够有进大厂、拿高薪的机会，业内好多著名的公司在招聘高级/资深 Java 工程师时基本上都要求熟练掌握、或熟悉 Netty。
这个名单还可以很长很长。。。
作为一个学 Java 的，如果没有研究过 Netty，那么你对 Java 语言的使用和理解仅仅停留在表面水平，会点 SSH，写几个 MVC，访问数据库和缓存，这些只是初、中等 Java 程序员干的事。如果你要进阶，想了解 Java 服务器的深层高阶知识，Netty 绝对是一个必须要过的门槛。
间接地好处是：多款开源框架中应用了 Netty，掌握了 Netty，就具有分析这些开源框架的基础了，也就是有了成为技术大牛的基础。
这些开源框架有哪些呢？
简单罗列一些典型的，如下：
1）阿里分布式服务框架 Dubbo 的 RPC 框架；
2）淘宝的消息中间件 RocketMQ；
3）Hadoop 的高性能通信和序列化组件 Avro 的 RPC 框架；
4）开源集群运算框架 Spark；
5）分布式计算框架 Storm；
6）并发应用和分布式应用 Akka；
7）名单依然很长很长。。。。
8、理论知识准备
本文的下半部分，将手翅手，带你动手实现一个传输字符串的简单实例。
在开始动手之前，必要的基础概念还是要知道的，要不然代码敲下来，功能倒是实现了，但对 Netty 还是一头雾水，这就不是本文要达到的目的了。
本示例需要用到的基础知识主要有以下几方面的东东，这些知识点最好有一个大概的了解，要不然，看实例会有一定的困难。
1）掌握 Java 基础；
2）掌握 Maven 基础；
3）熟悉 IntelliJ IDEA 集成开发工具的使用，这个工具简称 IDEA；
4）知道 TCP、Socket 的基本概念。
尤其提一下，TCP、Socket 没概念的，下面这几篇一定要读一下：
大致了解一下 Netty 的主要组件及概念：
1）I/O：各种各样的流（文件、数组、缓冲、管道。。。）的处理（输入输出）；
2）Channel：通道，代表一个连接，每个 Client 请对会对应到具体的一个 Channel；
3）ChannelPipeline：责任链，每个 Channel 都有且仅有一个 ChannelPipeline 与之对应，里面是各种各样的 Handler；
4）handler：用于处理出入站消息及相应的事件，实现我们自己要的业务逻辑；
5）EventLoopGroup：I/O 线程池，负责处理 Channel 对应的 I/O 事件；
6）ServerBootstrap：服务器端启动辅助对象；
7）Bootstrap：客户端启动辅助对象；
8）ChannelInitializer：Channel 初始化器；
9）ChannelFuture：代表 I/O 操作的执行结果，通过事件机制，获取执行结果，通过添加监听器，执行我们想要的操作；
10）ByteBuf：字节序列，通过 ByteBuf 操作基础的字节数组和缓冲区。
关于深入理解 Netty 的这些概念，建议有必要的话，务必详读：《新手入门：目前为止最透彻的的Netty高性能原理和框架架构解析》。
对于 Netty 开发，API 文档和源码是最常用的资料，以下是我整理的在线阅读链接：
1）Netty-4.1.x 源码地址：http://docs.52im.net/extend/docs/src/netty4_1/ （可在线阅读）
2）Netty-4.1.x API 文档：http://docs.52im.net/extend/docs/api/netty4_1/ （可在线阅读）
9、开发环境准备
开发环境准备主要有三个方面：JDK 安装及环境变量设置、Maven 安装及环境变量设置、IDEA 安装及基本设置。
下面请逐个跟着我来傻瓜式配置和操做即可。
9.1 JDK 安装及环境变量设置
JDK 下载，可以从官方现在，也可以度娘上随便搜下载链接，我这里下载的是 JDK8，要注意一点的是，现在从 JDK 的官网 Oracle 下载需要账号了，没账号的可下不了啦，不知道在搞什么东东。
官网下载地址：https://www.oracle.com ，截图依次如下：
下载完，一路 Next 安装完，在创建 Java 环境变量设置，[此电脑]右键-->[属性]-->[高级系统设置]-->[环境变量]-->[系统变量]。
截图如下：
Java 环境变量创建完毕后，在 DOS 窗口执行命令：java -version，测试一下是否正常
9.2 Maven 安装及环境变量设置
Maven 功能很强大，但大家不用担心、本实例中仅仅是利用其便利的 jar 包依赖、jar 包依赖传递，基本上没有任何学习成本。
jar 包依赖、jar 包依赖传递的概念如下图，清楚明了，都不用多做解释：
Maven 是下载，解压缩后，配置环境变量后就能用，不用安装的。
下载地址：https://downloads.apache.org/maven/maven-3/3.6.3/binaries/
安装：下载压缩包，解压，文件夹拷贝到所想存储的位置（如 C 盘根目录）。
配置环境变量，和 Java 的环境变量配置一样的，创建 MAVEN_HOME,指向 Maven 文件夹，再在 path 中添加进去就行。
如下图：
由于直接冲 Maven 的中央仓库中自动下载 jar 包较慢，一般在 Maven 的配置文件中，增加阿里云的公共仓库配置，这样会显著加快 jar 包的下载速度。
如下图所示：
上面的环境变量设置完后，通过 DOS 窗口中输入命令：mvn -version 进行验证是否成功，如下：
9.3 IDEA 安装及基本设置
IDEA 的下载和安装就不多说了，其版本分旗舰版和社区版，旗舰版收费，社区版免费，社区版不支持 html、js、css 等。
但对于本实例，社区版就够用了，但如果你不在乎那点银子，可以考虑旗舰版，一步到位，万一后面我们还要做 WEB 系统开发可以免得折腾。
其安装不用多说，一路 Next 就行，安装完后，在其配置里面指定一下 JDK、Maven 的位置就行了，如下图依次所示。
Maven 指定：[File]-->[setting]-->[Build,Excution,Deployment]-->[Build Tools]-->[Maven]
JDK 指定：[File]-->[Project Structure]-->[Project Setting]-->[Project]
9.4 在 IDEA 中创建 Maven 工程
新建工程：
填写包名及工程名称：
Maven 配置：
生成工程，自动创建 Maven 的依赖文件：
在 pom.xml 中配置 Netty 依赖：
经过上面的步骤，我们的 Maven 工程就已经创建完毕，现在可以编写 Netty 的第一个程序，这个程序很简单，传输一个字符串，虽然程序很简单，但是已经能够大体上反映 Netty 开发通信程序的一个整体流程了。
10、开始动手代码实战
10.1 Netty 开发的基本套路
Netty 开发的基本套路很简洁，服务器端和客户端都是这样。
大致的套路基本如下：
Netty 开发的实际代码过程，也确实并不复杂，就像下图这样，绿色的代表客户端流程、蓝色的代表服务器端流程，注意标红的部分。
实际代码过程就像下图这样：
10.2 创建客户端类
10.2.1）创建 Handler：
首先创建 Handler 类，该类用于接收服务器端发送的数据，这是一个简化的类，只重写了消息读取方法 channelRead0、捕捉异常方法 exceptionCaught。
客户端的 Handler 一般继承的是SimpleChannelInboundHandler，该类有丰富的方法，心跳、超时检测、连接状态等等。
代码如下：
import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandler;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;
import io.netty.util.CharsetUtil;
/**
* @Date: 2020/6/1 11:12
* @Description: 通用 handler，处理 I/O 事件
*/
@ChannelHandler.Sharable
public class HandlerClientHello extends SimpleChannelInboundHandler<ByteBuf>
{
@Override
protected void channelRead0(ChannelHandlerContext channelHandlerContext, ByteBuf byteBuf) throws Exception
{
/**
* @Description 处理接收到的消息
**/
System.out.println("接收到的消息："+byteBuf.toString(CharsetUtil.UTF_8));
}
@Override
public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throwsException
{
/**
* @Description 处理 I/O 事件的异常
**/
cause.printStackTrace();
ctx.close();
}
}
代码说明：
1）@ChannelHandler.Sharable：这个注解是为了线程安全，如果你不在乎是否线程安全，不加也可以；
2）SimpleChannelInboundHandler：这里的类型可以是 ByteBuf，也可以是 String，还可以是对象，根据实际情况来；
3）channelRead0：消息读取方法，注意名称中有个 0；
4）ChannelHandlerContext：通道上下文，代指 Channel；
5）ByteBuf：字节序列，通过 ByteBuf 操作基础的字节数组和缓冲区，因为 JDK 原生操作字节麻烦、效率低，所以 Netty 对字节的操作进行了封装，实现了指数级的性能提升，同时使用更加便利；
6）CharsetUtil.UTF_8：这个是 JDK 原生的方法，用于指定字节数组转换为字符串时的编码格式。
10.2.2）创建客户端启动类：
客户端启动类根据服务器端的 IP 和端口，建立连接，连接建立后，实现消息的双向传输。
代码较简洁，如下：
import com.sun.org.apache.bcel.internal.generic.ATHROW;
import io.netty.*;
import java.net.InetSocketAddress;
/**
* @Date: 2020/6/1 11:24
* @Description: 客户端启动类
*/
public class AppClientHello
{
private final String host;
private fina lint port;
public AppClientHello(String host, int port)
{
this.host = host;
this.port = port;
}
public void run() throws Exception
{
/**
* @Description 配置相应的参数，提供连接到远端的方法
**/
EventLoopGroup group = newNioEventLoopGroup();//I/O 线程池
try{
Bootstrap bs = newBootstrap();//客户端辅助启动类
bs.group(group)
.channel(NioSocketChannel.class)//实例化一个 Channel
.remoteAddress(newInetSocketAddress(host,port))
.handler(newChannelInitializer<SocketChannel>()//进行通道初始化配置
{
@Override
protected void initChannel(SocketChannel socketChannel) throws Exception
{
socketChannel.pipeline().addLast(newHandlerClientHello());//添加我们自定义的 Handler
}
});
//连接到远程节点；等待连接完成
ChannelFuture future=bs.connect().sync();
//发送消息到服务器端，编码格式是 utf-8
future.channel().writeAndFlush(Unpooled.copiedBuffer("Hello World", CharsetUtil.UTF_8));
//阻塞操作，closeFuture()开启了一个 channel 的监听器（这期间 channel 在进行各项工作），直到链路断开
future.channel().closeFuture().sync();
} finally{
group.shutdownGracefully().sync();
}
}
public static void main(String[] args) throws Exception
{
new AppClientHello("127.0.0.1",18080).run();
}
}
由于代码中已经添加了详尽的注释，这里只对极个别的进行说明：
1）ChannelInitializer：通道 Channel 的初始化工作，如加入多个 handler，都在这里进行；
2）bs.connect().sync()：这里的 sync()表示采用的同步方法，这样连接建立成功后，才继续往下执行；
3）pipeline()：连接建立后，都会自动创建一个管道 pipeline，这个管道也被称为责任链，保证顺序执行，同时又可以灵活的配置各类 Handler，这是一个很精妙的设计，既减少了线程切换带来的资源开销、避免好多麻烦事，同时性能又得到了极大增强。
10.3 创建服务器端类
10.3.1）创建 Handler：
和客户端一样，只重写了消息读取方法 channelRead(注意这里不是 channelRead0)、捕捉异常方法 exceptionCaught。
另外服务器端 Handler 继承的是ChannelInboundHandlerAdapter，而不是SimpleChannelInboundHandler，至于这两者的区别，这里不赘述，大家自行百度吧。
代码如下：
import io.netty.*;
/**
* @Date: 2020/6/1 11:47
* @Description: 服务器端 I/O 处理类
*/
@ChannelHandler.Sharable
public class HandlerServerHello extends ChannelInboundHandlerAdapter
{
@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception
{
//处理收到的数据，并反馈消息到到客户端
ByteBuf in = (ByteBuf) msg;
System.out.println("收到客户端发过来的消息: "+ in.toString(CharsetUtil.UTF_8));
//写入并发送信息到远端（客户端）
ctx.writeAndFlush(Unpooled.copiedBuffer("你好，我是服务端，我已经收到你发送的消息", CharsetUtil.UTF_8));
}
@Override
public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception
{
//出现异常的时候执行的动作（打印并关闭通道）
cause.printStackTrace();
ctx.close();
}
}
以上代码很简洁，大家注意和客户端 Handler 类进行比较。
10.3.2）创建服务器端启动类：
服务器端启动类比客户端启动类稍显复杂一点，先贴出代码如下：
import io.netty.*;
import java.net.InetSocketAddress;
/**
* @Date: 2020/6/1 11:51
* @Description: 服务器端启动类
*/
public class AppServerHello
{
private int port;
public AppServerHello(int port)
{
this.port = port;
}
public void run() throws Exception
{
EventLoopGroup group = newNioEventLoopGroup();//Netty 的 Reactor 线程池，初始化了一个 NioEventLoop 数组，用来处理 I/O 操作,如接受新的连接和读/写数据
try{
ServerBootstrap b = newServerBootstrap();//用于启动 NIO 服务
b.group(group)
.channel(NioServerSocketChannel.class) //通过工厂方法设计模式实例化一个 channel
.localAddress(newInetSocketAddress(port))//设置监听端口
.childHandler(newChannelInitializer<SocketChannel>() {
//ChannelInitializer 是一个特殊的处理类，他的目的是帮助使用者配置一个新的 Channel,用于把许多自定义的处理类增加到 pipline 上来
@Override
public void initChannel(SocketChannel ch) throws Exception {//ChannelInitializer 是一个特殊的处理类，他的目的是帮助使用者配置一个新的 Channel。
ch.pipeline().addLast(new HandlerServerHello());//配置 childHandler 来通知一个关于消息处理的 InfoServerHandler 实例
}
});
//绑定服务器，该实例将提供有关 IO 操作的结果或状态的信息
ChannelFuture channelFuture= b.bind().sync();
System.out.println("在"+ channelFuture.channel().localAddress()+"上开启监听");
//阻塞操作，closeFuture()开启了一个 channel 的监听器（这期间 channel 在进行各项工作），直到链路断开
channelFuture.channel().closeFuture().sync();
} finally{
group.shutdownGracefully().sync();//关闭 EventLoopGroup 并释放所有资源，包括所有创建的线程
}
}
public static void main(String[] args) throws Exception
{
new AppServerHello(18080).run();
}
}
代码说明：
1）EventLoopGroup：实际项目中，这里创建两个 EventLoopGroup 的实例，一个负责接收客户端的连接，另一个负责处理消息 I/O，这里为了简单展示流程，让一个实例把这两方面的活都干了；
2）NioServerSocketChannel：通过工厂通过工厂方法设计模式实例化一个 channel，这个在大家还没有能够熟练使用 Netty 进行项目开发的情况下，不用去深究。
到这里，我们就把服务器端和客户端都写完了 ，如何运行呢，先在服务器端启动类上右键，点 Run 'AppServerHello.main()'菜单运行，见下图。
然后，再同样的操作，运行客户端启动类，就能看见效果了。
11、写在最后
本文的内容就到这里结束了，希望本文能够让大家对 Netty 有一个整体的认识，并大概了解其开发流程。
Netty 的功能很多，本文只是一个入门的介绍，如果大家对于 Netty 开发有兴趣，可以关注我并给我留言，我会根据关注和留言情况，陆续再撰写 Netty 实战开发的文章。
得到肯定和正向反馈，才有继续写下去的愿望和动力，毕竟写这种事无巨细的文章，还是挺费精力的。
（本文同步发布于：http://www.52im.net/thread-3207-1-1.html）
还未添加个人签名 2019.08.26 加入
开源IM框架MobileIMSDK、BeautyEye的作者。
评论