server:服务端

　　服务端会产生一个ServerSocketChannel，它会注册到selector中，用于服务端和客户端通信使用

client:客户端

　　客户端会产生一个SocketChannel,它会注册到seletor中，用户服务端和客户端通信使用

buffer:缓冲区

　　用于客户端和服务端进行数据传输使用，既可以read也可以wirte

channel:通道

　　包括服务端的ServerSocketChannel和客户端的SocketChannel的通道，它是连接客户端和服务端的通道，是一个双向的既可以读也可以写，都是通过buffer完成的

selector:多路复用器

　　负责管理channel

selectedKeys:用于获取SocketChannel

//同步非阻塞  把整个过程分为三部分  建立连接  接收客户端数据(在客户端写之前，不会触发本事件，可以去处理其它的事件)  向客户端发送数据 类似于生产者消费者

public class NioServer {

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

        // 打开服务端通道

        ServerSocketChannel ssc = ServerSocketChannel.open();

        // 设置成非阻塞

        ssc.configureBlocking(false);

        // 绑定端口

        ssc.socket().bind(new InetSocketAddress(9000));

        // 打开多路复用器

        Selector selector = Selector.open();

        // 把ServerSocketChannel注册到selector上，并且selector对客户端accept连接感兴趣

        ssc.register(selector, SelectionKey.OP_ACCEPT);

        while (true) {

            System.out.println("等待事件发生。。");

            // 选择多路复用器里面的通道，方法是阻塞的，只有存在客户端进行连接，才可以执行后面逻辑

            int select = selector.select();

            System.out.println("有事件发生了。。");

            // 获取多路复用器里面的所有注册的通道key

            Iterator<SelectionKey> it = selector.selectedKeys().iterator();

            while (it.hasNext()) {

                // 获取某一个通道key

                SelectionKey key = it.next();

                // 删除当前可以，防止多次处理

                it.remove();

                handle(key);

            }

        }

    }

    private static void handle(SelectionKey key) throws IOException {

        // 验证当前通道属于什么事件

        if (key.isAcceptable()) { // 连接事件

            System.out.println("有客户端连接事件发生了。。");

            // 获取当前key所在的通道

            ServerSocketChannel ssc = (ServerSocketChannel) key.channel();

            // 调用accept()方法获取客户端SocketChannel通道。

            //注意这里是阻塞状态的，但是也是非阻塞状态的，这里就是NIO的精髓

            //我给大家讲解一下，accept()方法本身是阻塞，它要有客户端连接进来才能向下执行

            //前面已经判断是Acceptable()事件，所以一定有客户端进行连接，所以这里就不用等待了

            SocketChannel sc = ssc.accept();

            // 设置通道为非阻塞方式

            sc.configureBlocking(false);

            // 将通道注册到多路复用器上，并且注册事件是OP_READ时间

            sc.register(key.selector(), SelectionKey.OP_READ);

        } else if (key.isReadable()) {

            System.out.println("有客户端数据可读事件发生了。。");

            SocketChannel sc = (SocketChannel) key.channel();

            ByteBuffer buffer = ByteBuffer.allocate(1024);

            int len = sc.read(buffer);

            if (len != -1){

                System.out.println("读取到客户端发送的数据:" + new String(buffer.array(), 0, len));

            }

            ByteBuffer bufferToWrite = ByteBuffer.wrap("HelloClient".getBytes());

            sc.write(bufferToWrite);

            key.interestOps(SelectionKey.OP_READ | SelectionKey.OP_WRITE);

        } else if (key.isWritable()) {

            SocketChannel sc = (SocketChannel) key.channel();

            System.out.println("write事件");

            key.interestOps(SelectionKey.OP_READ);

        }

    }

}

//把整个过程分为三个事件  建立连接  向服务端发送数据 接收服务端数据(在服务端写之前，不会触发本事件，线程就可以去处理其它的事件)

public class NioClient {

    private Selector selector;

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

            new Thread(()->{

                try {

                    co(Thread.currentThread().getName());

                } catch (IOException e) {

                    e.printStackTrace();

                }

            }, "客户端1" ).start();

    }

    public static void co(String clientname ) throws IOException {

        NioClient nioClientDemo = new NioClient();

        // 初始化客户端

        nioClientDemo.initClient("localhost",9000);

        // 客户端进行对应操作

        nioClientDemo.connect( clientname);

    }

    /**

     * 初始化客户端

     * @param ip

     * @param port

     * @throws IOException

     */

    private  void initClient(String ip,int port) throws IOException {

        // 获取socket通道

        SocketChannel socketChannel = SocketChannel.open();

        // 配置非阻塞

        socketChannel.configureBlocking(false);

        // 打开多路复用器

        this.selector = Selector.open();

        // 连接服务端 其实改方法并没有实现连接，

        // 需要在listen()方法中调用channel.finishConnect();才能完成连接

        socketChannel.connect(new InetSocketAddress(ip,port));

        // 将socket注册到多路复用器，事件为SelectionKey.OP_CONNECT事件

        socketChannel.register(selector, SelectionKey.OP_CONNECT);

    }

    private void connect(String clientname) throws IOException {

        while (true){

            // 监听多路复用器里面是否存在需要处理的channel 这里是阻塞的

            selector.select();

            // 获取多路复用器中的channel对应的key

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

            while (iterator.hasNext()){

                // 获取SelectionKey

                SelectionKey key = iterator.next();

                // 获取到之后把当前可以删除，防止重复获取

                iterator.remove();

                // 验证SelectionKey对应的事件

                if(key.isConnectable()){

                    // 获取通道

                    SocketChannel channel = (SocketChannel) key.channel();

                    if(channel.isConnectionPending()){

                        channel.finishConnect();

                    }

                    // 配置成非阻塞方式

                    channel.configureBlocking(false);

                    // 写入缓冲流

                    String msg = clientname + "：Hello server";

                    ByteBuffer wrap = ByteBuffer.wrap(msg.getBytes());

                    // 向服务端写入信息

                    channel.write(wrap);

                    // 把当前通道注册到多路复用器中，并且注册事件是OP_READ事件

                    channel.register(selector,SelectionKey.OP_READ);

                }else if(key.isReadable()){

                    read(key);

                }else if(key.isWritable()){

                    System.out.println("客户端开始写事件");

                }

            }

        }

    }

    /**

     * 进行读消息

     * @param key

     * @throws IOException

     */

    private void read(SelectionKey key) throws IOException {

        // 获取通道

        SocketChannel channel = (SocketChannel) key.channel();

        // 设置缓存流一次读取的大小

        ByteBuffer buffer = ByteBuffer.allocate(1024);

        // 读取消息

        int len = channel.read(buffer);//channel.read()不是阻塞的

        if(len != -1){

            System.out.println("客户端收到消息：" + new String(buffer.array(),0,len)) ;

        }

    }

}