传输

最新推荐文章于 2022-03-12 20:24:46 发布

超速前行

最新推荐文章于 2022-03-12 20:24:46 发布

阅读量652

点赞数

Netty In Action 专栏收录该内容

8 篇文章 0 订阅

订阅专栏

传输

本章包括

传输
NIO，OIO，本地和嵌入式
使用场景
APIs

网络应用程序的最重要的任务是传输数据。这可以通过不同的传输方式来完成，但是传输的内容都一样，通过电缆来传输字节数组。传输层帮助抽象了数据的传输。你只需要知道你有字节要发送或者接收，不多也不少。
如果你以前使用过Java提供的方式进行网络编程，你很有可能碰到这样的场景：从阻塞传输变为非阻塞传输，或者恰恰相反。这一转换并不容易，因为阻塞和非阻塞使用不同的Java接口和类。
Netty在其传输实现的基础上提供了统一的API，使得上面的转换很容易。你会使你的代码尽可能的一般，而不是依赖于实现的API。当你从一种传输协议切换到另外一种传输协议的时候，你不需要重构你的整个方法。如果你曾经使用JDK提供的简单的网络API来完成，你已经知道有多麻烦。不要再在这些繁杂的事情上费时间，把时间花在更高效的事情上。
本章向你展示统一的API，以及如何使用它。我将这些API与JDK提供的API进行比较，你就会了解为什么使用Netty很容易。将会介绍Netty中的不同传输实现，以及使用的场景。在收集了这些知识之后，你会针对特定应用选择特定的方式，使得你的应用场景获得最佳结果。
除了Java自身之外，你不需要任何经验。具有网络矿建或者网络编程有帮助但不是必须的。
让我们来看一下，传输在现实场景中是如何完成的。

案例学习：传输演进

为了说明传输如何完成，我们将开始一个简单的例子，除了接受连接和向客户端写“Hi!”,这个例子什么都不做。完成这些之后，它将断开与客户端的连接。这里仅仅只是一个例子，我不会深入具体实现的细节。

不使用Netty的IO和NIO

这个案例开始，我们不使用Netty来实现这一应用。以下代码生意on个阻塞IO。
列表4.1没有使用Netty的阻塞网络

public class PlainOioServer {
    public void serve(int port) throws IOException {
        final ServerSocket socket = new ServerSocket(port); #1
        try {
            while (true) {
                final Socket clientSocket = socket.accept();    #2
                System.out.println("Accepted connection from " +
                clientSocket);
                new Thread(new Runnable() { #3
                    @Override
                    public void run() {
                        OutputStream out;
                        try {
                            out = clientSocket.getOutputStream();
                            out.write("Hi!\r\n".getBytes(Charset.forName("UTF-8")));    #4
                            out.flush();
                            clientSocket.close();   #5
                        } catch (IOException e) {
                            e.printStackTrace();
                            try {
                                clientSocket.close();
                            } catch (IOException ex) {
// ignore on close
                            }
                        }
                    }
                }).start(); #6
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
#1 绑定服务器端口
#2 接收连接
#3 创建一个新的线程来处理连接
#4 向连接的客户端写入数据
#5 当数据写完冲刷之后关闭连接
#6 开启线程

这个正常工作，但是过一段时间之后，你发现阻塞处理在你的应用中可扩展性很差。你想使用异步网络来处理所有的并发连接，但是问题是API完全不一样。你重新写了你的应用，如下列表所示。
列表4.2 没有Netty的异步网络

public class PlainNioServer {
    public void serve(int port) throws IOException {
        System.out.println("Listening for connections on port " + port);
        ServerSocketChannel serverChannel;
        Selector selector;
        serverChannel = ServerSocketChannel.open();
        ServerSocket ss = serverChannel.socket();
        InetSocketAddress address = new InetSocketAddress(port);
        ss.bind(address);   #1
        serverChannel.configureBlocking(false);
        selector = Selector.open(); #2
        serverChannel.register(selector, SelectionKey.OP_ACCEPT);   #3
        final ByteBuffer msg = ByteBuffer.wrap("Hi!\r\n".getBytes());
        while (true) {
            try {
                selector.select();  #4
            } catch (IOException ex) {
                ex.printStackTrace();
// handle in a proper way
                break;
            }
            Set<SelectedKey> readyKeys = selector.selectedKeys();   #5
            Iterator<SelectedKey> iterator = readyKeys.iterator();
            while (iterator.hasNext()) {
                SelectionKey key = iterator.next();
                iterator.remove();
                try {
                    if (key.isAcceptable()) {   #6
                        ServerSocketChannel server = (ServerSocketChannel)
                        key.channel();
                        SocketChannel client = server.accept();
                        System.out.println("Accepted connection from " +
                        client);
                        client.configureBlocking(false);
                        client.register(selector, SelectionKey.OP_WRITE |
                        SelectionKey.OP_READ, msg.duplicate()); #7
                    }
                    if (key.isWritable()) { #8
                        SocketChannel client = (SocketChannel) key.channel();
                        ByteBuffer buffer = (ByteBuffer) key.attachment();
                        while (buffer.hasRemaining()) {
                            if (client.write(buffer) == 0) {    #9
                                break;
                            }
                        }
                        client.close(); #10
                    }
                } catch (IOException ex) {
                    key.cancel();
                    try {
                        key.channel().close();
                    } catch (IOException cex) {
                    }
                }
            }
        }
    }
}
#1 绑定服务器端口
#2 打开选择器来处理通道
#3 注册通道到选择器上，并且指定关注接收客户端事件
#4 等待就绪处理的事件，这个会一直阻塞直到某些事情发生
#5 获取接收事件的所欲SelectionKey实例
#6 检核事件是否为接收事件
#7 将接收客户端通道注册到选择器中
#8 检核事件是否为套接字写事件
#9 向客户端写数据，如果网络不好不会全写；当网络恢复的时候会重新写入没有写入的数据
#10 关闭连接

就想你看到的那样，代码完全不同，尽管做的是相同的事情。这里只是一个简单的应用。如果应用复杂，可想而知工作量会多大。
记住这些，我们来通过Netty来实现相同的应用。

使用Netty的IO和NIO

列表4.3 使用Netty的阻塞网络

public class NettyOioServer {
    public void server(int port) throws Exception {
        final ByteBuf buf = Unpooled.unreleaseableBuffer(
            Unpooled.copiedBuffer("Hi!\r\n", Charset.forName("UTF-8")));
        EventLoopGroup group = new OioEventLoopGroup();
        try {
            ServerBootstrap b = new ServerBootstrap();  #1
            b.group(group) #2
            .channel(OioServerSocketChannel.class)
            .localAddress(new InetSocketAddress(port))
            .childHandler(new ChannelInitializer<SocketChannel>() { #3
                @Override
                public void initChannel(SocketChannel ch)
                throws Exception {
                    ch.pipeline().addLast(
                    new ChannelInboundHandlerAdapter() {    #4
                        @Override
                        public void channelActive(
                        ChannelHandlerContext ctx) throws Exception {
                            ctx.write(buf.duplicate())
                            .addListener(ChannelFutureListener.CLOSE);  #5
                        }
                    });
                }
            });
            ChannelFuture f = b.bind().sync();  #6
            f.channel().closeFuture().sync();
        } finally {
            group.shutdownGracefully().sync();  #7
        }
    }
}
#1 创建引导实例来引导服务器
#2 使用OioEventLoopGroup允许阻塞模式
#3 设置ChannelInitializer，将会在每一个接受的连接时候被调用 
#4 添加ChannelHandler来拦截事件
#5 写消息到客户端，添加监听器ChannelFutureListener，在数据被写完的时候被调用
#6 绑定服务器接收连接
#7 释放所有的资源

你可能注意到代码本身很紧凑，但做的事情和列表4.1中是一致的。但这只是其中一项优势。
我们来改一下代码，使得它可以异步执行。

实现异步支持

你将会看到在下面的列表中的代码和列表4.3中大多数都一样。从阻塞模式切换到非阻塞模式只需要改变两行代码。下面将更改的行加粗显示。
列表4.4 使用Netty的异步网络

public class NettyNioServer {
    public void server(int port) throws Exception {
        final ByteBuf buf = Unpooled.copiedBuffer("Hi!\r\n",
        Charset.forName("UTF-8"));
        EventLoopGroup group = new NioEventLoopGroup();
        try {
            ServerBootstrap b = new ServerBootstrap();  #1
            b.group(group)
            .channel(NioServerSocketChannel.class)
            .localAddress(new InetSocketAddress(port))
            .childHandler(new ChannelInitializer<SocketChannel>() { #3
                @Override
                public void initChannel(SocketChannel ch)
                throws Exception {
                    ch.pipeline().addLast(
                    new ChannelStateHandlerAdapter() {  #4
                        @Override
                        public void channelActive(
                        ChannelHandlerContext ctx) throws Exception {
                            ctx.write(buf.duplicate())
                            .addListener(ChannelFutureListener.CLOSE);  #5
                        }
                        @Override
                        public void inboundBufferUpdated(
                            ChannelHandHandlerContext ctx)
                        Throws Exception {
                            czx.fireInboundBufferUpdated();
                        }
                    });
                }
            });
            ChannelFuture f = b.bind().sync();  #6
            f.channel().closeFuture().sync();
        } finally {
            group.shutdownGracefully().sync();  #7
        }
    }
}
#1 创建引导实例来引导服务器
#2 使用NioEventLoopGroup允许阻塞模式
#3 设置ChannelInitializer，将会在每一个接受的连接时候被调用 
#4 添加ChannelHandler来拦截事件
#5 写消息到客户端，添加监听器ChannelFutureListener，在数据被写完的时候被调用
#6 绑定服务器接收连接
#7 释放所有的资源

因为Netty为每一种传输实现暴露相同的API，它不在乎你的实现。Netty通过Channel接口和它的ChannelPipeline和ChannelHandler暴露接口。
既然你已经看完了Netty的实战优势，我们深入开一下传输API。

传输API

传输API的核心是Channel接口，所有的流出操作都会使用。
Channel接口的继承图如图4.1所示

图4.1 Channel接口继承图
如图4.1所示，一个通道有一个ChannelPipeline和ChannelConfig。
ChannelConfig拥有通道的所有配置设置，并且可以动态的进行更新。通常传输有特定的配置设置只能针对指定的传输，对于其它的实现不一定可用。为了这个目的，暴露了ChannelConfig的子类。要想获取更多的信息，参照java文档查询特定的ChannelConfig实现。

ChannelPipeline持有所有的ChannelHandler实例，这些实例会在数据从通道流入或者流出的时候调用。这些ChannelHandler实现允许你对状态变化或者数据转换做出响应。
这本书包含一个章节来详细介绍ChannelHandler，它是Netty的核心概念之一。
当目前为止，我强调一下ChannelHandler可以完成哪些任务：

将数据从一种格式转换成另外一种
通知你异常
当通告活跃或者失去活跃的时候通知你
当通道从EventLoop中注册或者解注册的时候通知你
通知你用户指定的事件

ChannelHandler被放在ChannelPipeline中，在那里它们一个接一个执行。向你过去在Servlet中使用的职责链。了解ChannelHandler的详细信息，参照第6章节。

ChannelPipeline

ChannelPipeline实现了拦截过滤器模式，它意味着你可以将不同的ChannelHandler串联起来拦截经过ChannelPipeline的数据和事件。
UNIX系统中管道类似，允许串联不同的命令。

你同样可以动态的修改ChannelPipeline，允许你在需要的时候添加和移除ChannelHandler。这样可以使用Netty创建高度灵活的应用。
除了访问分配的ChannelPipeline和ChannelConfig，你可以直接操作Channel本身。Channel提供了许多方法，但最重要的显示在表格4.1中。
表格4.1最重要的通道方法

方法名	描述
eventLoop()	返回分配给通道的EventLoop
pipeline()	返回分配ChannelPipeline
isActive()	返回通道是否活跃，意味着是否连接到远程节点
localAddress()	返回本地绑定的SocketAddress
remoteAddress()	返回远程节点绑定的SocketAddress
write()	向远程节点写入数据。这些数据经过ChannelPipeline

你将会学习更多关于如何使用这些特征记住你将总是操作相同的接口，这样就给你很大的灵活性，这样在尝试不同的传输实现时就不需要大幅度的重构。
为了向远程节点写数据，你可以调用Channel.write()如下所示。
列表4.5 向通道中写入数据

Channel channel = ...
                  ByteBuf buf = Unpooled.copiedBuffer(„your data“, CharsetUtil.UTF_8);  #1
ChannelFuture cf = channel.write(buf);  #2
cf.addListener(new ChannelFutureListener() {    #3
    @Override
    public void operationComplete(ChannelFuture future) {
        if (future.isSuccess()) {   #4
            System.out.println(“Write successful“);
        } else {
            System.err.println(“Write error“);  #5
            future.cause().printStacktrace();
        }
    }
});
#1 创建持有数据的ByteBuf
#2 写数据
#3 添加监听器，在操作完成后被调用
#4 写操作完成没有错误
#5 写操作完成但是存在错误

注意到Channel是线程安全的，这意味着从不同的线程操作它是安全的。它的所有方法在多线程环境中使用是安全的。所以在你的应用中存储它的引用是安全的，当你想向远程节点写入数据时候可以使用它，即使使用多线程。以下代码展示了一个简单的使用多线程的例子。
列表4.6 在多线程中使用通道

final Channel channel = ...
                        final ByteBuf buf = Unpooled.copiedBuffer(„your data“,
                                CharsetUtil.UTF_8); #1
Runnable writer = new Runnable() {  #2
    @Override
    public void run() {
        channel.write(buf.duplicate());
    }
};
Executor executor = Executors.newChachedThreadPool();   #3
// write in one thread
executor.execute(writer);   #4
// write in another thread
executor.execute(writer);   #5
…
#1 创建持有数据的ByteBuf
#2 创建Runnable负责写数据到通道
#3 获取Executor的引用，Executor使用线程来执行任务
#4 将写任务给executor使用线程执行
#5 将另外一个写任务给executor使用线程执行

同样，这一方法确保了写的顺序是按照你传递到写方法的顺序。了解更多的方法，请残渣Java文档。
知道使用的接口很重要，直到Netty已经实现的传输也十分有帮助所有的东西都为你准备好了。在下一部分我们将看看已经提供的实现和它们的行为。

包含的传输

Netty已经包含了许多传输你可以使用。不是所有的传输都支持所有的协议，这也意味着你想使用的传输同样依赖于你的应用依赖的基础协议。在本部分你将直到哪些传输支持哪些协议。
表格4.1列出了Netty中默认包含的传输。
表格4.1提供的传输

名称	包	描述
NIO	io.netty.channel.socket.nio	使用java.nio.channels作为基础，所以使用基于选择器的方式
OIO	io.netty.channel.socket.oio	使用java.net包，所以使用组素流
Local	io.netty.channel.local	本地通讯，在VM中使用管道通讯
Embedded	io.netty.channel.embedded	嵌入式传输，允许不在真实网络中使用ChannelHandler，这在ChannelHandler实现的测试中很有用

现在，让我们看一看使用最多的传输实现，NIO传输。

NIO

NIO是目前使用最多的传输。它通过使用Java1.4之后基于选择器的方式和NIO子系统，提供了所有IO操作的完全异步的实现。
思想是用户通过注册来获得通道状态变化的通知。可能的状态变化包括：

一个新的Channel被接收并且就绪
一个通道连接完成
一个通道的数据读取就绪
一个通道发送数据就绪
实现负责对状态变化做出响应，并且重新设定它们使得状态变化时再次被通知到。这个由一个线程来完成，检查更新，如果存在更新它们。
在这里可以只注册一个事件，而忽略其它事件。
底层选择所支持的位集合如表格4.2所示。这些都定义在SelectionKey中。
表格4.2 选择操作位

名字	描述
OP_ACCEPT	当连接被接受，通道被创建的时候通知
OP_CONNECT	当连接完成的时候通知
OP_READ	当从通道中读数据时候通知
OP_WRITE	当能够向通道中写数据时通知。大多数情况下可能，除了套接字缓存已满。当你写的速度大于远程节点的处理速度时会发生

Netty的NIO传输内部使用这一模型接收和发送数据，但是将自身的API暴露给用户，完全隐藏了内部实现。就像前面提及的那样，向用户暴露统一的API，隐藏了所有的内部实现。图4.2展示了内部处理流程。

图4.2 选择器逻辑]

注册到选择器上的新创建的通道
处理状态变化的选择器
已经注册的通道
Selector.select()方法会一直阻塞直到状态变化或者超时
检核是否存在状态变化
处理所有的状态变化
在选择器执行的线程上执行其它任务

由于传输的自身特性，当处理事件的时候会有些许延迟，所以它比OIO传输要有更低的吞吐量（这里值得商榷）。这是由于选择器的工作方式决定的，状态通知需要花费一定时间。这里的延迟只是毫秒级别，而不是秒级别。这也许不是很大的延迟，如果你的网络应用使用的超高速的网络，这些延迟还是要考虑的。
只有NIO传输提供了叫做零文件拷贝的特性。这一特性允许你快速、高效的从文件系统传输数据。这一特性提哦给你了一种方式将字节数组从文件系统拷贝到网络堆栈，不需要将它从核心区拷贝到用户空间。
注意并不是所有的操作系统都支持这一特性。请参考操作系统文档来看一看它是否支持。同时，当你不对数据进行加密和压缩时，才能受益于它。否则你需要将字节首先拷贝到用户空间进行具体操作，所以只有传输原始能容才能利用这一特性。你也可以在传输文件之前预先加密它。
FTP和HTTP服务器可以充分利用这一特性。
下面我们将介绍OIO传输，它提供了阻塞传输。

OIO-老的阻塞IO

OIO传输在Netty中是个这种方案。它建立在已知的统一API至少，但是它不是异步的，因为在内部是使用阻塞的java.net来实现。乍一看，这一传输对你没有用，但是它有自身的使用场景。你会在后面看到几种使用场景，在这里我们先看一个。
假设你有一些历史代码，使用许多库包含阻塞调用（例如使用jdbc）。将这些代码改为非阻塞并不可行。然而，你可以先使用OIO传输，然后再把它变为真正的异步传输。我们来关注一下它是如何传输的。
因为OIO内部使用java.net来实现。如果你先前写过网络应用，你应该熟悉这一逻辑。
当使用这些类的时候，你通常有一个线程负责接收新的套接字，紧接着为每一个连接创建一个新的线程来通过套接字服务。这样做很有必要，因为套接字上的每一个操作在任何时候都可能阻塞。如果你存在多个连接共享一个线程，那么一个阻塞操作导致其它的套接字工作受阻。
你知道这些操作可能阻塞，可能会想，Netty为什么使用它，并且提供相同的API。Netty利用SO_TIMEOUT设置套接字。这一超时时间规定了等待IO操作完成的最长时间。如果在规定的时间内没有完成，将会抛出一个SocketTimeoutException异常。Netty捕获这个SocketTimeoutException异常，继续自己的工作。在下一个EventLoop运行时，再次尝试。不幸的是这是目前的唯一处理方式，也是Netty的内部处理方式。这一方式存在的问题是触发SocketTimeoutException并不是没有开销，它需要填充StrackTrace等等。
图4.3显示整个逻辑。

图4.3 OIO处理逻辑

分配给套接字的线程
套接字连接到远程节点
读操作，可能阻塞
读取完成
读操作完成，读取字节数组
执行提交给套接字的其它任务
再次试着读取

现在你已经知道Netty最常用的两种传输，在后续部分将继续介绍其它传输。

本地-VM内传输

Netty包含所谓的本地通讯。这个传输实现可以被用来在VM内通讯，但同时还使用相同的API。向NIO那样这个传输也是完全异步的。

每一个Channel同使用一个唯一的
SocketAddress，它被存储在注册表中。这个SocketAddress可以被用来通过客户端连接。它会在服务器运行的过程中被注册。当通道关闭的时候，它会自动撤销注册，所以客户端不能再次访问它。

连接到本地传输服务的行为和其它的传输实现差不多。有一件事情要注意，只能在客户端和服务器端同时使用。你不可能在服务器端使用本地传输，在客户端使用其它传输。这听起来不合理，但你仔细想一想，这是合理的。因为本地传输不绑定套接字，不会真正的网络，所以不能和其它的传输实现一起使用。

嵌入式传输

Netty同样包含嵌入式传输。当你和前面提起的其它的传输来比，它不像是一个真正的传输，但是在这一部分，它被包含了进来。不是真正的传输，那么，它有什么作用？
嵌入式传输允许你和你实现的ChannelHandler更简单的交互。同样可以很容易的将ChannelHandler嵌入其它ChannelHandler中，嵌入式传输更像是帮助类来使用。
这经常被用在测试用例中来测试实现的ChannelHandler，同样可以被用来重用一些ChannelHandler，而不用继承它们。为了达到这些目的，出现了一个具体的Channel实现。

表格4.4 嵌入式通道

通道类型	用处
EmbeddedChannel	测试ChannelHandler或者嵌入ChannelHandler来重用

第10章会详细介绍嵌入式传输如何用于测试

每一种传输类型的使用

你已经详细学习了所有的传输，你也许会问，应该如何选择。就像前面所提及的那样，不是所有的传输都支持核心协议。这也可以用来限制你想选择的传输。表格4.6列出了每个传输支持的协议。
表格4.5 传输支持的协议

传输	TCP	UDP	SCTP*
NIO	Χ	Χ	Χ
OIO	Χ	Χ	Χ
Local
Embedded

*代表目前仅在Linux上支持。这在未来有可能变化。表格中反映的是在本书发布时候的支持情况。

在Linux上启用SCTP

为了使用SCTP，你需要安装用户库，并且核心也需要支持它。
对于Ubuntu系统，使用下面的命令：

sudo apt-get install libsctp1

对于Fedora系统，使用yum：

sudo yum install kernel-modules-extra.x86_64 lksctp-tools.x86_64

具体请参考每一个Linux的发布文档。

除了SCTP，没有其它的硬性规定，但是由于传输的自身特性，有一些建议。当你实现服务器的时候要比客户端的实现要考虑更多的并发连接。
我们来看一下你可能用到的场景。

低的并发连接数目
对于低的并发数目的应用，你可以使用OIO传输。因为并发数目很低，你不用担心每个连接分配一个线程的限制。这种场景下，资源使用不是问题。你也许问，什么样的数目叫做低并发连接数，很难说，但是请记住NIO传输方式可以支持成千上万的并发连接。我会将低于1000的并发连接都叫做低并发连接数目。在一些特殊场景，你也许会从OIO的低延迟中获益，在这种情况下，你可能看到更好的吞吐量。无论如何总存在场景，低并发连接的情况下，NIO表现的较好。例如如果你的连接很活跃，OIO需要的上下文切换影响很大。大多数情况下很难给出硬性规则，都依赖于你的应用和需求。
高并发连接数
如果你想你的应用同时处理许多并发连接数，选择NIO传输。这些传输处理多个并发连接，不是每个线程一个连接，而是几个线程，被许多连接共享。
低延迟
如果你需要十分低的延迟，你应该首先考虑使用OIO。因为内部的设计，OIO要比NIO延迟更小，先前的两个部分已经强调。但是，无论如何，在低的延迟和多的并发数目之间要做出选择。
阻塞历史代码
如果你要转换老的代码使用Netty，它很大基于阻塞网络设计，你有几项操作阻塞IO线程，以至于不能使用异步传输例如NIO进行高效的扩展。你可以重写整个堆栈来解决这些问题，如果时间不够就不可取。在这种场景下，你可以先以OIO开始，然后需要的时候再扩展到NIO。
在JVM内进行传输
如果你只是需要在同一个虚拟机内进行通讯，而不需要通过网络来暴露服务，你最好使用本地传输。因为你会移除算有的先前的网络通讯操作，但是还是可以使用先前的Netty代码块。这样同样很容易后来需求需要将服务暴露到网络上。只需要将传输替换为NIO和OIO，也许要添加一些编码器和解码器将Java对象转为ByteBuf或者相反。
测试ChannelHandler的实现
如果你想测试你的ChannelHandler实现，而没有集成测试，该嵌入式传输上场了。这样就很容易测试ChannelHandler，不需要创建许多模拟测试，同时还能确保在事件流在所有的传输中一致。这样就确保了ChannelHandler在一些实际的传输中照常工作。第7章中给出了测试ChannelHandlers的详细介绍。

了解的你的应用特性很重要，这样选择的传输给你最好的结果。表格4.6总结了一般的使用场景。
表格4.6 应用的最优化传输

应用需求	推荐传输
低的并发连接数目	OIO
高的并发连接数目	NIO
低延迟	OIO
低的阻塞代码基线	OIO
在同一个JVM中传输	本地
测试你的ChannelHandler实现	嵌入式

总结

在本章，你学习了一个Netty的基础，以及它向用户提供了什么。你了解传输是什么，以及它可以用于什么。我还阐述了API，还给出了一些例子。
我还强调了Netty已经有的传输，以及它们的特性。你了解到传输的最低要求是什么，不是所有的传输都在同一个Java版本上工作，还有只运行在特定的操作系统上。
你了解到各个传输的使用场景，并不是每一个传输对于一种用例都是最优的。
如果，你想实现自己的传输，并使它在Netty中可用，参照第17章。这里提供了你所需要的所有步骤。
下一章会关注ByteBuf和MessageList，是Netty中的数据容器。你将学习到如何使用它，以及如何从它获得最好的执行效率。

超速前行

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
传输

传输本章包括传输NIO，OIO，本地和嵌入式使用场景APIs网络应用程序的最重要的任务是传输数据。这可以通过不同的传输方式来完成，但是传输的内容都一样，通过电缆来传输字节数组。传输层帮助抽象了数据的传输。你只需要知道你有字节要发送或者接收，不多也不少。如果你以前使用过Java提供的方式进行网络编程，你很有可能碰到这样的场景：从阻塞传输变为非阻塞传输，或者恰恰相反。这一转换并不容易，因为
复制链接

扫一扫

专栏目录