當(dāng)前位置：首頁 > 编程资源 > 编程问答 >内容正文

编程问答

闭关修炼（十二） NIO

發(fā)布時(shí)間：2023/12/14 编程问答 42 豆豆

生活随笔收集整理的這篇文章主要介紹了闭关修炼（十二） NIO 小編覺得挺不錯(cuò)的,現(xiàn)在分享給大家,幫大家做個(gè)參考.

Netty的前置學(xué)習(xí)

文章目錄

NIO
- 什么是NIO
- 緩沖區(qū)
- - 什么是緩沖區(qū)？
  - ByteBuffer-HeapByteBuffer類源碼解析
  - ByteBuffer例子
  - mark和reset
  - - mark例子
  - 直接緩沖區(qū)和非直接緩沖區(qū)
  - - 哪一種緩沖區(qū)更為安全？
    - 簡易病毒制作
    - IO 緩沖區(qū)
- 通道
- - 什么是NIO通道？
  - Channel例子
- 分散讀取和聚集寫入
- - 什么是分散讀取和聚集寫入
  - 例子
  - 分析源碼，drl
編碼格式
- 例子說明
- encode源碼
- 解密源碼

NIO

什么是NIO

New/NoneBlocking IO的簡寫。

NIO是一個(gè)可以替代標(biāo)準(zhǔn)java IO API的IO API(JKD1.4)，在IO基礎(chǔ)之上進(jìn)行改進(jìn)，最大改進(jìn)在NIO有一個(gè)非阻塞的IO，面向緩沖區(qū)的，原來的IO是阻塞的，面向流的。

NIO效率比IO高，非阻塞IO常用于網(wǎng)絡(luò)通信

在IO中程序讀取文件用InputStream輸入流，寫文件用OutputStream輸出流，是單向的

NIO中保留了IO本質(zhì)的讀寫操作，文件和程序之間存在有通道+緩沖區(qū)，使用緩沖區(qū)進(jìn)行雙向的讀寫操作，緩沖區(qū)可以復(fù)用，通道可以比作成馬路，緩沖區(qū)比作成一輛貨車，在文件和程序兩端來回傳輸數(shù)據(jù)。

緩沖區(qū)

什么是緩沖區(qū)？

在傳輸數(shù)據(jù)過程做存放數(shù)據(jù)的作用，和通道一起配合使用

存儲(chǔ)數(shù)據(jù)有很多類型：
ByteBuffer
LongBuffer
IntegerBuffer
FloatBuffer
DoubleBuffer
沒有布爾類型，其中ByteBuffer使用最多，傳輸數(shù)據(jù)基本都是傳String

ByteBuffer-HeapByteBuffer類源碼解析

首先看構(gòu)造函數(shù)，其實(shí)用ByteBuffer.allocate新建ByteBuffer是實(shí)例化它的子類HeapByteBuffer（讀/寫堆字節(jié)緩沖區(qū)，是非直接緩沖區(qū)）

public static ByteBuffer allocate(int capacity) {if (capacity < 0)throw new IllegalArgumentException();return new HeapByteBuffer(capacity, capacity);}

ByteBuffer繼承了Buffer類

Buffer類的屬性

/*** The characteristics of Spliterators that traverse and split elements* maintained in Buffers.*/static final int SPLITERATOR_CHARACTERISTICS =Spliterator.SIZED | Spliterator.SUBSIZED | Spliterator.ORDERED;// Invariants: mark <= position <= limit <= capacityprivate int mark = -1;private int position = 0;private int limit;private int capacity;// Used only by direct buffers// NOTE: hoisted here for speed in JNI GetDirectBufferAddresslong address;// Creates a new buffer with the given mark, position, limit, and capacity,// after checking invariants.//

重要的4個(gè)屬性mark，position，limit，capacity
最后一個(gè)address，僅由直接緩沖區(qū)使用

類型都是整數(shù)型
mark：mrak是一個(gè)索引，通過Buffer中mark()方法指定Buffer中一個(gè)特定的position，之后可以通過調(diào)用reset()恢復(fù)到這個(gè)position

position：緩沖區(qū)正在操作的位置

limit：緩沖區(qū)可用大小

capacity：緩沖區(qū)最大容量，一旦聲明不能改變

核心方法：
put：往buffer中存放數(shù)據(jù)，本質(zhì)上寫一個(gè)數(shù)組，依次寫一個(gè)值，position++

public final ByteBuffer put(byte[] src) {return put(src, 0, src.length);}public ByteBuffer put(byte[] src, int offset, int length) {checkBounds(offset, length, src.length);if (length > remaining())throw new BufferOverflowException();int end = offset + length;for (int i = offset; i < end; i++)this.put(src[i]);return this;}public ByteBuffer put(byte x) {hb[ix(nextPutIndex())] = x;return this;}final int nextPutIndex() { // package-privateif (position >= limit)throw new BufferOverflowException();return position++;}

get：從buffer獲取數(shù)據(jù)，本質(zhì)上讀一個(gè)數(shù)組，依次讀一個(gè)值，position++

public ByteBuffer get(byte[] dst) {return get(dst, 0, dst.length);}public ByteBuffer get(byte[] dst, int offset, int length) {checkBounds(offset, length, dst.length);if (length > remaining())throw new BufferUnderflowException();int end = offset + length;for (int i = offset; i < end; i++)dst[i] = get();return this;}public final int remaining() {return limit - position;}static void checkBounds(int off, int len, int size) { // package-privateif ((off | len | (off + len) | (size - (off + len))) < 0)throw new IndexOutOfBoundsException();}public byte get() {return hb[ix(nextGetIndex())];}final int nextGetIndex() { // package-privateif (position >= limit)throw new BufferUnderflowException();return position++;}

flip讀模式 flip()，看源碼也可以明白了為什么要多一個(gè)limit屬性來表示可用大小了，目的是在讀時(shí)候僅返回存放數(shù)據(jù)大小的數(shù)據(jù)，并且讀完后的回到初始的position

public final Buffer flip() {limit = position;position = 0;mark = -1;return this;}

rewind讀模式rewind()，沒有設(shè)置limit，讀完后的position直接到buffer末尾

public final Buffer rewind() {position = 0;mark = -1;return this;}

clear()，清空緩沖區(qū)，類似軟刪除，并沒有真正的刪除，只是將position置為0，再次寫入新數(shù)據(jù)覆蓋舊數(shù)據(jù)。

public final Buffer clear() {position = 0;limit = capacity;mark = -1;return this;}

ByteBuffer例子

import org.junit.Test; import java.nio.ByteBuffer;public class Test1 {@Testpublic void bufferTest() {// 初始化buffer大小ByteBuffer byteBuffer = ByteBuffer.allocate(1024);// 打印正在操作的位置System.out.println(byteBuffer.position());// 打印緩沖區(qū)可用大小 1024System.out.println(byteBuffer.limit());// 打印最大容量 1024System.out.println(byteBuffer.capacity());System.out.println("=========================");System.out.println("存放數(shù)據(jù)");// 存放數(shù)據(jù)byteBuffer.put("abcde".getBytes());// 打印正在操作的位置System.out.println(byteBuffer.position());// 打印緩沖區(qū)可用大小 1024System.out.println(byteBuffer.limit());// 打印最大容量 1024System.out.println(byteBuffer.capacity());System.out.println("=========================");System.out.println("讀取數(shù)據(jù)");// 開啟讀取模式，作用是將position標(biāo)識(shí)為0byteBuffer.flip();// 打印正在操作的位置System.out.println(byteBuffer.position());// 創(chuàng)建byte[]byte[] bytes = new byte[byteBuffer.limit()];// 獲取所有值存放到bytes中，讀取完后position還原成5byteBuffer.get(bytes);System.out.println(new String(bytes, 0, bytes.length));System.out.println(byteBuffer.position());System.out.println(bytes.length);System.out.println("=========================");System.out.println("清空緩沖區(qū)");byteBuffer.clear();}@Testpublic void testRewind(){// 初始化buffer大小ByteBuffer byteBuffer = ByteBuffer.allocate(1024);// 打印正在操作的位置System.out.println(byteBuffer.position());// 打印緩沖區(qū)可用大小 1024System.out.println(byteBuffer.limit());// 打印最大容量 1024System.out.println(byteBuffer.capacity());System.out.println("=========================");System.out.println("存放數(shù)據(jù)");// 存放數(shù)據(jù)byteBuffer.put("abcde".getBytes());// 打印正在操作的位置System.out.println(byteBuffer.position());// 打印緩沖區(qū)可用大小 1024System.out.println(byteBuffer.limit());// 打印最大容量 1024System.out.println(byteBuffer.capacity());System.out.println("=========================");System.out.println("讀取數(shù)據(jù)");// 開啟重復(fù)讀模式byteBuffer.rewind();// 打印正在操作的位置System.out.println(byteBuffer.position());// 創(chuàng)建byte[]byte[] bytes = new byte[byteBuffer.limit()];// 獲取所有值存放到bytes中byteBuffer.get(bytes);System.out.println(new String(bytes, 0, bytes.length));System.out.println(byteBuffer.position());System.out.println(bytes.length);} }

mark和reset

標(biāo)記與重置：mrak是一個(gè)索引，通過Buffer中mark()方法指定Buffer中一個(gè)特定的position，之后可以通過調(diào)用reset()恢復(fù)到這個(gè)position

mark例子

@Testpublic void testMark() {// 初始化buffer大小ByteBuffer byteBuffer = ByteBuffer.allocate(10);byteBuffer.put("abcd".getBytes());// 開啟讀模式byteBuffer.flip();byte[] bytes = new byte[byteBuffer.limit()];// 只取兩個(gè)值byteBuffer.get(bytes, 0, 2);System.out.println(new String(bytes, 0, bytes.length));System.out.println("當(dāng)前位置：" + byteBuffer.position());byteBuffer.mark();byteBuffer.get(bytes, 2, 2);System.out.println(new String(bytes, 0, bytes.length));System.out.println("當(dāng)前位置：" + byteBuffer.position());byteBuffer.reset();System.out.println("回到原來的位置：" + byteBuffer.position());}

順便看一下源碼，很簡單

public final Buffer mark() {mark = position;return this;}public final Buffer reset() {int m = mark;if (m < 0)throw new InvalidMarkException();position = m;return this;}

直接緩沖區(qū)和非直接緩沖區(qū)

非直接緩沖區(qū)主要存放在jvm緩沖區(qū)中

直接緩沖區(qū)存放在物理內(nèi)存中

存放在物理內(nèi)存中效率高，因?yàn)橹苯泳彌_區(qū)不需要來回的拷貝，直接操作內(nèi)存，而非直接緩沖區(qū)需要來回拷貝。

下圖是應(yīng)用程序使用非直接緩沖區(qū)讀寫數(shù)據(jù)流程，讀的時(shí)候需要將物理內(nèi)存的數(shù)據(jù)copy到j(luò)vm空間，寫的時(shí)候需要將jvm空間數(shù)據(jù)copy到物理內(nèi)存中去

ByteBuffer.allocate方法創(chuàng)建的緩沖區(qū)是非直接緩沖區(qū)

想創(chuàng)建直接緩沖區(qū)調(diào)用ByteBuffer.allocateDirect，底層使用的是DirectByteBuffer。

public static ByteBuffer allocateDirect(int capacity) {return new DirectByteBuffer(capacity);}DirectByteBuffer(int cap) { // package-privatesuper(-1, 0, cap, cap);boolean pa = VM.isDirectMemoryPageAligned();int ps = Bits.pageSize();long size = Math.max(1L, (long)cap + (pa ? ps : 0));Bits.reserveMemory(size, cap);long base = 0;try {base = unsafe.allocateMemory(size);} catch (OutOfMemoryError x) {Bits.unreserveMemory(size, cap);throw x;}unsafe.setMemory(base, size, (byte) 0);if (pa && (base % ps != 0)) {// Round up to page boundaryaddress = base + ps - (base & (ps - 1));} else {address = base;}cleaner = Cleaner.create(this, new Deallocator(base, size, cap));att = null;}

DirectByteBuffer類使用Unsafe類進(jìn)行操作了，直接到底層地獄，就不解析了

public ByteBuffer put(int i, byte x) {unsafe.putByte(ix(checkIndex(i)), ((x)));return this;}

甚至都不是java實(shí)現(xiàn)的了

所以跳過吧

哪一種緩沖區(qū)更為安全？

非直接緩沖區(qū)，為什么呢？

因?yàn)橹苯觾?nèi)存直接讀寫物理內(nèi)存，不安全，出現(xiàn)異常時(shí)可能造成數(shù)據(jù)只寫了一半，或者在寫的時(shí)候，其他的程序可能會(huì)清除或修改了之前寫的內(nèi)容。

簡易病毒制作

使用DirectByteBuffer，用死循環(huán)一直往內(nèi)存里寫東西，電腦會(huì)卡到只能重啟。

IO 緩沖區(qū)

原先的IO緩沖區(qū)使用的非直接緩沖區(qū)

通道

什么是NIO通道？

表示打開IO設(shè)備（例如：文件，socket）的連接。獲取IO設(shè)備的通道后，程序可以操作緩沖區(qū)，對數(shù)據(jù)進(jìn)行處理。Channel賦值傳輸，Buffer負(fù)責(zé)存儲(chǔ)。

Channel類似傳統(tǒng)的Stream，但是自身不能訪問數(shù)據(jù)，要與buffer配合使用

channels包下有File、Socket、ServerSocket、DatagramChannel等抽象類

他們的實(shí)現(xiàn)在_____ChannelImpl

jdk1.7后新增了open方法創(chuàng)建channel

Channel例子

非直接緩沖區(qū)

@SneakyThrows@Testpublic void testChannel() {long startTime = System.currentTimeMillis();// 讀入流FileInputStream fi = new FileInputStream("t.txt");// 寫入流FileOutputStream fo = new FileOutputStream("2.txt");// 創(chuàng)建通道FileChannel inChannel = fi.getChannel();FileChannel outChannel = fo.getChannel();// 分配指定大小緩沖區(qū)ByteBuffer buffer = ByteBuffer.allocate(1024);// 讀寫操作while (inChannel.read(buffer) != -1) {// 開啟讀取模式buffer.flip();// 寫入到通道中outChannel.write(buffer);// 讀完后清空緩沖區(qū)buffer.clear();}// 關(guān)閉通道inChannel.close();outChannel.close();fi.close();fo.close();long endTime = System.currentTimeMillis();System.out.println(endTime - startTime);}

直接緩沖區(qū)

@SneakyThrows@Testpublic void directChannel() {long startTime = System.currentTimeMillis();// 創(chuàng)建管道FileChannel in = FileChannel.open(Paths.get("t.txt"), StandardOpenOption.READ);FileChannel out = FileChannel.open(Paths.get("2.txt"),StandardOpenOption.READ,StandardOpenOption.WRITE,StandardOpenOption.CREATE);// 定義映射文件MappedByteBuffer inMap = in.map(FileChannel.MapMode.READ_ONLY, 0, in.size());MappedByteBuffer outMap = out.map(FileChannel.MapMode.READ_WRITE, 0, in.size());// 直接對緩沖區(qū)操作byte[] bytes = new byte[inMap.limit()];// 讀取inMap.get(bytes);// 寫入outMap.put(bytes);// 關(guān)閉管道in.close();out.close();long endTime = System.currentTimeMillis();System.out.println(endTime - startTime);}

分散讀取和聚集寫入

什么是分散讀取和聚集寫入

一條通道支持多個(gè)buffer，多個(gè)buffer可以整合成一個(gè)buffer

分散讀取：將通道中的數(shù)據(jù)分散到多個(gè)緩沖區(qū)中

聚集寫入：將多個(gè)緩沖區(qū)的數(shù)據(jù)聚集通道中

多個(gè)buffer同時(shí)讀，提高效率，最后聚集起來寫入文件

例子

@SneakyThrows@Testpublic void disperseAndGather(){// SE 隨機(jī)訪問RandomAccessFile raf = new RandomAccessFile("t.txt", "rw");// 獲取通道tFileChannel channel = raf.getChannel();// 分配指定緩沖區(qū)ByteBuffer buffer1 = ByteBuffer.allocate(100);ByteBuffer buffer2 = ByteBuffer.allocate(1024);// 分散讀取ByteBuffer[] buffers = {buffer1, buffer2};channel.read(buffers);System.out.println(new String(buffers[0].array(), 0, buffers[0].limit()));System.out.println(new String(buffers[1].array(), 0, buffers[1].limit()));System.out.println("--分散讀取完畢--");for (ByteBuffer b: buffers){// 切換讀模式b.flip();}// 聚集讀寫RandomAccessFile raf2 = new RandomAccessFile("2.txt", "rw");// 獲取通道FileChannel channel2 = raf2.getChannel();// 寫入channel2.write(buffers);}

分析源碼，drl

IO包中的getChannel源碼，我們可以看到其實(shí)底層是調(diào)用的Channel的open方法

public final FileChannel getChannel() {synchronized (this) {if (channel == null) {channel = FileChannelImpl.open(fd, path, true, rw, this);}return channel;}}

反編譯出來的open方法，返回的對象是FileChannelImpl

public static FileChannel open(FileDescriptor var0, String var1, boolean var2, boolean var3, Object var4) {return new FileChannelImpl(var0, var1, var2, var3, false, var4);}

分散讀底層實(shí)現(xiàn)，用了synchronized同步代碼塊來保證的線程安全，不過編譯出來的可讀性太差了，勉強(qiáng)能看出用了IOUtil循環(huán)讀數(shù)據(jù)，有他們nio自定義的Thread類，還用到了IOStatus，以后再研究一下吧，這篇先加入收藏夾了https://www.cnblogs.com/Jack-Blog/p/12078767.html。收藏從未停下，學(xué)習(xí)何時(shí)開始

// 抽象類中的分散讀public final long read(ByteBuffer[] dsts) throws IOException {return read(dsts, 0, dsts.length);}public abstract long read(ByteBuffer[] dsts, int offset, int length) throws IOException;// 分散讀實(shí)現(xiàn)public long read(ByteBuffer[] var1, int var2, int var3) throws IOException {if (var2 >= 0 && var3 >= 0 && var2 <= var1.length - var3) {this.ensureOpen();if (!this.readable) {throw new NonReadableChannelException();} else {synchronized(this.positionLock) {long var5 = 0L;int var7 = -1;try {this.begin();var7 = this.threads.add();long var8;if (!this.isOpen()) {var8 = 0L;return var8;} else {do {var5 = IOUtil.read(this.fd, var1, var2, var3, this.nd);} while(var5 == -3L && this.isOpen());var8 = IOStatus.normalize(var5);return var8;}} finally {this.threads.remove(var7);this.end(var5 > 0L);assert IOStatus.check(var5);}}}} else {throw new IndexOutOfBoundsException();}}

編碼格式

了解即可
Charset，CharsetEncoder和CharsetDecoder進(jìn)行加密解密

例子說明

@SneakyThrows@Testpublic void charsetTest(){// 獲取編碼器Charset charset = Charset.forName("UTF-8");// 加密器CharsetEncoder ce = charset.newEncoder();// 獲取解碼器CharsetDecoder cd = charset.newDecoder();// 創(chuàng)建緩沖區(qū)CharBuffer buffer = CharBuffer.allocate(1024);buffer.put("測試122345677");// 讀模式，將position置0buffer.flip();// 編碼格式ByteBuffer encodeBuf = ce.encode(buffer);for (int i = 0; i < encodeBuf.limit(); i++) {// 輸出加密的內(nèi)容System.out.println(encodeBuf.get());}// 讀模式，position置0encodeBuf.flip();// 將編碼解密CharBuffer decodeBuf = cd.decode(encodeBuf);System.out.println(decodeBuf.toString());}

encode源碼

將單個(gè)輸入字符緩沖區(qū)的剩余內(nèi)容編碼到一個(gè)新分配的字節(jié)緩沖區(qū)中。（*UP注釋，因此使用前一般都用flip()新置一下position和limit）
這個(gè)方法實(shí)現(xiàn)了一個(gè)完整的編碼操作；也就是說，它先重置這個(gè)編碼器，然后對給定字符緩沖區(qū)中的字符進(jìn)行編碼，最后刷新這個(gè)編碼器。
如果一個(gè)編碼操作已經(jīng)在進(jìn)行中，就不應(yīng)該調(diào)用這個(gè)方法。

public final ByteBuffer encode(CharBuffer in)throws CharacterCodingException{int n = (int)(in.remaining() * averageBytesPerChar());ByteBuffer out = ByteBuffer.allocate(n);if ((n == 0) && (in.remaining() == 0))return out;reset();for (;;) {CoderResult cr = in.hasRemaining() ?encode(in, out, true) : CoderResult.UNDERFLOW;if (cr.isUnderflow())cr = flush(out);if (cr.isUnderflow())break;if (cr.isOverflow()) {n = 2*n + 1; // Ensure progress; n might be 0!ByteBuffer o = ByteBuffer.allocate(n);out.flip();o.put(out);out = o;continue;}cr.throwException();}out.flip();return out;}

了解即可。

從給定的輸入緩沖區(qū)編碼盡可能多的字符，并將結(jié)果寫入給定的輸出緩沖區(qū)。
從當(dāng)前位置開始讀取和寫入緩沖區(qū)。最多讀取in.stay()字符，最多寫入out.stay()字節(jié)。緩沖區(qū)的位置將被提前，以反映讀取的字符和寫入的字節(jié)，但它們的標(biāo)記和限制不會(huì)被修改。
除了從輸入緩沖區(qū)讀取字符和向輸出緩沖區(qū)寫入字節(jié)外，該方法還返回一個(gè)CoderResult對象來描述其終止的原因。
CoderResult.UNDERFLOW表示盡可能多的輸入緩沖區(qū)已經(jīng)被編碼。如果沒有進(jìn)一步的輸入，那么調(diào)用者可以繼續(xù)進(jìn)行下一步的編碼操作。否則應(yīng)再次調(diào)用該方法，并輸入更多的信息。
CoderResult.OVERFLOW表示輸出緩沖區(qū)中沒有足夠的空間來編碼更多的字符。應(yīng)該在輸出緩沖區(qū)有更多剩余字節(jié)的情況下再次調(diào)用本方法。這通常是通過排出輸出緩沖區(qū)中的任何編碼字節(jié)來實(shí)現(xiàn)的。
malformed-input的結(jié)果表示已經(jīng)檢測到一個(gè)畸形輸入錯(cuò)誤。畸形字符從輸入緩沖區(qū)的（可能是遞增的）位置開始；畸形字符的數(shù)量可以通過調(diào)用結(jié)果對象的長度方法來確定。這種情況只適用于該編碼器的畸形動(dòng)作為CodingErrorAction.report的情況；否則，畸形輸入將被忽略或按要求替換。
不可映射字符的結(jié)果表示檢測到了一個(gè)不可映射字符的錯(cuò)誤。編碼不可映射字符的字符從輸入緩沖區(qū)的位置開始（可能是遞增的）；這些字符的數(shù)量可以通過調(diào)用結(jié)果對象的長度方法來確定。這種情況只適用于該編碼器的不可映射動(dòng)作是CodingErrorAction.report的情況；否則，不可映射字符將被忽略或按要求替換。
在任何情況下，如果這個(gè)方法要在同一個(gè)編碼操作中重新調(diào)用，那么就應(yīng)該注意保留輸入緩沖區(qū)中剩余的任何字符，以便它們可以用于下一次調(diào)用。
endOfInput參數(shù)告知本方法，除了給定的輸入緩沖區(qū)所包含的輸入之外，調(diào)用者是否還能提供更多的輸入。如果有可能提供額外的輸入，那么調(diào)用者應(yīng)該為這個(gè)參數(shù)傳遞false；如果沒有可能提供進(jìn)一步的輸入，那么調(diào)用者應(yīng)該傳遞true。在一次調(diào)用中傳遞false，而后來發(fā)現(xiàn)實(shí)際上沒有進(jìn)一步的輸入，這并不是錯(cuò)誤的，事實(shí)上也很常見。然而，至關(guān)重要的是，在一系列調(diào)用中，該方法的最后一次調(diào)用總是傳遞true，這樣任何剩余的未編碼輸入都將被視為畸形輸入。
該方法的工作原理是調(diào)用 encodeLoop 方法，解釋其結(jié)果，處理錯(cuò)誤條件，并在必要時(shí)重新調(diào)用它。

以上翻譯自注解，所以講了一大堆真真的是調(diào)用encodeLoop，其他都是錯(cuò)誤處理

public final CoderResult encode(CharBuffer in, ByteBuffer out,boolean endOfInput){int newState = endOfInput ? ST_END : ST_CODING;if ((state != ST_RESET) && (state != ST_CODING)&& !(endOfInput && (state == ST_END)))throwIllegalStateException(state, newState);state = newState;for (;;) {CoderResult cr;try {cr = encodeLoop(in, out);} catch (BufferUnderflowException x) {throw new CoderMalfunctionError(x);} catch (BufferOverflowException x) {throw new CoderMalfunctionError(x);}if (cr.isOverflow())return cr;if (cr.isUnderflow()) {if (endOfInput && in.hasRemaining()) {cr = CoderResult.malformedForLength(in.remaining());// Fall through to malformed-input case} else {return cr;}}CodingErrorAction action = null;if (cr.isMalformed())action = malformedInputAction;else if (cr.isUnmappable())action = unmappableCharacterAction;elseassert false : cr.toString();if (action == CodingErrorAction.REPORT)return cr;if (action == CodingErrorAction.REPLACE) {if (out.remaining() < replacement.length)return CoderResult.OVERFLOW;out.put(replacement);}if ((action == CodingErrorAction.IGNORE)|| (action == CodingErrorAction.REPLACE)) {// Skip erroneous input either wayin.position(in.position() + cr.length());continue;}assert false;}}

encodeLoop，hasArray()方法用于確保給定緩沖區(qū)是否由可訪問的字節(jié)數(shù)組支持。

protected final CoderResult encodeLoop(CharBuffer var1, ByteBuffer var2) {return var1.hasArray() && var2.hasArray() ? this.encodeArrayLoop(var1, var2) : this.encodeBufferLoop(var1, var2);}

這段代碼實(shí)現(xiàn)了完整的編碼操作。

（又到了底層地獄，打擾了，有誰看懂了嗎，我竟然查不到encodeArrayLoop這函數(shù)的資料…）

private CoderResult encodeArrayLoop(CharBuffer src, ByteBuffer dst){ char[] sa = src.array(); int sp = src.arrayOffset() + src.position(); int sl = src.arrayOffset() + src.limit(); byte[] da = dst.array(); int dp = dst.arrayOffset() + dst.position(); int dl = dst.arrayOffset() + dst.limit(); int dlASCII = dp + Math.min(sl - sp, dl - dp); // ASCII only loop while (dp < dlASCII && sa[sp] < '\u0080') da[dp++] = (byte) sa[sp++]; while (sp < sl) { char c = sa[sp]; if (c < 0x80) { // Have at most seven bits if (dp >= dl) return overflow(src, sp, dst, dp); da[dp++] = (byte)c; } else if (c < 0x800) { // 2 bytes, 11 bits if (dl - dp < 2) return overflow(src, sp, dst, dp); da[dp++] = (byte)(0xc0 | (c >> 6)); da[dp++] = (byte)(0x80 | (c & 0x3f)); } else if (Character.isSurrogate(c)) { // Have a surrogate pair if (sgp == null) sgp = new Surrogate.Parser(); int uc = sgp.parse(c, sa, sp, sl); if (uc < 0) { updatePositions(src, sp, dst, dp); return sgp.error(); } if (dl - dp < 4) return overflow(src, sp, dst, dp); da[dp++] = (byte)(0xf0 | ((uc >> 18))); da[dp++] = (byte)(0x80 | ((uc >> 12) & 0x3f)); da[dp++] = (byte)(0x80 | ((uc >> 6) & 0x3f)); da[dp++] = (byte)(0x80 | (uc & 0x3f)); sp++; // 2 chars } else { // 3 bytes, 16 bits if (dl - dp < 3) return overflow(src, sp, dst, dp); da[dp++] = (byte)(0xe0 | ((c >> 12))); da[dp++] = (byte)(0x80 | ((c >> 6) & 0x3f)); da[dp++] = (byte)(0x80 | (c & 0x3f)); } sp++; } updatePositions(src, sp, dst, dp); return CoderResult.UNDERFLOW; }

解密源碼

和加密類似，鏡像的編程，就不貼出來了，感興趣可以自己解析一下encodeArrayLoop和decodeArrayLoop，因?yàn)榇_實(shí)沒有研究這個(gè)實(shí)現(xiàn)

private CoderResult decodeArrayLoop(ByteBuffer var1, CharBuffer var2) {byte[] var3 = var1.array();int var4 = var1.arrayOffset() + var1.position();int var5 = var1.arrayOffset() + var1.limit();char[] var6 = var2.array();int var7 = var2.arrayOffset() + var2.position();int var8 = var2.arrayOffset() + var2.limit();for(int var9 = var7 + Math.min(var5 - var4, var8 - var7); var7 < var9 && var3[var4] >= 0; var6[var7++] = (char)var3[var4++]) {}while(true) {while(var4 < var5) {byte var10 = var3[var4];if (var10 < 0) {if (var10 >> 5 == -2 && (var10 & 30) != 0) {if (var5 - var4 < 2 || var7 >= var8) {return xflow(var1, var4, var5, var2, var7, 2);}byte var17 = var3[var4 + 1];if (isNotContinuation(var17)) {return malformedForLength(var1, var4, var2, var7, 1);}var6[var7++] = (char)(var10 << 6 ^ var17 ^ 3968);var4 += 2;} else {int var11;byte var12;byte var13;if (var10 >> 4 == -2) {var11 = var5 - var4;if (var11 < 3 || var7 >= var8) {if (var11 > 1 && isMalformed3_2(var10, var3[var4 + 1])) {return malformedForLength(var1, var4, var2, var7, 1);}return xflow(var1, var4, var5, var2, var7, 3);}var12 = var3[var4 + 1];var13 = var3[var4 + 2];if (isMalformed3(var10, var12, var13)) {return malformed(var1, var4, var2, var7, 3);}char var18 = (char)(var10 << 12 ^ var12 << 6 ^ var13 ^ -123008);if (Character.isSurrogate(var18)) {return malformedForLength(var1, var4, var2, var7, 3);}var6[var7++] = var18;var4 += 3;} else {if (var10 >> 3 != -2) {return malformed(var1, var4, var2, var7, 1);}var11 = var5 - var4;if (var11 >= 4 && var8 - var7 >= 2) {var12 = var3[var4 + 1];var13 = var3[var4 + 2];byte var14 = var3[var4 + 3];int var15 = var10 << 18 ^ var12 << 12 ^ var13 << 6 ^ var14 ^ 3678080;if (!isMalformed4(var12, var13, var14) && Character.isSupplementaryCodePoint(var15)) {var6[var7++] = Character.highSurrogate(var15);var6[var7++] = Character.lowSurrogate(var15);var4 += 4;continue;}return malformed(var1, var4, var2, var7, 4);}int var16 = var10 & 255;if (var16 <= 244 && (var11 <= 1 || !isMalformed4_2(var16, var3[var4 + 1] & 255))) {if (var11 > 2 && isMalformed4_3(var3[var4 + 2])) {return malformedForLength(var1, var4, var2, var7, 2);}return xflow(var1, var4, var5, var2, var7, 4);}return malformedForLength(var1, var4, var2, var7, 1);}}} else {if (var7 >= var8) {return xflow(var1, var4, var5, var2, var7, 1);}var6[var7++] = (char)var10;++var4;}}return xflow(var1, var4, var5, var2, var7, 0);}}

總結(jié)

以上是生活随笔為你收集整理的闭关修炼（十二） NIO的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯(cuò)，歡迎將生活随笔推薦給好友。

NIO
十二

上一篇：开源C++单元测试框架Google Te
下一篇： crh寄存器_STM32的寄存器控制SD