一分钟搞定Netty 三大组件，如果搞不定，再看3遍

1. 三大组件简介

Channel 与 Buffer

Java NIO 系统的核心在于：通道 (Channel) 和缓冲区 (Buffer)。通道表示打开到 IO 设备 (例如：文件、套接字) 的连接。若需要使用 NIO 系统，需要获取用于连接 IO 设备的通道以及用于容纳数据的缓冲区。然后操作缓冲区，对数据进行处理

【资料图】

简而言之，通道负责传输，缓冲区负责存储

常见的 Channel 有以下四种，其中 FileChannel 主要用于文件传输，其余三种用于网络通信

• FileChannel
• DatagramChannel
• SocketChannel
• ServerSocketChannel

Buffer 有以下几种，其中使用较多的是 ByteBuffer

• ByteBuffer

  • MappedByteBuffer
  • DirectByteBuffer
  • HeapByteBuffer

• ShortBuffer

• IntBuffer

• LongBuffer

• FloatBuffer

• DoubleBuffer

• CharBuffer

1、Selector

在使用 Selector 之前，处理 socket 连接还有以下两种方法

使用多线程技术

为每个连接分别开辟一个线程，分别去处理对应的 socket 连接

这种方法存在以下几个问题

• 内存占用高
  • 每个线程都需要占用一定的内存，当连接较多时，会开辟大量线程，导致占用大量内存
• 线程上下文切换成本高
• 只适合连接数少的场景
  • 连接数过多，会导致创建很多线程，从而出现问题

使用线程池技术

使用线程池，让线程池中的线程去处理连接

这种方法存在以下几个问题

• 阻塞模式下，线程仅能处理一个连接
  • 线程池中的线程获取任务（task）后，只有当其执行完任务之后（断开连接后），才会去获取并执行下一个任务
  • 若 socke 连接一直未断开，则其对应的线程无法处理其他 socke 连接
• 仅适合短连接场景
  • 短连接即建立连接发送请求并响应后就立即断开，使得线程池中的线程可以快速处理其他连接

使用选择器

selector 的作用就是配合一个线程来管理多个 channel（fileChannel 因为是阻塞式的，所以无法使用 selector），，获取这些 channel 上发生的事件，这些 channel 工作在非阻塞模式下，当一个 channel 中没有执行任务时，可以去执行其他channel 中的任务。适合连接数多，但流量较少的场景

若事件未就绪，调用 selector 的 select () 方法会阻塞线程，直到 channel 发生了就绪事件。这些事件就绪后，select 方法就会返回这些事件交给 thread 来处理

2、ByteBuffer

使用案例

使用方式

• 向 buffer 写入数据，例如调用 channel.read (buffer)

• 调用 flip () 切换至

  读模式

  • flip 会使得 buffer 中的 limit 变为 position，position 变为 0

• 从 buffer 读取数据，例如调用 buffer.get ()

• 调用 clear () 或者 compact () 切换至

  写模式

  • 调用 clear () 方法时 position=0，limit 变为 capacity
  • 调用 compact () 方法时，会将缓冲区中的未读数据压缩到缓冲区前面

• 重复以上步骤

使用 ByteBuffer 读取文件中的内容

public class TestByteBuffer {     public static void main(String[] args) {        try (FileChannel channel = new FileInputStream("stu.txt").getChannel()){            //给缓冲区 分配空间            ByteBuffer buffer = ByteBuffer.allocate(10);            int read = 0 ;            StringBuilder builder = new StringBuilder();            while ((read =channel.read(buffer))>0){                //切换成 读模式 limit = position; position=0                buffer.flip();                while (buffer.hasRemaining()){                    builder.append((char)buffer.get());                }                //清空字节数组 切换成 写模式 position=0 ;limit = capacity                buffer.clear();            }            System.out.println(builder.toString());        } catch (Exception e) {            e.printStackTrace();        } finally {                    }    }}

打印结果：

0123456789abcdef

核心属性

字节缓冲区的父类 Buffer 中有几个核心属性，如下

// Invariants: mark <= position <= limit <= capacityprivate int mark = -1;private int position = 0;private int limit;private int capacity;

• capacity：缓冲区的容量。通过构造函数赋予，一旦设置，无法更改
• limit：缓冲区的界限。位于 limit 后的数据不可读写。缓冲区的限制不能为负，并且 不能大于其容量
• position： 下一个读写位置的索引（类似 PC）。缓冲区的位置不能为负，并且不能大于 limit
• mark：记录当前 position 的值。position 被改变后，可以通过调用 reset () 方法恢复到 mark 的位置。

以上四个属性必须满足以下要求

mark <= position <= limit <= capacity

核心方法

put () 方法

• put () 方法可以将一个数据放入到缓冲区中。
• 进行该操作后，postition 的值会 +1，指向下一个可以放入的位置。capacity = limit ，为缓冲区容量的值。

flip () 方法

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

get () 方法

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

rewind () 方法

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

clear () 方法

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

mark () 和 reset () 方法

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

compact () 方法

此方法为 ByteBuffer 的方法，而不是 Buffer 的方法

• compact 会把未读完的数据向前压缩，然后切换到写模式
• 数据前移后，原位置的值并未清零，写时会覆盖之前的值

clear() VS compact()

clear 只是对 position、limit、mark 进行重置，而 compact 在对 position 进行设置，以及 limit、mark 进行重置的同时，还涉及到数据在内存中拷贝（会调用 array）。所以 compact 比 clear 更耗性能。但 compact 能保存你未读取的数据，将新数据追加到为读取的数据之后；而 clear 则不行，若你调用了 clear，则未读取的数据就无法再读取到了

所以需要根据情况来判断使用哪种方法进行模式切换

方法调用及演示

ByteBuffer 调试工具类

需要先导入 netty 依赖

  io.netty  netty-all  4.1.51.Final

import java.nio.ByteBuffer;import io.netty.util.internal.MathUtil;import io.netty.util.internal.StringUtil;import io.netty.util.internal.MathUtil.*;public class ByteBufferUtil {    private static final char[] BYTE2CHAR = new char[256];    private static final char[] HEXDUMP_TABLE = new char[256 * 4];    private static final String[] HEXPADDING = new String[16];    private static final String[] HEXDUMP_ROWPREFIXES = new String[65536 >>> 4];    private static final String[] BYTE2HEX = new String[256];    private static final String[] BYTEPADDING = new String[16];    static {        final char[] DIGITS = "0123456789abcdef".toCharArray();        for (int i = 0; i < 256; i++) {            HEXDUMP_TABLE[i << 1] = DIGITS[i >>> 4 & 0x0F];            HEXDUMP_TABLE[(i << 1) + 1] = DIGITS[i & 0x0F];        }        int i;        // Generate the lookup table for hex dump paddings        for (i = 0; i < HEXPADDING.length; i++) {            int padding = HEXPADDING.length - i;            StringBuilder buf = new StringBuilder(padding * 3);            for (int j = 0; j < padding; j++) {                buf.append("   ");            }            HEXPADDING[i] = buf.toString();        }        // Generate the lookup table for the start-offset header in each row (up to 64KiB).        for (i = 0; i < HEXDUMP_ROWPREFIXES.length; i++) {            StringBuilder buf = new StringBuilder(12);            buf.append(StringUtil.NEWLINE);            buf.append(Long.toHexString(i << 4 & 0xFFFFFFFFL | 0x100000000L));            buf.setCharAt(buf.length() - 9, "|");            buf.append("|");            HEXDUMP_ROWPREFIXES[i] = buf.toString();        }        // Generate the lookup table for byte-to-hex-dump conversion        for (i = 0; i < BYTE2HEX.length; i++) {            BYTE2HEX[i] = " " + StringUtil.byteToHexStringPadded(i);        }        // Generate the lookup table for byte dump paddings        for (i = 0; i < BYTEPADDING.length; i++) {            int padding = BYTEPADDING.length - i;            StringBuilder buf = new StringBuilder(padding);            for (int j = 0; j < padding; j++) {                buf.append(" ");            }            BYTEPADDING[i] = buf.toString();        }        // Generate the lookup table for byte-to-char conversion        for (i = 0; i < BYTE2CHAR.length; i++) {            if (i <= 0x1f || i >= 0x7f) {                BYTE2CHAR[i] = ".";            } else {                BYTE2CHAR[i] = (char) i;            }        }    }    /**     * 打印所有内容     * @param buffer     */    public static void debugAll(ByteBuffer buffer) {        int oldlimit = buffer.limit();        buffer.limit(buffer.capacity());        StringBuilder origin = new StringBuilder(256);        appendPrettyHexDump(origin, buffer, 0, buffer.capacity());        System.out.println("+--------+-------------------- all ------------------------+----------------+");        System.out.printf("position: [%d], limit: [%d]\n", buffer.position(), oldlimit);        System.out.println(origin);        buffer.limit(oldlimit);    }    /**     * 打印可读取内容     * @param buffer     */    public static void debugRead(ByteBuffer buffer) {        StringBuilder builder = new StringBuilder(256);        appendPrettyHexDump(builder, buffer, buffer.position(), buffer.limit() - buffer.position());        System.out.println("+--------+-------------------- read -----------------------+----------------+");        System.out.printf("position: [%d], limit: [%d]\n", buffer.position(), buffer.limit());        System.out.println(builder);    }    private static void appendPrettyHexDump(StringBuilder dump, ByteBuffer buf, int offset, int length) {        if (MathUtil.isOutOfBounds(offset, length, buf.capacity())) {            throw new IndexOutOfBoundsException(                    "expected: " + "0 <= offset(" + offset + ") <= offset + length(" + length                            + ") <= " + "buf.capacity(" + buf.capacity() + ")");        }        if (length == 0) {            return;        }        dump.append(                "         +-------------------------------------------------+" +                        StringUtil.NEWLINE + "         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |" +                        StringUtil.NEWLINE + "+--------+-------------------------------------------------+----------------+");        final int startIndex = offset;        final int fullRows = length >>> 4;        final int remainder = length & 0xF;        // Dump the rows which have 16 bytes.        for (int row = 0; row < fullRows; row++) {            int rowStartIndex = (row << 4) + startIndex;            // Per-row prefix.            appendHexDumpRowPrefix(dump, row, rowStartIndex);            // Hex dump            int rowEndIndex = rowStartIndex + 16;            for (int j = rowStartIndex; j < rowEndIndex; j++) {                dump.append(BYTE2HEX[getUnsignedByte(buf, j)]);            }            dump.append(" |");            // ASCII dump            for (int j = rowStartIndex; j < rowEndIndex; j++) {                dump.append(BYTE2CHAR[getUnsignedByte(buf, j)]);            }            dump.append("|");        }        // Dump the last row which has less than 16 bytes.        if (remainder != 0) {            int rowStartIndex = (fullRows << 4) + startIndex;            appendHexDumpRowPrefix(dump, fullRows, rowStartIndex);            // Hex dump            int rowEndIndex = rowStartIndex + remainder;            for (int j = rowStartIndex; j < rowEndIndex; j++) {                dump.append(BYTE2HEX[getUnsignedByte(buf, j)]);            }            dump.append(HEXPADDING[remainder]);            dump.append(" |");            // Ascii dump            for (int j = rowStartIndex; j < rowEndIndex; j++) {                dump.append(BYTE2CHAR[getUnsignedByte(buf, j)]);            }            dump.append(BYTEPADDING[remainder]);            dump.append("|");        }        dump.append(StringUtil.NEWLINE +                "+--------+-------------------------------------------------+----------------+");    }    private static void appendHexDumpRowPrefix(StringBuilder dump, int row, int rowStartIndex) {        if (row < HEXDUMP_ROWPREFIXES.length) {            dump.append(HEXDUMP_ROWPREFIXES[row]);        } else {            dump.append(StringUtil.NEWLINE);            dump.append(Long.toHexString(rowStartIndex & 0xFFFFFFFFL | 0x100000000L));            dump.setCharAt(dump.length() - 9, "|");            dump.append("|");        }    }    public static short getUnsignedByte(ByteBuffer buffer, int index) {        return (short) (buffer.get(index) & 0xFF);    }}

调用 ByteBuffer 的方法

public class TestByteBuffer {    public static void main(String[] args) {        ByteBuffer buffer = ByteBuffer.allocate(10);        // 向buffer中写入1个字节的数据        buffer.put((byte)97);        // 使用工具类，查看buffer状态        ByteBufferUtil.debugAll(buffer);        // 向buffer中写入4个字节的数据        buffer.put(new byte[]{98, 99, 100, 101});        ByteBufferUtil.debugAll(buffer);        // 获取数据        buffer.flip();        ByteBufferUtil.debugAll(buffer);        System.out.println(buffer.get());        System.out.println(buffer.get());        ByteBufferUtil.debugAll(buffer);        // 使用compact切换模式        buffer.compact();        ByteBufferUtil.debugAll(buffer);        // 再次写入        buffer.put((byte)102);        buffer.put((byte)103);        ByteBufferUtil.debugAll(buffer);    }}

运行结果

// 向缓冲区写入了一个字节的数据，此时postition为1+--------+-------------------- all ------------------------+----------------+position: [1], limit: [10]         +-------------------------------------------------+         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |+--------+-------------------------------------------------+----------------+|00000000| 61 00 00 00 00 00 00 00 00 00                   |a.........      |+--------+-------------------------------------------------+----------------+// 向缓冲区写入四个字节的数据，此时position为5+--------+-------------------- all ------------------------+----------------+position: [5], limit: [10]         +-------------------------------------------------+         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |+--------+-------------------------------------------------+----------------+|00000000| 61 62 63 64 65 00 00 00 00 00                   |abcde.....      |+--------+-------------------------------------------------+----------------+// 调用flip切换模式，此时position为0，表示从第0个数据开始读取+--------+-------------------- all ------------------------+----------------+position: [0], limit: [5]         +-------------------------------------------------+         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |+--------+-------------------------------------------------+----------------+|00000000| 61 62 63 64 65 00 00 00 00 00                   |abcde.....      |+--------+-------------------------------------------------+----------------+// 读取两个字节的数据             9798            // position变为2             +--------+-------------------- all ------------------------+----------------+position: [2], limit: [5]         +-------------------------------------------------+         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |+--------+-------------------------------------------------+----------------+|00000000| 61 62 63 64 65 00 00 00 00 00                   |abcde.....      |+--------+-------------------------------------------------+----------------+             // 调用compact切换模式，此时position及其后面的数据被压缩到ByteBuffer前面去了// 此时position为3，会覆盖之前的数据             +--------+-------------------- all ------------------------+----------------+position: [3], limit: [10]         +-------------------------------------------------+         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |+--------+-------------------------------------------------+----------------+|00000000| 63 64 65 64 65 00 00 00 00 00                   |cdede.....      |+--------+-------------------------------------------------+----------------+             // 再次写入两个字节的数据，之前的 0x64 0x65 被覆盖         +--------+-------------------- all ------------------------+----------------+position: [5], limit: [10]         +-------------------------------------------------+         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |+--------+-------------------------------------------------+----------------+|00000000| 63 64 65 66 67 00 00 00 00 00                   |cdefg.....      |+--------+-------------------------------------------------+----------------+

字符串与 ByteBuffer 的相互转换

方法一

编码：字符串调用 getByte 方法获得 byte 数组，将 byte 数组放入 ByteBuffer 中

解码：先调用 ByteBuffer 的 flip 方法，然后通过 StandardCharsets 的 decoder 方法解码

public class Translate {    public static void main(String[] args) {        // 准备两个字符串        String str1 = "hello";        String str2 = "";        ByteBuffer buffer1 = ByteBuffer.allocate(16);        // 通过字符串的getByte方法获得字节数组，放入缓冲区中        buffer1.put(str1.getBytes());        ByteBufferUtil.debugAll(buffer1);        // 将缓冲区中的数据转化为字符串        // 切换模式        buffer1.flip();                // 通过StandardCharsets解码，获得CharBuffer，再通过toString获得字符串        str2 = StandardCharsets.UTF_8.decode(buffer1).toString();        System.out.println(str2);        ByteBufferUtil.debugAll(buffer1);    }}

运行结果

+--------+-------------------- all ------------------------+----------------+position: [5], limit: [16]         +-------------------------------------------------+         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |+--------+-------------------------------------------------+----------------+|00000000| 68 65 6c 6c 6f 00 00 00 00 00 00 00 00 00 00 00 |hello...........|+--------+-------------------------------------------------+----------------+hello+--------+-------------------- all ------------------------+----------------+position: [5], limit: [5]         +-------------------------------------------------+         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |+--------+-------------------------------------------------+----------------+|00000000| 68 65 6c 6c 6f 00 00 00 00 00 00 00 00 00 00 00 |hello...........|+--------+-------------------------------------------------+----------------+

方法二

编码：通过 StandardCharsets 的 encode 方法获得 ByteBuffer，此时获得的 ByteBuffer 为读模式，无需通过 flip 切换模式

解码：通过 StandardCharsets 的 decoder 方法解码

public class Translate {    public static void main(String[] args) {        // 准备两个字符串        String str1 = "hello";        String str2 = "";        // 通过StandardCharsets的encode方法获得ByteBuffer        // 此时获得的ByteBuffer为读模式，无需通过flip切换模式        ByteBuffer buffer1 = StandardCharsets.UTF_8.encode(str1);        ByteBufferUtil.debugAll(buffer1);        // 将缓冲区中的数据转化为字符串        // 通过StandardCharsets解码，获得CharBuffer，再通过toString获得字符串        str2 = StandardCharsets.UTF_8.decode(buffer1).toString();        System.out.println(str2);        ByteBufferUtil.debugAll(buffer1);    }}

运行结果

+--------+-------------------- all ------------------------+----------------+position: [0], limit: [5]         +-------------------------------------------------+         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |+--------+-------------------------------------------------+----------------+|00000000| 68 65 6c 6c 6f                                  |hello           |+--------+-------------------------------------------------+----------------+hello+--------+-------------------- all ------------------------+----------------+position: [5], limit: [5]         +-------------------------------------------------+         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |+--------+-------------------------------------------------+----------------+|00000000| 68 65 6c 6c 6f                                  |hello           |+--------+-------------------------------------------------+----------------+

方法三

编码：字符串调用 getByte () 方法获得字节数组，将字节数组传给 ByteBuffer 的 wrap () 方法，通过该方法获得 ByteBuffer。同样无需调用 flip 方法切换为读模式

解码：通过 StandardCharsets 的 decoder 方法解码

public class Translate {    public static void main(String[] args) {        // 准备两个字符串        String str1 = "hello";        String str2 = "";        // 通过StandardCharsets的encode方法获得ByteBuffer        // 此时获得的ByteBuffer为读模式，无需通过flip切换模式        ByteBuffer buffer1 = ByteBuffer.wrap(str1.getBytes());        ByteBufferUtil.debugAll(buffer1);        // 将缓冲区中的数据转化为字符串        // 通过StandardCharsets解码，获得CharBuffer，再通过toString获得字符串        str2 = StandardCharsets.UTF_8.decode(buffer1).toString();        System.out.println(str2);        ByteBufferUtil.debugAll(buffer1);    }}

运行结果

+--------+-------------------- all ------------------------+----------------+position: [0], limit: [5]         +-------------------------------------------------+         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |+--------+-------------------------------------------------+----------------+|00000000| 68 65 6c 6c 6f                                  |hello           |+--------+-------------------------------------------------+----------------+hello+--------+-------------------- all ------------------------+----------------+position: [5], limit: [5]         +-------------------------------------------------+         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |+--------+-------------------------------------------------+----------------+|00000000| 68 65 6c 6c 6f                                  |hello           |+--------+-------------------------------------------------+----------------+

粘包与半包

现象

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

• Hello,world\n
• I’m Nyima\n
• How are you?\n

变成了下面的两个 byteBuffer (粘包，半包)

• Hello,world\nI’m Nyima\nHo
• w are you?\n

出现原因

粘包

发送方 在发送数据时，并不是一条一条地发送数据，而是将数据整合在一起，当数据达到一定的数量后再一起发送。这就会导致多条信息被放在一个缓冲区中被一起发送出去

半包

接收方 的缓冲区的大小是有限的，当接收方的缓冲区满了以后，就需要将信息截断，等缓冲区空了以后再继续放入数据。这就会发生一段完整的数据最后被截断的现象

解决办法

• 通过 get (index) 方法遍历 ByteBuffer，遇到分隔符时进行处理。

  注意

  ：get (index) 不会改变 position 的值

  • 记录该段数据长度，以便于申请对应大小的缓冲区
  • 将缓冲区的数据通过 get () 方法写入到 target 中

• 调用 compact 方法切换模式，因为缓冲区中可能还有未读的数据

public class ByteBufferDemo {    public static void main(String[] args) {        ByteBuffer buffer = ByteBuffer.allocate(32);        // 模拟粘包+半包        buffer.put("Hello,world\nI"m Nyima\nHo".getBytes());        // 调用split函数处理        split(buffer);        buffer.put("w are you?\n".getBytes());        split(buffer);    }    private static void split(ByteBuffer buffer) {        // 切换为读模式        buffer.flip();        for(int i = 0; i < buffer.limit(); i++) {            // 遍历寻找分隔符            // get(i)不会移动position            if (buffer.get(i) == "\n") {                // 缓冲区长度                int length = i+1-buffer.position();                ByteBuffer target = ByteBuffer.allocate(length);                // 将前面的内容写入target缓冲区                for(int j = 0; j < length; j++) {                    // 将buffer中的数据写入target中                    target.put(buffer.get());                }                // 打印查看结果                ByteBufferUtil.debugAll(target);            }        }        // 切换为写模式，但是缓冲区可能未读完，这里需要使用compact        buffer.compact();    }}

运行结果

+--------+-------------------- all ------------------------+----------------+position: [12], limit: [12]         +-------------------------------------------------+         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |+--------+-------------------------------------------------+----------------+|00000000| 48 65 6c 6c 6f 2c 77 6f 72 6c 64 0a             |Hello,world.    |+--------+-------------------------------------------------+----------------++--------+-------------------- all ------------------------+----------------+position: [10], limit: [10]         +-------------------------------------------------+         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |+--------+-------------------------------------------------+----------------+|00000000| 49 27 6d 20 4e 79 69 6d 61 0a                   |I"m Nyima.      |+--------+-------------------------------------------------+----------------++--------+-------------------- all ------------------------+----------------+position: [13], limit: [13]         +-------------------------------------------------+         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |+--------+-------------------------------------------------+----------------+|00000000| 48 6f 77 20 61 72 65 20 79 6f 75 3f 0a          |How are you?.   |+--------+-------------------------------------------------+----------------+

3、FileChannel

工作模式

FileChannel 只能在阻塞模式下工作，所以无法搭配 Selector

获取

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

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

读取

通过 FileInputStream 获取 channel，通过 read 方法将数据写入到 ByteBuffer 中

read 方法的返回值表示读到了多少字节，若读到了文件末尾则返回 - 1

int readBytes = channel.read(buffer);

可根据返回值判断是否读取完毕

while(channel.read(buffer) > 0) {    // 进行对应操作    ...}

写入

因为 channel 也是有大小的，所以 write 方法并不能保证一次将 buffer 中的内容全部写入 channel。必须需要按照以下规则进行写入

// 通过hasRemaining()方法查看缓冲区中是否还有数据未写入到通道中while(buffer.hasRemaining()) {channel.write(buffer);}

关闭

通道需要 close，一般情况通过 try-with-resource 进行关闭，最好使用以下方法获取 strea 以及 channel，避免某些原因使得资源未被关闭

public class TestChannel {    public static void main(String[] args) throws IOException {        try (FileInputStream fis = new FileInputStream("stu.txt");             FileOutputStream fos = new FileOutputStream("student.txt");             FileChannel inputChannel = fis.getChannel();             FileChannel outputChannel = fos.getChannel()) {                        // 执行对应操作            ...                        }    }}

位置

position

channel 也拥有一个保存读取数据位置的属性，即 position

long pos = channel.position();

可以通过 position (int pos) 设置 channel 中 position 的值

long newPos = ...;channel.position(newPos);

设置当前位置时，如果设置为文件的末尾

• 这时读取会返回 -1
• 这时写入，会追加内容，但要注意如果 position 超过了文件末尾，再写入时在新内容和原末尾之间会有空洞（00）

强制写入

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

2、两个 Channel 传输数据

transferTo 方法

使用 transferTo 方法可以快速、高效地将一个 channel 中的数据传输到另一个 channel 中，但一次只能传输 2G 的内容

transferTo 底层使用了零拷贝技术

public class TestChannel {    public static void main(String[] args){        try (FileInputStream fis = new FileInputStream("stu.txt");             FileOutputStream fos = new FileOutputStream("student.txt");             FileChannel inputChannel = fis.getChannel();             FileChannel outputChannel = fos.getChannel()) {            // 参数：inputChannel的起始位置，传输数据的大小，目的channel            // 返回值为传输的数据的字节数            // transferTo一次只能传输2G的数据            inputChannel.transferTo(0, inputChannel.size(), outputChannel);        } catch (IOException e) {            e.printStackTrace();        }    }}

当传输的文件大于 2G 时，需要使用以下方法进行多次传输

public class TestChannel {    public static void main(String[] args){        try (FileInputStream fis = new FileInputStream("stu.txt");             FileOutputStream fos = new FileOutputStream("student.txt");             FileChannel inputChannel = fis.getChannel();             FileChannel outputChannel = fos.getChannel()) {            long size = inputChannel.size();            long capacity = inputChannel.size();            // 分多次传输            while (capacity > 0) {                // transferTo返回值为传输了的字节数                capacity -= inputChannel.transferTo(size-capacity, capacity, outputChannel);            }        } catch (IOException e) {            e.printStackTrace();        }    }}

3、Path 与 Paths

• Path 用来表示文件路径
• Paths 是工具类，用来获取 Path 实例

Path source = Paths.get("1.txt"); // 相对路径 不带盘符 使用 user.dir 环境变量来定位 1.txtPath source = Paths.get("d:\\1.txt"); // 绝对路径 代表了  d:\1.txt 反斜杠需要转义Path source = Paths.get("d:/1.txt"); // 绝对路径 同样代表了  d:\1.txtPath projects = Paths.get("d:\\data", "projects"); // 代表了  d:\data\projects

• . 代表了当前路径
• .. 代表了上一级路径

例如目录结构如下

d:|- data|- projects|- a|- b

代码

Path path = Paths.get("d:\\data\\projects\\a\\..\\b");System.out.println(path);System.out.println(path.normalize()); // 正常化路径 会去除 . 以及 ..

输出结果为

d:\data\projects\a\..\bd:\data\projects\b

4、Files

查找

检查文件是否存在

Path path = Paths.get("helloword/data.txt");System.out.println(Files.exists(path));

创建

创建一级目录

Path path = Paths.get("helloword/d1");Files.createDirectory(path);

• 如果目录已存在，会抛异常 FileAlreadyExistsException
• 不能一次创建多级目录，否则会抛异常 NoSuchFileException

创建多级目录用

Path path = Paths.get("helloword/d1/d2");Files.createDirectories(path);

拷贝及移动

拷贝文件

Path source = Paths.get("helloword/data.txt");Path target = Paths.get("helloword/target.txt");Files.copy(source, target);

• 如果文件已存在，会抛异常 FileAlreadyExistsException

如果希望用 source 覆盖掉 target，需要用 StandardOption 来控制

Files.copy(source, target, StandardOption.REPLACE_EXISTING);

移动文件

Path source = Paths.get("helloword/data.txt");Path target = Paths.get("helloword/data.txt");Files.move(source, target, StandardOption.ATOMIC_MOVE);

• StandardOption.ATOMIC_MOVE 保证文件移动的原子性

删除

删除文件

Path target = Paths.get("helloword/target.txt");Files.delete(target);

• 如果文件不存在，会抛异常 NoSuchFileException

删除目录

Path target = Paths.get("helloword/d1");Files.delete(target);

• 如果目录还有内容，会抛异常 DirectoryNotEmptyException

遍历

可以使用 Files 工具类中的 walkFileTree (Path, FileVisitor) 方法，其中需要传入两个参数

• Path：文件起始路径

• FileVisitor：文件访问器，

  使用访问者模式

  • 接口的实现类

    SimpleFileVisitor

    有四个方法

    • preVisitDirectory：访问目录前的操作
    • visitFile：访问文件的操作
    • visitFileFailed：访问文件失败时的操作
    • postVisitDirectory：访问目录后的操作

public class TestFiles {    public static void main(String[] args) throws IOException {        AtomicInteger ditCount = new AtomicInteger();        AtomicInteger fileCount = new AtomicInteger();        Files.walkFileTree(Paths.get("D:\\Program Files\\jdk7"),new SimpleFileVisitor(){            @Override            public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs) throws IOException {                System.err.println("=====>"+dir);                ditCount.incrementAndGet();                return super.preVisitDirectory(dir, attrs);            }            @Override            public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {                System.out.println("=====>"+file);                fileCount.incrementAndGet();                return super.visitFile(file, attrs);            }        });        System.out.println("dir count :"+ditCount);        System.out.println("file count :"+fileCount);    }}

运行结果如下

...=====>D:\Program Files\jdk7\jre7\lib\zi\SystemV\EST5EDT=====>D:\Program Files\jdk7\jre7\lib\zi\SystemV\HST10=====>D:\Program Files\jdk7\jre7\lib\zi\SystemV\MST7=====>D:\Program Files\jdk7\jre7\lib\zi\SystemV\MST7MDT=====>D:\Program Files\jdk7\jre7\lib\zi\SystemV\PST8=====>D:\Program Files\jdk7\jre7\lib\zi\SystemV\PST8PDT=====>D:\Program Files\jdk7\jre7\lib\zi\SystemV\YST9=====>D:\Program Files\jdk7\jre7\lib\zi\SystemV\YST9YDT=====>D:\Program Files\jdk7\jre7\lib\zi\WET=====>D:\Program Files\jdk7\jre7\lib\zi\ZoneInfoMappings=====>D:\Program Files\jdk7\jre7\LICENSE=====>D:\Program Files\jdk7\jre7\README.txt=====>D:\Program Files\jdk7\jre7\release=====>D:\Program Files\jdk7\jre7\THIRDPARTYLICENSEREADME-JAVAFX.txt=====>D:\Program Files\jdk7\jre7\THIRDPARTYLICENSEREADME.txt=====>D:\Program Files\jdk7\jre7\Welcome.htmldir count :183file count :2437

本文由传智教育博学谷教研团队发布。

如果本文对您有帮助，欢迎关注和点赞；如果您有任何建议也可留言评论或私信，您的支持是我坚持创作的动力。

转载请注明出处！

关键词： 传输数据 写入磁盘

• 

  一分钟搞定Netty 三大组件，如果搞不定，再看3遍

  1 三大组件简介Channel与BufferJavaNIO系统的核心在于：通道(Channel)和缓冲区(Buffer)。通道表示打开...

  来源： 2022-12-28
• 

  世界播报:《阿凡达2》差的远！2022国内电影票房前10：第一超40亿

  《阿凡达2》差的远！2022国内电影票房前10：第一超40亿

  来源： 2022-12-28
• 

  前沿热点：折叠旗舰卖到白菜价！moto razr 2022宣布调价至4999元

  折叠旗舰卖到白菜价！motorazr2022宣布调价至4999元

  来源： 2022-12-28
• 

  美国人钱包年末又迎重击！极端寒潮导致上周电价飙升超6000%

  美国人钱包年末又迎重击！极端寒潮导致上周电价飙升超6000%

  来源： 2022-12-28

• 一分钟搞定Netty 三大组件，如果搞不定，再看3遍

• 世界播报:《阿凡达2》差的远！2022国内电影票房前10：第一超40亿

• 前沿热点：折叠旗舰卖到白菜价！moto razr 2022宣布调价至4999元

• 美国人钱包年末又迎重击！极端寒潮导致上周电价飙升超6000%

• 天天时讯：或售70万对刚比亚迪！东风猛士M-Terrain量产实车曝光：凶悍

• 只有Redmi做到了！米粉没想到2022年2500元的手机都有无线充电

• 环球热文：隐私计算之多方安全计算（MPC，Secure Multi-Party Computation）

• 河南郑新黄河大桥因大雾多车相撞：涉及200多辆车

• 速递！安卓手机不卡顿！一加11内存基因重组技术揭秘：数据抓取量提升16倍

• 特斯拉股价年内暴跌70% 韩国散户疯狂抄底！背后原因不简单

• 女生病假期上9天班反欠公司三百多：被扣10天工资

• 环球速看：曝特斯拉上海工厂将在1月实施减产计划 原因未知

• 直降120：百度网盘超级会员12个月SVIP 178元大促

• 今日关注：交叉编译esp8089

• 【环球新要闻】Python中itertools详解

• playgo是什么意思？playgo是什么牌子？

• 十年之痒是什么意思？十年之痒的婚姻感悟小说有哪些？

• 【天天聚看点】女子投资100万元 本金4年仅剩1.71万元！基金经理被集体起诉

• 神价手慢无：OATLY噢麦力燕麦奶1L*2瓶/19.9元抄底

• 焦点速读：轿车加气站去加气 一开后备厢车被炸报废

• 诚意碾压苹果官网！京东开启年终优惠：iPhone 14直降900元

• 用户已破6亿！钉钉7.0版本发布：解决产业链协同问题

• 室内地坪是什么意思？室内地坪漆用什么颜色？

• 苏武留胡节不辱是什么意思？苏武的精神品质是什么？

• 调配奶粉是什么意思？调制奶粉的营养价值有哪些？

• 亚热带水果有哪些？亚热带水果的生长环境有哪些？

• 拜托小姐大结局是什么？拜托小姐演员表

• 东非大裂谷是哪两个板块张裂形成的？东非大裂谷形成的原因是什么？

• 龙应台的作品有哪些？龙应台最经典的句子

• 乌龟和老鹰的寓意是什么？乌龟和老鹰告诉我们什么道理？

• 【世界热闻】Python实验报告（第8章）

• 全球观速讯丨Java HashMap原理

• 天天亮点！认证管理（锐捷交换篇）

• 天天快看：[PHP]用socket写一个简单的WEB服务器

• 游戏盒子哪个好？2022年游戏盒子排行榜

• 无线网络受限或者是无连接是什么原因？无线网受限制或无连接怎么办？

• 网上订火车票如何取票？网上订火车票用什么软件最好？

• 小米2s和小米2的区别有哪些？小米2s开不了机怎么办？

• 网通玩电信游戏卡是什么原因？网通玩电信游戏卡怎么办？

• 849元 墨案电纸书Air发布：24级冷暖光、30天长续航

• 焦点简讯:亿万富翁芒格：别再抱怨了、现在的生活比过去好了5倍多

• 天天报道:比亚迪推出“疯狂星期三”活动：奖品够香 附答案！

• 落差很大 五菱“电动吉姆尼”谍照曝光：像老头乐

• 全球要闻：Redmi K60系列最香版本！米粉评K60：2499元无敌 把门焊死了

• 天天速讯：「实操」结合图数据库、图算法、机器学习、GNN 实现一个推荐系统

• 天天短讯！HTML 常用标签 tag

• Python爬虫实战，requests+openpyxl模块，爬取小说数据并保存txt文档（附源码）

• 关注：面试官问：为啥不建议使用 Select *？请你大声地回答他！！

• 即时：DAG任务调度系统 Taier 演进之道，探究DataSourceX 模块

• 【天天速看料】苹果推出跨年优惠 其实一点也没便宜

• 时讯：株洲卡丁车比赛事故致车手死亡后续 车手俱乐部声讨场地方

• 全球今日讯！彻底重构安卓内存底层！一加11将全球首发“内存基因重组”技术

• 天天微资讯！马斯克被曝内部圈子缺乏持不同观点的人：全是马屁精

• 全球滚动:K60发布后 倪飞发声：努比亚Z50才是旗舰焊门员

• 世界观点：RTX 4090玩游戏性能过剩 外星人懂了：将推500Hz高刷显示器

• 苹果股价三连跌创一年多来最低：2022累计蒸发27%

• 性能仅比3080略强？RTX 4070 Ti售价曝光 7199元你还可能买不到

• 全球快资讯：6年过去了：一代神卡GTX 1060依然值得入手

• 天天微头条丨平价神器！新iPad mini曝光：苹果加量不加价、还在密谋折叠屏惊喜

• 环球快看点丨马斯克赔哭 公司股价腰斩！消息称特斯拉上海工厂又要减产 卖不动国人不敢兴趣？

• 速看：中国GPU欲弯道超车：国产显卡向AMD、NV发起冲击

• 【天天新要闻】实现小程序onShow第一次页面加载不执行

• Java String类为什么用final修饰

• 天天通讯！Spring IOC官方文档学习笔记（五）之bean的作用域

• 【播资讯】华硕发布灵耀AX小魔方Pro分布式路由：双频3000M 449元

• 威联通发布TS-1655 NAS：可塞入16块硬盘 超级别墅

• 全球热文：男子嫌妻子开车水平差 醉驾被查：这下5年内别嫌弃了

• 一家比苹果还赚钱的日本企业：日本人自己都不知道

• 快讯：一文带你入门Transformer

• 全球观焦点：飞机票+高铁票可以一起买了：仅一笔支付 支持30个城市

• 今日要闻!听吐了！一对夫妻决定众筹买下《圣诞曲》版权将其下架

• 观点：国际空间站宇宙飞船发生泄漏 俄罗斯公布原因：外部机械性损坏

• AcWing. 1165.单词环

• 全球热推荐：绚丽又冷静！酷冷至尊莫比乌斯风扇评测：马力全开也只有60分贝

• 当前资讯!剧情澎湃！张艺谋新片《满江红》定档春节 双男主沈腾+易烊千玺

• 【天天报资讯】字节掐准了商家命门

• 全球即时看！[数据结构]单向链表的翻转(C语言)

• 【世界速看料】诺基亚、爱立信宣布退出 俄罗斯移动网路恐将倒退30年

• 速读：日系车笑了：国人把丰田买成了全球第一

• 每日速递：差价800元 Redmi K60与K60 Pro如何选？这三点不同

• 《王者荣耀》吕布FMVP皮肤来了：2023年第一款皮肤

• 观点：与微念和解 停更531天的李子柒何时复出？回应来了

• 全球播报:FreeSWITCH编译加载新模块

• python学习： fire库的使用教程

• 可能是Redmi最帅手机！Redmi K60 Pro亮相

• 焦点速讯：卢伟冰：Redmi K60 Pro干掉了电竞手机 将被市场淘汰

• 支付宝迎来“史诗级”更新：深色模式终于开启测试

• 天降横财！土耳其在黑海发现580亿立方米天然气

• 焦点讯息：日本N多影院设备陈旧 无法播放《阿凡达2》48帧版：影迷大规模退票

• window10/window11不能登录微软账户等

• 焦点速递！cmd命令curl的简单使用以及通过ip查所对应地址的方法

• 环球今亮点！Gateway

• 相当差劲！中汽研公布新一批碰撞测试：合创Z03仅获三星

• 博主称餐厅虚假营销：抓起帝王蟹扯腿吃掉

• 世界通讯！十年N饭称AMD显卡驱动有一个优点 就是不太稳定

• 全球消息！轻松瓦解重油污 奥妙桂花青梅香型洗洁精4 x 1.1KG 29.9元

• 鹤岗铁路开通运营：“绿巨人”开到中国最北端！时速160公里

• 比304更昂贵的316L不锈钢 富光真空保温杯年末清仓：多款式多容量可选

• 当前信息：清幽雅致 索泰RTX 4080 AMP EXTREME AIRO月白图赏

• 焦点播报:豪华超跑质感！Redmi K60冠军版官宣