Netty框架学习之(一）：Netty框架简介

古城微笑少年丶 2021-11-26 23:10 536阅读 0赞

1. 简介  
官方定义为：”Netty 是一款异步的事件驱动的网络应用程序框架，支持快速地开发可维护的高性能的面向协议的服务器   
和客户端”,按照惯例贴上一张High Level的架构图：

纵观Java系的多种服务器/大数据框架，都离不开Netty做出的贡献，本文对Netty做一个简单的概述

2. 主要特性  
Netty有很多重要的特性，主要特性如下：   
\- 优雅的设计   
\- 统一的API接口，支持多种传输类型，例如OIO,NIO   
\- 简单而强大的线程模型   
\- 丰富的文档   
\- 卓越的性能   
\- 拥有比原生Java API 更高的性能与更低的延迟   
\- 基于池化和复用技术，使资源消耗更低   
\- 安全性   
\- 完整的SSL/TLS以及StartTLS支持   
\- 可用于受限环境，如Applet以及OSGI

Netty的以上特性，比较适合客户端数据较大的请求/处理场景，例如web服务器等，要想知道有哪些系统使用了Netty,可以参考：http://netty.io/wiki/adopters.html

3. 主要术语  
在正式开始之前，先对Netty涉及到的一些术语做个简单的说明

3.1 IO模型：BIO/NIO/Netty  
3.1.1 BIO(Blocking IO)：阻塞IO  
早期的Java API(java.net)提供了由本地系统套接字库提供的所谓的阻塞函数，样例代码如下：

ServerSocket serverSocket = new ServerSocket(portNumber);  
Socket clientSocket = serverSocket.accept();  
BufferedReader in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));  
PrintWriter out =new PrintWriter(clientSocket.getOutputStream(), true);  
String request, response;  
while ((request = in.readLine()) != null) \{  
    if ("Done".equals(request)) \{  
        break;  
\}  
response = processRequest(request);  
out.println(response);  
\}  
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
这段代码片段将只能同时处理一个连接，要管理多个并发客户端，需要为每个新的客户端   
Socket 创建一个新的 Thread,线程模型如下图所示：

该种模型存在以下两个问题：   
1. 在任何时候都可能有大量的线程处于休眠状态，只是等待输入或者输出数据就绪，这可能算是一种资源浪费   
2. 需要为每个线程的调用栈都分配内存   
3. 即使 Java 虚拟机（JVM） 在物理上可以支持非常大数量的线程， 但是远在到达该极限之前， 上下文切换所带来的开销就会带来麻烦

3.1.2 NIO(Non Blocking IO):非阻塞IO  
Java的NIO特性在JDK 1.4中引入，其结构如下：

从该图可以看出Selector 是Java 的非阻塞 I/O 实现的关键。它使用了事件通知 API   
以确定在一组非阻塞套接字中有哪些已经就绪能够进行 I/O 相关的操作。因为可以在任何的时间检查任意的读操作或者写操作的完成状态。该种模型下，一个单一的线程便可以处理多个并发的连接。   
与BIO相比，该模型有以下特点：   
1. 使用较少的线程便可以处理许多连接，因此也减少了内存管理和上下文切换所带来开销   
2. 当没有 I/O 操作需要处理的时候，线程也可以被用于其他任务

虽然Java 的NIO在性能上比BIO已经相当的优秀，但是要做到如此正确和安全并   
不容易。特别是，在高负载下可靠和高效地处理和调度 I/O 操作是一项繁琐而且容易出错的任务，此时就时Netty上场的时间了。

3.1.3 Netty  
Netty对NIO的API进行了封装，通过以下手段让性能又得到了一定程度的提升   
1. 使用多路复用技术，提高处理连接的并发性   
2. 零拷贝：   
1. Netty的接收和发送数据采用DIRECT BUFFERS，使用堆外直接内存进行Socket读写，不需要进行字节缓冲区的二次拷贝   
2. Netty提供了组合Buffer对象，可以聚合多个ByteBuffer对象进行一次操作   
3. Netty的文件传输采用了transferTo方法，它可以直接将文件缓冲区的数据发送到目标Channel，避免了传统通过循环write方式导致的内存拷贝问题   
3. 内存池：为了减少堆外直接内存的分配和回收产生的资源损耗问题，Netty提供了基于内存池的缓冲区重用机制   
4. 使用主从Reactor多线程模型，提高并发性   
5. 采用了串行无锁化设计，在IO线程内部进行串行操作，避免多线程竞争导致的性能下降   
6. 默认使用Protobuf的序列化框架   
7. 灵活的TCP参数配置

详细说明，可参考： http://www.infoq.com/cn/articles/netty-high-performance\#anch111813

3.1.4 简单的性能测试  
通过在本地分别使用BIO,NIO,Netty NIO实现了一个简单的服务端程序（该程序接收到请求后，sleep 1毫秒，并返回简单的一句话）分别对三种方式使用Jemeter进行性能测试（一百个并发，每个并发发送一百个相同消息），结果如下：

单线程的java net:

NIO：

Netty NIO:

以上结果或是受到其他条件的影响，结果仅供供参考

3.2 Callback:  
回调在广泛的编程场景中都有应用，一般是在完成某个特定的操作后对相关方法进行调用。

Netty 在内部使用回调来处理事件；当一个回调被触发时，相关的事件可以被一个 interfaceChannelHandler 的实现处理，例如Channel激活时会调用ChannelActive方法，样例代码如下：

public class ConnectHandler extends ChannelInboundHandlerAdapter \{  
@Override  
    public void channelActive(ChannelHandlerContext ctx)throws Exception \{  
        System.out.println("Client " + ctx.channel().remoteAddress() + connected");

\}  
\}  
1  
2  
3  
4  
5  
6  
7  
3.3 Future:  
Future一般用在当执行异步操作时需要获取未来的某个时候才能获取到的结果。

JDK 预置了 interface java.util.concurrent.Future，但是其所提供的实现，只   
允许手动检查对应的操作是否已经完成，或者一直阻塞直到它完成。这是非常繁琐的，所以 Netty提供了它自己的实现——ChannelFuture，用于在执行异步操作的时候使用。

ChannelFuture提供了几种额外的方法，这些方法使得我们能够注册一个或者多个   
ChannelFutureListener实例。监听器的回调方法operationComplete()，将会在对应的   
操作完成时被调用。然后监听器可以判断该操作是成功地完成了还是出错了。如果是后者，我们可以检索产生的Throwable。 通过使用ChannelFutureListener机制可以避免对   
操作结果进行手动检查。

每个 Netty 的出站 I/O 操作都将返回一个ChannelFuture，即不会阻塞后续的操作。

下面的例子中的connect()方法会直接返回，后续的成功或失败将由其注册的FutureListener来处理。

try \{  
            // 使用异步的方式连接Server,不管成功失败，都是执行下面System.out的语句，最后的连接结果由FutureListener进行处理  
            ChannelFuture future = bootstrap.connect();  
            System.out.println("Finished connect operation");  
            future.addListener((ChannelFutureListener) future1 -> \{  
                if (future1.isSuccess())\{  
                    ByteBuf buffer = Unpooled.copiedBuffer(  
                            "Hello", Charset.defaultCharset());  
                    ChannelFuture wf = future1.channel()  
                            .writeAndFlush(buffer);  
                    System.out.println("Connect successful!");  
                \}else\{  
                    System.out.println("Connect failed!");  
                    Throwable cause = future1.cause();  
                    cause.printStackTrace();  
                \}  
            \});  
            System.out.println("Finished connect operation2");  
            future.channel().closeFuture().sync();  
        \} catch (InterruptedException e) \{  
            e.printStackTrace();  
        \}  
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
18  
19  
20  
21  
22  
23  
最后的打印结果如下：

Finished connect operation  
Finished connect operation2  
Connect failed!  
io.netty.channel.AbstractChannel$AnnotatedConnectException: Connection refused: no further information: localhost/127.0.0.1:8888  
    at sun.nio.ch.SocketChannelImpl.checkConnect(Native Method)  
    at sun.nio.ch.SocketChannelImpl.finishConnect(SocketChannelImpl.java:717)  
    at io.netty.channel.socket.nio.NioSocketChannel.doFinishConnect(NioSocketChannel.java:325)  
    at io.netty.channel.nio.AbstractNioChannel$AbstractNioUnsafe.finishConnect  
    ...............................................  
    Caused by: java.net.ConnectException: Connection refused: no further information  
    ... 11 more  
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
3.4 Event  
Netty 使用不同的事件来通知状态的改变或者是操作的状态。事件可能包括：   
\- 连接已被激活或者连接失活   
\- 数据读取；   
\- 用户事件；   
\- 错误事件。   
\- 打开或者关闭到远程节点的连接；   
\- 将数据写到或者冲刷到套接字。

每个事件都可以被分发给 ChannelHandler 类中的某个用户实现的方法。这是将事件驱动范式直接转换为应用程序逻辑处理比较理想的位置。   
下图展示了事件是怎么被处理的：

对每个事件可以进行，记录日志，数据转换，应用程序逻辑处理等操作，

Netty 提供了大量预定义的可以开箱即用的 ChannelHandler 实现，包括用于各种协议   
（如 HTTP 和 SSL/TLS）的 ChannelHandler。后续博文会对一些Handler进行简单的介绍  
\---------------------   
作者：小Alpha   
来源：CSDN   
原文：https://blog.csdn.net/eric\_sunah/article/details/80424344   
版权声明：本文为博主原创文章，转载请附上博文链接！