关于java:一篇文章搞定Netty-三大组件如果搞不定再加俩钟

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 <= capacity
private 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 依赖

<dependency>
  <groupId>io.netty</groupId>
  <artifactId>netty-all</artifactId>
  <version>4.1.51.Final</version>
</dependency>

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.....      |
+--------+-------------------------------------------------+----------------+
// 读取两个字节的数据             
97
98
            
// 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.txt

Path source = Paths.get("d:\\1.txt"); // 绝对路径 代表了  d:\1.txt 反斜杠须要本义

Path source = Paths.get("d:/1.txt"); // 绝对路径 同样代表了  d:\1.txt

Path 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\..\b
d:\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<Path>(){
            @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.html
dir count :183
file count :2437

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

如果本文对您有帮忙，欢送关注和点赞；如果您有任何倡议也可留言评论或私信，您的反对是我保持创作的能源。

转载请注明出处！

关于java:一篇文章搞定Netty-三大组件如果搞不定再加俩钟

1. 三大组件简介

1、Selector

2、ByteBuffer

应用案例

应用形式

外围属性

外围办法

put () 办法

flip () 办法

get () 办法

rewind () 办法

clear () 办法

mark () 和 reset () 办法

compact () 办法

clear() VS compact()

办法调用及演示

ByteBuffer 调试工具类

调用 ByteBuffer 的办法

字符串与 ByteBuffer 的互相转换

办法一

办法二

办法三

粘包与半包

景象

呈现起因

解决办法

3、FileChannel

工作模式

获取

读取

写入

敞开

地位

强制写入

2、两个 Channel 传输数据

transferTo 办法

3、Path 与 Paths

4、Files

查找

创立

拷贝及挪动

拷贝文件

删除

遍历

评论

发表回复 取消回复

更多文章

DDN HPC 存储硬件架构设计深度分析

探秘IO500：从Lustre并行文件系统出发，开启HPC存储性能新征程

苹果iOS打包的ipa应用无法安装？一篇文章带你了解可能的原因及排查方法

图解Golang：从零开始实现简易版过期LRU缓存

发表回复取消回复