Java I/O与NIO的设计模式与实现
2021-12-286.9k 阅读
Java I/O 基础概念与设计模式
Java I/O 提供了一套丰富的类库，用于处理输入和输出操作。其设计围绕着数据流的概念展开，通过字节流和字符流来处理不同类型的数据。在 I/O 包中，有两个重要的抽象类：InputStream 和 OutputStream 用于字节流，Reader 和 Writer 用于字符流。
装饰器设计模式在 Java I/O 中的应用
Java I/O 类库广泛应用了装饰器设计模式。装饰器模式允许向一个现有的对象添加新的功能，同时又不改变其结构。以 InputStream 为例，FilterInputStream 是一个抽象装饰器，它继承自 InputStream。具体的装饰器类如 DataInputStream、BufferedInputStream 等继承自 FilterInputStream。
假设我们有一个简单的文件读取需求，直接使用 FileInputStream 可以读取文件的字节数据。但如果我们希望提高读取效率，添加缓冲功能，就可以使用 BufferedInputStream 来装饰 FileInputStream。
import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
public class DecoratorPatternExample {
public static void main(String[] args) {
try {
// 创建一个 FileInputStream
InputStream fileInputStream = new FileInputStream("example.txt");
// 使用 BufferedInputStream 装饰 FileInputStream
InputStream bufferedInputStream = new BufferedInputStream(fileInputStream);
int data;
while ((data = bufferedInputStream.read()) != -1) {
System.out.print((char) data);
}
// 关闭流
bufferedInputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
在上述代码中，BufferedInputStream 为 FileInputStream 添加了缓冲功能，而不需要修改 FileInputStream 的原有代码，符合装饰器模式的设计理念。
工厂设计模式在 Java I/O 中的体现
工厂设计模式在 Java I/O 中也有体现。例如，File 类的 createNewFile() 方法实际上是一种简单的工厂方法，它创建了一个新的空文件。另外，FileInputStream、FileOutputStream 等类通过接收 File 对象作为参数来创建相应的流对象，这也类似于工厂模式的创建对象方式。
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
public class FactoryPatternExample {
public static void main(String[] args) {
try {
File file = new File("example.txt");
// 使用 File 创建 FileInputStream
InputStream inputStream = new FileInputStream(file);
int data;
while ((data = inputStream.read()) != -1) {
System.out.print((char) data);
}
inputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
这里通过 File 对象创建 FileInputStream，体现了工厂模式中对象创建的概念。
Java I/O 的实现细节
字节流的实现
InputStream：这是所有字节输入流的抽象基类。它定义了基本的读取方法，如read()读取单个字节，read(byte[] b)读取字节数组。具体的子类，如FileInputStream实现了从文件中读取字节数据。
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
public class ByteStreamExample {
public static void main(String[] args) {
try {
InputStream inputStream = new FileInputStream("example.txt");
int data;
while ((data = inputStream.read()) != -1) {
System.out.print((char) data);
}
inputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
OutputStream：所有字节输出流的抽象基类。定义了写入方法，如write(int b)写入单个字节，write(byte[] b)写入字节数组。FileOutputStream是其常用子类，用于将字节数据写入文件。
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
public class ByteStreamWriteExample {
public static void main(String[] args) {
try {
OutputStream outputStream = new FileOutputStream("output.txt");
String message = "Hello, Java I/O!";
byte[] bytes = message.getBytes();
outputStream.write(bytes);
outputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
字符流的实现
Reader：字符输入流的抽象基类。它提供了读取字符数据的方法，如read()读取单个字符，read(char[] cbuf)读取字符数组。FileReader是用于读取文件字符数据的子类。
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;
public class CharacterStreamReadExample {
public static void main(String[] args) {
try {
Reader reader = new FileReader("example.txt");
int data;
while ((data = reader.read()) != -1) {
System.out.print((char) data);
}
reader.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
Writer：字符输出流的抽象基类。定义了写入字符数据的方法，如write(int c)写入单个字符，write(char[] cbuf)写入字符数组。FileWriter用于将字符数据写入文件。
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;
public class CharacterStreamWriteExample {
public static void main(String[] args) {
try {
Writer writer = new FileWriter("output.txt");
String message = "Hello, Java Character Stream!";
writer.write(message);
writer.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
Java NIO 基础概念与设计模式
Java NIO（New I/O）是 Java 1.4 引入的一套新的 I/O 类库，与传统 I/O 不同，NIO 提供了基于缓冲区和通道的 I/O 操作，支持非阻塞 I/O。
通道与缓冲区设计模式
- 通道（Channel）：通道是 NIO 中用于连接 I/O 源和目标的对象，类似于传统 I/O 中的流，但通道支持双向操作且可以异步读写。例如，
FileChannel用于文件 I/O，SocketChannel用于套接字 I/O。通道体现了一种对象封装的设计理念，将底层的 I/O 操作封装在通道对象中。
import java.io.FileOutputStream;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
public class ChannelExample {
public static void main(String[] args) {
try {
FileOutputStream fileOutputStream = new FileOutputStream("output.txt");
FileChannel fileChannel = fileOutputStream.getChannel();
String message = "Hello, NIO Channel!";
ByteBuffer byteBuffer = ByteBuffer.wrap(message.getBytes());
fileChannel.write(byteBuffer);
fileChannel.close();
fileOutputStream.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
- 缓冲区（Buffer）：缓冲区是 NIO 中数据的载体，用于存储和操作数据。它是一个线性数组，并且提供了一些方法来管理数据的读取和写入。不同类型的数据有对应的缓冲区类，如
ByteBuffer、CharBuffer等。缓冲区的设计采用了对象池模式的思想，通过复用缓冲区对象来提高性能。
import java.nio.ByteBuffer;
public class BufferExample {
public static void main(String[] args) {
// 创建一个 ByteBuffer
ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
String message = "Hello, Buffer!";
byte[] bytes = message.getBytes();
byteBuffer.put(bytes);
byteBuffer.flip();
byte[] result = new byte[byteBuffer.remaining()];
byteBuffer.get(result);
System.out.println(new String(result));
}
}
选择器（Selector）设计模式
选择器是 NIO 中的一个关键组件，它基于事件驱动的设计模式。选择器允许单个线程管理多个通道，通过轮询通道上的事件（如可读、可写等），提高 I/O 操作的效率。Selector 类提供了注册通道和监听事件的方法。
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.*;
import java.util.Iterator;
import java.util.Set;
public class SelectorExample {
public static void main(String[] args) {
try {
// 创建 Selector
Selector selector = Selector.open();
// 创建 ServerSocketChannel 并绑定端口
ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
serverSocketChannel.bind(new InetSocketAddress(8080));
serverSocketChannel.configureBlocking(false);
// 将 ServerSocketChannel 注册到 Selector 上，监听连接事件
serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
while (true) {
int readyChannels = selector.select();
if (readyChannels == 0) continue;
Set<SelectionKey> selectedKeys = selector.selectedKeys();
Iterator<SelectionKey> keyIterator = selectedKeys.iterator();
while (keyIterator.hasNext()) {
SelectionKey key = keyIterator.next();
if (key.isAcceptable()) {
ServerSocketChannel serverChannel = (ServerSocketChannel) key.channel();
SocketChannel clientChannel = serverChannel.accept();
clientChannel.configureBlocking(false);
clientChannel.register(selector, SelectionKey.OP_READ);
} else if (key.isReadable()) {
SocketChannel clientChannel = (SocketChannel) key.channel();
ByteBuffer buffer = ByteBuffer.allocate(1024);
int bytesRead = clientChannel.read(buffer);
if (bytesRead > 0) {
buffer.flip();
byte[] data = new byte[buffer.remaining()];
buffer.get(data);
System.out.println("Received: " + new String(data));
}
}
keyIterator.remove();
}
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
在上述代码中，Selector 不断轮询注册的通道上的事件，当有事件发生时，相应的处理逻辑被执行。这种设计模式大大提高了 I/O 操作的效率，尤其是在处理大量并发连接时。
Java NIO 的实现细节
通道的实现
FileChannel：FileChannel用于文件的 I/O 操作。它提供了诸如读取、写入、映射文件等方法。通过FileOutputStream、FileInputStream或RandomAccessFile的getChannel()方法可以获取FileChannel。
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
public class FileChannelExample {
public static void main(String[] args) {
try {
FileInputStream fileInputStream = new FileInputStream("source.txt");
FileOutputStream fileOutputStream = new FileOutputStream("destination.txt");
FileChannel inputChannel = fileInputStream.getChannel();
FileChannel outputChannel = fileOutputStream.getChannel();
ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
while (inputChannel.read(byteBuffer) != -1) {
byteBuffer.flip();
outputChannel.write(byteBuffer);
byteBuffer.clear();
}
inputChannel.close();
outputChannel.close();
fileInputStream.close();
fileOutputStream.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
SocketChannel和ServerSocketChannel：SocketChannel用于客户端套接字 I/O，ServerSocketChannel用于服务器端监听连接。它们支持非阻塞 I/O 操作，可以通过配置configureBlocking(false)来实现。
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SocketChannel;
public class SocketChannelExample {
public static void main(String[] args) {
try {
SocketChannel socketChannel = SocketChannel.open();
socketChannel.connect(new InetSocketAddress("localhost", 8080));
String message = "Hello, Server!";
ByteBuffer byteBuffer = ByteBuffer.wrap(message.getBytes());
socketChannel.write(byteBuffer);
byteBuffer.clear();
socketChannel.read(byteBuffer);
byteBuffer.flip();
byte[] result = new byte[byteBuffer.remaining()];
byteBuffer.get(result);
System.out.println("Received from server: " + new String(result));
socketChannel.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
缓冲区的实现
缓冲区有几个重要的属性：容量（capacity）、位置（position）和限制（limit）。容量是缓冲区的总大小，位置表示当前读写的位置，限制表示缓冲区中有效数据的截止位置。不同类型的缓冲区在实现上有各自的特点，但基本操作原理相似。
例如，ByteBuffer 除了基本的读写方法外，还提供了一些方便的方法，如 asCharBuffer() 将 ByteBuffer 转换为 CharBuffer，方便处理字符数据。
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
public class ByteBufferConversionExample {
public static void main(String[] args) {
String message = "Hello, Conversion!";
ByteBuffer byteBuffer = ByteBuffer.wrap(message.getBytes());
CharBuffer charBuffer = byteBuffer.asCharBuffer();
System.out.println(charBuffer.toString());
}
}
Java I/O 与 NIO 的比较
性能比较
- 传统 I/O：传统 I/O 是阻塞式的，在进行 I/O 操作时，线程会被阻塞，直到操作完成。这在处理大量并发连接时，会导致线程资源的浪费，性能较低。例如，在一个服务器应用中，如果使用传统 I/O 处理多个客户端连接，每个连接都需要一个单独的线程来处理 I/O，随着连接数的增加，线程开销会变得非常大。
- NIO：NIO 支持非阻塞 I/O，通过选择器可以用一个线程管理多个通道的 I/O 操作。这大大提高了 I/O 操作的效率，尤其适用于高并发场景。例如，在一个基于 NIO 的服务器应用中，一个线程可以处理成百上千个客户端连接的 I/O 事件，减少了线程资源的开销。
设计模式与编程模型比较
- 传统 I/O：传统 I/O 基于流的设计，使用装饰器模式来动态添加功能。其编程模型相对简单，适合处理简单的 I/O 任务。但在处理复杂的 I/O 场景，如并发 I/O 时，代码会变得复杂且难以维护。
- NIO：NIO 基于通道和缓冲区的设计，采用事件驱动的编程模型。通道和缓冲区的设计模式提供了更灵活和高效的数据处理方式。事件驱动的编程模型使得代码在处理高并发 I/O 时更加简洁和易于维护。
实际应用场景
Java I/O 的应用场景
- 简单文件操作：对于简单的文件读写操作，如读取配置文件、写入日志文件等，Java I/O 提供了简单易用的接口。例如，使用
FileReader和FileWriter可以方便地读写文本文件。
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
public class SimpleFileOperation {
public static void main(String[] args) {
try {
FileReader fileReader = new FileReader("config.txt");
FileWriter fileWriter = new FileWriter("log.txt");
int data;
while ((data = fileReader.read()) != -1) {
fileWriter.write(data);
}
fileReader.close();
fileWriter.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
- 小型网络应用：在一些小型的网络应用中，如简单的客户端 - 服务器通信，Java I/O 的
Socket和ServerSocket类可以满足需求。虽然它们是阻塞式的，但对于连接数较少的场景，开发简单且性能足够。
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
public class SimpleNetworkApp {
public static void main(String[] args) {
try {
ServerSocket serverSocket = new ServerSocket(8080);
Socket clientSocket = serverSocket.accept();
BufferedReader in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
PrintWriter out = new PrintWriter(clientSocket.getOutputStream(), true);
String inputLine;
while ((inputLine = in.readLine()) != null) {
System.out.println("Received: " + inputLine);
out.println("Message received: " + inputLine);
}
in.close();
out.close();
clientSocket.close();
serverSocket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
Java NIO 的应用场景
- 高并发网络服务器：在高并发的网络服务器应用中，如 Web 服务器、即时通讯服务器等，Java NIO 的非阻塞 I/O 和选择器机制可以大大提高服务器的性能和并发处理能力。通过选择器监听多个通道的事件，一个线程可以处理大量的客户端连接。
- 大数据处理：在大数据处理场景中，需要高效地处理大量的数据读写。Java NIO 的缓冲区和通道机制可以提供更高效的数据传输和处理方式。例如，在读取大文件时，可以使用
FileChannel的map()方法将文件映射到内存，提高读取效率。
import java.io.RandomAccessFile;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;
public class BigDataProcessingExample {
public static void main(String[] args) {
try {
RandomAccessFile randomAccessFile = new RandomAccessFile("bigfile.txt", "r");
FileChannel fileChannel = randomAccessFile.getChannel();
MappedByteBuffer mappedByteBuffer = fileChannel.map(FileChannel.MapMode.READ_ONLY, 0, fileChannel.size());
// 处理 mappedByteBuffer 中的数据
randomAccessFile.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
总结 Java I/O 和 NIO 的选择
在实际应用中，选择 Java I/O 还是 NIO 取决于具体的需求。如果是简单的 I/O 任务，对并发处理要求不高，Java I/O 简单易用的特点使其成为不错的选择。而对于高并发、大数据处理等对性能要求较高的场景，Java NIO 的非阻塞 I/O 和高效的数据处理机制则更为合适。同时，理解两者的设计模式和实现细节，有助于开发人员根据实际情况选择最优的解决方案，提高应用程序的性能和可维护性。