Java Netty

NIO 基础

non Blocking IO 非阻塞 IO

1、三大组件

1.1 Channel & Buffer

channel 有一点类似于 stream，它就是读写数据的双向通道，可以从 channel 将数据读入 buffer，也可以将 buffer 的数据写入 channel，而之前的 stream 要么是写入，要么是输出。
常见的 Channel 有：

  • FileChannel
  • DatagramChannel
  • SocketChannel
  • ServerSocketChannel

buffer 则用来缓冲读写数据，常见的 buffer 有：

  • ByteBuffer
    • MappedByteBuffer
    • DirectByteBuffer
    • HeapByteBuffer

  • Short/Int/Long/Float/Double/Char Buffer

    1.2 Selector

    使用多线程技术

    为每个连接分别开辟一个线程，分别去处理对应的 socket 连接
    Netty入门 - 图1
    exclamation: 多线程缺点

  • 内存占用高

  • 线程上下文切换成本高

  • 只适合连接数较少的场景

    使用线程池技术

    使用线程池，让线程池中的线程去处理连接
    Netty入门 - 图2
    这种方式存在以下几个问题：

  • 阻塞模式下，线程仅能处理一个连接

  • 仅适合短连接场景

    使用 Selector

    selector 的作用就是配合一个线程来管理多个 channel（fileChannel 因为是阻塞式的，所以无法使用 selector），获取这些 channel 上发生的事件，这些 channel 工作在非阻塞模式下，当一个 channel 中没有执行任务时，可以去执行其他 channel 中的任务。适合连接数多，但流量较少的场景。
    Netty入门 - 图3
    若事件未就绪，调用 selector 的 select() 方法会阻塞线程，直到 channel 发生了就绪事件。这些事件就绪后，select() 方法就会返回这些事件交给 thread 来处理。

    2、ByteBuffer

    使用案例
    有一普通文本文件 data.txt 内容为
    1. 1234567890abc
    使用 FileChannel 来读取文件内容
    1. @Slf4j
    2. public class TestByteBuffer {
    3.   public static void main(String[] args) {
    4.       // FileChannel
    5.       // 1.输入输出流 2.RandomAccessFile
    6.       try {
    7.           FileChannel fileChannel = new FileInputStream("data.txt").getChannel();
    8.           // 准备缓冲区
    9.           ByteBuffer buf = ByteBuffer.allocate(10);
    10.           // 从 Channel 中读取数据，向 Buffer 写入
    11.           int len;
    12.           while ((len = fileChannel.read(buf)) != -1) {
    13.               log.info("读取到的字节：{}", len);
    14.               buf.flip(); // 切换至读模式
    15.               log.debug("输出内容为：{}", new String(buf.array(), 0, len));
    16. //                while (buf.hasRemaining()) { // 是否还剩余数据
    17. //                    byte b = buf.get();
    18. //                    log.debug("输出内容为：{}", (char) b);
    19. //                }
    20.               // 切换为写模式
    21.               buf.clear();
    22.           }
    23.       } catch (IOException e) {
    24.           e.printStackTrace();
    25.       }
    26.   }
    27. }

    2.1 ByteBuffer 使用步骤

  1. 向 buffer 写入数据，e.g. 调用 channel.read(buf)
  2. 调用 flip() 切换至读模式
  3. 向 buffer 读取数据，e.g. 调用 buf.get()
  4. 调用 clear() 或 compact() 切换至写模式
  5. 重复 1~4 步骤

    2.2 ByteBuffer 结构

    核心属性

    字节缓冲区的父类 Buffer 中有几个核心属性，如下：
    1. // Invariants: mark <= position <= limit <= capacity
    2. private int mark = -1;
    3. private int position = 0;
    4. private int limit;
    5. private int capacity;
  • capacity：缓冲区的容量。通过构造函数赋予，一旦设置，无法更改。
  • limit：缓冲区的界限。位于 limit 后的数据不可读写。缓冲的限制不能为负，并且不能大于其容量。
  • position：下一个读写位置的索引（类似 PC）。缓冲区的位置不能为负，并且不能大于 limit。

  • mark：记录当前 position 的值。position 被改变后，可以通过调用 reset() 方法恢复到 mark 的位置。

    核心方法：

    put() 方法

  • put() 方法可以将一个数据放入缓冲区

  • 进行该操作后，position 的值会 +1，指向下一个可以放入的位置。capacity = limit。

flip() 方法

  • flip() 方法会切换对缓冲区的操作模式，由写 -> 读 / 读 -> 写
  • 进行该操作后
    • 如果是 写模式 -> 读模式，position = 0，limit 指向最后一个元素的下一个位置，capacity 不变
    • 如果是读 -> 写，则恢复为 put() 方法中的值

get()方法

  • get() 方法会读取缓冲区中的一个值
  • 进行该操作后，position 会 +1，如果超过了 limit 则会抛出异常
  • 注意：get(i)方法不会改变 position 的值

rewind() 方法

  • 该方法只能在读写模式下使用
  • rewind() 方法后，会恢复 position、limit 和 capacity 的值，变为进行 get() 前的值

clean() 方法

  • clean() 方法会将缓冲区中的各个属性恢复为最初的状态，position = 0，capacity = limit
  • 此时，缓冲区的数据依然存在，处于“被遗忘”状态，下次进行写操作时会覆盖这些数据

mark()和reset()方法

  • mark() 方法会将 position 的值保存到 mark 属性中
  • reset() 方法会将 position 的值改为 mark 中保存的值

compact() 方法
此方法为 ByteBuffer 的方法，而不是 Buffer 的方法

  • compact() 会把未读完的数据向前压缩，然后切换到写模式

  • 数据前移后，原位置的值并未清零，写时会覆盖之前的值

    2.3 ByteBuffer 结构

    ByteBuffer 有以下重要属性

  • capacity

  • position
  • limit

刚开始
0021
写模式下，position 是写入位置，limit 等于容量，下图表示写入了 4 个字节后的状态。
0018
flip 动作发生后，position 切换为读取位置，limit 切换为读取限制。
Netty入门 - 图6
读取 4 个 byte 后，状态：
Netty入门 - 图7
clear 动作发生后，状态变为一开始。
compact() 方法，是把未读完的部分向前压缩，然后切换至写模式。
Netty入门 - 图8

💡 调试工具类

导入依赖：

  1. <dependency>
  2.   <groupId>io.netty</groupId>
  3.   <artifactId>netty-all</artifactId>
  4.   <version>4.1.51.Final</version>
  5. </dependency>
  1. public class ByteBufferUtil {
  2.     private static final char[] BYTE2CHAR = new char[256];
  3.     private static final char[] HEXDUMP_TABLE = new char[256 * 4];
  4.     private static final String[] HEXPADDING = new String[16];
  5.     private static final String[] HEXDUMP_ROWPREFIXES = new String[65536 >>> 4];
  6.     private static final String[] BYTE2HEX = new String[256];
  7.     private static final String[] BYTEPADDING = new String[16];
  9.     static {
  10.         final char[] DIGITS = "0123456789abcdef".toCharArray();
  11.         for (int i = 0; i < 256; i++) {
  12.             HEXDUMP_TABLE[i << 1] = DIGITS[i >>> 4 & 0x0F];
  13.             HEXDUMP_TABLE[(i << 1) + 1] = DIGITS[i & 0x0F];
  14.         }
  16.         int i;
  18.         // Generate the lookup table for hex dump paddings
  19.         for (i = 0; i < HEXPADDING.length; i++) {
  20.             int padding = HEXPADDING.length - i;
  21.             StringBuilder buf = new StringBuilder(padding * 3);
  22.             for (int j = 0; j < padding; j++) {
  23.                 buf.append("   ");
  24.             }
  25.             HEXPADDING[i] = buf.toString();
  26.         }
  28.         // Generate the lookup table for the start-offset header in each row (up to 64KiB).
  29.         for (i = 0; i < HEXDUMP_ROWPREFIXES.length; i++) {
  30.             StringBuilder buf = new StringBuilder(12);
  31.             buf.append(NEWLINE);
  32.             buf.append(Long.toHexString(i << 4 & 0xFFFFFFFFL | 0x100000000L));
  33.             buf.setCharAt(buf.length() - 9, '|');
  34.             buf.append('|');
  35.             HEXDUMP_ROWPREFIXES[i] = buf.toString();
  36.         }
  38.         // Generate the lookup table for byte-to-hex-dump conversion
  39.         for (i = 0; i < BYTE2HEX.length; i++) {
  40.             BYTE2HEX[i] = ' ' + StringUtil.byteToHexStringPadded(i);
  41.         }
  43.         // Generate the lookup table for byte dump paddings
  44.         for (i = 0; i < BYTEPADDING.length; i++) {
  45.             int padding = BYTEPADDING.length - i;
  46.             StringBuilder buf = new StringBuilder(padding);
  47.             for (int j = 0; j < padding; j++) {
  48.                 buf.append(' ');
  49.             }
  50.             BYTEPADDING[i] = buf.toString();
  51.         }
  53.         // Generate the lookup table for byte-to-char conversion
  54.         for (i = 0; i < BYTE2CHAR.length; i++) {
  55.             if (i <= 0x1f || i >= 0x7f) {
  56.                 BYTE2CHAR[i] = '.';
  57.             } else {
  58.                 BYTE2CHAR[i] = (char) i;
  59.             }
  60.         }
  61.     }
  63.     /**
  64.      * 打印所有内容
  65.      * @param buffer
  66.      */
  67.     public static void debugAll(ByteBuffer buffer) {
  68.         int oldlimit = buffer.limit();
  69.         buffer.limit(buffer.capacity());
  70.         StringBuilder origin = new StringBuilder(256);
  71.         appendPrettyHexDump(origin, buffer, 0, buffer.capacity());
  72.         System.out.println("+--------+-------------------- all ------------------------+----------------+");
  73.         System.out.printf("position: [%d], limit: [%d]\n", buffer.position(), oldlimit);
  74.         System.out.println(origin);
  75.         buffer.limit(oldlimit);
  76.     }
  78.     /**
  79.      * 打印可读取内容
  80.      * @param buffer
  81.      */
  82.     public static void debugRead(ByteBuffer buffer) {
  83.         StringBuilder builder = new StringBuilder(256);
  84.         appendPrettyHexDump(builder, buffer, buffer.position(), buffer.limit() - buffer.position());
  85.         System.out.println("+--------+-------------------- read -----------------------+----------------+");
  86.         System.out.printf("position: [%d], limit: [%d]\n", buffer.position(), buffer.limit());
  87.         System.out.println(builder);
  88.     }
  90.     private static void appendPrettyHexDump(StringBuilder dump, ByteBuffer buf, int offset, int length) {
  91.         if (isOutOfBounds(offset, length, buf.capacity())) {
  92.             throw new IndexOutOfBoundsException(
  93.                     "expected: " + "0 <= offset(" + offset + ") <= offset + length(" + length
  94.                             + ") <= " + "buf.capacity(" + buf.capacity() + ')');
  95.         }
  96.         if (length == 0) {
  97.             return;
  98.         }
  99.         dump.append(
  100.                 "         +-------------------------------------------------+" +
  101.                         NEWLINE + "         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |" +
  102.                         NEWLINE + "+--------+-------------------------------------------------+----------------+");
  104.         final int startIndex = offset;
  105.         final int fullRows = length >>> 4;
  106.         final int remainder = length & 0xF;
  108.         // Dump the rows which have 16 bytes.
  109.         for (int row = 0; row < fullRows; row++) {
  110.             int rowStartIndex = (row << 4) + startIndex;
  112.             // Per-row prefix.
  113.             appendHexDumpRowPrefix(dump, row, rowStartIndex);
  115.             // Hex dump
  116.             int rowEndIndex = rowStartIndex + 16;
  117.             for (int j = rowStartIndex; j < rowEndIndex; j++) {
  118.                 dump.append(BYTE2HEX[getUnsignedByte(buf, j)]);
  119.             }
  120.             dump.append(" |");
  122.             // ASCII dump
  123.             for (int j = rowStartIndex; j < rowEndIndex; j++) {
  124.                 dump.append(BYTE2CHAR[getUnsignedByte(buf, j)]);
  125.             }
  126.             dump.append('|');
  127.         }
  129.         // Dump the last row which has less than 16 bytes.
  130.         if (remainder != 0) {
  131.             int rowStartIndex = (fullRows << 4) + startIndex;
  132.             appendHexDumpRowPrefix(dump, fullRows, rowStartIndex);
  134.             // Hex dump
  135.             int rowEndIndex = rowStartIndex + remainder;
  136.             for (int j = rowStartIndex; j < rowEndIndex; j++) {
  137.                 dump.append(BYTE2HEX[getUnsignedByte(buf, j)]);
  138.             }
  139.             dump.append(HEXPADDING[remainder]);
  140.             dump.append(" |");
  142.             // Ascii dump
  143.             for (int j = rowStartIndex; j < rowEndIndex; j++) {
  144.                 dump.append(BYTE2CHAR[getUnsignedByte(buf, j)]);
  145.             }
  146.             dump.append(BYTEPADDING[remainder]);
  147.             dump.append('|');
  148.         }
  150.         dump.append(NEWLINE +
  151.                 "+--------+-------------------------------------------------+----------------+");
  152.     }
  154.     private static void appendHexDumpRowPrefix(StringBuilder dump, int row, int rowStartIndex) {
  155.         if (row < HEXDUMP_ROWPREFIXES.length) {
  156.             dump.append(HEXDUMP_ROWPREFIXES[row]);
  157.         } else {
  158.             dump.append(NEWLINE);
  159.             dump.append(Long.toHexString(rowStartIndex & 0xFFFFFFFFL | 0x100000000L));
  160.             dump.setCharAt(dump.length() - 9, '|');
  161.             dump.append('|');
  162.         }
  163.     }
  165.     public static short getUnsignedByte(ByteBuffer buffer, int index) {
  166.         return (short) (buffer.get(index) & 0xFF);
  167.     }
  168. }

测试：

  1. public static void main(String[] args) {
  2.     ByteBuffer buffer = ByteBuffer.allocate(16);
  3.     // 向 buffer 写入一个数据
  4.     buffer.put((byte) 97);
  5.     debugAll(buffer);
  6.     // 获取数据
  7.     buffer.flip();
  8.     debugAll(buffer);
  9.     System.out.println((char) buffer.get());
  10.     debugAll(buffer);
  11.     // 使用 compact() 切换模式
  12.     buffer.compact();
  13.     debugAll(buffer);
  14.     // 再次写入
  15.     buffer.put((byte) 98);
  16.     buffer.put((byte) 99);
  17.     debugAll(buffer);
  19. }

结果：

  1. 10:01:36.720 [main] DEBUG io.netty.util.internal.logging.InternalLoggerFactory - Using SLF4J as the default logging framework
  2. +--------+-------------------- all ------------------------+----------------+
  3. position: [1], limit: [16]
  4.          +-------------------------------------------------+
  5.          |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
  6. +--------+-------------------------------------------------+----------------+
  7. |00000000| 61 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 |a...............|
  8. +--------+-------------------------------------------------+----------------+
  9. +--------+-------------------- all ------------------------+----------------+
  10. position: [0], limit: [1]
  11.          +-------------------------------------------------+
  12.          |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
  13. +--------+-------------------------------------------------+----------------+
  14. |00000000| 61 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 |a...............|
  15. +--------+-------------------------------------------------+----------------+
  16. a
  17. +--------+-------------------- all ------------------------+----------------+
  18. position: [1], limit: [1]
  19.          +-------------------------------------------------+
  20.          |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
  21. +--------+-------------------------------------------------+----------------+
  22. |00000000| 61 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 |a...............|
  23. +--------+-------------------------------------------------+----------------+
  24. +--------+-------------------- all ------------------------+----------------+
  25. position: [0], limit: [16]
  26.          +-------------------------------------------------+
  27.          |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
  28. +--------+-------------------------------------------------+----------------+
  29. |00000000| 61 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 |a...............|
  30. +--------+-------------------------------------------------+----------------+
  31. +--------+-------------------- all ------------------------+----------------+
  32. position: [2], limit: [16]
  33.          +-------------------------------------------------+
  34.          |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
  35. +--------+-------------------------------------------------+----------------+
  36. |00000000| 62 63 00 00 00 00 00 00 00 00 00 00 00 00 00 00 |bc..............|
  37. +--------+-------------------------------------------------+----------------+

2.4 ByBuffer 常见方法

分配空间 allocate()

  1. ByteBuffer buf = ByteBuffer.allocate(16);

向 buffer 写入数据

  • 调用 channel 的 read() 方法

  • 调用 buffer 的 put() 方法

    1. int read = channel.read(buf);
    2. // 第二种
    3. buf.put((byte) 97);

    从 buffer 读取数据

  • 调用 channel 的 write() 方法

  • 调用 buffer 的 get() 方法

    1. int writeBytes = channel.write(buf);
    2. byte b = buf.get();

    get() 方法会让 position 读指针后移，如果想重复读取数据

  • 可以调用 rewind() 方法将 position 重置为 0。

    1. public final Buffer rewind() {
    2.   position = 0;
    3.   mark = -1;
    4.   return this;
    5. }

  • 或者调用 get(int i) 获取索引 i 的内容，不会移动读指针。

mark() and reset()
mark 是在读取时，做一个标记，即使 position 改变，只要调用 reset 就能够回到 mark 的位置
注意：
rewind() 和 flip() 都会清楚 mark 位置。
字符串与 ByteBuffer 互转

  1. // 字符串与 ByteBuffer 互转
  2. // 1.还是写模式
  3. byte[] bytes = "hello".getBytes();
  4. ByteBuffer buf2 = ByteBuffer.allocate(16);
  5. buf2.put(bytes);
  6. debugAll(buf2);
  7. // 2.Charset，切换到读模式
  8. ByteBuffer buf3 = StandardCharsets.UTF_8.encode("hello");
  9. debugAll(buf3);
  10. // 3.wrap() 方法，切换到读模式
  11. ByteBuffer buf4 = ByteBuffer.wrap("hello".getBytes());
  12. debugAll(buf4);
  13. System.out.println((char) buf4.get()); // h
  15. // ByteBuffer --> String
  16. String buf2Str = StandardCharsets.UTF_8.decode(buf3).toString();
  17. System.out.println(buf2Str);

Buffer 的线程安全
Buffer 是非线程安全的。

2.5 Scattering Reads

分散读取，有一个文本文件

  1. onttwothree

使用如下方式读取，可以将数据填充至多个 buffer

  1. // 分散读取
  2. try {
  3.     FileChannel channel = new RandomAccessFile("words.txt", "r").getChannel();
  4.     ByteBuffer buf1 = ByteBuffer.allocate(3);
  5.     ByteBuffer buf2 = ByteBuffer.allocate(3);
  6.     ByteBuffer buf3 = ByteBuffer.allocate(5);
  7.     channel.read(new ByteBuffer[]{buf1, buf2, buf3});
  8.     buf1.flip();
  9.     buf2.flip();
  10.     buf3.flip();
  11.     debugAll(buf1);
  12.     debugAll(buf2);
  13.     debugAll(buf3);
  14. } catch (IOException e) {
  15.     e.printStackTrace();
  16. }
  1. 12:58:55.475 [main] DEBUG io.netty.util.internal.logging.InternalLoggerFactory - Using SLF4J as the default logging framework
  2. +--------+-------------------- all ------------------------+----------------+
  3. position: [0], limit: [3]
  4.          +-------------------------------------------------+
  5.          |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
  6. +--------+-------------------------------------------------+----------------+
  7. |00000000| 6f 6e 65                                        |one             |
  8. +--------+-------------------------------------------------+----------------+
  9. +--------+-------------------- all ------------------------+----------------+
  10. position: [0], limit: [3]
  11.          +-------------------------------------------------+
  12.          |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
  13. +--------+-------------------------------------------------+----------------+
  14. |00000000| 74 77 6f                                        |two             |
  15. +--------+-------------------------------------------------+----------------+
  16. +--------+-------------------- all ------------------------+----------------+
  17. position: [0], limit: [5]
  18.          +-------------------------------------------------+
  19.          |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
  20. +--------+-------------------------------------------------+----------------+
  21. |00000000| 74 68 72 65 65                                  |three           |
  22. +--------+-------------------------------------------------+----------------+

2.6 Gathering Writes

  1. try {
  2.     RandomAccessFile file = new RandomAccessFile("words2.txt", "rw");
  3.     FileChannel channel = file.getChannel();
  4.     ByteBuffer buf = ByteBuffer.allocate(4);
  5.     ByteBuffer buf2 = ByteBuffer.allocate(4);
  6.     channel.position(11);
  7.     buf.put(new byte[]{'f', 'o', 'u', 'r'});
  8.     buf2.put(new byte[]{'f', 'i', 'v', 'e'});
  9.     buf.flip();
  10.     buf2.flip();
  11.     debugAll(buf);
  12.     debugAll(buf2);
  13.     channel.write(new ByteBuffer[]{buf, buf2});
  14. } catch (IOException e) {
  15.     e.printStackTrace();
  16. }
  1. 13:05:19.694 [main] DEBUG io.netty.util.internal.logging.InternalLoggerFactory - Using SLF4J as the default logging framework
  2. +--------+-------------------- all ------------------------+----------------+
  3. position: [0], limit: [4]
  4.          +-------------------------------------------------+
  5.          |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
  6. +--------+-------------------------------------------------+----------------+
  7. |00000000| 66 6f 75 72                                     |four            |
  8. +--------+-------------------------------------------------+----------------+
  9. +--------+-------------------- all ------------------------+----------------+
  10. position: [0], limit: [4]
  11.          +-------------------------------------------------+
  12.          |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
  13. +--------+-------------------------------------------------+----------------+
  14. |00000000| 66 69 76 65                                     |five            |
  15. +--------+-------------------------------------------------+----------------+

2.7 粘包、半包现象

网络上有多条数据发送给服务端，数据之间使用 \n 进行分隔；但由于某种原因这些数据在接收时，被进行了重新组合，例如原始数据有 3 条为：

  1. hello, world\n
  2. I'm zhangsan\n
  3. How are you?\n

变成了下面的两个 ByteBuffer

  1. hello, world\nI'm zhangsan\nHo
  2. w are you?\n

要求编写程序，将错乱的数据恢复成原始的 \n 分隔的数据。

  1. public static void main(String[] args) {
  2.     // 黏包、半包
  3.     ByteBuffer source = ByteBuffer.allocate(32);
  4.     source.put("Hello, world\nI'm zhangsan\nHo".getBytes());
  5.     split(source);
  6.     source.put("w are you?\n".getBytes());
  7.     split(source);
  8. }
  10. private static void split(ByteBuffer source) {
  11.     // 传进来的参数是写模式，切换到读模式
  12.     source.flip();
  13.     for (int i = 0; i < source.limit(); i++) {
  14.         if (source.get(i) == '\n') {
  15.             int len = i + 1 - source.position();
  16.             // 把这条完整的消息写入到新的 ByteBuffer
  17.             ByteBuffer target = ByteBuffer.allocate(len);
  18.             for (int j = 0; j < len; j++) {
  19.                 target.put(source.get());
  20.             }
  21.             debugAll(target);
  22.         }
  23.     }
  24.     // 切换到写模式，有些数据被拆分，所以使用 compact()
  25.     source.compact();
  26. }
  1. 13:26:33.581 [main] DEBUG io.netty.util.internal.logging.InternalLoggerFactory - Using SLF4J as the default logging framework
  2. +--------+-------------------- all ------------------------+----------------+
  3. position: [13], limit: [13]
  4.          +-------------------------------------------------+
  5.          |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
  6. +--------+-------------------------------------------------+----------------+
  7. |00000000| 48 65 6c 6c 6f 2c 20 77 6f 72 6c 64 0a          |Hello, world.   |
  8. +--------+-------------------------------------------------+----------------+
  9. +--------+-------------------- all ------------------------+----------------+
  10. position: [13], limit: [13]
  11.          +-------------------------------------------------+
  12.          |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
  13. +--------+-------------------------------------------------+----------------+
  14. |00000000| 49 27 6d 20 7a 68 61 6e 67 73 61 6e 0a          |I'm zhangsan.   |
  15. +--------+-------------------------------------------------+----------------+
  16. +--------+-------------------- all ------------------------+----------------+
  17. position: [13], limit: [13]
  18.          +-------------------------------------------------+
  19.          |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
  20. +--------+-------------------------------------------------+----------------+
  21. |00000000| 48 6f 77 20 61 72 65 20 79 6f 75 3f 0a          |How are you?.   |
  22. +--------+-------------------------------------------------+----------------+

3、文件编程

3.1 FileChannel

FileChannel 只能工作在阻塞模式下

获取

不能直接打开 FileChannel，必须通过 FileInputStream、FileOutputStream 或者 RandomAccessFile 来获取 FileChannel，它们都有 getChannel() 方法。

  • 通过 FileInputStream 获取的 channel 只能读
  • 通过 FileOutputStream 获取的 channel 只能写
  • 通过 RandomAccessFile 是否能读写根据构造 RandomAccessFile 时的读写模式决定。

    读取

    返回 -1 表示达到了文件的末尾。
    1. int read = channel.read(buf);

    写入

    1. ByteBuffer buf = ...;
    2. buf.put(...); // 存入数据
    3. buf.flip(); // 切换读模式
    4. while (buf.hasRemaining()) {
    5.   channel.write(buf);
    6. }
    在 while 中调用 channel.write 是因为 write 方法并不能保证一次将 buffer 中的内容全部写入 channel。

    关闭

    channel 必须关闭，不过调用了 FileInputStream、FileOutputStream 或者 RandomAccessFile 的 close 方法会间接地调用 channel 的 close 方法。

    位置

    ```java long pos = channel.position(); // 获取当前位置

long newPos = …; channel.position(newPos); // 设置当前位置

  1. 设置当前位置时，如果设置为文件的末尾
  3. - 这时会返回  `-1`
  4. - 这时写入，会追加内容，但是注意如果 position 超过了文件末尾，再写入时在新内容和原末尾之间会有空洞（00）。
  5. <a name="sikxi"></a>
  6. #### 大小
  7. ```java
  8. channel.size(); // 获取文件的大小

强制写入

操作系统出于性能的考虑，会将数据缓存，不是立刻写入磁盘。可以调用 force(true) 方法将文件内容和元数据（文件的权限等信息）立刻写入磁盘。

3.2 两个 Channel 传输数据

  1. public static void main(String[] args) {
  2.     try (FileChannel from = new FileInputStream("data.txt").getChannel();
  3.          FileChannel to = new FileOutputStream("to.txt").getChannel();
  4.         ) {
  5.         // 效率高，底层会利用操作系统的零拷贝进行优化
  6.         // from.transferTo(0, from.size(), to);
  7.         long size = from.size();
  8.         for (long left = size; left > 0; ) {
  9.             left -= from.transferTo((size - left), left, to);
  10.         }
  11.     } catch (IOException e) {
  12.         e.printStackTrace();
  13.     }
  14. }

3.3 Path

jdk7 引入了 Path 和 Paths 类

  • Path 用来表示文件路径
  • Paths 是工具类，用来获取 Path 实例
    1. Path source = Paths.get("1.txt");
    2. sout(source.normalize()); // 正常化路径

    3.4 Files

    | 方法 | 说明 | | —- | —- | | Files.exists(path) | 检查文件是否存在 | | Files.createDirectory(path) | 创建一级目录
    如果目录已存在，则抛出异常 FileAlreadyExistsException
    不能一次创建多级目录，否则会抛异常 NoSuchFileException | | Files.createDirectories(path) | 创建多及目录 | | Files.copy(Path, Path, StandardCopyOption.REPLACE_EXISTING) | 拷贝文件，如果文件已存在，抛异常 | | Files.move(source, target, StandardCopyOption.ATOMIC_MOVE); | 移动文件，StandardCopyOption.ATOMIC_MOVE 保证文件移动的原子性 | | Files.delete(target) | 删除目录，目录里面若存在内容，抛异常，DirectoryNotEmptyException |

遍历目录文件

  1. public static void main(String[] args) throws IOException {
  2.     Path path = Paths.get("E:\\BaiduNetdiskDownload\\Netty网络编程");
  3.     // 文件目录总数
  4.     AtomicInteger dirCount = new AtomicInteger();
  5.     // 文件总数
  6.     AtomicInteger fileCount = new AtomicInteger();
  7.     Files.walkFileTree(path, new SimpleFileVisitor<Path>() {
  8.         @Override
  9.         public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs) throws IOException {
  10.             System.out.println("-->" + dir);
  11.             dirCount.getAndIncrement();
  12.             return super.preVisitDirectory(dir, attrs);
  13.         }
  15.         @Override
  16.         public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
  17.             System.out.println("file: " + file);
  18.             fileCount.getAndIncrement();
  19.             return super.visitFile(file, attrs);
  20.         }
  21.     });
  22.     System.out.println("文件夹数目：" + dirCount);
  23.     System.out.println("文件数目：" + fileCount);
  24. }

SimpleFileVisitor
Netty入门 - 图9
运行结果：
Netty入门 - 图10

统计 .md 文档的数目

  1. Path path = Paths.get("E:\\BaiduNetdiskDownload\\Netty网络编程");
  2. // 统计 .md 文档数目
  3. AtomicInteger mdCnt = new AtomicInteger();
  4. Files.walkFileTree(path, new SimpleFileVisitor<Path>() {
  5.     @Override
  6.     public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
  7.         if (file.toString().endsWith(".md")) { // toFile().toString().
  8.             System.out.println(file.toString());
  9.             mdCnt.incrementAndGet();
  10.         }
  11.         return super.visitFile(file, attrs);
  12.     }
  13. });
  14. System.out.println("md文档数目：" + mdCnt);

删除多级目录

  1. Path path = Paths.get("d:\\a");
  2. Files.walkFileTree(path, new SimpleFileVisitor<Path>(){
  3.     @Override
  4.     public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) 
  5.         throws IOException {
  6.         Files.delete(file);
  7.         return super.visitFile(file, attrs);
  8.     }
  10.     @Override
  11.     public FileVisitResult postVisitDirectory(Path dir, IOException exc) 
  12.         throws IOException {
  13.         Files.delete(dir);
  14.         return super.postVisitDirectory(dir, exc);
  15.     }
  16. });

拷贝多级目录

  1. long start = System.currentTimeMillis();
  2. String source = "D:\\Snipaste-1.16.2-x64";
  3. String target = "D:\\Snipaste-1.16.2-x64aaa";
  5. Files.walk(Paths.get(source)).forEach(path -> {
  6.     try {
  7.         String targetName = path.toString().replace(source, target);
  8.         // 是目录
  9.         if (Files.isDirectory(path)) {
  10.             Files.createDirectory(Paths.get(targetName));
  11.         }
  12.         // 是普通文件
  13.         else if (Files.isRegularFile(path)) {
  14.             Files.copy(path, Paths.get(targetName));
  15.         }
  16.     } catch (IOException e) {
  17.         e.printStackTrace();
  18.     }
  19. });
  20. long end = System.currentTimeMillis();
  21. System.out.println(end - start);