IO · NIO · Okio — 三种 I/O 模型对比

Java 传统 I/O（java.io包）的核心抽象是流（Stream）。流是一个单向的数据管道，数据像水流一样从一端流向另一端：

• InputStream / OutputStream：字节流，以 byte为单位读写
• Reader / Writer：字符流，以 char为单位读写，自动处理编码

流的特点是单向：你要么在读（InputStream），要么在写（OutputStream），一个流不能同时做两件事。

// 传统 IO：读取文件
try (FileInputStream fis = new FileInputStream("test.txt");
     BufferedInputStream bis = new BufferedInputStream(fis)) {

    byte[] buffer = new byte[1024];
    int bytesRead;
    while ((bytesRead = bis.read(buffer)) != -1) {
        // 处理读取到的数据
        System.out.write(buffer, 0, bytesRead);
    }

} catch (IOException e) {
    e.printStackTrace();
}

// 传统 IO：写入文件
try (FileOutputStream fos = new FileOutputStream("output.txt");
     BufferedOutputStream bos = new BufferedOutputStream(fos)) {

    bos.write("Hello World".getBytes());
    bos.flush();  // 缓冲流需要手动 flush

} catch (IOException e) {
    e.printStackTrace();
}

传统 IO 大量使用装饰器模式来叠加功能：基础流负责原始读写，装饰流负责增强（缓冲、转换、过滤等）。

每个装饰器都是一层包装，像洋葱皮一样层层包裹，每层增加一种能力。优点是灵活组合，缺点是类爆炸——想加个缓冲就得套一层。

NIO（java.nio包，Java 1.4 引入）用 Channel（通道）替代了 Stream。Channel 和 Stream 最大的区别：

• Channel 是双向的：同一个 Channel 可以同时读和写（比如 SocketChannel）
• Channel 必须通过 Buffer 读写：你不能直接从 Channel 读数据到字节数组，必须经过 Buffer 中转
• Channel 支持非阻塞模式（仅限网络 Channel）

// NIO：读取文件（必须通过 Buffer）
try (FileChannel channel = FileChannel.open(
        Path.of("test.txt"),
        StandardOpenOption.READ)) {

    // 1. 分配一个 Buffer（必须！）
    ByteBuffer buffer = ByteBuffer.allocate(1024);

    // 2. 从 Channel 读 → 数据写入 Buffer
    int bytesRead = channel.read(buffer);

    // 3. 翻转 Buffer：写模式 → 读模式
    buffer.flip();

    // 4. 从 Buffer 中取出数据
    byte[] data = new byte[buffer.remaining()];
    buffer.get(data);
    System.out.write(data);

} catch (IOException e) {
    e.printStackTrace();
}

// NIO：写入文件
try (FileChannel channel = FileChannel.open(
        Path.of("output.txt"),
        StandardOpenOption.WRITE,
        StandardOpenOption.CREATE)) {

    ByteBuffer buffer = ByteBuffer.wrap("Hello World".getBytes());
    channel.write(buffer);  // Buffer → Channel → 文件

} catch (IOException e) {
    e.printStackTrace();
}

NIO 的 I/O 操作永远是Channel ↔ Buffer的双向交互。没有 Buffer，Channel 什么也做不了：

每个 NIO Buffer 内部都维护了三个关键指针，它们控制着 Buffer 的读写行为。理解这三个属性是用好 NIO 的前提：

三者关系恒满足：0 ≤ position ≤ limit ≤ capacity

Buffer 在写模式和读模式之间切换，关键操作就是 flip()：

// flip() 的等价逻辑
// 写模式 → 读模式
buffer.flip();
// 等价于：
// limit = position;   // 记录写了多少数据
// position = 0;       // 从头开始读

// 读模式 → 写模式（清空重置）
buffer.clear();
// 等价于：
// position = 0;
// limit = capacity;   // 重新允许写满

// 读模式 → 写模式（保留未读数据，继续写）
buffer.compact();
// 把未读数据移到开头，position 指向未读数据末尾

一个常见的误解是"NIO 就是非阻塞 IO"。实际上：

更关键的限制是：

非阻塞模式必须配合 Selector（选择器）使用才有意义。Selector 像一个大管家，同时监听多个 Channel，哪个 Channel 就绪了就处理哪个：

Okio 是 Square 公司开源的 I/O 库，现在也是 OkHttp 的底层 I/O 引擎。与 NIO 另起炉灶不同，Okio 回归了 Stream 模型，但重新设计了 API：

• Source（源）：对应"输入"，负责读取数据，等价于 InputStream
• Sink（汇）：对应"输出"，负责写入数据，等价于 OutputStream
• 单向设计：Source 只管读，Sink 只管写，和传统 IO 一样单向

Okio 提供了两种使用方式——需要 Buffer 时手动操作，不需要时直接用便捷方法：

// 风格一：手动操作 Buffer（需要精细控制时）
private static void io() {
    try (Source source = Okio.source(new File(path))) {
        Buffer buffer = new Buffer();
        // 从 Source → Buffer（读 1024 字节到 Buffer）
        source.read(buffer, 1024);
        // 从 Buffer → 目标（读一行 UTF-8 文本）
        String line = buffer.readUtf8Line();
        System.out.println(line);

    } catch (FileNotFoundException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    }
}

// 风格二：用 BufferedSource 包装（更简洁，推荐）
private static void io() {
    try (BufferedSource source = Okio.buffer(
            Okio.source(new File(path)))) {
        // 一行代码搞定，Buffer 被封装在内部
        System.out.println(source.readUtf8Line());

    } catch (FileNotFoundException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    }
}

Okio 底层仍然基于 Java 的 InputStream / OutputStream。你可以随时在 Okio 和传统 IO 之间转换：

// InputStream → Okio Source
Source source = Okio.source(inputStream);

// OutputStream → Okio Sink
Sink sink = Okio.sink(outputStream);

// Okio Source → InputStream
InputStream is = Okio.buffer(source).inputStream();

// Okio Sink → OutputStream
OutputStream os = Okio.buffer(sink).outputStream();

这意味着 Okio 不是一个全新的 I/O 框架，而是对传统 IO 的上层封装和增强。

和 NIO 的 ByteBuffer 相比，Okio 的 Buffer 在设计哲学上有三个本质不同：

Okio Buffer 提供了非常丰富的高级方法，不需要手动 flip/clear：

Buffer buffer = new Buffer();

// 写入数据
buffer.writeUtf8("Hello World");
buffer.writeInt(42);
buffer.writeByte(0x0A);
buffer.write(ByteString.encodeUtf8("更多数据"));

// 读取数据
String line = buffer.readUtf8Line();    // 读一行
int num = buffer.readInt();             // 读一个 int
byte b = buffer.readByte();             // 读一个字节
ByteString bs = buffer.readByteString();// 读一个 ByteString

// 无需 flip()！Buffer 内部自动管理读写位置
// 也无需 clear()！读完的数据自动消费掉

这是 NIO 和 Okio 最容易被忽略但最重要的区别：

这看起来让人困惑，但其实取决于你的视角——你是站在 Buffer 的立场，还是站在程序的立场：

Okio 确实是 Java IO 的上层封装，但它不只是"包了一层皮"，而是做了很多实质性的改进：

Okio 也可以基于 NIO 的 Channel 工作吗？不能直接基于 Channel，但可以间接适配：

// Okio 不能直接包装 Channel，但可以这样桥接
// 方式一：通过 InputStream 桥接
SocketChannel channel = ...;
InputStream is = Channels.newInputStream(channel);
Source source = Okio.source(is);

// 方式二：Okio 直接支持 Socket（底层还是 Stream）
Socket socket = ...;
Source source = Okio.source(socket);
Sink sink = Okio.sink(socket);

NIO 和 Okio 都建立在传统 IO 之上，但走向了不同的方向