学习Netty的第一节课

发表于 2年以前 | 总阅读数：385 次

你是不是厌倦了每天写 CRUD 业务代码？

你是不是厌倦了每天写访问数据库和缓存的代码？

那不如学点新东西吧。从初级程序员进阶到高级程序员必须要了解一点高阶的东西，Java 服务端是个不错的方向，Netty 是实现服务端非常优秀的框架，也是大家走向进阶必须要迈过的一道坎。

开头有点像广告，技术干货正式开始。

Netty 初次见面

打开 Netty 的官网可以看到这样一段话：

Netty is an asynchronous event-driven network application frameworkfor rapid development of maintainable high performance protocol servers & clients.

翻译成中文是这样：

Netty是一个异步事件驱动的网络应用程序框架，用于快速开发可维护的高性能协议服务器和客户端。

这一段话看起来简单，实际上包含的信息很多：告诉了我们 Netty 是什么，然后可以干什么。再解释几个关键词：

异步事件驱动：Netty是异步事件驱动的框架，所有的IO调用会立即返回，并不保证调用成功与否，但是调用会返回ChannelFuture，netty会通过ChannelFuture通知你调用是成功了还是失败了或者是取消了。

协议服务端和客户端：使用 Netty 你就可以定制编解码协议，实现自己的特定协议的服务器。如果编解码用 HTTP 协议就是 HTTP 服务器，编解码是私有 Dubbo 协议那就是 Dubbo 服务器，Netty 给了足够的灵活度。

Netty 为什么会出现？

初出茅庐的 BIO

前面的文章使用传统 BIO 演示了一个服务端 demo，用来接收客户端的连接请求和处理读取、发送消息，我们再回顾一下基本流程：

（1）创建一个 ServerSocket 对象，绑定并监听一个端口；

（2）大量客户端请求连接服务端指定端口；

（3）服务端调用accept()方法获得一个客户端连接 Socket 对象；

（4）启动一个新线程处理客户端连接：读取 Socket 对象返回输入流，解码协议数据得到客户端发送的消息，处理消息，编码返回消息，将结果写入输出流，将 Socket 对象返回给客户端；

（5）一次客户端请求结束，继续循环执行第三步；

从这个流程可以看出，每来一个连接客户端都需要新起或者从线程池里挑出一个线程去处理，在高并发的场景下，线程数量可能会爆，线程是宝贵的资源，导致操作系统任务调度压力大，系统负载也比较高。该怎么办？

用力过猛的 NIO

BIO 性能太差，Java 官方也看不下去了，于是 NIO 就诞生了。NIO 的诞生其实是有条件的，NIO 底层依赖操作系统提供的系统调用，所以最大的原因是因为 Linux IO 技术上有所突破。

早期 Linux 操作系统使用的是select, 性能比较差，后来技术突破提供了epoll操作。Java 官方看到后顿时燃起了热情，希望改变 BIO 性能差的问题，最终推出了 Java NIO。

BIO的全称是：Blocking IO，翻译为中文：阻塞 IO；NIO 的全称是：None Blocking IO，翻译为中文：非阻塞 IO。那这个阻塞到底是什么意思呢？我们通过 BIO 服务端三个操作来逐一说明。

（1）BIO 服务端启动后会执行accept()方法，在新连接来之前会一直阻塞，所以 accept() 是阻塞的。

（2）BIO 服务端读取read()客户端发送来的数据，数据没来之前是一直阻塞的，所以 read()是阻塞的；

（3）BIO 服务端向客户端写数据write()，客户端接受完数据线程才能返回，所以 write()是阻塞的；

从这三个操作来看，BIO 服务端整体都是阻塞的，线程在 accept(), read(), write() 操作结束前是干等着啥事也做不了，极大的浪费了资源。

NIO 通过事件机制加上 IO 多路复用技术解决了阻塞问题。

横空出世的 Netty

也可能用力过猛或者其他原因，NIO 出来后引起开发者大量吐槽：API 复杂难用、臭名昭著的空轮询 bug、等等。

既然不好用，那不能再靠 Java 官方优化了，于是有些大牛基于 NIO 接口再造了一个轮子：Netty。Netty 吸取前者的经验教训，提供了一个易于操作的模式和接口，开发者使用起来也非常便捷，赢来大量好评。

为什么 Netty 受欢迎？

Netty 能被众多开发者所青睐，我觉得有如下几点原因：

并发高
传输快
封装好
社区活跃

并发高

Netty是一款基于NIO（Nonblocking I/O，非阻塞IO）的网络通信框架，对比于BIO（Blocking I/O，阻塞IO），他的并发性能得到了很大提高。

并发性能提升重要的原因之一是 NIO 使用Selector多路复用技术，使得单线程能处理的连接数量比 BIO 要高出很多。我们简单分析下 NIO 是如何优化的：

对于服务端来说，当一个连接建立之后，有两个步骤要做：第一步是接收完客户端发过来的全部数据，第二步是服务端处理完请求之后返回消息给客户端。

NIO和BIO的区别主要是在第一步。在BIO中，等待客户端发数据过来这个过程是阻塞的，这样就造成了服务端一个线程只能处理一个请求的情况，而一台机器能支持的最大线程数是有限的，这就是为什么BIO不能支持高并发的原因。

而NIO中，当一个客户端请求建立好之后，服务端线程会将这个请求交给Selector，然后紧接着去接受其他客户端连接，并不会阻塞。

传输快

我们知道，Java 的内存有堆内存（Heap）、栈内存（Stack）等，其中堆内存是占用内存空间最大的一块，也是Java对象存放的地方，一般我们的数据如果需要从IO读取到堆内存，中间需要经过Socket缓冲区，也就是说一个数据会被拷贝两次才能到达他的的终点，如果数据量大，就会造成不必要的资源浪费。

针对这种情况，Netty 继承了 Java NIO 中的一大特性：零拷贝，当他需要接收数据的时候，他会在堆内存之外开辟一块内存，数据就直接从IO读到了那块内存中去，在 Netty 里面通过ByteBuf可以直接对这些数据进行直接操作，从而加快了传输速度。

总结一下：Netty 传输快是因为继承了 Java NIO 的一个重要特性：零拷贝。

封装好

Netty 框架 API 使用简单，简化开发难度。通过对 ChannelHandler 的扩展，开发者可以根据业务场景自定义各类因为拦截器。

社区活跃

判断一个开源项目是否活跃，可以看最新发布版本的时间，以及 issue 的质量和处理速度。

Netty 在 github 上非常活跃，截止现在star 有 29k

Issue 数量也是非常多的。

版本更新速度也比较快：

这些足以说明大家对 Netty 框架的喜爱。

Netty 能做什么？

实现一个 HTTP 服务器

tomcat 应该很多人都用过，使用 Netty 也可以实现一个类似的 HTTP 服务器，接收用户发送的 HTTP 请求，解析请求携带的参数，根据路由将请求分配到不同的 handler 进行处理。

对 Socket的支持

Netty 可以实现Socket 编程，这也是它应用最广泛的场景之一。

对 Websocket 的支持

Netty对WebSocket也提供了强大的支持, netty内置的处理器会为我们做好大量的机械性麻烦性的工作。

支持自定义编解码协议

除了标准的 HTTP 等协议，通常业务还可以自行定义通信协议，例如 Dubbo 使用 Netty 实现了私有协议通信。

Netty 有哪些成功的应用场景？

互联网行业：

随着系统并发访问量越来越高，传统的单体结构无法满足需求，需要将应用进行服务化拆分为微服务。架构拆分后，各个微服务节点间需要远程调用，高性能的 RPC 框架必不可少，Netty 作为高性能的通信框架，往往作为基础通信组件被这些 RPC 框架使用。

典型的应用有：阿里RPC服务框架 Dubbo 默认使用 Netty 作为基础通信组件，用于实现各进程节点之间的内部通信。

游戏行业：

无论是手游服务端、还是大型的网络游戏都可以很方便通过 Netty 进行高性能的通信。Netty 作为高性能的基础通信组件，本身提供了 TCP/UDP 协议栈，同时也方便定制和开发私有协议栈。

大数据领域：

在大数据领域，经典的 Hadoop 框架，在使用集群时默认采用 Netty 进行跨节点通信。大数据计算往往采用多个计算节点和一个/N个汇总节点进行分布式部署，各节点之间存在海量的数据交换。由于 Netty 的综合性能是目前各个成熟 NIO 框架中最高的，因此，往往会被选中用作大数据各节点间的通信。

以上仅列出了几个典型的使用场景，Netty 作为基础的通信组件在涉及网络编程领域已成为实事标准。

永远的 Hello World

maven 中配置好依赖，引入 Netty：

<dependency>
    <groupId>io.netty</groupId>
    <artifactId>netty-all</artifactId>
    <version>4.1.74.Final</version>
</dependency>

下面写一个最简单的服务端 demo，主要功能是监听8888端口，打印客户端发送过来的消息。

import io.netty.bootstrap.ServerBootstrap;
import io.netty.buffer.ByteBuf;
import io.netty.channel.*;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.util.CharsetUtil;

public class ServerDemo {

    public static void main(String[] args) throws Exception {
        // 创建两个线程组 boosGroup、workerGroup
        EventLoopGroup bossGroup = new NioEventLoopGroup(1);
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        try {
            // 创建服务端的启动对象
            ServerBootstrap bootstrap = new ServerBootstrap();
            // 设置两个线程组boosGroup和workerGroup
            bootstrap.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 {
                            // 给workerGroup的EventLoop对应的管道设置处理器
                            socketChannel.pipeline().addLast(new MyHandler());
                        }
                    });

            // 绑定端口号，启动服务端
            ChannelFuture channelFuture = bootstrap.bind(8888).sync();
            System.out.println("服务端已启动...");
            // 对关闭通道进行监听
            channelFuture.channel().closeFuture().sync();
        } finally {
            // 关闭线程组
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }

    public static class MyHandler extends ChannelInboundHandlerAdapter {
        @Override
        public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
            // 获取客户端发送过来的消息
            ByteBuf byteBuf = (ByteBuf) msg;
            System.out.println("收到客户端{" + ctx.channel().remoteAddress() + "}发送的消息：" + byteBuf.toString(CharsetUtil.UTF_8));
        }
    }
}

测试一下：

使用 telnet 命令行模拟客户端发送消息：