public class BioServer {

    public static void main(String[] args) throws IOException {
        // 創(chuàng)建listen-socket
        ServerSocket listenSocket = new ServerSocket(8080);
        // 進(jìn)入監(jiān)聽(tīng)狀態(tài)，是一個(gè)阻塞狀態(tài)
        // 有客戶(hù)端連接時(shí)從監(jiān)聽(tīng)狀態(tài)返回
        // 并創(chuàng)建代表這個(gè)客戶(hù)端的client-socket
        Socket clientSocket = listenSocket.accept();
        // 獲取client-socket輸入流
        BufferedReader bufferedReader = new BufferedReader(
                new InputStreamReader(clientSocket.getInputStream()));
        // 讀取客戶(hù)端發(fā)送的數(shù)據(jù)
        // 如果數(shù)據(jù)沒(méi)準(zhǔn)備好，會(huì)進(jìn)入阻塞狀態(tài)
        String data = bufferedReader.readLine();
        System.out.println(data);

        // 獲取client-socket輸出流
        BufferedWriter bufferedWriter = new BufferedWriter(
                new OutputStreamWriter(clientSocket.getOutputStream()));
        // 服務(wù)端向客戶(hù)端發(fā)送數(shù)據(jù)
        bufferedWriter.write("來(lái)自服務(wù)端的返回?cái)?shù)據(jù)\n");
        // 刷新流
        bufferedWriter.flush();
    }

}

public class BioClient {

    public static final String SERVER_IP = "127.0.0.1";
    public static final int SERVER_PORT = 8080;

    public static void main(String[] args) throws IOException {
        // 客戶(hù)端創(chuàng)建connect-socket
        Socket connectSocket = new Socket(SERVER_IP, SERVER_PORT);
        // 獲取connect-socket輸出流
        BufferedWriter bufferedWriter = new BufferedWriter(
                new OutputStreamWriter(connectSocket.getOutputStream()));
        // 客戶(hù)端向服務(wù)端發(fā)送數(shù)據(jù)
        bufferedWriter.write("來(lái)自客戶(hù)端的請(qǐng)求數(shù)據(jù)\n");
        // 刷新流
        bufferedWriter.flush();

        // 獲取connect-socket輸入流
        BufferedReader bufferedReader = new BufferedReader(
                new InputStreamReader(connectSocket.getInputStream()));
        // 讀取服務(wù)端發(fā)送的數(shù)據(jù)
        String returnData = bufferedReader.readLine();
        System.out.println(returnData);
    }

}

public class NonbioServer {

    public static final List<SocketChannel> clientSocketChannels = new ArrayList<>();

    public static void main(String[] args) throws Exception {
        // 客戶(hù)端創(chuàng)建listen-socket管道
        // 管道支持非阻塞模式和同時(shí)讀寫(xiě)
        ServerSocketChannel listenSocketChannel = ServerSocketChannel.open();
        // 設(shè)置為非阻塞模式
        listenSocketChannel.configureBlocking(false);
        // 綁定監(jiān)聽(tīng)的端口號(hào)
        listenSocketChannel.socket().bind(new InetSocketAddress(8080));
        // 在子線(xiàn)程中遍歷clientSocketChannels并讀取客戶(hù)端數(shù)據(jù)
        handleSocketChannels();

        while (true) {
            // 非阻塞方式監(jiān)聽(tīng)客戶(hù)端連接
            // 如果無(wú)客戶(hù)端連接則返回空
            // 有客戶(hù)端連接則創(chuàng)建代表這個(gè)客戶(hù)端的client-socket管道
            SocketChannel clientSocketChannel = listenSocketChannel.accept();
            if (clientSocketChannel != null) {
                // 設(shè)置為非阻塞模式
                clientSocketChannel.configureBlocking(false);
                // 添加到clientSocketChannels中
                // 用于子線(xiàn)程遍歷并讀取客戶(hù)端數(shù)據(jù)
                clientSocketChannels.add(clientSocketChannel);
            } else {
                LockSupport.parkNanos(1000 * 1000 * 1000);
            }
        }
    }

    public static void handleSocketChannels() {
        new Thread(() -> {
            while (true) {
                // 遍歷每一個(gè)client-socket管道
                Iterator<SocketChannel> iterator = clientSocketChannels.iterator();
                while (iterator.hasNext()) {
                    SocketChannel clientSocketChannel = iterator.next();
                    ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
                    int read = 0;
                    try {
                        // 將客戶(hù)端發(fā)送的數(shù)據(jù)讀取到ByteBuffer中
                        // 這一步的操作也是非阻塞的
                        read = clientSocketChannel.read(byteBuffer);
                    } catch (IOException e) {
                        // 移除發(fā)生異常的client-socket管道
                        iterator.remove();
                        e.printStackTrace();
                    }
                    if (read == 0) {
                        System.out.println("客戶(hù)端數(shù)據(jù)未就緒");
                    } else {
                        System.out.println("客戶(hù)端數(shù)據(jù)為：" + new String(byteBuffer.array()));
                    }
                }
                LockSupport.parkNanos(1000 * 1000 * 1000);
            }
        }).start();
    }

}

public class NioServer {

    private static Selector selector;

    public static void main(String[] args) {

        try {
            // 開(kāi)啟并得到多路復(fù)用器
            selector = Selector.open();
            // 服務(wù)端創(chuàng)建listen-socket管道
            ServerSocketChannel listenSocketChannel = ServerSocketChannel.open();
            // 設(shè)置為非阻塞模式
            listenSocketChannel.configureBlocking(false);
            // 為管道綁定端口
            listenSocketChannel.socket().bind(new InetSocketAddress(8080));
            // 將listen-socket管道注冊(cè)到多路復(fù)用器上，并指定監(jiān)聽(tīng)ACCEPT事件
            listenSocketChannel.register(selector, SelectionKey.OP_ACCEPT);

            while (true) {
                // 獲取發(fā)生的事件，這個(gè)操作是阻塞的
                selector.select();
                // 拿到有事件發(fā)生的SelectionKey集合
                // SelectionKey表示管道與多路復(fù)用器的綁定關(guān)系
                Set<SelectionKey> selectionKeys = selector.selectedKeys();
                // 遍歷每個(gè)發(fā)生的事件，然后判斷事件類(lèi)型
                // 根據(jù)事件類(lèi)型，進(jìn)行不同的處理
                Iterator<SelectionKey> iterator = selectionKeys.iterator();
                while (iterator.hasNext()) {
                    SelectionKey selectionKey = iterator.next();
                    iterator.remove();
                    if (selectionKey.isAcceptable()) {
                        // 處理客戶(hù)端連接事件
                        handlerAccept(selectionKey);
                    } else if (selectionKey.isReadable()) {
                        // 處理客戶(hù)端數(shù)據(jù)可讀事件
                        handlerRead(selectionKey);
                    }
                }
                LockSupport.parkNanos(1000 * 1000 * 1000);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private static void handlerAccept(SelectionKey selectionKey) {
        // 從事件中獲取到listen-socket管道
        ServerSocketChannel listenSocketChannel = (ServerSocketChannel) selectionKey.channel();
        try {
            // 為連接的客戶(hù)端創(chuàng)建client-socket管道
            SocketChannel clientSocketChannel = listenSocketChannel.accept();
            // 設(shè)置為非阻塞模式
            clientSocketChannel.configureBlocking(false);
            // 將client-socket管道注冊(cè)到多路復(fù)用器上，并指定監(jiān)聽(tīng)READ事件
            clientSocketChannel.register(selector, SelectionKey.OP_READ);
            // 給客戶(hù)端發(fā)送數(shù)據(jù)
            clientSocketChannel.write(ByteBuffer.wrap("連接已建立\n".getBytes()));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private static void handlerRead(SelectionKey selectionKey) {
        // 從事件中獲取到client-socket管道
        SocketChannel clientSocketChannel = (SocketChannel) selectionKey.channel();
        ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
        try {
            // 讀取客戶(hù)端數(shù)據(jù)
            int read = clientSocketChannel.read(byteBuffer);
            if (read <= 0) {
                // 關(guān)閉管道
                clientSocketChannel.close();
                // 從多路復(fù)用器移除綁定關(guān)系
                selectionKey.cancel();
            } else {
                System.out.println(new String(byteBuffer.array()));
            }
        } catch (IOException e1) {
            try {
                // 關(guān)閉管道
                clientSocketChannel.close();
            } catch (IOException e2) {
                e2.printStackTrace();
            }
            // 從多路復(fù)用器移除綁定關(guān)系
            selectionKey.cancel();
            e1.printStackTrace();
        }
    }

}

public class NioClient {

    private static Selector selector;

    public static final String SERVER_IP = "127.0.0.1";
    public static final int SERVER_PORT = 8080;

    public static void main(String[] args) {
        try {
            // 開(kāi)啟并得到多路復(fù)用器
            selector = Selector.open();
            // 創(chuàng)建connect-socket管道
            SocketChannel connectSocketChannel = SocketChannel.open();
            // 設(shè)置為非阻塞模式
            connectSocketChannel.configureBlocking(false);
            // 設(shè)置服務(wù)端IP和端口
            connectSocketChannel.connect(new InetSocketAddress(SERVER_IP, SERVER_PORT));
            // 將connect-socket管道注冊(cè)到多路復(fù)用器上，并指定監(jiān)聽(tīng)CONNECT事件
            connectSocketChannel.register(selector, SelectionKey.OP_CONNECT);

            while (true) {
                // 獲取發(fā)生的事件，這個(gè)操作是阻塞的
                selector.select();
                // 拿到有事件發(fā)生的SelectionKey集合
                // SelectionKey表示管道與多路復(fù)用器的綁定關(guān)系
                Set<SelectionKey> selectionKeys = selector.selectedKeys();
                // 遍歷每個(gè)發(fā)生的事件，然后判斷事件類(lèi)型
                // 根據(jù)事件類(lèi)型，進(jìn)行不同的處理
                Iterator<SelectionKey> iterator = selectionKeys.iterator();
                while (iterator.hasNext()) {
                    SelectionKey selectionKey = iterator.next();
                    iterator.remove();
                    if (selectionKey.isConnectable()) {
                        // 處理連接建立事件
                        handlerConnect(selectionKey);
                    } else if (selectionKey.isReadable()) {
                        // 處理服務(wù)端數(shù)據(jù)可讀事件
                        handlerRead(selectionKey);
                    }
                }
                LockSupport.parkNanos(1000 * 1000 * 1000);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private static void handlerConnect(SelectionKey selectionKey) throws IOException {
        // 拿到connect-socket管道
        SocketChannel connectSocketChannel = (SocketChannel) selectionKey.channel();
        if (connectSocketChannel.isConnectionPending()) {
            connectSocketChannel.finishConnect();
        }
        // 設(shè)置為非阻塞模式
        connectSocketChannel.configureBlocking(false);
        // 將connect-socket管道注冊(cè)到多路復(fù)用器上，并指定監(jiān)聽(tīng)READ事件
        connectSocketChannel.register(selector, SelectionKey.OP_READ);
        // 向服務(wù)端發(fā)送數(shù)據(jù)
        connectSocketChannel.write(ByteBuffer.wrap("客戶(hù)端發(fā)送的數(shù)據(jù)\n".getBytes()));
    }

    private static void handlerRead(SelectionKey selectionKey) {
        // 拿到connect-socket管道
        SocketChannel connectSocketChannel = (SocketChannel) selectionKey.channel();
        ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
        try {
            // 讀取服務(wù)端數(shù)據(jù)
            int read = connectSocketChannel.read(byteBuffer);
            if (read <= 0) {
                // 關(guān)閉管道
                connectSocketChannel.close();
                // 從多路復(fù)用器移除綁定關(guān)系
                selectionKey.cancel();
            } else {
                System.out.println(new String(byteBuffer.array()));
            }
        } catch (IOException e1) {
            try {
                // 關(guān)閉管道
                connectSocketChannel.close();
            } catch (IOException e2) {
                e2.printStackTrace();
            }
            // 從多路復(fù)用器移除綁定關(guān)系
            selectionKey.cancel();
            e1.printStackTrace();
        }
    }

}