Java NIO學習，一次讀懂Java NIO

// 編碼解碼
@Test
public void test10() throws CharacterCodingException {
    Charset charset = Charset.forName("GBK");
    // 獲取編碼器
    CharsetEncoder encoder = charset.newEncoder();
    // 獲取解碼器
    CharsetDecoder decoder = charset.newDecoder();


    CharBuffer charBuffer = CharBuffer.allocate(1024);
    charBuffer.put("尚硅谷威武！");
    // 切換讀模式
    charBuffer.flip();


    // 編碼
    ByteBuffer buffer = encoder.encode(charBuffer);
    for (int i = 0; i < 12; i++) {
        System.out.println(buffer.get());
    }
    // 解碼
    buffer.flip();
    CharBuffer cb = decoder.decode(buffer);
    System.out.println(cb.toString());
    System.out.println("============================");
    buffer.flip();
    Charset cs = Charset.forName("UTF-8");
    CharBuffer cBuf = cs.decode(buffer);
    System.out.println(cBuf.toString());
}

使用NIO完成網路通信的三大核心：

1、通道（Channel）：負責連接

java.nio.channels.Channel 介面：

|--SelectableChannel

|--SocketChannel

|--ServerSocketChannel //上兩個是TCP

|--DatagramChannel //UDP，都是用于網路 IO

|--Pipe.SinkChannel

|--Pipi.SourceChannel

2、緩沖區（Buffer）：負責資料的存取

3、選擇器（Selector）：是 SelectableChannel 的多路復用器，用于監控 SelectableChannel 的 IO 狀況

SelectionKey：表示 SelectableChannel 和 Selector 之間的注冊關系，每次向選擇器注冊通道時就會選澤一個事件（選擇鍵）

示例1：阻塞式IO

當client端向server端發送請求時，如果server端不能確定client請求的讀/寫的資料，server端會處于阻塞狀態，阻塞狀態下server端下的此執行緒不能做其他操作，一直等待，當server有client端需要讀/寫的資料時，會將資料讀/寫給用戶，然后釋放資源

// 模擬網路IO，客戶端
@Test
public void nioClient(){
    SocketChannel socketChannel = null;
    FileChannel fileChannel = null;
    try {
        // 1. 獲取通道
        socketChannel = SocketChannel.open(new InetSocketAddress("127.0.0.1",9898));

        fileChannel = FileChannel.open(Paths.get("E:\\休閑生活\\桌面壁紙\\無情的戰爭.jpg"), StandardOpenOption.READ);
        // 2. 分配指定大小緩沖區
        ByteBuffer buf = ByteBuffer.allocate(1024);
        // 3. 讀取本地檔案，并發送到服務器
        while (fileChannel.read(buf)!=-1){
            buf.flip();
            socketChannel.write(buf);
            buf.clear();
        }

    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        // 關閉通道
        try {
            if(fileChannel!=null){
                fileChannel.close();
            }
            if (socketChannel!=null){
                socketChannel.close();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}


// 服務端
@Test
public void nioServer(){
    ServerSocketChannel ssChannel = null;
    FileChannel outChannel = null;
    try {
        // 1. 獲取通道
        ssChannel = ServerSocketChannel.open();
        outChannel = FileChannel.open(Paths.get("E:\\休閑生活\\桌面壁紙\\2.jpg"),StandardOpenOption.WRITE,StandardOpenOption.CREATE);
        // 2. 系結連接
        ssChannel.bind(new InetSocketAddress(9898));
        // 3. 獲取客戶端通道
        SocketChannel sChannel = ssChannel.accept();
        // 4. 分配指定大小的緩沖區
        ByteBuffer buf = ByteBuffer.allocate(1024);
        // 5. 接收客戶端資料，并保存到本地
        while (sChannel.read(buf)!=-1){
            buf.flip();
            outChannel.write(buf);
            buf.clear();
        }


    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        // 關閉通道
        try {
            if(outChannel!=null){
                outChannel.close();
            }
            if(ssChannel!=null){
                ssChannel.close();
            }
        } catch (Exception e){
            e.printStackTrace();
        }
    }
}

非阻塞式IO

示例1：非阻塞式IO

public class TestNonBlockingIO {


    @Test
    public void client() throws IOException {
        //獲取通道
        SocketChannel sChannel = SocketChannel.open(new InetSocketAddress("127.0.0.1", 9898));
        //切換成非阻塞式
        sChannel.configureBlocking(false);
        //分配指定大小的緩沖區
        ByteBuffer buf = ByteBuffer.allocate(1024);
        //發送資料給服務端
//        buf.put(LocalDateTime.now().toString().getBytes());
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNext()){
            String str = scanner.next();
            buf.put((new Date().toString() +"\n" + str).getBytes());
            buf.flip();
            sChannel.write(buf);
            buf.clear();
        }


        //關閉通道
        sChannel.close();
    }


    @Test
    public void server() throws IOException {
        // 1. 獲取通道
        ServerSocketChannel ssChannel = ServerSocketChannel.open();
        // 2. 切換非阻塞式
        ssChannel.configureBlocking(false);
        // 3. 系結連接
        ssChannel.bind(new InetSocketAddress(9898));
        // 4. 獲取選擇器
        Selector selector = Selector.open();
        // 5. 將通道注冊到選擇器上，并指定“監聽連接事件”
        ssChannel.register(selector, SelectionKey.OP_ACCEPT);
        // 6. 輪詢式的獲取選擇器上以及“準備就緒”的事件
        while (selector.select()>0){
            // 7. 獲取當前選擇器中所有注冊的“選擇鍵（已就緒的監聽事件）”
            Iterator<SelectionKey> it = selector.selectedKeys().iterator();
            while (it.hasNext()){
                // 8. 獲取準備“就緒”的事件
                SelectionKey sk = it.next();
                // 9. 判斷具體是什么事件準備就緒
                if(sk.isAcceptable()){
                    // 10. 若“接收就緒”，獲取客戶端連接
                    SocketChannel sChannel = ssChannel.accept();
                    // 11. 切換非阻塞模式
                    sChannel.configureBlocking(false);
                    // 12. 將該通道注冊到選擇器上
                    sChannel.register(selector,SelectionKey.OP_READ);
                } else if(sk.isReadable()){
                    // 13. 獲取當前選擇器上“讀就緒”狀態的通道
                    SocketChannel sChannel = (SocketChannel) sk.channel();
                    // 14. 讀取資料
                    ByteBuffer buf = ByteBuffer.allocate(1024);
                    int len = 0;
                    while ((len = sChannel.read(buf))>0){
                        buf.flip();
                        System.out.println(new String(buf.array(),0,len));
                        buf.clear();
                    }
                }
                // 15. 取消選擇鍵，SelectionKey
                it.remove();
            }
        }
    }
}