Java NIO编程入门与实践：教程与示例

需积分: 2 148 浏览量更新于2024-07-18 收藏 1.32MB PDF 举报

Java NIO (New I/O) 是Java平台的一部分，专为处理大量并发I/O操作而设计。它在J2SE 1.4版本中由Sun Microsystems引入，以补充传统的标准I/O方法。NIO的核心理念是通过提供底层操作系统级别的访问，实现更高效、非阻塞的I/O操作，这在处理网络通信、文件操作等场景中尤其重要。本书《Java NIO Programming Cookbook》是一本实用指南，包含了丰富的教程，适合初学者入门并深入了解NIO。书中内容涵盖了以下几个关键知识点： 1. **Java NIO基础** - **缓冲区（Buffers）**: Buffer是NIO的核心组件，它们用于临时存储数据，包括ByteBuffer，可以进行读写操作，如示例中的缓冲区创建和使用。 - **通道（Channels）**: Channels代表了I/O连接，如FileChannel，提供了对文件的操作，例如文件读写和大块数据传输。 - **字符集（Charsets）**: 字符编码在NIO中也有所涉及，确保正确处理不同编码的数据流。 - **选择器（Selectors）**: 选择器是事件驱动机制，允许监听多个通道的活动，简化了多路复用和并发处理。 2. **Java NIO与SSL（Secure Sockets Layer）**: - SSL用于保护网络通信的安全性，书中的例子展示了如何使用NIO API实现SSL连接，包括SSL引擎的生命周期管理和SSL握手过程。 - 提供了一个完整的NioSSLExample，包括主类、NioSSLProvider和SSLProvider类的实现。 3. **Java NIO与Socket编程**: - 传统Java Socket与NIO的非阻塞SocketChannel进行了对比，演示了如何创建和使用非阻塞SocketChannel进行客户端和服务器之间的通信。 - 包括服务器代码、客户端代码以及运行结果分析。 4. **Java NIO文件写入（Write File Example）**: - 介绍NIO API在文件操作中的应用，如创建NIO路径，用于写入文件时提供了高级操作的便利性。通过本书，读者将逐步掌握如何在Java项目中有效地利用NIO进行高效、安全的I/O操作，提升程序性能和可扩展性。每个章节都包含实例代码，便于实践学习和理解NIO的工作原理。对于任何希望提升Java编程技能，尤其是在I/O密集型应用开发的开发者来说，这是一本不可或缺的参考书籍。

Java NIO Programming Cookbook 6 / 73

final int numSelectedKeys = selector.select();

if (numSelectedKeys > 0) {

handleSelectionKeys(selector.selectedKeys(), serverSocket);

}

• line 1: We create a Selector using the systems default SelectorProvider.

• line 2: We create a ServerSocketChannel which is a SelectableChannel.

• line 6: We conﬁgure the ServerSocketChannel for non-blocking mode.

• line 7: We then register the ServerSocketChannel with the Selector, we receive a SelectionKey from the registration although I

discard it, having no use for it. The serverSocket.validOps() call will return an operation set that is supported by the

Channel, which in this case is only the "Accept Connection" event. The returned SelectionKey contains an "interest set" which

indicates the set of IO events the Selector must monitor the Channel for.

• line 10: We call select() on the Selector which is blocking until some IO occurs on any of the SelectableChannel instances

that are registered with it. It will return the number of keys which are ready for IO activity.

The following code snippet demonstrates iterating through all the SelectionKey instances that indicate IO "ready" events from

Channel instances managed by the single Selector. We are only interested in "Accept" and Readable" events. For every new

connection accepted an "Accept" event is signaled and we can act on it. Likewise with a "read" ready event we can read

incoming data. It is important to remove the SelectionKey from the set after handling it, as the Selector does not do this and you

will continue to process that stale event.

Working with SelectionKeys

final Iterator<SelectionKey> selectionKeyIterator = selectionKeys.iterator();

while (selectionKeyIterator.hasNext()) {

final SelectionKey key = selectionKeyIterator.next();

if (key.isAcceptable()) {

acceptClientSocket(key, serverSocket);

} else if (key.isReadable()) {

readRequest(key);

} else {

System.out.println("Invalid selection key");

}

selectionKeyIterator.remove();

}

• line 13: Remember to remove the SelectionKey from the selected set as the Selector does not do this for us, if we don’t do it,

we will continue to process stale events.

The following code snippet demonstrates the use of registration of a SocketChannel with the same Selector that manages the

ServerSocketChannel. Here, however, the interest set is only for IO "read" events.

Registering a Channel with a Selector

final SocketChannel client = serverSocket.accept();

client.configureBlocking(false);

client.register(key.selector(), SelectionKey.OP_READ);

Java NIO Programming Cookbook 8 / 73

Chapter 2

Java Nio SSL Example

This is an example of a non-blocking I/O provided by java.nio using SSL handshake.

2.1 Deﬁnition of Secure Sockets Layer Protocol (SSL)

SSL is the secure communication protocol of choice for a large part of the Internet community. There are many applications of

SSL in existence, since it is capable of securing any transmission over TCP. Secure HTTP, or HTTPS, is a familiar application of

SSL in e-commerce or password transactions. Along with this popularity comes demands to use it with different I/O and threading

models in order to satisfy the applications’ performance, scalability, footprint, and other requirements. There are demands to

use it with blocking and non-blocking I/O channels, asynchronous I/O, input and output streams and byte buffers.The main

point of the protocol is to provide privacy and reliability between two communicating applications. The following fundamental

characteristics provide connection security:

• Privacy - connection using encryption

• Identity authentication - identiﬁcation using certiﬁcates

• Reliability - dependable maintenance of a secure connection through message integrity

Many developers may be wondering how to use SSL with Java NIO. With the traditional blocking sockets API, security is a

simple issue: just set up an SSLContext instance with the appropriate key material, use it to create instances of SSLSocke

tFactory or SSLServerSocketFactory and ﬁnally use these factories to create instances of SSLServerSocket or

SSLSocket . In Java 1.6, a new abstraction was introduced to allow applications to use the SSL/TLS protocols in a transport

independent way, and thus freeing applications to choose transport and computing models that best meet their needs. Not only

does this new abstraction allow applications to use non-blocking I/O channels and other I/O models, it also accommodates

different threading models.

2.2 The SSL Engine API

The new abstraction is therefore an advanced API having as core class the javax.net.ssl.SSLEngine . It encapsulates

an SSL/TLS state machine and operates on inbound and outbound byte buffers supplied by the user of the SSLEngine.

2.2.1 Lifecycle

The SSLEngine must ﬁrst go through the handshake, where the server and the client negotiate the cipher suite and the session

keys. This phase typically involves the exchange of several messages. After completing the handshake, the application can

start sending and receiving application data. This is the main state of the engine and will typically last until the connection is

CLOSED (see image below). In some situations, one of the peers may ask for a renegotiation of the session parameters, either

剩余80页未读，继续阅读

defning

粉丝: 1
资源: 16

Java NIO编程入门与实践：教程与示例

Java NIO深入解析PDF版

Java NIO高性能框架开发指南

Java NIO深入浅出：提高Java代码执行效率的新特性

java nio教程pdf

java nio.pdf

javaNIO.pdf

JavaNIO.pdf

2017 Java NIO Programing PDF

JavaNIO_PDF_CN

单元学习JavaNIO.pdf

最新资源