Netty入门指南：电子书《Netty in Action》

需积分: 3 170 浏览量更新于2024-07-21 收藏 2.97MB PDF 举报

"Netty in Action 是一本介绍Netty框架的电子书，适合初学者入门，由Manning Publications出版。本书涵盖了Netty的核心功能、设计思想、实战示例以及高级主题。" 《Netty in Action》深入浅出地介绍了Netty这一高性能、异步事件驱动的网络应用程序框架，它主要用于开发Java的TCP、UDP和HTTP等协议的应用。Netty因其高效、灵活和强大的特性在Java社区中备受推崇。 Part 1: Getting Started 这部分是入门引导，主要讲解了Netty与Java NIO（非阻塞I/O）APIs的关系。Java NIO为Netty提供了底层的支持，使得Netty能够实现高效的网络通信。第2章则通过一个简单的应用实例，让读者快速了解如何使用Netty构建网络应用。 Part 2: Core Functions/Parts 这部分详细阐述了Netty的核心组件和设计理念。第3章介绍了Netty的一般设计思路，包括其异步模型和事件驱动架构。第4章至第9章分别探讨了传输层（Transports）、缓冲区（Buffers）、通道处理器（Channel Handlers）、编码解码器（Codec）以及提供的预定义通道处理器（Provided Channel Handlers）。这些内容构成了Netty处理网络通信的基础。 Part 3: Netty by Example 这部分通过一系列实战示例帮助读者理解Netty的实际应用。第10章至第13章分别展示了如何使用Netty实现HTTP服务来提供内容下载、WebSocket聊天应用、SPDY（一种快速的HTTP版本）服务以及通过UDP进行广播消息的发送。 Part 4: Advanced Topics 这部分深入探讨了Netty的高级特性。第14章讲述了Netty的线程模型，这在理解Netty如何处理并发和性能优化时至关重要。第15章介绍了如何在I/O线程中注销并重新注册通道，这是管理网络连接的关键操作。第16章涉及用户自定义事件，展示了如何扩展Netty以满足特定需求。第17章则指导读者如何编写自己的传输实现，这有助于定制更符合应用场景的通信协议。附录部分通常包含额外的技术细节或参考资料，有助于读者进一步提升对Netty的理解。《Netty in Action》是一本全面而实用的Netty教程，无论是对网络编程感兴趣的新手还是有经验的开发者，都能从中获益匪浅。通过阅读此书，读者可以掌握Netty的精髓，从而更高效地构建高性能的网络应用。

PrintWriter writer = new

PrintWriter(clientSocket

.getOutputStream(), true);

while(true) { #4

writer.println(reader.readLine());

writer.flush();

}

} catch (IOException e) {

e.printStackTrace();

try {

clientSocket.close();

} catch (IOException ex) {

// ignore on close

}

}).start(); #5

}

} catch (IOException e) {

e.printStackTrace();

}

#1Bind Server to port

#2 Block until new Client connection was accepted

#3 Create a new Thread which will handle the Client connection

#4 Read data from Client and write it back

#5 Start the Thread

This listing should look quite familiar to you if you have ever written a network application

in Java. But let us think about it for a few seconds. What problems may be present with this

sort of "design"?

©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 Tracy Whitaker <woburnpyqsc@hotmail.com>

Just let us revisit these lines again:

final Socket clientSocket = socket.accept();

new Thread(new Runnable() {

@Override

public void run() {

…

}

}).start();

Hopefully it is clear that one thread is needed for each new client connection that is

served. You may argue that we could make use of a thread pool to get rid of the overhead of

creating the threads, but that would only help for a while. The fundamental problem will still

remain, that is, the number of concurrent clients that can be served is limited to the number

of threads that you can have "alive" at the same time. Once your Application needs to handle

thousands of concurrent clients this will be a big problem. This problem will not be present

when using NIO, as will be demonstrated in our next example of how this would be

implemented in a non-blocking way via NIO.

1.4.2 NON-BLOCKING IO

Java 7 introduced a new NIO API aka NIO.2, it is possible to choose between NIO and NIO.2.

This new API is also asynchronous but is quite different from the original NIO implementation

in both its API and implementation. They are not completely different however and both APIs

share some common features. For example, both of the implementations use an abstraction

called a

ByteBuffer as data container.

BYTEBUFFER

ByteBuffer is fundamental to both NIO APIs and indeed to Netty. Before we take a

look at the NIO version of echo server, it is important to understand the key concepts of a

ByteBuffer.

ByteBuffer can either be allocated on the heap or direct, which means it will be

stored outside of the Heap-Space. Usually using a direct buffer is faster when pass it to the

Channel, but the allocation/deallocation costs are higher. In both cases the API for a

ByteBuffer is the same, which provides a unified way of accessing and manipulating data.

ByteBuffer allows the same data to be easily shared between ByteBuffer instances

without the need to do any memory copying. It further allows slicing and other operations to

limit the data that is visible.

©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 Tracy Whitaker <woburnpyqsc@hotmail.com>

So the typical usage of the ByteBuffer would be:

• Write data into the

ByteBuffer

• Call

ByteBuffer.flip() to adjust the position and limit

• Read data out of the

ByteBuffer

• Call either

ByteBuffer.clear() or ByteBuffer.compact()

When you write some data in the

ByteBuffer, it will keep track of the amount of data you

have written. It does this by updating the position of the write index in the buffer; this can

also be done manually. Once you are ready to read the data you need to call

Bytebuffer.flip() to switch from “writing-mode” to “reading-mode”. Calling

ByteBuffer.flip() has the effect of setting the limit of the ByteBuffer to the current

position and then update its position to 0. This way you can read all the data that is present

in the

ByteBuffer.

Once you want to write to the

ByteBuffer again you need to switch the modes again. For

this you can either call

ByteBuffer.clear() or Bytebuffer.compact(). The

difference is that

ByteBuffer.clear() will "clear" the whole ByteBuffer whereas

ByteBuffer.compact() will only clear out the data that was already read. It does that by

moving all unread data to the beginning of the

ByteBuffer and adjusting the position. The

process used by

ByteBuffer.compact() involves memory copying.

Listing 1.5 demonstrates what was just discussed and shows how you would usually use a

ByteBuffer.

Listing 1.5 Working with a ByteBuffer

Channel inChannel = ....;

ByteBuffer buf = ByteBuffer.allocate(48);

int bytesRead = -1;

do {

bytesRead = inChannel.read(buf); #1

if (bytesRead != -1) {

buf.flip(); #2

while(buf.hasRemaining()){

System.out.print((char) buf.get()); #3

©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 Tracy Whitaker <woburnpyqsc@hotmail.com>

}

buf.clear(); #4

}

} while (bytesRead != -1);

inChannel.close();

#1Read data into the ByteBuffer from the Channel

#2 Make buffer ready for read by calling flip()

#3 Read the bytes in the ByteBuffer. Every get() operation will update the position by 1

#4 Make the ByteBuffer ready for writing again by calling clear()

This section should hopefully have provided you with a basic understanding of how a

ByteBuffer is used. The next section will build on this by covering the two NIO

implementations in more detail and showing how the

ByteBuffer is essential to each.

WORKING WITH NIO SELECTORS AND BYTEBUFFER

This section will provide a brief introduction to the NIO API introduced in Java 1.4 which is

still the most widely used of the two NIO APIs.

This implementation use a selector-based approach to handle network events and data. A

channel represents a connection to an entity capable of performing IO operations such as a

file or a socket. A

Selector is a NIO component that is able to determine if one or more

channels are ready for reading and/or writing, thus a single select selector can be used to

handle multiple connections, alleviating the need for the "thread per connection" model

described earlier in the blocking IO echo server example.

Typically what happens is, you create one or more selectors to which opened channels

(sockets) can be registered. When a channel is registered you specify what events you're

interested in listening in. The four available events (or Ops/operations) are:

1. OP_ACCEPT - Operation-set bit for socket-accept operations.

2. OP_CONNECT - Operation-set bit for socket-connect operations.

3. OP_READ - Operation-set bit for read operations.

4. OP_WRITE - Operation-set bit for write operations.

©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 Tracy Whitaker <woburnpyqsc@hotmail.com>

剩余166页未读，继续阅读

nihaoadam

粉丝: 2
资源: 10

Netty入门指南：电子书《Netty in Action》

Netty In Action中文版-高清.pdf

Netty In Action中文版.pdf

Netty In Action

netty in action

Netty in Action mobi

Netty in Action合集

netty in action源码

Manning Netty in Action

Essential Netty In Action

2000-2021年中国科技统计年鉴（分省年度）面板数据集-最新更新.zip

最新资源