目录

Netty_异步和事件驱动

本章主要内容

  • Java 网络编程
  • Netty 简介
  • Netty 的核心组件

假设你正在为一个重要的大型公司开发一款全新的任务关键型的应用程序。在第一次会议 上,你得知该系统必须要能够扩展到支撑 150 000 名并发用户,并且不能有任何的性能损失,这 时所有的目光都投向了你。你会怎么说呢?

如果你可以自信地说:“当然,没问题。”那么大家都会向你脱帽致敬。但是,我们大多数人 可能会采取一个更加谨慎的立场,例如:“听上去是可行的。”然后,一回到计算机旁,我们便开 始搜索“high performance Java networking”(高性能 Java 网络编程)。

如果你现在搜索它,在第一页结果中,你将会看到下面的内容:

1
2
3
4
5
Netty: Home

netty.io/

Netty 是一款异步的事件驱动的网络应用程序框架,支持快速地开发可维护的高性能的面向协议的服务器和客户端。

Netty 是一款异步的事件驱动的网络应用程序框架,支持快速地开发 可维护的 高性能的 面向协议的 服务器和客户端。

如果你和大多数人一样,通过这样的方式发现了 Netty,那么你的下一步多半是:浏览该网 站,下载源代码,仔细阅读 Javadoc 和一些相关的博客,然后写点儿代码试试。如果你已经有了 扎实的网络编程经验,那么可能进展还不错,不然则可能是一头雾水。

这是为什么呢?因为像我们例子中那样的高性能系统不仅要求超一流的编程技巧,还需要几 个复杂领域(网络编程、多线程处理和并发)的专业知识。Netty 优雅地处理了这些领域的知识, 使得即使是网络编程新手也能使用。但到目前为止,由于还缺乏一本全面的指南,使得对它的学 习过程比实际需要的艰涩得多——因此便有了这本书。

我们编写这本书的主要目的是:使得 Netty 能够尽可能多地被更加广泛的开发者采用。这也包括那些拥有创新的内容或者服务,却没有时间或者兴趣成为网络编程专家的人。如果这适用于你, 我们相信你将会非常惊讶自己这么快便可以开始创建你的第一款基于 Netty 的应用程序了。当然在 另一个层面上讲,我们也需要支持那些正在寻找工具来创建他们自己的网络协议的高级从业人员。

Netty 确实提供了极为丰富的网络编程工具集,我们将花大部分的时间来探究它的能力。但 是,Netty 终究是一个框架,它的架构方法和设计原则是:每个小点都和它的工作性内容一样重要,穷其精妙。因此,我们也将探讨很多其他方面的内容,例如:

  • 关注点分离——业务和网络逻辑解耦;
  • 模块化和可复用性;
  • 可测试性作为首要的要求。

在这第 1 章中,我们将从一些与高性能网络编程相关的背景知识开始铺陈,特别是它在 Java 开发工具包(JDK)中的实现。有了这些背景知识后,我们将介绍 Netty,它的核心概念以及构 建块。在本章结束之后,你就能够编写你的第一款基于 Netty 的客户端和服务器应用程序了。

Java网络编程

早期的网络编程开发人员,需要 花费大量的时间去学习复杂的 C 语言套接字库,去处理它们 在不同的操作系统上出现的古怪问题。虽然最早的 Java(1995—2002)引入了足够多的面向对象 facade(门面)来隐藏一些棘手的细节问题,但是创建一个复杂的客户端/服务器协议仍然需要大量的样板代码(以及相当多的底层研究才能使它整个流畅地运行起来)。

那些最早期的 Java API( java.net )只支持由本地系统套接字库提供的所谓的阻塞函数。 代码清单 1-1 展示了一个使用了这些函数调用的服务器代码的普通示例。

代码清单 1-1 阻塞 I/O 示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
package com.eh.eden.pattern;

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;

class Server {
    public static void main(String[] args) throws IOException {
        int portNumber = 8080;
      // 创建一个新的 ServerSocket, 用以监听指定端口上的连接请求
        ServerSocket serverSocket = new ServerSocket(portNumber);
      // 对 accept()方法的调用将被阻塞,直到一个连接建立
        Socket clientSocket = serverSocket.accept();

      // 这些流对象都派生于该套接字的流对象
        BufferedReader in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
        PrintWriter out = new PrintWriter(clientSocket.getOutputStream(), true);

        String request, response;
      // 3 处理 循环 开始
        while ((request = in.readLine()) != null) {
         // 如果客户端发送了“Done”,则退出处理循环 
            if ("Done".equals(request)) {
                break;
            }
          // 4 请求被传递给服 务器的处理方法
            response = processRequest(request);
          // 服务器的响应被发送给了客户端
            out.println(response);
        }

        clientSocket.close();
        serverSocket.close();

    }

    private static String processRequest(String request) {
        System.out.println("recv msg:" + request);
        return "ok, recv msg: " + request;
    }
  
  // 运行结果
  recv msg:hello
  recv msg:world
}

class Client {
    public static void main(String[] args) throws IOException {
        int port = 8080;
        String host = "127.0.0.1";

        Socket socket = new Socket(host, port);

        BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
        BufferedWriter out = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));

        out.write("hello\nworld\nDone");
        out.flush();
        String response;
        while ((response = in.readLine()) != null) {
            System.out.println(response);
        }

        socket.close();
    }
  // 运行结果
  ok, recv msg: hello
	ok, recv msg: world
}

代码清单 1-1 实现了 Socket API 的基本模式之一。以下是最重要的几点。

  • ServerSocket 上的 accept() 方法将会一直阻塞到一个连接建立,随后返回一个 新的 Socket 用于客户端和服务器之间的通信。该 ServerSocket 将继续监听传入的 连接(如果放在while循环里的话)。
  • BufferedReader 和 PrintWriter 都衍生自 Socket 的输入输出流。前者从一个 字符输入流中读取文本,后者打印对象的格式化的表示到文本输出流
  • readLine()方法将会阻塞,直到在//3处一个由换行符或者回车符结尾的字 符串被 读取。
  • //4客户端的请求已经被处理。

这段代码片段将只能同时处理一个连接,要管理多个并发客户端,需要为每个新的客户端 Socket 创建一个新的 Thread ,如图 1-1 所示。

https://gitee.com/lienhui68/picStore/raw/master/null/20200903075526.png

让我们考虑一下这种方案的影响。第一,在任何 时候都可能有大量的线程处于休眠状态,只是等待输 入或者输出数据就绪,这可能算是一种资源浪费。第 二,需要为每个线程的调用栈都分配内存,其默认值 大小区间为 64 KB 到 1 MB ,具体取决于操作系统。第三,即使 Java 虚拟机( JVM )在物理上可以支持非常 大数量的线程,但是远在到达该极限之前,上下文切换所带来的开销就会带来麻烦,例如,在达 到 10 000 个连接的时候。

虽然这种并发方案对于支撑中小数量的客户端来说还算可以接受,但是为了支撑 100 000 或 者更多的并发连接所需要的资源使得它很不理想。幸运的是,还有一种方案。

Java NIO

除了代码清单 1-1 中代码底层的阻塞系统调用之外,本地套接字库很早就提供了非阻塞调用, 其为网络资源的利用率提供了相当多的控制:

  • 可以使用 setsockopt() 方法配置 套接字 ,以便读 / 写 也就是说,如果是一个阻塞调用应该已经被阻塞了

  • 可以使用操作系统的事件通知 API 注册一组非阻塞套接字,以确定它们中是否有任何的 套接字已经有数据可供读写。

    也称为 I/O 多路复用,该接口从最初的 select()和 poll()调用到更加高性能的实现,已经演 多年。

Java 对于非阻塞 I/O 的支持是在 2002 年引入的,位于 JDK 1.4 的 java.nio 包中。

新的还是非阻塞的

NIO 最开始是新的输入/输出(New Input/Output)的英文缩写,但是,该 Java API 已经出现足够长的时间 了,不再是“新的”了,因此,如今大多数的用户认为 NIO 代表非阻塞 I/O(Non-blocking I/O),而阻塞 I/O(blocking I/O)是旧的输入/输出(old input/output,OIO)。你也可能遇到它被称为普通 I/O(plain I/O)的时候。

选择器

图 1-2 展示了一个非阻塞设计,其实际上消除了 上一节中所描述的那些弊端。

https://gitee.com/lienhui68/picStore/raw/master/null/20200903080017.png

class java.nio.channels.Selector 是 Java 的非阻塞 I/O 实现的关键。它使用了事件通知 API 以确定在一组非阻塞套接字中有哪些已经就绪能够进 行 I/O 相关的操作。因为可以在任何的时间检查任意 的读操作或者写操作的完成状态,所以如图 1-2 所示, 一个单一的线程便可以处理多个并发的连接。

总体来看,与阻塞 I/O 模型相比,这种模型提供 了更好的资源管理:

  • 使用较少的线程便可以处理许多连接,因此也减少了内存浪费和上下文切换所带来开销
  • 当没有 I/O 操作需要处理的时候,线程也可以被用于其他任务。

尽管已经有许多直接使用 Java NIO API 的应用程序被构建了,但是要做到如此正确和安全并不容易。特别是,在高负载下可靠和高效地处理和调度 I/O 操作是一项繁琐而且容易出错的任务, 最好留给高性能的网络编程专家——Netty。

Netty简介

不久以前,我们在本章一开始所呈现的场景——支持成千上万的并发客户端——还被认定为 是不可能的。然而今天,作为系统用户,我们将这种能力视为理所当然;同时作为开发人员,我 们期望将水平线提得更高(支撑更多的并发的客户端)。因为我们知道,总会有更高的 吞吐量和可扩展性的要求——在更低 的成本的基础上进行交付

不要低估了这最后一点的重要性。我们已经从漫长的痛苦经历中学到:直接使用底层的API 暴露了复杂性,并且引入了对往往供不应求的技能的关键性依赖(这里指熟悉这些底层的 API 的人员少)。这也就是,面向对象的基本概念:用较简单的抽象隐藏底层实现的复杂性。

这一原则也催生了大量框架的开发,它们 为常见的编程任务封装了解决方案,其中的许多都和分布式系统的开发密切相关。我们可以确定地说:所有专业的Java开发人员都至少对它们熟知 一二。对于我们许多人来说,它们已经变得不可或缺,因为它们既能满足我们的工作需求,又 能满足我们的时间表。

Spring 框架大概是最出名的,并且实际上是一个完整的应用程序框架的生态系统,处理了对象的创建、 批量处理、数据库编程等。

在网络编程领域,Netty是Java的卓越框架。它驾驭了Java高级API的能力,并将其隐藏在一个易于使用的API之后。Netty使你可以专注于自己真正感兴趣的——你的应用程序的独一无二的价值(业务和网络处理逻辑解耦)。

在我们开始首次深入地了解 Netty 之前,请仔细审视表 1-1 中所总结的关键特性。有些是技 术性的,而其他的更多的则是关于架构或设计哲学的。在本书的学习过程中,我们将不止一次地 重新审视它们。

https://gitee.com/lienhui68/picStore/raw/master/null/20200903080954.png

谁在使用Netty

Netty拥有一个充满活力并且不断壮大的用户社区,其中不乏大型公司,如Apple、Twitter、 Facebook、Google、Square和Instagram,还有流行的开源项目,如Infinispan、HornetQ、Vert.x、 Apache Cassandra和Elasticsearch,它们所有的核心代码都利用了Netty强大的网络抽象。在初创企业中,Firebase和Urban Airship也在使用Netty,前者用来做HTTP长连接,而后者用来支持各种各样的推送通知

每当你使用Twitter,你便是在使用Finagle,它们基于Netty的系统间通信框架。Facebook在 Nifty中使用了Netty,它们的Apache Thrift服务。可伸缩性和性能对这两家公司来说至关重要,他 们也经常为Netty贡献代码。

反过来,Netty 也已从这些项目中受益,通过实现 FTP、SMTP、HTTP 和 WebSocket 以及其他的基于二进制和基于文本的协议,Netty 扩展了它的应用范围及灵活性。

异步和事件驱动

因为我们要大量地使用“异步”这个词,所以现在是一个澄清上下文的好时机。异步(也就 是非同步)事件肯定大家都熟悉。考虑一下电子邮件:你可能会也可能不会收到你已经发出去的 电子邮件对应的回复,或者你也可能会在正在发送一封电子邮件的时候收到一个意外的消息。异步事件也可以具有某种有序的关系。通常,你只有在已经问了一个问题之后才会得到一个和它对应的答案,而在你等待它的同时你也可以做点别的事情。

在日常的生活中,异步自然而然地就发生了,所以你可能没有对它考虑过多少。但是让一个 计算机程序以相同的方式工作就会产生一些非常特殊的问题。本质上,一个既是异步的又是事件驱动的系统会表现出一种特殊的、对我们来说极具价值的行为:它可以以任意的顺序响应在任意的时间点产生的事件。

这种能力对于实现最高级别的可伸缩性至关重要, 定义为:“一种系统、网络或者进程在需要处理的工作不断增长时,可以通过某种可行的方式(性能优化)或者扩大它的处理能力(扩容)来适应这种增长的能力。

异步和可伸缩性之间的联系又是什么呢?

  • 非阻塞网络调用使得我们可以不必等待一个操作的完成。完全异步的 I/O 正是基于这个特性构建的,并且更进一步:异步方法会立即返回,并且在它完成时,会直接或者在稍后的某个时间点通知用户。
  • 选择器使得我们能够通过较少的线程便可监视许多连接上的事件。

架构中的可扩展和可伸缩

可伸缩性是指系统通过增加或减少硬件水平从而提升或降低系统性能的难易程度。可伸缩性分为scale up和scale out。

scale up是指提高单台服务器的硬件水平来提高系统的整体处理能力,可以调整的有CPU,存储,内存等;

netty实现可伸缩就是指scale up,软件层面

scale out是指通过增加系统的处理节点的方式来提高系统的整体处理能力。

可扩展性是软件系统应对需求增加或需求变化的能力。

将这些元素结合在一起,与使用阻塞 I/O 来处理大量事件相比,使用非阻塞 I/O 来处理更快 速、更经济。从网络编程的角度来看,这是构建我们理想系统的关键,而且你会看到,这也是 Netty 的设计底蕴的关键。

在 1.3 节中,我们将首先看一看 Netty 的核心组件。现在,只需要将它们看作是域对象,而 不是具体的 Java 类。随着时间的推移,我们将看到它们是如何协作,来为在网络上发生的事件 提供通知,并使得它们可以被处理的。

域对象:也是一个属性,不过这个属性是一个对象,不是基本数据类型。

Netty的核心组件

在本节中我将要讨论 Netty 的主要构件块:

  • Channel
  • 回调
  • Future
  • 事件和ChannelHandler

这些构建块代表了不同类型的构造:资源、逻辑以及通知。你的应用程序将使用它们来访问 网络以及流经网络的数据。

构件:任何可以被Maven的坐标系统唯一标识的对象都是一个Maven构件。大多数情况下,构件是构建Maven项目所生成的文件,如Jar。但是,只包含其他POM(该文件并不产生构件)使用的定义的POM文件也是Maven构件。

对于每个组件来说,我们都将提供一个基本的定义,并且在适当的情况下,还会提供一个简 单的示例代码来说明它的用法。

Channel

Channel 是 Java NIO 的一个基本构造。它代表一个到实体(如一个硬件设备、一个文件、一个网络套接字或者一个能够执行一个或者多个不同的I/O操作的程序组件)的开放连接,可以执行读操作和写操作 。

目前,可以把 Channel 看作是传入(入站)或者传出(出站)数据的载体。因此,它可以被打开或者被关闭,连接或者断开连接。

回调

一个回调其实就是一个方法,一个指向已经被提供给另外一个方法的方法引用。这使得后者(指接受回调的方法)可以在适当的时候调用前者。回调在广泛的编程场景中都有应用,而且也是在操作完成后通知相关方最常见的方式之一。

Netty 在内部使用了回调来处理事件;当一个回调被触发时,相关的事件可以被一个 interface ChannelHandler的实现处理。代码清单 1-2 展示了一个例子:当一个新的连接已经被建立时, ChannelHandler 的 channelActive() 回调方法将会被调用,并将打印出一条信息。

代码清单 1-2 被回调触发的 ChannelHandler

1
2
3
4
5
6
7
8
public class ConnectHandler extends ChannelInboundHandlerAdapter {

    // 当一个新的连接已经被建立时, channelActive(ChannelHandler Context)将会被调用
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        System.out.println("Client " + ctx.channel().remoteAddress() + " connected");
    }
}

Future

Future 提供了另一种在操作完成时通知应用程序的方式。这个对象可以看作是一个异步操作的结果的占位符;它将在未来的某个时刻完成,并提供对其结果的访问

上述要表达的意思和下面操作一样,当Future中填入结果时即可对该结果进行访问。

1
CompletableFuture.supplyAsync(() -> "hello").thenAccept(System.out::println);

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

ChannelFuture 提供了几种额外的方法, 这些方法使得我们能够注册一个或者多个 ChannelFutureListener 实例。监听器的回调方法 operationComplete() ,将会在对应的操作完成时被调用 。监听器可以判断该操作是成功地完成了还是出错了。如果是后者,我 们可以检索产生的 Throwable 。简而言之 ,由 ChannelFutureListener 提供的通知机制消除 了手动检查对应的操作是否完成的必要。

如果在 ChannelFutureListener 添加到 ChannelFuture 的时候,ChannelFuture 已经完成, 那么该 ChannelFutureListener 将会被直接地通知。

每个 Netty 的出站 I/O 操作都将返回一个 ChannelFuture ;也就是说,它们都不会阻塞。 正如我们前面所提到过的一样,Netty 完全是异步和事件驱动的。

代码清单 1-3 展示了一个 ChannelFuture 作为一个 I/O 操作的一部分返回的例子。这里, connect() 方法将会直接返回,而不会阻塞,该调用将会在后台完成。这究竟什么时候会发生 则取决于若干的因素,但这个关注点已经从代码中抽象出来了。因为线程不用阻塞以等待对应的 操作完成,所以它可以同时做其他的工作,从而更加有效地利用资源。

代码清单 1-3 异步地建立连接

1
2
3
Channel channel = ...;
// Does not block, 异步地连接到远程节点
ChannelFuture future = channel.connect(new InetSocketAddress("127.0.0.1", 25));

代码清单 1-4 显示了如何利用 ChannelFutureListener 。 首先, 要连接到远程节点 上。 然后, 要注册一个新的 ChannelFutureListener 到对 connect() 方法的调用所返 回的 ChannelFuture 上。 当该监听器被通知连接已经建立的时候, 要检查对应的状态 。 如果该操作是成功的, 那么将数据写到该 Channel 。 否则, 要从 ChannelFuture 中检索 对应的 Throwable 。

代码清单 1-4 回调实战

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
Channel channel = ...;
// Does not block, 异步地连接到远程节点
ChannelFuture future = channel.connect(new InetSocketAddress("127.0.0.1", 25));
// 注册一个 ChannelFutureListener, 以便在操作完成时获得通知
future.addListener(new ChannelFutureListener() {
    @Override
    public void operationComplete(ChannelFuture channelFuture) throws Exception {
        // 检查操作的状态
        if (channelFuture.isSuccess()) {
            // 如果操作是成功的,则创建 一个 ByteBuf 以持有数据
            ByteBuf buffer = Unpooled.copiedBuffer("hello", Charset.defaultCharset());

            // 将数据异步地发送到远程节点。 返回一个 ChannelFuture
            ChannelFuture wf = future.channel().writeAndFlush(buffer);
            ...
        } else { // 如果发生错误,则访问描述原因 的 Throwable
            Throwable cause = future.cause();
            cause.printStackTrace();
        }
    }
});

需要注意的是,对错误的处理完全取决于你、目标,当然也包括目前任何对于特定类型的错误 加以的限制。例如,如果连接失败,你可以尝试重新连接或者建立一个到另一个远程节点的连接。

如果你把 ChannelFutureListener 看作是回调的一个更加精细的版本,那么你是对的。 事实上,回调和 Future 是相互补充的机制;它们相互结合,构成了 Netty 本身的关键构件块之一。

事件和ChannelHandler

Netty 使用不同的事件来通知我们状态的改变或者是操作的状态。这使得我们能够基于已经发生的事件来触发适当的动作。这些动作可能是:

  • 记录日志
  • 数据转换
  • 流控制
  • 应用程序逻辑

Netty 是一个网络编程框架,所以事件是按照它们与入站或出站数据流的相关性进行分类的

可能由入站数据或者相关的状态更改而触发的事件包括

  • 连接已被激活或者连接失活;
  • 数据读取;
  • 用户事件;
  • 错误事件。

出站事件是未来将会触发的某个动作的操作结果,这些动作包括

  • 打开或者关闭到远程节点的连接;
  • 将数据写到或者冲刷到套接字。

每个事件都可以被分发给 ChannelHandler 类中的某个用户实现的方法。这是一个很好的将事件驱动范式直接转换为应用程序构件块的例子。图 1-3 展示了一个事件是如何被一个这样的 ChannelHandler 链处理的。

https://gitee.com/lienhui68/picStore/raw/master/null/20200903092849.png

Netty的ChannelHandler 为处理器(应用程序processor方法)提供了基本的抽象,如图 1-3 所示的那些。 我们会 在适当的时候对 ChannelHandler 进行更多的说明, 但是目前你可以认为每个 ChannelHandler 的实例都类似于一种为了响应特定事件而被执行的回调

Netty 提供了大量预定义的可以开箱即用的 ChannelHandler 实现,包括用于各种协议 (如 HTTP 和 SSL/TLS)的 ChannelHandler 。在内部, ChannelHandler 自己也使用了事件 和 Future ,使得它们也成为了你的应用程序将使用的相同抽象的消费者。

把它们放在一起

在本章中,我们介绍了 Netty 实现高性能网络编程的方式,以及它的实现中的一些主要的组 件。让我们大体回顾一下我们讨论过的内容吧。

Future、回调和 ChannelHandler

Netty的异步编程模型是建立在 Future 和回调的概念之上的,而将事件派发到 ChannelHandler 的方法则发生在更深的层次上。结合在一起,这些元素就提供了一个处理环境,使你的应用程序逻辑可以独立于任何网络操作相关的顾虑而独立地演变。这也是 Netty 的设计方式的一个关键目标。

拦截操作以及高速地转换入站数据和出站数据,都只需要你提供回调或者利用操作所返回的 Future 。这使得链接操作变得既简单又高效,并且促进了可重用的通用代码的编写。

选择器、事件和 EventLoop

Netty 通过触发事件将 Selector 从应用程序中抽象出来,消除了所有本来将需要手动编写 的派发代码。在内部,将会为每个 Channel 分配一个 EventLoop ,用以处理所有事件,包括:

  • 注册感兴趣的事件;
  • 将事件派发给 ChannelHandler ;
  • 安排进一步的动作。

EventLoop 本身只由一个线程驱动,其处理了一个 Channel 的所有 I/O 事件,并且在该 EventLoop 的整个生命周期内都不会改变。 这个简单而强大的设计消除了你可能有的在 ChannelHandler 实现 中需要进行同步的任何顾虑,因此,你可以专注于提供正确的逻辑,用 来在有感兴趣的数据要处理的时候执行。如同我们在详细探讨 Netty 的线程模型时将会看到的, 该 API 是简单而紧凑的。

小结

在这一章中,我们介绍了 Netty 框架的背景知识,包括 Java 网络编程 API 的演变过程,阻塞 和非阻塞网络操作之间的区别,以及异步 I/O 在高容量、高性能的网络编程中的优势。

然后,我们概述了 Netty 的特性、设计和优点,其中包括 Netty 异步模型的底层机制,包括回调、Future 以及它们的结合使用。。我们还谈到了事件是如何产生的以及如何拦截和处理它们。

在本书接下来的部分,我们将更加深入地探讨如何利用这些丰富的工具集来满足自己的应用 程序的特定需求。

在下一章中,我们将要深入地探讨 Netty 的 API 以及编程模型的基础知识,而你则将编写你 的第一款客户端和服务器应用程序。