深入理解Netty v5：实战篇

5星 · 超过95%的资源需积分: 0 106 浏览量更新于2024-07-23 6 收藏 5.4MB PDF 举报

"Netty in Action v5 pdf 是一本关于Netty框架的专业书籍，由Manning Publications出版。本书通过Manning Early Access Program (MEAP) 提供给读者，旨在帮助读者理解和掌握Netty及其与Java NIO API的交互。作者鼓励读者在阅读过程中提供反馈，除了拼写和简单错误，这些将在最终出版时修正。本书内容覆盖了Netty的入门、核心功能、实例应用以及高级主题，适合不同层次的开发者学习。" Netty是一个高性能、异步事件驱动的网络应用程序框架，用于快速开发可维护的高性能协议服务器和客户端。在"Netty in Action v5"中，读者将深入了解到以下几个方面： 1. Netty与Java NIO APIs：这部分介绍Netty如何利用Java的非阻塞I/O（NIO）来实现高效的网络通信。Netty简化了NIO的复杂性，提供了更易用的API，使开发者能够专注于业务逻辑。 2. 你的第一个Netty应用：教程式地引导读者创建一个简单的Netty应用程序，理解其基本架构和工作流程。 3. Netty从零开始：深入到Netty的核心组件和设计模式，包括事件循环（Event Loop）、通道（Channel）和处理器（Channel Handler）。 4. 传输层（Transports）：解释Netty支持的不同类型的传输，如TCP、UDP以及自定义传输的实现。 5. 缓冲区（Buffers）：Netty的Buffer系统是高效数据处理的关键，它提供了安全、高效的字节操作和内存管理。 6. ChannelHandler：介绍如何编写和配置ChannelHandler，以处理网络事件，如连接建立、数据接收和发送等。 7. 编码解码（Codec）：探讨如何使用Netty的编码器和解码器来处理各种协议，如HTTP、FTP等。 8. 预置的Channel Handlers和Codecs：列出Netty提供的现成组件，帮助开发者快速实现常见协议和功能。 9. Netty应用的启动（Bootstrapping）：详细说明如何配置和启动Netty服务器和客户端。 10. 单元测试代码：展示如何编写针对Netty应用的单元测试，确保代码质量。 11. WebSockets：讲解如何使用Netty构建WebSocket服务器和客户端，支持实时双向通信。 12. SPDY：介绍SPDY协议，它是HTTP/2之前的实验性协议，旨在减少网页加载时间。 13. 通过UDP广播事件：演示如何利用Netty处理UDP协议的广播和多播。 14. 实现自定义编码器：指导读者如何根据需求扩展Netty，实现特定协议的编码和解码。 15. 选择合适的线程模型：讨论Netty中的多线程模型，如何根据系统资源和负载选择最佳实践。 16. 注销/重新注册EventLoop：说明如何动态地管理EventLoop，以应对动态环境的变化。 17. 案例研究：通过实际的案例分析，展示Netty在复杂应用场景下的解决方案。附录部分提供了社区参与方式、相关书籍推荐和与Netty相关的项目列表，为读者进一步学习和贡献Netty生态系统提供了资源和支持。通过阅读此书，读者将能够充分利用Netty的潜力，构建出高性能、可靠的网络应用。

ServerSocketChannel serverChannel = ServerSocketChannel.open();

ServerSocket ss = serverChannel.socket();

InetSocketAddress address = new InetSocketAddress(port);

ss.bind(address); #1

serverChannel.configureBlocking(false);

Selector selector = Selector.open();

serverChannel.register(selector, SelectionKey.OP_ACCEPT); #2

while (true) {

try {

selector.select(); #3

} catch (IOException ex) {

ex.printStackTrace();

// handle in a proper way

break;

}

Set readyKeys = selector.selectedKeys(); #4

Iterator iterator = readyKeys.iterator();

while (iterator.hasNext()) {

SelectionKey key = (SelectionKey) iterator.next();

iterator.remove(); #5

try {

if (key.isAcceptable()) {

ServerSocketChannel server = (ServerSocketChannel)

key.channel();

SocketChannel client = server.accept(); #6

System.out.println("Accepted connection from " +

client);

client.configureBlocking(false);

client.register(selector, SelectionKey.OP_WRITE |

SelectionKey.OP_READ, ByteBuffer.allocate(100)); #7

}

if (key.isReadable()) { #8

SocketChannel client = (SocketChannel) key.channel();

ByteBuffer output = (ByteBuffer) key.attachment();

client.read(output); #9

}

if (key.isWritable()) { #10

SocketChannel client = (SocketChannel) key.channel();

ByteBuffer output = (ByteBuffer) key.attachment();

output.flip();

client.write(output); #11

output.compact();

}

} catch (IOException ex) {

key.cancel();

try {

key.channel().close();

} catch (IOException cex) {

}

©Manning Publications Co. We welcome reader comments about anything in the manuscript - other than typos and

other simple mistakes. These will be cleaned up during production of the book by copyeditors and proofreaders.

http://www.manning-sandbox.com/forum.jspa?forumID=857

Licensed to Jinpu Hu <hujinpu@gmail.com>

#1 Bind server to port

#2 Register the channel with the selector to be interested in new Client connections that get accepted

#3 Block until something is selected

#4 Get all SelectedKey instances

#5 Remove the SelectedKey from the iterator

#6 Accept the client connection

#7 Register connection to selector and set ByteBuffer

#8 Check for SelectedKey for read

#9 Read data to ByteBuffer

#10 Check for SelectedKey for write

#11 Write data from ByteBuffer to channel

This example is more complex than the previous version of EchoServer. This complexity is a

trade off; asynchronous code is typically more complicated than its synchronous counterpart.

Semantically, the original NIO and the new NIO.2 API are similar, but their implementations

are different. We’ll take a look the differences next, and we’ll implement version 3 of

EchoServer.

1.3.4 EchoServer based on NIO.2

Unlike the original NIO implementation, NIO.2 allows you to issue IO operations and provide

what is called a completion handler (

CompletionHandler class). This completion handler

gets executed after the operation completes. Therefore, execution of the completion handler is

driven by the underlying system and the implementation is hidden from the developer. It also

guarantees that only one

CompletionHandler is executed for channel at the same time. This

approach helps to simplify the code because it removes the complexity that comes with

multithreaded execution.

The major difference between the original NIO and NIO.2 is that you don’t have to check

whether an event accours on the Channel and then trigger some action. In NIO.2 you can just

trigger an IO operation and register a completion handler with it, this handler will then get

notified once the operation complates. This removes the need to create your own application

logic to check for completion, which itself results in unnecessary processing.

Now let’s see how the same asynchronous EchoServer would be implemented with

NIO2,implementation as shown in the next listing.

Listing 1.7 EchoServer v3: NIO.2

public class PlainNio2EchoServer {

public void serve(int port) throws IOException {

System.out.println("Listening for connections on port " + port);

final AsynchronousServerSocketChannel serverChannel =

AsynchronousServerSocketChannel.open();

InetSocketAddress address = new InetSocketAddress(port);

serverChannel.bind(address); #1

final CountDownLatch latch = new CountDownLatch(1);

serverChannel.accept(null, new

CompletionHandler<AsynchronousSocketChannel, Object>() { #2

@Override

public void completed(final AsynchronousSocketChannel channel,

Object attachment) {

©Manning Publications Co. We welcome reader comments about anything in the manuscript - other than typos and

other simple mistakes. These will be cleaned up during production of the book by copyeditors and proofreaders.

http://www.manning-sandbox.com/forum.jspa?forumID=857

Licensed to Jinpu Hu <hujinpu@gmail.com>

serverChannel.accept(null, this); #3

ByteBuffer buffer = ByteBuffer.allocate(100);

channel.read(buffer, buffer,

new EchoCompletionHandler(channel)); #4

}

@Override

public void failed(Throwable throwable, Object attachment) {

try {

serverChannel.close(); #5

} catch (IOException e) {

// ingnore on close

} finally {

latch.countDown();

}

});

try {

latch.await();

} catch (InterruptedException e) {

Thread.currentThread().interrupt();

}

private final class EchoCompletionHandler implements

CompletionHandler<Integer, ByteBuffer> {

private final AsynchronousSocketChannel channel;

EchoCompletionHandler(AsynchronousSocketChannel channel) {

this.channel = channel;

}

@Override

public void completed(Integer result, ByteBuffer buffer) {

buffer.flip();

channel.write(buffer, buffer, new CompletionHandler<Integer,

ByteBuffer>() { #6

@Override

public void completed(Integer result, ByteBuffer buffer) {

if (buffer.hasRemaining()) {

channel.write(buffer, buffer, this); #7

} else {

buffer.compact();

channel.read(buffer, buffer,

EchoCompletionHandler.this); #8

}

@Override

public void failed(Throwable exc, ByteBuffer attachment) {

try {

channel.close();

} catch (IOException e) {

// ingnore on close

}

});

}

©Manning Publications Co. We welcome reader comments about anything in the manuscript - other than typos and

other simple mistakes. These will be cleaned up during production of the book by copyeditors and proofreaders.

http://www.manning-sandbox.com/forum.jspa?forumID=857

Licensed to Jinpu Hu <hujinpu@gmail.com>

@Override

public void failed(Throwable exc, ByteBuffer attachment) {

try {

channel.close();

} catch (IOException e) {

// ingnore on close

}

#1Bind Server to port

#2 Start to accept new Client connections. Once one is accepted the CompletionHandler will get called.

#3 Again accept new Client connections

#4 Trigger a read operation on the Channel, the given CompletionHandler will be notified once

something was read

#5 Close the socket on error

#6 Trigger a write operation on the Channel, the given CompletionHandler will be notified once

something was written

#7 Trigger again a write operation if something is left in the ByteBuffer

#8 Trigger a read operation on the Channel, the given CompletionHandler will be notified once

something was read

At first glance, it may look like more code than what you had when using the previous NIO

implementation. But notice that NIO.2 handles threading and the creation of the so-called

event loop for you. This approach simplifies the code needed to build a multithreaded NIO

application, even though it may not seem to be the case in this example. As the complexity of

the application increases, the gains become more evident because you’ll be producing cleaner

code.

In the next section, we’ll look at some known problems that exist in the JDK’s NIO

implementation.

1.4 NIO problems and how Netty comes to the rescue

In this section, we’ll look at some problems and limitations of the Java NIO APIs and how Netty

addresses these issues. Having the NIO packages of the JDK is a great step in the right

direction, but users are limited in how they can use them. These issues are often the result of

design choices that were made in the past and aren’t easy to change now, others are defects.

1.4.1 Cross-platform and compatibility issues

NIO is low level and depends on how the operating system (OS) handles IO. So fulfilling the

requirement of having a unified API exposed in Java, which works and behaves the same on all

OSs, isn’t trivial.

When using NIO you often find that your code works fine on Linux, for example, but has

problems on Windows. My general advice, even if you’re not using NIO, but it’s more important

if you are, is to test on all the OSs you want to support or use. Even if all the tests pass on

your Linux workstation, be sure to verify it on the other OSs. If you don’t verify, prepare to

have fun later.

other simple mistakes. These will be cleaned up during production of the book by copyeditors and proofreaders.

http://www.manning-sandbox.com/forum.jspa?forumID=857

Licensed to Jinpu Hu <hujinpu@gmail.com>

Ideal as NIO.2 may seem, it’s only supported in Java 7, and if your application runs on Java

6, you may not be able to use it. Also, at the time of writing, there is no NIO.2 API for

datagram channels (for UDP applications), so its usage is limited to TCP applications only.

Netty addresses this problem by providing a unified API, which allows the same semantics

to work seamlessly on either Java 6 or 7. You don’t have to worry about the underlying

version, and you benefit from a simple and consistent API.

1.4.2 Extending ByteBuffer ... or not

As you saw previously, ByteBuffer is used as data container. Unfortunately, the JDK doesn’t

contain a

ByteBuffer implementation that allows wrapping an array of ByteBuffer

instances. This functionality is useful if you want to minimize memory copies. If you ‘rethinking

I’ll implement it myself, don’t waste your time;

ByteBuffer has a private constructor, so it

isn’t possible to extend it.

Netty provides its own

ByteBuffer implementation, which gets around this limitation and

goes further by providing several other means of constructing, using, and manipulating a

ByteBuffer all with a simpler API.

1.4.3 Scattering and gathering may leak

Many channel implementations support scattering and gathering. This feature allows writing to

or reading from many

ByteBuffer instances at the same time with better performance. Here

the kernel/OS handles how these are written/read, which often gives you the best performance

because the kernel/OS, being closer to the hardware, knows how to do it in the most efficient

way.

Scattering/gathering is often used if you want to split data in different

ByteBuffer

instances to handle each buffer separately. For example, you may want to have the header in

one

ByteBuffer and the body in another.

Figure 1.4 shows how a scattering read is performed. You pass an array of

ByteBuffer

instances to the

ScatteringByteChannel and the data gets scattered from the channel to

the buffers.

Figure 1.4 A scattering read from a channel

other simple mistakes. These will be cleaned up during production of the book by copyeditors and proofreaders.

http://www.manning-sandbox.com/forum.jspa?forumID=857

Licensed to Jinpu Hu <hujinpu@gmail.com>

剩余264页未读，继续阅读

jawjaway

粉丝: 0
资源: 2

深入理解Netty v5：实战篇

essential-netty-in-action.pdf

Netty in Action 无水印pdf

Netty-In-Action中文版.pdf

netty进阶之路 pdf

netty in.readInt();

深入学习netty的书籍

netty进阶之路:跟着案例学netty pdf

跟闪电侠学 netty:netty 即时聊天实战与底层原理 pdf

netty权威指南第三版 pdf

netty原理解析与开发实战 柳 pdf

最新资源

netty原理解析与开发实战柳 pdf