Netty实战：探索Java NIO API与高级特性

3星 · 超过75%的资源需积分: 9 28 浏览量更新于2024-07-23 收藏 3.3MB PDF 举报

"Netty_in_Action 是一本关于Netty框架的英文完整版书籍，由Manning Publications出版。这本书涵盖了从入门到高级的Netty技术知识，包括Netty与Java NIO API的关系、构建第一个Netty应用、核心组件如传输、缓冲区、ChannelHandler、编码解码器等内容，并通过实例展示了如何进行单元测试、WebSocket、SPDY协议的实现以及自定义编解码器等。此外，还涉及了高级主题，如选择合适的线程模型、在EventLoop中注销和重新注册，以及案例研究。书后附有社区参与指南、相关书籍推荐和关联项目列表。" 《Netty in Action》详细介绍了Netty框架，以下将重点讲解部分关键知识点： 1. **Netty与Java NIO API**：Netty是基于Java NIO（非阻塞I/O）构建的，它简化了NIO的使用，提供了更高级别的API，使得开发者可以更高效地处理并发连接和网络通信。 2. **Your first Netty application**：这部分引导读者创建第一个Netty应用，涵盖基本的服务器和客户端配置，理解事件驱动模型和异步I/O的工作方式。 3. **Netty from the ground up**：深入讲解Netty的基础架构，包括事件循环(EventLoop)、管道(ChannelPipeline)和通道(Channel)的概念，以及它们如何协同工作。 4. **Transports**：Netty支持多种传输类型，如TCP、UDP和本地套接字，这部分会讲解如何选择和使用不同的传输层。 5. **Buffers**：Netty的ByteBuf是高效的数据容器，它提供了管理和操作二进制数据的方法，比Java的ByteBuffer更为强大。 6. **ChannelHandler**：ChannelHandler是处理网络事件的核心组件，用于编码、解码、业务逻辑处理等。 7. **Codec**：Netty提供了一种灵活的编码解码机制，允许用户自定义或使用已有的编码解码器，如ByteToMessageDecoder和MessageToByteEncoder。 8. **Provided ChannelHandlers and Codecs**：书中会介绍Netty提供的内置处理器和编解码器，如LineBasedFrameDecoder用于按行处理数据，Delimiters用于识别特定分隔符等。 9. **Bootstrapping Netty applications**：这部分阐述如何启动和配置Netty服务器和客户端，包括设置事件循环组(EventLoopGroup)、绑定端口等步骤。 10. **Unit-test your code**：Netty提供了测试工具，帮助开发者编写单元测试，确保网络代码的正确性。 11. **WebSockets and SPDY**：WebSockets是一种全双工的通信协议，而SPDY是Google提出的一种优化HTTP的协议，Netty支持这两种协议，书中会讲解如何在Netty中实现它们。 12. **Broadcasting events via UDP**：通过UDP广播事件，展示了Netty如何处理多播和广播通信。 13. **Advanced topics**：包含如自定义编解码器、选择合适的线程模型等高级话题，帮助开发者优化性能和解决复杂问题。 14. **Implement a custom codec**：自定义编解码器是Netty的一个强大功能，这部分将指导读者如何根据具体需求设计和实现自己的编解码逻辑。 15. **Choosing the right thread model**：线程模型的选择对于高性能网络应用至关重要，这部分讨论如何根据系统负载和资源来选择合适的模型。 16. **Deregister / re-register with EventLoop**：在某些情况下，可能需要注销或重新注册Channel到EventLoop，这部分将解释这些操作的场景和方法。 17. **Case studies**：通过实际案例，展示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

#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

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

@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

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

剩余264页未读，继续阅读

sdh567

粉丝: 1
资源: 23

Netty实战：探索Java NIO API与高级特性

Netty_In_Action中文版（有目录）

Netty_In_Action中文版.pdf

Netty_in_Action_v10_MEAP

netty 实战-netty_in_action.zip

netty实战-netty_in_action.zip

Netty_In_Action中文版

Netty_in_Action学习.zip

Netty_In_Action第5版电子书及书中源码

Netty_in_Action(第五版目录修正)

netty4 in action

最新资源