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();
            }
        }
    }
}