前言

公司業務需求，需要用到tcp數據傳輸，基于java自帶的socket太low，而且編程復雜，市面上比較流行的netty比較適合。學習netty之前，先簡單總結一下各種數據傳輸類型。

java支持的類型

Java 共支持 3 種網絡編程模型/IO 模式：BIO、NIO、AIO

Java BIO：

理解： 同步并阻塞(傳統阻塞型)，服務器實現模式為一個連接一個線程，即客戶端有連接請求時服務器
端就需要啟動一個線程進行處理，如果這個連接不做任何事情會造成不必要的線程開銷
適用場景：BIO 方式適用于連接數目比較小且固定的架構，這種方式對服務器資源要求比較高，并發局限于應用中，JDK1.4
以前的唯一選擇，但程序簡單易理解。
通俗理解：一個請求需要創建一個新的線程，如果客戶端比較多的話，服務器肯定是受不了的

Java NIO ：

理解： 同步非阻塞，服務器實現模式為一個線程處理多個請求(連接)，即客戶端發送的連接請求都會注
冊到多路復用器上，多路復用器輪詢到連接有 I/O 請求就進行處理
適用場景：NIO 方式適用于連接數目多且連接比較短（輕操作）的架構，比如聊天服務器，彈幕系統，服務器間通訊等。
編程比較復雜，JDK1.4 開始支持。
通俗理解:NIO有緩沖池，有通道。有選擇器，一個選擇器一個線程，多個通道對應多個緩沖池，可對應一個通道，這樣有請求過來，直接放到選擇器，由選擇器一個個執行，這樣就做到了同步，并且非阻塞。

Java AIO

理解： 異步非阻塞，AIO 引入異步通道的概念，采用了 Proactor 模式，簡化了程序編寫，有效
的請求才啟動線程，它的特點是先由操作系統完成后才通知服務端程序啟動線程去處理，一般適用于連接數較
多且連接時間較長的應用，JDK1.4 開始支持。
適用場景：AIO 方式使用于連接數目多且連接比較長（重操作）的架構，比如相冊服務器，充分調用 OS 參與并發操作，
編程比較復雜，JDK7 開始支持。
通俗理解：這個是1.7以后才支持的，用的比較少，跟netty關系也不大，感興趣的可自行研究。

NIO三大核心

因為netty是基礎NIO模型的框架，所以下面著重講一下NIO的三大核心。

NIO模型圖解：

緩沖區

理解：緩沖區本質上是一個 可以讀寫數據的內存塊可以理解成是一個 容器對象（包含數組的對象）。它能夠跟蹤和記錄緩沖區內的狀態變化。
主要實現方法
頂級父類是buffer。

屬性

通道

理解：NIO 的通道類似于流，但有些區別如下

1. 通道可以同時進行讀寫，而流只能讀或者只能寫

2. 通道可以實現異步讀寫數據

3. 通道可以從緩沖讀數據，也可以寫數據到緩沖
   主要實現方法
   頂級父類是channel
   實現子類：

4. FileChannel 用于文件的數據讀寫

5. DatagramChannel 用于 UDP 的數據讀寫

6. ServerSocketChannel是TCP服務端數據讀寫

7. SocketChannel 是客戶端TCP 的數據讀寫。
   常見方法

8. public int read(ByteBuffer dst) ，從通道讀取數據并放到緩沖區中

9. public int write(ByteBuffer src) ，把緩沖區的數據寫到通道中

10. public long transferFrom(ReadableByteChannel src, long position, long count)，從目標通道中復制數據到當前通道

11. public long transferTo(long position, long count, WritableByteChannel target)，把數據從當前通道復制給目標通道

選擇器

理解：用非阻塞的 IO 方式。可以用一個線程，處理多個的客戶端連接，就會使用到 Selector(選擇器)，一個選擇器管理多個通道，其管理的通道注冊到選擇器上，然后選擇器會監聽通道內是否發生變化，如果變化了，才會去處理，這樣就降低了連接的開銷。

常用方法
open（）得到一個選擇器對象
select（long timeout） 監控所有注冊的通道。當其中有IO操作的時候，將對應的selectkey加入到內部集合并且返回。參數用來設置超時時間，
selectkeys（）用來獲取所有注冊到選擇器上面的通道。

流程圖

文字解釋

代碼示例

客戶端代碼

package com.huali.nio.groupchat;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.SocketChannel;
import java.util.Iterator;
import java.util.Scanner;
import java.util.Set;

public class GroupChatClient {

    //定義相關的屬性
    private final String HOST = "127.0.0.1"; // 服務器的ip
    private final int PORT = 6667; //服務器端口
    private Selector selector;
    private SocketChannel socketChannel;
    private String username;

    //構造器, 完成初始化工作
    public GroupChatClient() throws IOException {

        selector = Selector.open();
        //連接服務器
        socketChannel = socketChannel.open(new InetSocketAddress("127.0.0.1", PORT));
        //設置非阻塞
        socketChannel.configureBlocking(false);
        //將channel 注冊到selector
        socketChannel.register(selector, SelectionKey.OP_READ);
        //得到username
        username = socketChannel.getLocalAddress().toString().substring(1);
        System.out.println(username + " is ok...");

    }

    //向服務器發送消息
    public void sendInfo(String info) {

        info = username + " 說：" + info;

        try {
            socketChannel.write(ByteBuffer.wrap(info.getBytes()));
        }catch (IOException e) {
            e.printStackTrace();
        }
    }

    //讀取從服務器端回復的消息
    public void readInfo() {

        try {

            int readChannels = selector.select();
            if(readChannels > 0) {//有可以用的通道

                Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
                while (iterator.hasNext()) {

                    SelectionKey key = iterator.next();
                    if(key.isReadable()) {
                        //得到相關的通道
                       SocketChannel sc = (SocketChannel) key.channel();
                       //得到一個Buffer
                        ByteBuffer buffer = ByteBuffer.allocate(1024);
                        //讀取
                        sc.read(buffer);
                        //把讀到的緩沖區的數據轉成字符串
                        String msg = new String(buffer.array());
                        System.out.println(msg.trim());
                    }
                }
                iterator.remove(); //刪除當前的selectionKey, 防止重復操作
            } else {
                //System.out.println("沒有可以用的通道...");

            }

        }catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) throws Exception {

        //啟動我們客戶端
        GroupChatClient chatClient = new GroupChatClient();

        //啟動一個線程, 每個3秒，讀取從服務器發送數據
        new Thread() {
            public void run() {

                while (true) {
                    chatClient.readInfo();
                    try {
                        Thread.currentThread().sleep(3000);
                    }catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }.start();

        //發送數據給服務器端
        Scanner scanner = new Scanner(System.in);

        while (scanner.hasNextLine()) {
            String s = scanner.nextLine();
            chatClient.sendInfo(s);
        }
    }


}

客戶端代碼

package com.huali.nio.groupchat;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.*;
import java.util.Iterator;

public class GroupChatServer {
    //定義屬性
    private Selector selector;
    private ServerSocketChannel listenChannel;
    private static final int PORT = 6667;

    //構造器
    //初始化工作
    public GroupChatServer() {

        try {

            //得到選擇器
            selector = Selector.open();
            //ServerSocketChannel
            listenChannel =  ServerSocketChannel.open();
            //綁定端口
            listenChannel.socket().bind(new InetSocketAddress(PORT));
            //設置非阻塞模式
            listenChannel.configureBlocking(false);
            //將該listenChannel 注冊到selector
            listenChannel.register(selector, SelectionKey.OP_ACCEPT);

        }catch (IOException e) {
            e.printStackTrace();
        }

    }

    //監聽
    public void listen() {

        System.out.println("監聽線程: " + Thread.currentThread().getName());
        try {

            //循環處理
            while (true) {

                int count = selector.select();
                if(count > 0) {//有事件處理

                    //遍歷得到selectionKey 集合
                    Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
                    while (iterator.hasNext()) {
                        //取出selectionkey
                        SelectionKey key = iterator.next();

                        //監聽到accept
                        if(key.isAcceptable()) {
                            SocketChannel sc = listenChannel.accept();
                            sc.configureBlocking(false);
                            //將該 sc 注冊到seletor
                            sc.register(selector, SelectionKey.OP_READ);

                            //提示
                            System.out.println(sc.getRemoteAddress() + " 上線 ");

                        }
                        if(key.isReadable()) { //通道發送read事件，即通道是可讀的狀態
                            //處理讀 (專門寫方法..)

                            readData(key);

                        }
                        //當前的key 刪除，防止重復處理
                        iterator.remove();
                    }

                } else {
                    System.out.println("等待....");
                }
            }

        }catch (Exception e) {
            e.printStackTrace();

        }finally {
            //發生異常處理....

        }
    }

    //讀取客戶端消息
    private void readData(SelectionKey key) {

        //取到關聯的channle
        SocketChannel channel = null;

        try {
           //得到channel
            channel = (SocketChannel) key.channel();
            //創建buffer
            ByteBuffer buffer = ByteBuffer.allocate(1024);

            int count = channel.read(buffer);
            //根據count的值做處理
            if(count > 0) {
                //把緩存區的數據轉成字符串
                String msg = new String(buffer.array());
                //輸出該消息
                System.out.println("form 客戶端: " + msg);

                //向其它的客戶端轉發消息(去掉自己), 專門寫一個方法來處理
                sendInfoToOtherClients(msg, channel);
            }

        }catch (IOException e) {
            try {
                System.out.println(channel.getRemoteAddress() + " 離線了..");
                //取消注冊
                key.cancel();
                //關閉通道
                channel.close();
            }catch (IOException e2) {
                e2.printStackTrace();;
            }
        }
    }

    //轉發消息給其它客戶(通道)
    private void sendInfoToOtherClients(String msg, SocketChannel self ) throws  IOException{

        System.out.println("服務器轉發消息中...");
        System.out.println("服務器轉發數據給客戶端線程: " + Thread.currentThread().getName());
        //遍歷 所有注冊到selector 上的 SocketChannel,并排除 self
        for(SelectionKey key: selector.keys()) {

            //通過 key  取出對應的 SocketChannel
            Channel targetChannel = key.channel();

            //排除自己
            if(targetChannel instanceof  SocketChannel && targetChannel != self) {

                //轉型
                SocketChannel dest = (SocketChannel)targetChannel;
                //將msg 存儲到buffer
                ByteBuffer buffer = ByteBuffer.wrap(msg.getBytes());
                //將buffer 的數據寫入 通道
                dest.write(buffer);
            }
        }

    }

    public static void main(String[] args) {

        //創建服務器對象
        GroupChatServer groupChatServer = new GroupChatServer();
        groupChatServer.listen();
    }
}

//可以寫一個Handler
class MyHandler {
    public void readData() {

    }
    public void sendInfoToOtherClients(){

    }
}