Netty实战v5：早期访问版2013

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

"Netty in Action v5 MEAP 2013" 本书是"Netty in Action"的第五版，由Manning Publications于2013年推出，是早期访问计划（Manning Early Access Program，MEAP）的一部分。Netty是一个高性能、异步事件驱动的网络应用程序框架，用于快速开发可维护的协议服务器和客户端。这本书旨在帮助读者理解和掌握Netty的核心功能和高级特性。 1. **Netty与Java NIO API** Netty基于Java的非阻塞I/O（New I/O，NIO）API构建，提供了更高级别的抽象，使得开发者能够更容易地处理并发和网络通信。本章将介绍Netty如何使用Java NIO来实现高效、低延迟的网络编程，并对比传统的阻塞I/O模型。 2. **第一个Netty应用** 这一章引导读者创建第一个Netty应用，通过实际操作学习Netty的基本用法，包括设置服务器、建立连接、处理网络事件等。 3. **Netty从零开始** 这部分深入解析Netty的设计理念和架构，介绍其核心组件，如EventLoop、Channel、Pipeline等，帮助读者理解Netty如何进行事件驱动的网络编程。 4. **传输层（Transports）** Netty支持多种传输方式，如TCP、UDP等。本章将讨论如何配置和使用这些传输层，以及它们在不同场景下的选择和优缺点。 5. **缓冲区（Buffers）** Netty的Buffer类提供了一种高效的数据操作方式，可以进行读写、复制、合并等操作，本章会详细介绍其用法和优势。 6. **ChannelHandler** ChannelHandler是Netty处理网络事件的关键组件，负责事件的处理和转发。本章将介绍如何定义和组合ChannelHandler，以实现复杂的网络逻辑。 7. **编码解码（Codec）** Netty的编码解码机制允许开发者自定义协议，将原始数据转换为可处理的对象，反之亦然。本章将展示如何实现自定义编码器和解码器。 8. **预置的ChannelHandlers和Codecs** Netty提供了一系列预置的处理器和编码器，如HTTP、WebSocket等。本章将介绍这些预置组件的用法和配置。 9. **启动Netty应用（Bootstrapping）** 本章讲解如何设置和启动Netty服务器和客户端，包括配置EventLoopGroup、创建Bootstrap和ServerBootstrap等。 10. **单元测试你的代码** Netty应用的测试策略和工具，包括如何编写针对Netty组件的单元测试，确保代码质量。 11. **WebSockets** 这一章将探讨如何使用Netty实现WebSocket服务器和客户端，支持双向实时通信。 12. **SPDY** SPDY是Google提出的一种协议，旨在减少网页加载时间。本章会介绍如何在Netty中支持SPDY协议。 13. **通过UDP广播事件** 展示如何利用Netty的UDP支持进行广播事件的发送和接收。 14. **实现自定义编解码器** 对于复杂或定制的协议，本章将指导读者如何设计和实现自定义的编码解码器。 15. **选择正确的线程模型** 讨论Netty中不同线程模型的选取，如单线程、多线程、线程池等，以及它们对性能和资源消耗的影响。 16. **注销/重新注册到EventLoop** 如何管理EventLoop的生命周期，包括在运行时注销和重新注册Channel。 17. **案例研究** 提供一些实际项目中的案例，展示Netty在真实场景中的应用和解决方案。 18. **附录** - 社区参与：如何加入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

#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页未读，继续阅读

wupf86

粉丝: 0
资源: 33

Netty实战v5：早期访问版2013

netty in action v5 meap版本 增加了阅读批注，有些地方是正式版没有写的，但是我个人觉得很有启发意义

netty in action （meap）

Netty In Action中文版-高清.pdf

Netty in Action V5 MEAP版：新增阅读批注与独特洞察

Netty实战v5：MEAP版2013年

Netty in Action 2014 v10 MEAP

netty in action

Netty In Action

Netty in Action V5：深度探索Java网络编程框架

Netty实战：探索MEAP V04版

最新资源

netty in action v5 meap版本增加了阅读批注，有些地方是正式版没有写的，但是我个人觉得很有启发意义