✏️ 写在前面的话：

Netty本质是一个NIO框架，适用于服务器通讯相关的多种应用场景。

Netty作为一款基于Java开发的高性能网络框架，想要从认识到熟悉再到掌握最终理解，因此我们需要从最基础的NIO开始学习。如果你已经学习并掌握了NIO相关知识，那么可以直接进入Netty相关文章的学习；如果没有了解过也没有关系，那我们就从当前文章开始学习吧！🎉🎉🎉

这里我们先简单了解一下这一篇文章中我们将要学习的内容：

首先是NIO的基本介绍，了解NIO的三大组件
ByteBuffer 字节缓冲区的基本使用
FileChannel 文件通道的基本使用
文件编程基础
网络编程基础
Selecter 选择器的基本使用

如果你已经学习过其中某些部分，当然你可以挑选其中某些章节进行回顾复习，也可以参考学习一下其他部分内容。

1.NIO 概述：

Java NIO（New IO或 Non Blocking IO）是从Java 1.4 版本开始引入的一个新的 IO API，可以替代标准的Java IO API。NIO支持面向缓冲区的、基于通道的IO操作。NIO将以更加高效的方式进行文件的读写操作。（NIO非阻塞 IO操作）

1.1 NIO 三大组件：

1.1.1 通道（Channel）：

Channel是读写数据的双向通道，可以从 Channel 将数据读入 Buffer，也可以将 Buffer 中的数据写出到 Channel。Channel 类似于Stream，但是 Stream 输入输出流一般是单向传递，而Channel是双向传递的，既可以输出又可以输入）

常见的 Channel 有：

FileChannel
DatagramChannel
SocketChannel
ServerSocketChannel

1.1.2 缓冲区（Buffer）：

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

ByteBuffer

MappedByteBuffer
DirectByteBuffer
HeapByteBuffer

ShortBuffer
IntBuffer
LongBuffer
FloatBuffer
DoubleBuffer
CharBuffer

1.1.3 选择器（Selector）：

我们从服务器端的设置方案来思考Selector的作用：

⚠️ 多线程版：

多线程版本设计是针对服务器端每接收到一个客户端的Socket连接都会创建一个新的线程进行业务处理。这样设计的问题就在于对服务而言：

服务器系统内存占用太高。每一个线程只对当前连接处理，如果连接处于长时间等待状态，而不执行任何业务逻辑，那么这样的连接线程就是一种资源的浪费。
线程上下文切换成本高。创建线程和销毁线程会消费过多的系统资源，如果大部分连接是短连接（处理业务时间端，数量大），很容造成服务器应资源消耗而宕机。
只适合连接数少的场景。

⚠️ 线程池版：

我们可以使用线程池来维护线程，保证了在一定程度下节省了系统创建和销毁线程的资源浪费。但是基础线程池的问题在于，线程工作处于阻塞模式下，一个线程仍然只能处理一个 Socket 连接。只适合短连接场景。

⚠️ Selector 版：

Selector 的作用就是配合一个线程来管理多个 Channel，获取这些 Channel 上发生的事件，这些 Channel 工作在非阻塞模式下，不会让线程吊死在一个 Channel 上。适合连接数特别多，但流量低的场景（low traffic）

调用 Selector 的 Select() 会阻塞直到 Channel 发生了读写就绪事件，这些事件发生，Select 方法就会返回这些事件交给 Thread 来处理。

1.2 依赖引入：

Netty 核心依赖：

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

其他依赖：

<dependency><groupId>org.projectlombok</groupId><artifactId>lombok</artifactId><version>1.18.24</version></dependency><dependency><groupId>com.google.code.gson</groupId><artifactId>gson</artifactId><version>2.8.7</version></dependency><dependency><groupId>com.google.guava</groupId><artifactId>guava</artifactId><version>20.0</version></dependency><dependency><groupId>ch.qos.logback</groupId><artifactId>logback-classic</artifactId><version>1.2.11</version></dependency>

2.ByteBuffer 字节缓冲区：

⚠️ Buffer 是非线程安全

2.1 ByteBuffer 基本使用：

向 Buffer 写入数据，例如调用channel.read(buffer)
调用filp()切换至读模式
从 buffer 中读取数据，例如调用buffer.get()
调用clear()或者compact()切换至写模式
重复 1~4 步骤

这里有一个使用场景，我们将文件中的数据读到内存，然后在控制台进行输出：

创建一个文本文件：

注意：Maven工程读取文件相对路径是基于当前模块。

1234567890abc

编写测试类：

使用 FileChannel 来读取文件内容

@Slf4jpublicclassTestByteBuffer {
publicstaticvoidmain(String[] args) {
// 由于是对文件进行读写操作，所以选择使用FileChannel// 1.创建输入流将文件写入到FileChannel中，通过输入流获取通道：// JDK7异常处理新特性try (FileChannelchannel=newFileInputStream("D:\\Project\\NettyTest\\data.txt").getChannel()) {
// 2.声明缓冲区，设置容量大小为10个字节：ByteBufferbyteBuffer=ByteBuffer.allocate(10);
// 循环从通道中读取数据：while (true) {
// 3.把通道中的数据读入缓冲区：intlen=channel.read(byteBuffer);
log.info("读取到的字节数：{}", len);
if (len==-1) break;
// 4.切换缓冲区读写模式，将数据写出：byteBuffer.flip();
while (byteBuffer.hasRemaining()) {
byteb=byteBuffer.get();
log.info("读取到的字节：{}", (char)b);
                }
// 5.切换缓冲区为写模式：byteBuffer.clear();
            }
        } catch (IOExceptione) {
log.error(e.getMessage());
        }
    }
}

输出：

12:12:47.143 [main] INFO wiki.csbox.TestByteBuffer - 读取到的字节数：10
12:12:47.146 [main] INFO wiki.csbox.TestByteBuffer - 读取到的字节：1
12:12:47.146 [main] INFO wiki.csbox.TestByteBuffer - 读取到的字节：2
12:12:47.146 [main] INFO wiki.csbox.TestByteBuffer - 读取到的字节：3
12:12:47.146 [main] INFO wiki.csbox.TestByteBuffer - 读取到的字节：4
12:12:47.146 [main] INFO wiki.csbox.TestByteBuffer - 读取到的字节：5
12:12:47.146 [main] INFO wiki.csbox.TestByteBuffer - 读取到的字节：6
12:12:47.146 [main] INFO wiki.csbox.TestByteBuffer - 读取到的字节：7
12:12:47.147 [main] INFO wiki.csbox.TestByteBuffer - 读取到的字节：8
12:12:47.147 [main] INFO wiki.csbox.TestByteBuffer - 读取到的字节：9
12:12:47.147 [main] INFO wiki.csbox.TestByteBuffer - 读取到的字节：0
12:12:47.147 [main] INFO wiki.csbox.TestByteBuffer - 读取到的字节数：3
12:12:47.147 [main] INFO wiki.csbox.TestByteBuffer - 读取到的字节：a
12:12:47.147 [main] INFO wiki.csbox.TestByteBuffer - 读取到的字节：b
12:12:47.147 [main] INFO wiki.csbox.TestByteBuffer - 读取到的字节：c
12:12:47.147 [main] INFO wiki.csbox.TestByteBuffer - 读取到的字节数：-1

2.2 ByteBuffer 内部结构：

ByteBuffer 有三个重要的属性：

capacity：当前声明的缓冲区容量
position：当前缓冲区的读写指针索引位置
limit：当前缓冲区的写入限制

2.2.1 ByteBuffer 读写流程：

初始化缓冲区时状态：

写模式下，position 是写入位置，limit 等于容量，下图表示写入了 4 个字节后的状态

flip 动作发生后，position 切换为读取位置，limit 切换为读取限制：

读取 4 个字节后，状态：

clear 动作发生后，状态：

compact 方法，是把未读完的部分向前压缩，然后切换至写模式：

2.3 ByteBuffer 调试工具类：

💡 使用这个工具类提供的方法可以查看 ByteBuffer 缓冲区中的属性变化情况。

注意：使用改工具类时，需要引入Netty依赖

importio.netty.util.internal.StringUtil;
importjava.nio.ByteBuffer;
importstaticio.netty.util.internal.MathUtil.isOutOfBounds;
importstaticio.netty.util.internal.StringUtil.NEWLINE;
publicclassByteBufferUtil {
privatestaticfinalchar[] BYTE2CHAR=newchar[256];
privatestaticfinalchar[] HEXDUMP_TABLE=newchar[256*4];
privatestaticfinalString[] HEXPADDING=newString[16];
privatestaticfinalString[] HEXDUMP_ROWPREFIXES=newString[65536>>>4];
privatestaticfinalString[] BYTE2HEX=newString[256];
privatestaticfinalString[] BYTEPADDING=newString[16];
static {
finalchar[] DIGITS="0123456789abcdef".toCharArray();
for (inti=0; i<256; i++) {
HEXDUMP_TABLE[i<<1] =DIGITS[i>>>4&0x0F];
HEXDUMP_TABLE[(i<<1) +1] =DIGITS[i&0x0F];
        }
inti;
// Generate the lookup table for hex dump paddingsfor (i=0; i<HEXPADDING.length; i++) {
intpadding=HEXPADDING.length-i;
StringBuilderbuf=newStringBuilder(padding*3);
for (intj=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++) {
StringBuilderbuf=newStringBuilder(12);
buf.append(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 conversionfor (i=0; i<BYTE2HEX.length; i++) {
BYTE2HEX[i] =' '+StringUtil.byteToHexStringPadded(i);
        }
// Generate the lookup table for byte dump paddingsfor (i=0; i<BYTEPADDING.length; i++) {
intpadding=BYTEPADDING.length-i;
StringBuilderbuf=newStringBuilder(padding);
for (intj=0; j<padding; j++) {
buf.append(' ');
            }
BYTEPADDING[i] =buf.toString();
        }
// Generate the lookup table for byte-to-char conversionfor (i=0; i<BYTE2CHAR.length; i++) {
if (i<=0x1f||i>=0x7f) {
BYTE2CHAR[i] ='.';
            } else {
BYTE2CHAR[i] = (char) i;
            }
        }
    }
/*** 打印所有内容** @param buffer*/publicstaticvoiddebugAll(ByteBufferbuffer) {
intoldlimit=buffer.limit();
buffer.limit(buffer.capacity());
StringBuilderorigin=newStringBuilder(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*/publicstaticvoiddebugRead(ByteBufferbuffer) {
StringBuilderbuilder=newStringBuilder(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);
    }
privatestaticvoidappendPrettyHexDump(StringBuilderdump, ByteBufferbuf, intoffset, intlength) {
if (isOutOfBounds(offset, length, buf.capacity())) {
thrownewIndexOutOfBoundsException(
"expected: "+"0 <= offset("+offset+") <= offset + length("+length+") <= "+"buf.capacity("+buf.capacity() +')');
        }
if (length==0) {
return;
        }
dump.append(
"         +-------------------------------------------------+"+NEWLINE+"         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |"+NEWLINE+"+--------+-------------------------------------------------+----------------+");
finalintstartIndex=offset;
finalintfullRows=length>>>4;
finalintremainder=length&0xF;
// Dump the rows which have 16 bytes.for (introw=0; row<fullRows; row++) {
introwStartIndex= (row<<4) +startIndex;
// Per-row prefix.appendHexDumpRowPrefix(dump, row, rowStartIndex);
// Hex dumpintrowEndIndex=rowStartIndex+16;
for (intj=rowStartIndex; j<rowEndIndex; j++) {
dump.append(BYTE2HEX[getUnsignedByte(buf, j)]);
            }
dump.append(" |");
// ASCII dumpfor (intj=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) {
introwStartIndex= (fullRows<<4) +startIndex;
appendHexDumpRowPrefix(dump, fullRows, rowStartIndex);
// Hex dumpintrowEndIndex=rowStartIndex+remainder;
for (intj=rowStartIndex; j<rowEndIndex; j++) {
dump.append(BYTE2HEX[getUnsignedByte(buf, j)]);
            }
dump.append(HEXPADDING[remainder]);
dump.append(" |");
// Ascii dumpfor (intj=rowStartIndex; j<rowEndIndex; j++) {
dump.append(BYTE2CHAR[getUnsignedByte(buf, j)]);
            }
dump.append(BYTEPADDING[remainder]);
dump.append('|');
        }
dump.append(NEWLINE+"+--------+-------------------------------------------------+----------------+");
    }
privatestaticvoidappendHexDumpRowPrefix(StringBuilderdump, introw, introwStartIndex) {
if (row<HEXDUMP_ROWPREFIXES.length) {
dump.append(HEXDUMP_ROWPREFIXES[row]);
        } else {
dump.append(NEWLINE);
dump.append(Long.toHexString(rowStartIndex&0xFFFFFFFFL|0x100000000L));
dump.setCharAt(dump.length() -9, '|');
dump.append('|');
        }
    }
publicstaticshortgetUnsignedByte(ByteBufferbuffer, intindex) {
return (short) (buffer.get(index) &0xFF);
    }
}

2.4 ByteBuffer API：

2.4.1 分配空间：

allocate()

ByteBufferbyteBuffer=ByteBuffer.allocate(缓冲区容量);

调用 ByteBuffer 的 allocate 方法，返回一个class java.nio.HeapByteBuffer（Java堆内存缓冲区）。基于堆内存的缓冲区读写效率较低。受到垃圾回收GC的影响。

publicstaticByteBufferallocate(intcapacity) {
if (capacity<0)
thrownewIllegalArgumentException();
returnnewHeapByteBuffer(capacity, capacity);
}

allocateDirect

ByteBufferbyteBuffer=ByteBuffer.allocateDirect(缓冲区容量);

allocateDirect 返回的时class java.nio.DirectByteBuffer，直接基于系统内存创建缓冲区，相比于Java虚拟机的堆内存直接内存读写效率更高，但是由于申请内存空间需要发生系统调用（等待操作系统响应），所以分配效率低于堆内存。不会被GC影响，但是如果使用不当会造成内存泄漏等问题。

publicstaticByteBufferallocateDirect(intcapacity) {
returnnewDirectByteBuffer(capacity);
}

2.4.2 读入数据：

向ByteBuffer中读入数据有两种办法：

调用 channel 的 channel.read(buffer)

intreadBytes=channel.read(buf);

调用 buffer 自己的 buffer.put(byte)

buffer.put((byte)127);

2.4.3 写出数据：

从 buffer 获取数据有两种办法：

调用 channel 的 write()

intwriteBytes=channel.write(buf);

调用 buffer 的 get()

byteb=buf.get();

注意：get()会让 position 读指针向后走，如果想重复读取数据：

可以调用rewind()将 position 重新置为 0。
或者调用 get(int i) 方法获取索引 i 的内容，它不会移动读指针。

mark() 和reset()：

mark 是在读取时，做一个标记，即使 position 改变，只要调用 reset 就能回到 mark 的位置。mark 本质是使用了get(index)，传入索引获取缓冲区元素，不会改变 position。

注意：rewind 和 flip 都会清除 mark 位置

2.4.4 String 与 ByteBuffer 互转：

String 转换为 ByteBuffer ：

字符串转换为 Byte数组写入ByteBuffer：

// 使用字符串直接获取Byte数组方式：

buffer.put("Hello Krian !".getBytes());

使用java.nio.charset.StandardCharsets类方法：

ByteBuffer buffer = StandardCharsets.UTF_8.encode("Hello Krian !");

使用java.nio.charset.Charset抽象类方法：

ByteBuffer buffer = Charset.forName("utf-8").encode("Hello Krian !");

使用ByteBuffer的wrap()方法：

ByteBuffer buffer = ByteBuffer.wrap("Hello Krian !".getBytes());

ByteBuffer 转换为 String ：

使用java.nio.charset.StandardCharsets类方法：

String str = StandardCharsets.UTF_8.decode(buffer).toString;

注意：缓冲区的读写模式转换！

2.5 ByteBuffer 大小分配问题：

每个 channel 都需要记录可能被切分的消息，因为 ByteBuffer 不能被多个 channel 共同使用，因此需要为每个 channel 维护一个独立的 ByteBuffer
ByteBuffer 不能太大，比如一个 ByteBuffer 1Mb 的话，要支持百万连接就要 1Tb 内存，因此需要设计大小可变的 ByteBuffer

一种思路是首先分配一个较小的 buffer，例如 4k，如果发现数据不够，再分配 8k 的 buffer，将 4k buffer 内容拷贝至 8k buffer，优点是消息连续容易处理，缺点是数据拷贝耗费性能，参考实现 http://tutorials.jenkov.com/java-performance/resizable-array.html
另一种思路是用多个数组组成 buffer，一个数组不够，把多出来的内容写入新的数组，与前面的区别是消息存储不连续解析复杂，优点是避免了拷贝引起的性能损耗

3.分散读集中写：

3.1 Scattering Reads 分散读：

分散读取文件内容。这里有一个文本文件 3parts.txt

onetwothree

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

try (RandomAccessFilefile=newRandomAccessFile("3parts.txt", "rw")) {
FileChannelchannel=file.getChannel();
ByteBuffera=ByteBuffer.allocate(3);
ByteBufferb=ByteBuffer.allocate(3);
ByteBufferc=ByteBuffer.allocate(5);
channel.read(newByteBuffer[]{a, b, c});
a.flip();
b.flip();
c.flip();
debug(a);
debug(b);
debug(c);
} catch (IOExceptione) {
e.printStackTrace();
}

结果

+-------------------------------------------------+
          |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
 +--------+-------------------------------------------------+----------------+
 |00000000| 6f 6e 65                                        |one             |
 +--------+-------------------------------------------------+----------------+
          +-------------------------------------------------+
          |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
 +--------+-------------------------------------------------+----------------+
 |00000000| 74 77 6f                                        |two             |
 +--------+-------------------------------------------------+----------------+
          +-------------------------------------------------+
          |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
 +--------+-------------------------------------------------+----------------+
 |00000000| 74 68 72 65 65                                  |three           |
 +--------+-------------------------------------------------+----------------+

3.2 Gathering Writes 集中写：

使用如下方式写入，可以将多个 Buffer 的数据填充至 Channel

try (RandomAccessFilefile=newRandomAccessFile("3parts.txt", "rw")) {
FileChannelchannel=file.getChannel();
ByteBufferd=ByteBuffer.allocate(4);
ByteBuffere=ByteBuffer.allocate(4);
channel.position(11);
d.put(newbyte[]{'f', 'o', 'u', 'r'});
e.put(newbyte[]{'f', 'i', 'v', 'e'});
d.flip();
e.flip();
debug(d);
debug(e);
channel.write(newByteBuffer[]{d, e});
} catch (IOExceptione) {
e.printStackTrace();
}

输出：

+-------------------------------------------------+
          |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
 +--------+-------------------------------------------------+----------------+
 |00000000| 66 6f 75 72                                     |four            |
 +--------+-------------------------------------------------+----------------+
          +-------------------------------------------------+
          |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
 +--------+-------------------------------------------------+----------------+
 |00000000| 66 69 76 65                                     |five            |
 +--------+-------------------------------------------------+----------------+

文件内容：

onetwothreefourfive

4.FileChannel 文件通道：

⚠️ FileChannel 只能工作在阻塞模式下

4.1 FileChannel API：

4.1.1 通道获取：

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

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

4.1.2 写入数据：

从 Buffer 缓冲区中把数据写入到 Channel 中：

ByteBuffer buffer = ...;

buffer.put(...); // 存入数据

buffer.flip(); // 切换读模式

while(buffer.hasRemaining()) {

channel.write(buffer);

}

在 while 中调用 channel.write() 是因为 write 方法并不能保证一次将 Buffer 中的内容全部写入 Channel。

4.1.3 读取数据：

从 Channel 读取数据填充 ByteBuffer，返回值表示读到了多少字节，-1 表示到达了文件的末尾。

int readBytes = channel.read(buffer);

4.1.4 通道关闭：

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

4.1.5 位置：

获取当前读写位置：

long pos = channel.position();

设置当前位置：

long newPos = ...;

channel.position(newPos);

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

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

4.1.6 大小：

使用 size 方法获取文件的大小。

channel.size();

4.1.7 强制写入：

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

channel.force(true);

4.2 Channel 间数据传输：

transferTo方法，实现了两个通道之间的数据交换。底层是利用了操作系统的零拷贝技术进行优化。但是通道的文件容量上限是2G。

StringFROM="helloword/data.txt";
StringTO="helloword/to.txt";
longstart=System.nanoTime();
try (FileChannelfrom=newFileInputStream(FROM).getChannel();
FileChannelto=newFileOutputStream(TO).getChannel();
    ) {
from.transferTo(0, from.size(), to);
} catch (IOExceptione) {
e.printStackTrace();
}
longend=System.nanoTime();
System.out.println("transferTo 用时："+ (end-start) /1000_000.0);

transferTo 用时：8.2011

超过 2g 大小的文件传输：

publicclassTestFileChannelTransferTo {
publicstaticvoidmain(String[] args) {
try (
FileChannelfrom=newFileInputStream("data.txt").getChannel();
FileChannelto=newFileOutputStream("to.txt").getChannel();
        ) {
// 效率高，底层会利用操作系统的零拷贝进行优化longsize=from.size();
// left 变量代表还剩余多少字节for (longleft=size; left>0; ) {
System.out.println("position:"+ (size-left) +" left:"+left);
left-=from.transferTo((size-left), left, to);
            }
        } catch (IOExceptione) {
e.printStackTrace();
        }
    }
}

实际传输一个超大文件：

position:0 left:7769948160

position:2147483647 left:5622464513

position:4294967294 left:3474980866

position:6442450941 left:1327497219

PS：Path、File等，在这里不做过多且深入的介绍，详细的学习会记录在【文件编程】系列文章中 😏

5.文件编程：

5.1 Path 路径：

JDK7 引入了 Path 和 Paths 类：

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

Path source = Paths.get("data.txt"); // 相对路径使用 user.dir 环境变量来定位 1.txt

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

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

Path projects = Paths.get("d:\\data", "projects"); // 代表了 d:\data\projects

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

例如目录结构如下：

|- 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

5.2 Files 文件：

检查文件是否存在：

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

创建一级目录：

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

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

创建多级目录用：

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

拷贝文件：

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

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

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

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

移动文件：

Pathsource=Paths.get("helloword/data.txt");
Pathtarget=Paths.get("helloword/data.txt");
Files.move(source, target, StandardCopyOption.ATOMIC_MOVE);

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

删除文件：

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

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

删除目录：

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

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

遍历目录文件：

publicstaticvoidmain(String[] args) throwsIOException {
Pathpath=Paths.get("C:\\Program Files\\Java\\jdk1.8.0_91");
AtomicIntegerdirCount=newAtomicInteger();
AtomicIntegerfileCount=newAtomicInteger();
Files.walkFileTree(path, newSimpleFileVisitor<Path>(){
@OverridepublicFileVisitResultpreVisitDirectory(Pathdir, BasicFileAttributesattrs) 
throwsIOException {
System.out.println(dir);
dirCount.incrementAndGet();
returnsuper.preVisitDirectory(dir, attrs);
        }
@OverridepublicFileVisitResultvisitFile(Pathfile, BasicFileAttributesattrs) 
throwsIOException {
System.out.println(file);
fileCount.incrementAndGet();
returnsuper.visitFile(file, attrs);
        }
    });
System.out.println(dirCount); // 133System.out.println(fileCount); // 1479}

统计 jar 的数目

Pathpath=Paths.get("C:\\Program Files\\Java\\jdk1.8.0_91");
AtomicIntegerfileCount=newAtomicInteger();
Files.walkFileTree(path, newSimpleFileVisitor<Path>(){
@OverridepublicFileVisitResultvisitFile(Pathfile, BasicFileAttributesattrs) 
throwsIOException {
if (file.toFile().getName().endsWith(".jar")) {
fileCount.incrementAndGet();
        }
returnsuper.visitFile(file, attrs);
    }
});
System.out.println(fileCount); // 724

删除多级目录：

Pathpath=Paths.get("d:\\a");
Files.walkFileTree(path, newSimpleFileVisitor<Path>(){
@OverridepublicFileVisitResultvisitFile(Pathfile, BasicFileAttributesattrs) 
throwsIOException {
Files.delete(file);
returnsuper.visitFile(file, attrs);
    }
@OverridepublicFileVisitResultpostVisitDirectory(Pathdir, IOExceptionexc) 
throwsIOException {
Files.delete(dir);
returnsuper.postVisitDirectory(dir, exc);
    }
});

⚠️ 删除是危险操作，确保要递归删除的文件夹没有重要内容

拷贝多级目录：

longstart=System.currentTimeMillis();
Stringsource="D:\\Snipaste-1.16.2-x64";
Stringtarget="D:\\Snipaste-1.16.2-x64aaa";
Files.walk(Paths.get(source)).forEach(path-> {
try {
StringtargetName=path.toString().replace(source, target);
// 是目录if (Files.isDirectory(path)) {
Files.createDirectory(Paths.get(targetName));
        }
// 是普通文件elseif (Files.isRegularFile(path)) {
Files.copy(path, Paths.get(targetName));
        }
    } catch (IOExceptione) {
e.printStackTrace();
    }
});
longend=System.currentTimeMillis();
System.out.println(end-start);

PS：网络编程中的其他内容在这里不做过多的介绍，详细的学习会记录在【网络编程】系列文章中 😏

6.网络编程：

6.1 阻塞模式：

服务器端代码：

// 使用 nio 来理解阻塞模式, 单线程// 0. ByteBufferByteBufferbuffer=ByteBuffer.allocate(16);
// 1. 创建了服务器ServerSocketChannelssc=ServerSocketChannel.open();
// 2. 绑定监听端口ssc.bind(newInetSocketAddress(8080));
// 3. 连接集合List<SocketChannel>channels=newArrayList<>();
while (true) {
// 4. accept 建立与客户端连接， SocketChannel 用来与客户端之间通信log.debug("connecting...");
SocketChannelsc=ssc.accept(); // 阻塞方法，线程停止运行log.debug("connected... {}", sc);
channels.add(sc);
for (SocketChannelchannel : channels) {
// 5. 接收客户端发送的数据log.debug("before read... {}", channel);
channel.read(buffer); // 阻塞方法，线程停止运行buffer.flip();
debugRead(buffer);
buffer.clear();
log.debug("after read...{}", channel);
    }
}

客户端代码：

SocketChannelsc=SocketChannel.open();
sc.connect(newInetSocketAddress("localhost", 8080));
System.out.println("waiting...");

阻塞模式下，相关方法都会导致线程暂停

ServerSocketChannel.accept 会在没有连接建立时让线程暂停
SocketChannel.read 会在没有数据可读时让线程暂停
阻塞的表现其实就是线程暂停了，暂停期间不会占用 cpu，但线程相当于闲置

单线程下，阻塞方法之间相互影响，几乎不能正常工作，需要多线程支持
但多线程下，有新的问题，体现在以下方面

32 位 jvm 一个线程 320k，64 位 jvm 一个线程 1024k，如果连接数过多，必然导致 OOM，并且线程太多，反而会因为频繁上下文切换导致性能降低
可以采用线程池技术来减少线程数和线程上下文切换，但治标不治本，如果有很多连接建立，但长时间 inactive，会阻塞线程池中所有线程，因此不适合长连接，只适合短连接

6.2 非阻塞模式：

服务器端代码：

// 使用 nio 来理解非阻塞模式, 单线程// 0. ByteBufferByteBufferbuffer=ByteBuffer.allocate(16);
// 1. 创建了服务器ServerSocketChannelssc=ServerSocketChannel.open();
ssc.configureBlocking(false); // 非阻塞模式// 2. 绑定监听端口ssc.bind(newInetSocketAddress(8080));
// 3. 连接集合List<SocketChannel>channels=newArrayList<>();
while (true) {
// 4. accept 建立与客户端连接， SocketChannel 用来与客户端之间通信SocketChannelsc=ssc.accept(); // 非阻塞，线程还会继续运行，如果没有连接建立，但sc是nullif (sc!=null) {
log.debug("connected... {}", sc);
sc.configureBlocking(false); // 非阻塞模式channels.add(sc);
    }
for (SocketChannelchannel : channels) {
// 5. 接收客户端发送的数据intread=channel.read(buffer);// 非阻塞，线程仍然会继续运行，如果没有读到数据，read 返回 0if (read>0) {
buffer.flip();
debugRead(buffer);
buffer.clear();
log.debug("after read...{}", channel);
        }
    }
}

客户端代码：

SocketChannelsc=SocketChannel.open();
sc.connect(newInetSocketAddress("localhost", 8080));
System.out.println("waiting...");

非阻塞模式下，相关方法都会不会让线程暂停

在 ServerSocketChannel.accept 在没有连接建立时，会返回 null，继续运行
SocketChannel.read 在没有数据可读时，会返回 0，但线程不必阻塞，可以去执行其它 SocketChannel 的 read 或是去执行 ServerSocketChannel.accept
写数据时，线程只是等待数据写入 Channel 即可，无需等 Channel 通过网络把数据发送出去

但非阻塞模式下，即使没有连接建立，和可读数据，线程仍然在不断运行，白白浪费了 cpu
数据复制过程中，线程实际还是阻塞的（AIO 改进的地方）

6.3 多路复用：

单线程可以配合 Selector 完成对多个 Channel 可读写事件的监控，这称之为多路复用。限于网络传输能力，Channel 未必时时可写，一旦 Channel 可写，会触发 Selector 的可写事件

多路复用仅针对网络 IO、普通文件 IO 没法利用多路复用。如果不用 Selector 的非阻塞模式，线程大部分时间都在做无用功，而 Selector 能够保证：

有可连接事件时才去连接
有可读事件才去读取
有可写事件才去写入

服务器端代码：

@Slf4jpublicclassServer {
publicstaticvoidmain(String[] args) throwsIOException {
// 1.创建Selector，管理多个 Channel：Selectorselector=Selector.open();
ServerSocketChannelserverSocketChannel=ServerSocketChannel.open();
// 设置当前通道为非阻塞：serverSocketChannel.configureBlocking(false);
// 2.建立Selector 和 Channel的联系（注册Channel到Selector中）// SelectionKey 就是将来事件发生后，通过Key可以知道事件和哪个Channel。SelectionKeyselectionKey=serverSocketChannel.register(selector, 0, null);
log.info("registerKey: {}",selectionKey);
// 设置Key只关注accept事件：selectionKey.interestOps(SelectionKey.OP_ACCEPT);
serverSocketChannel.bind(newInetSocketAddress(8090));
while (true) {
// 3.select方法，没有事件发生时，线程阻塞；有事件发生时，线程才会恢复运行。selector.select();
// 4.处理事件，selectionKey 内部包含了所有发生的事件Iterator<SelectionKey>iterator=selector.selectedKeys().iterator();
while (iterator.hasNext()) {
SelectionKeykey=iterator.next();
log.info("key: {}", key);
ServerSocketChannelchannel= (ServerSocketChannel) key.channel();
channel.accept();
log.info("{}", channel);
            }
        }
    }
}

客户端代码：

SocketChannelsc=SocketChannel.open();
sc.connect(newInetSocketAddress("localhost", 8090));
System.out.println("waiting...");

使用多路复用的好处：

一个线程配合 selector 就可以监控多个 channel 的事件，事件发生线程才去处理。避免非阻塞模式下所做无用功
让这个线程能够被充分利用
节约了线程的数量
减少了线程上下文切换

7.Selector 选择器：

7.1 Selector 基本使用：

7.1.1 创建 Selector：

Selectorselector=Selector.open()

7.1.2 绑定 Channel 事件：

绑定事件也称之为注册事件，绑定的事件 selector 才会关心

channel.configureBlocking(false);
SelectionKeykey=channel.register(selector, 绑定事件);

注意：channel 必须工作在非阻塞模式。FileChannel 没有非阻塞模式，因此不能配合 selector 一起使用

绑定的事件类型可以有：

connect：客户端连接成功时触发
accept：服务器端成功接受连接时触发
read：数据可读入时触发，有因为接收能力弱，数据暂不能读入的情况
write：数据可写出时触发，有因为发送能力弱，数据暂不能写出的情况

7.1.3 监听 Channel 事件：

可以通过下面三种方法来监听是否有事件发生，方法的返回值代表有多少 channel 发生了事件。

阻塞直到绑定事件发生

intcount=selector.select();

阻塞直到绑定事件发生，或是超时（时间单位为 ms）

intcount=selector.select(longtimeout);

不会阻塞，也就是不管有没有事件，立刻返回，自己根据返回值检查是否有事件

intcount=selector.selectNow();

💡 select 何时不阻塞：

事件发生时：

客户端发起连接请求，会触发 accept 事件
客户端发送数据过来，客户端正常、异常关闭时，都会触发 read 事件，另外如果发送的数据大于 buffer 缓冲区，会触发多次读取事件
channel 可写，会触发 write 事件
在 linux 下 nio bug 发生时

调用 selector.wakeup()
调用 selector.close()
selector 所在线程 interrupt

7.2 事件处理：

7.2.1 处理 accept 事件：

客户端代码：

publicclassClient {
publicstaticvoidmain(String[] args) {
try (Socketsocket=newSocket("localhost", 8080)) {
System.out.println(socket);
socket.getOutputStream().write("world".getBytes());
System.in.read();
        } catch (IOExceptione) {
e.printStackTrace();
        }
    }
}

服务器端代码：

@Slf4jpublicclassChannelDemo {
publicstaticvoidmain(String[] args) {
try (ServerSocketChannelchannel=ServerSocketChannel.open()) {
channel.bind(newInetSocketAddress(8080));
System.out.println(channel);
Selectorselector=Selector.open();
channel.configureBlocking(false);
channel.register(selector, SelectionKey.OP_ACCEPT);
while (true) {
intcount=selector.select();
//                int count = selector.selectNow();log.debug("select count: {}", count);
//                if(count <= 0) {//                    continue;//                }// 获取所有事件Set<SelectionKey>keys=selector.selectedKeys();
// 遍历所有事件，逐一处理Iterator<SelectionKey>iter=keys.iterator();
while (iter.hasNext()) {
SelectionKeykey=iter.next();
// 判断事件类型if (key.isAcceptable()) {
ServerSocketChannelc= (ServerSocketChannel) key.channel();
// 必须处理SocketChannelsc=c.accept();
log.debug("{}", sc);
                    }
// 处理完毕，必须将事件移除iter.remove();
                }
            }
        } catch (IOExceptione) {
e.printStackTrace();
        }
    }
}

💡 事件发生后能否不处理：

事件发生后，要么处理，要么取消（cancel），不能什么都不做，否则下次该事件仍会触发，这是因为 NIO 底层使用的是水平触发。

7.2.2 处理 read 事件：

@Slf4jpublicclassChannelDemo6 {
publicstaticvoidmain(String[] args) {
try (ServerSocketChannelchannel=ServerSocketChannel.open()) {
channel.bind(newInetSocketAddress(8080));
System.out.println(channel);
Selectorselector=Selector.open();
channel.configureBlocking(false);
channel.register(selector, SelectionKey.OP_ACCEPT);
while (true) {
intcount=selector.select();
//                int count = selector.selectNow();log.debug("select count: {}", count);
//                if(count <= 0) {//                    continue;//                }// 获取所有事件Set<SelectionKey>keys=selector.selectedKeys();
// 遍历所有事件，逐一处理Iterator<SelectionKey>iter=keys.iterator();
while (iter.hasNext()) {
SelectionKeykey=iter.next();
// 判断事件类型if (key.isAcceptable()) {
ServerSocketChannelc= (ServerSocketChannel) key.channel();
// 必须处理SocketChannelsc=c.accept();
sc.configureBlocking(false);
sc.register(selector, SelectionKey.OP_READ);
log.debug("连接已建立: {}", sc);
                    } elseif (key.isReadable()) {
SocketChannelsc= (SocketChannel) key.channel();
ByteBufferbuffer=ByteBuffer.allocate(128);
intread=sc.read(buffer);
if(read==-1) {
key.cancel();
sc.close();
                        } else {
buffer.flip();
debug(buffer);
                        }
                    }
// 处理完毕，必须将事件移除iter.remove();
                }
            }
        } catch (IOExceptione) {
e.printStackTrace();
        }
    }
}

开启两个客户端，修改一下发送文字，输出：

sun.nio.ch.ServerSocketChannelImpl[/0:0:0:0:0:0:0:0:8080]
21:16:39 [DEBUG] [main] c.i.n.ChannelDemo6 - select count: 1
21:16:39 [DEBUG] [main] c.i.n.ChannelDemo6 - 连接已建立: java.nio.channels.SocketChannel[connected local=/127.0.0.1:8080 remote=/127.0.0.1:60367]
21:16:39 [DEBUG] [main] c.i.n.ChannelDemo6 - select count: 1
+-------------------------------------------------+
|  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| 68 65 6c 6c 6f                                  |hello           |
+--------+-------------------------------------------------+----------------+
21:16:59 [DEBUG] [main] c.i.n.ChannelDemo6 - select count: 1
21:16:59 [DEBUG] [main] c.i.n.ChannelDemo6 - 连接已建立: java.nio.channels.SocketChannel[connected local=/127.0.0.1:8080 remote=/127.0.0.1:60378]
21:16:59 [DEBUG] [main] c.i.n.ChannelDemo6 - select count: 1
+-------------------------------------------------+
|  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| 77 6f 72 6c 64                                  |world           |
+--------+-------------------------------------------------+----------------+

💡 为何要iter.remove()？

因为 select 在事件发生后，就会将相关的 key 放入 selectedKeys 集合，但不会在处理完后从 selectedKeys 集合中移除，需要我们自己编码删除。例如

第一次触发了 ssckey 上的 accept 事件，没有移除 ssckey
第二次触发了 sckey 上的 read 事件，但这时 selectedKeys 中还有上次的 ssckey ，在处理时因为没有真正的 serverSocket 连上了，就会导致空指针异常

💡 cancel 的作用：

cancel 会取消注册在 selector 上的 channel，并从 keys 集合中删除 key 后续不会再监听事件

7.2.3 处理 write 事件：

一次无法写完例子：

非阻塞模式下，无法保证把 buffer 中所有数据都写入 channel，因此需要追踪 write 方法的返回值（代表实际写入字节数）
用 selector 监听所有 channel 的可写事件，每个 channel 都需要一个 key 来跟踪 buffer，但这样又会导致占用内存过多，就有两阶段策略

当消息处理器第一次写入消息时，才将 channel 注册到 selector 上
selector 检查 channel 上的可写事件，如果所有的数据写完了，就取消 channel 的注册
如果不取消，会每次可写均会触发 write 事件

服务端代码：

publicclassWriteServer {
publicstaticvoidmain(String[] args) throwsIOException {
ServerSocketChannelssc=ServerSocketChannel.open();
ssc.configureBlocking(false);
ssc.bind(newInetSocketAddress(8080));
Selectorselector=Selector.open();
ssc.register(selector, SelectionKey.OP_ACCEPT);
while(true) {
selector.select();
Iterator<SelectionKey>iter=selector.selectedKeys().iterator();
while (iter.hasNext()) {
SelectionKeykey=iter.next();
iter.remove();
if (key.isAcceptable()) {
SocketChannelsc=ssc.accept();
sc.configureBlocking(false);
SelectionKeysckey=sc.register(selector, SelectionKey.OP_READ);
// 1. 向客户端发送内容StringBuildersb=newStringBuilder();
for (inti=0; i<3000000; i++) {
sb.append("a");
                    }
ByteBufferbuffer=Charset.defaultCharset().encode(sb.toString());
intwrite=sc.write(buffer);
// 3. write 表示实际写了多少字节System.out.println("实际写入字节:"+write);
// 4. 如果有剩余未读字节，才需要关注写事件if (buffer.hasRemaining()) {
// read 1  write 4// 在原有关注事件的基础上，多关注 写事件sckey.interestOps(sckey.interestOps() +SelectionKey.OP_WRITE);
// 把 buffer 作为附件加入 sckeysckey.attach(buffer);
                    }
                } elseif (key.isWritable()) {
ByteBufferbuffer= (ByteBuffer) key.attachment();
SocketChannelsc= (SocketChannel) key.channel();
intwrite=sc.write(buffer);
System.out.println("实际写入字节:"+write);
if (!buffer.hasRemaining()) { // 写完了key.interestOps(key.interestOps() -SelectionKey.OP_WRITE);
key.attach(null);
                    }
                }
            }
        }
    }
}

客户端：

publicclassWriteClient {
publicstaticvoidmain(String[] args) throwsIOException {
Selectorselector=Selector.open();
SocketChannelsc=SocketChannel.open();
sc.configureBlocking(false);
sc.register(selector, SelectionKey.OP_CONNECT|SelectionKey.OP_READ);
sc.connect(newInetSocketAddress("localhost", 8080));
intcount=0;
while (true) {
selector.select();
Iterator<SelectionKey>iter=selector.selectedKeys().iterator();
while (iter.hasNext()) {
SelectionKeykey=iter.next();
iter.remove();
if (key.isConnectable()) {
System.out.println(sc.finishConnect());
                } elseif (key.isReadable()) {
ByteBufferbuffer=ByteBuffer.allocate(1024*1024);
count+=sc.read(buffer);
buffer.clear();
System.out.println(count);
                }
            }
        }
    }
}

💡 write 为何要取消：

只要向 channel 发送数据时，socket 缓冲可写，这个事件会频繁触发，因此应当只在 socket 缓冲区写不下时再关注可写事件，数据写完之后再取消关注。

7.3 边界处理：

7.3.1 不处理边界问题：

服务端：

publicclassServer {
publicstaticvoidmain(String[] args) throwsIOException {
ServerSocketss=newServerSocket(9000);
while (true) {
Sockets=ss.accept();
InputStreamin=s.getInputStream();
// 这里这么写，有没有问题byte[] arr=newbyte[4];
while(true) {
intread=in.read(arr);
// 这里这么写，有没有问题if(read==-1) {
break;
                }
System.out.println(newString(arr, 0, read));
            }
        }
    }
}

客户端：

publicclassClient {
publicstaticvoidmain(String[] args) throwsIOException {
Socketmax=newSocket("localhost", 9000);
OutputStreamout=max.getOutputStream();
out.write("hello".getBytes());
out.write("world".getBytes());
out.write("你好".getBytes());
max.close();
    }
}

输出：

hell
owor
ld�
�好

由于没有处理边界，所以会导致字节数组在编码处理的时候会出现异常情况。

7.3.2 处理消息的边界：

一种思路是固定消息长度，数据包大小一样，服务器按预定长度读取，缺点是浪费带宽。另一种思路是按分隔符拆分，缺点是效率低。

TLV 格式，即 Type 类型、Length 长度、Value 数据，类型和长度已知的情况下，就可以方便获取消息大小，分配合适的 buffer，缺点是 buffer 需要提前分配，如果内容过大，则影响 server 吞吐量

Http 1.1 是 TLV 格式
Http 2.0 是 LTV 格式

服务器端：

privatestaticvoidsplit(ByteBuffersource) {
source.flip();
for (inti=0; i<source.limit(); i++) {
// 找到一条完整消息if (source.get(i) =='\n') {
intlength=i+1-source.position();
// 把这条完整消息存入新的 ByteBufferByteBuffertarget=ByteBuffer.allocate(length);
// 从 source 读，向 target 写for (intj=0; j<length; j++) {
target.put(source.get());
            }
debugAll(target);
        }
    }
source.compact(); // 0123456789abcdef  position 16 limit 16}
publicstaticvoidmain(String[] args) throwsIOException {
// 1. 创建 selector, 管理多个 channelSelectorselector=Selector.open();
ServerSocketChannelssc=ServerSocketChannel.open();
ssc.configureBlocking(false);
// 2. 建立 selector 和 channel 的联系（注册）// SelectionKey 就是将来事件发生后，通过它可以知道事件和哪个channel的事件SelectionKeysscKey=ssc.register(selector, 0, null);
// key 只关注 accept 事件sscKey.interestOps(SelectionKey.OP_ACCEPT);
log.debug("sscKey:{}", sscKey);
ssc.bind(newInetSocketAddress(8080));
while (true) {
// 3. select 方法, 没有事件发生，线程阻塞，有事件，线程才会恢复运行// select 在事件未处理时，它不会阻塞, 事件发生后要么处理，要么取消，不能置之不理selector.select();
// 4. 处理事件, selectedKeys 内部包含了所有发生的事件Iterator<SelectionKey>iter=selector.selectedKeys().iterator(); // accept, readwhile (iter.hasNext()) {
SelectionKeykey=iter.next();
// 处理key 时，要从 selectedKeys 集合中删除，否则下次处理就会有问题iter.remove();
log.debug("key: {}", key);
// 5. 区分事件类型if (key.isAcceptable()) { // 如果是 acceptServerSocketChannelchannel= (ServerSocketChannel) key.channel();
SocketChannelsc=channel.accept();
sc.configureBlocking(false);
ByteBufferbuffer=ByteBuffer.allocate(16); // attachment// 将一个 byteBuffer 作为附件关联到 selectionKey 上SelectionKeyscKey=sc.register(selector, 0, buffer);
scKey.interestOps(SelectionKey.OP_READ);
log.debug("{}", sc);
log.debug("scKey:{}", scKey);
            } elseif (key.isReadable()) { // 如果是 readtry {
SocketChannelchannel= (SocketChannel) key.channel(); // 拿到触发事件的channel// 获取 selectionKey 上关联的附件ByteBufferbuffer= (ByteBuffer) key.attachment();
intread=channel.read(buffer); // 如果是正常断开，read 的方法的返回值是 -1if(read==-1) {
key.cancel();
                    } else {
split(buffer);
// 需要扩容if (buffer.position() ==buffer.limit()) {
ByteBuffernewBuffer=ByteBuffer.allocate(buffer.capacity() *2);
buffer.flip();
newBuffer.put(buffer); // 0123456789abcdef3333\nkey.attach(newBuffer);
                        }
                    }
                } catch (IOExceptione) {
e.printStackTrace();
key.cancel();  // 因为客户端断开了,因此需要将 key 取消（从 selector 的 keys 集合中真正删除 key）                }
            }
        }
    }
}

客户端：

SocketChannelsc=SocketChannel.open();
sc.connect(newInetSocketAddress("localhost", 8080));
SocketAddressaddress=sc.getLocalAddress();
// sc.write(Charset.defaultCharset().encode("hello\nworld\n"));sc.write(Charset.defaultCharset().encode("0123\n456789abcdef"));
sc.write(Charset.defaultCharset().encode("0123456789abcdef3333\n"));
System.in.read();

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

【Netty】Java NIO 基础

✏️ 写在前面的话：

1.NIO 概述：

1.1 NIO 三大组件：

1.1.1 通道（Channel）：

1.1.2 缓冲区（Buffer）：

1.1.3 选择器（Selector）：

1.2 依赖引入：

2.ByteBuffer 字节缓冲区：

2.1 ByteBuffer 基本使用：

2.2 ByteBuffer 内部结构：

2.2.1 ByteBuffer 读写流程：

2.3 ByteBuffer 调试工具类：

2.4 ByteBuffer API：

2.4.1 分配空间：

2.4.2 读入数据：

2.4.3 写出数据：

2.4.4 String 与 ByteBuffer 互转：

2.5 ByteBuffer 大小分配问题：

3.分散读集中写：

3.1 Scattering Reads 分散读：

3.2 Gathering Writes 集中写：

4.FileChannel 文件通道：

4.1 FileChannel API：

4.1.1 通道获取：

4.1.2 写入数据：

4.1.3 读取数据：

4.1.4 通道关闭：

4.1.5 位置：

4.1.6 大小：

4.1.7 强制写入：

4.2 Channel 间数据传输：

5.文件编程：

5.1 Path 路径：

5.2 Files 文件：

6.网络编程：

6.1 阻塞模式：

6.2 非阻塞模式：

6.3 多路复用：

7.Selector 选择器：

7.1 Selector 基本使用：

7.1.1 创建 Selector：

7.1.2 绑定 Channel 事件：

7.1.3 监听 Channel 事件：

7.2 事件处理：

7.2.1 处理 accept 事件：

7.2.2 处理 read 事件：

7.2.3 处理 write 事件：

7.3 边界处理：

7.3.1 不处理边界问题：

7.3.2 处理消息的边界：

热门文章

最新文章

相关课程

相关电子书

相关实验场景