一、序言

　　在Java的软件设计开发中，通信架构是不可避免的，我们在进行不同系统或者不同进程之间的数据交互，或者在高并发下的通信场景都需要用到网络通信相关的技术。

　　1、通信技术整体解决的问题：

　　1）局域网内的通信要求；

　　2）多系统间的底层消息传递机制；

　　3）高并发下，大数据量的通信场景需要；

　　4）游戏行业。

　　2、在Java中，主要有三种IO模型，分别是：

　　1）同步阻塞IO（BIO）；

　　2）同步非阻塞IO（NIO）;

　　3）异步IO（AIO）。

二、同步阻塞IO（BIO）

　　Java BIO（blocking I/O）：就是传统的java io编程，其相关的类和接口在java.io包下。同步并阻塞，服务器实现模式为一个连接一个线程，即每当客户端有连接请求时，服务端都需要启动一个线程进行处理，如下图。

　　在高并发的情况下，服务端会产生大量线程，线程间会发生竞争和上下文切换，同时要占用栈空间和CPU资源，而且其中有些线程可能什么事情都不会做，一直阻塞着，这些情况都会造成服务端性能下降。

　　所以BIO方式适合用于连接数目固定，而且比较小的架构，这种方式对服务器资源要求比较高，并发局限于应用中，但是程序简单易懂。

　　1、Java中的BIO分布式分为两种：

　　1）传统BIO：即上图中的一请求一应答；

　　2）伪异步IO：通过线程池固定线程的最大数量，可以防止资源的浪费。

　　2、BIO编程简单流程：

　　1）服务器启动一个ServerSocket；

　　2）客户端启动Socket请求与服务器连接，默认情况下服务器端需要对每个客户建立一个线程与之通信；

　　3）客户端发出请求之后，先咨询服务器是否有线程响应，如果没有则会等待，或者被服务端拒绝；

　　4）如果有响应，客户端线程会等待请求结束后，再继续执行。

　　3、使用BIO进行通信的简单案例

　　1）服务端代码

public class Server {
    public static void main(String[] args) throws IOException {
        //服务器端开启一个ServerSocket，并绑定6666端口
        ServerSocket ss = new ServerSocket(6666);
        System.out.println("服务器已开启！");
        while (true){
            Socket socket = ss.accept();
            System.out.println("来自" + socket.getRemoteSocketAddress() + "的连接");
            new Handler(socket).start();
        }
    }
}

//为每个客户端连接开启的线程
class Handler extends Thread {
    Socket socket;

    public Handler(Socket socket) {
        this.socket = socket;
    }

    @Override
    public void run() {
        try (InputStream inputStream = socket.getInputStream()) {
            try (OutputStream outputStream = socket.getOutputStream()) {
                handle(inputStream, outputStream);
            }
        } catch (IOException e) {
            try{
                //关闭socket
                socket.close();
            }catch (IOException e1){

            }
        }
        System.out.println("客户端" + socket.getRemoteSocketAddress()+ "断开连接");
    }

    private void handle(InputStream inputStream, OutputStream outputStream) throws IOException{
        //获得一个字符输入流
        var reader = new BufferedReader(new InputStreamReader(inputStream,
                StandardCharsets.UTF_8));
        //获得一个字符输出流
        var writer = new BufferedWriter(new OutputStreamWriter(outputStream,
                StandardCharsets.UTF_8));
        writer.write("连接成功！\n");
        writer.flush();
        while(true){
            //每次从管道中读入一行
            String str = reader.readLine();
            //当客户端传来"Bye"代表断开连接
            if("Bye".equals(str)){
                writer.write("Bye\n");
                writer.flush();
                break;
            }
            writer.write("已经收到：" + str + "\n");
            writer.flush();
        }
    }
}

　　2)客户端代码

public class Client {
    public static void main(String[] args) throws IOException {
        Socket socket = new Socket("127.0.0.1", 6666);
        try (InputStream inputStream = socket.getInputStream()){
            try (OutputStream outputStream = socket.getOutputStream()){
                handle(inputStream, outputStream);
            }
        }catch (IOException e){
            try{
                socket.close();
            }catch (IOException e1){

            }
        }

    }
    private static void handle(InputStream inputStream, OutputStream outputStream) throws IOException{
        var reader = new BufferedReader(new InputStreamReader(inputStream,
                StandardCharsets.UTF_8));
        var writer = new BufferedWriter(new OutputStreamWriter(outputStream,
                StandardCharsets.UTF_8));
        Scanner in = new Scanner(System.in);
        System.out.println("<<<" + reader.readLine());
        while (true){
            System.out.print(">>>");
            String str = in.nextLine();
            writer.write(str);
            writer.newLine();
            writer.flush();
            String resp = reader.readLine();
            System.out.println("<<<" + resp);
            if("Bye".equals(str)){
                break;
            }
        }
    }
}

　　3）启动服务器端，再启动客户端，使用客户端与服务端进行通信

　　　Server的控制台：

服务器已开启！
来自/127.0.0.1:51871的连接
客户端/127.0.0.1:51871断开连接

　　　　Client的控制台：

<<<连接成功！
>>>你好
<<<已经收到：你好
>>>在吗
<<<已经收到：在吗
>>>吃了吗
<<<已经收到：吃了吗
>>>Bye
<<<Bye

 三、同步非阻塞IO（NIO）

　　Java NIO（New IO）：也称java non-blocking IO，是从java1.4版本开始引入的一个新IO API，可以代替标准的java IO API。NIO与原来的IO具有同样的作用和目的，但是使用的方式完全不同，NIO支持面向缓冲区的、基于通道的IO操作。NIO将以更加高效的方式进行文件的读写操作。NIO可以理解为非阻塞IO，传统IO的read和write只能阻塞执行，线程在读写IO期间不能干其他事。而NIO则可以配置socket为非阻塞模式。

　　Java NIO的阻塞模式，使一个线程从某通道发送请求或者读取数据，但是它仅能得到目前可用的数据，如果目前没有数据可用，则什么都不会获取，而不是保持线程阻塞，所以直至数据变得可用读取之前，该线程可以继续做其他事情。

 　　工作示意图如下：

　　1、BIO 和 NIO 的区别？

　　1）BIO 以流的方式处理数据，而 NIO 以块的方式处理数据;

　　2）BIO 是阻塞的， NIO 是非阻塞的

　　3）BIO 基于字节流和字符流进行操作，而 NIO 基于 Channel（通道）和 Buffer（缓冲区）进行操作，数据总是从通道读取到缓冲区，或者从缓冲区写入到通道中。

　　2、NIO 的三大组件

　　1）Buffer 缓冲区：缓冲区本质是一块可以写入数据，然后可以从中读取数据的内存。这块内存被包装成了 NIO Buffer 对象，并提供了一组方法，用来方便对该快的访问。

　　　Buffer 就像一个数组，可以保存多个相同类型的数据。根据数据类型不同，有以下常用的 Buffer 子类：ByteBuffer, CharBuffer, ShortBuffer, IntBuffer, LongBuffer, FloatBuffer, DoubleBuffer。

　　创建方法如下：

static XxxBuffer allocate(int capacity) : 创建一个容量为capacity 的 XxxBuffer 对象

　　　基本属性：

• 　　容量（capacity）：作为一个内存块，Buffer具有一定的固定大小，也称为“容量”，缓冲区不能为负，并且创建后不能更改。
• 　　限制（limit）：表示缓冲区中可以操作的数据的大小（位于limit后的数据不能进行读写）。缓冲区的Buffer也不能为负数，并且不能大于其容量。在写入模式下，limit大于capacity。在读取模式下，limit等于写入的数据量。
• 　　位置（position）：下一个要读取或者写入的数据的索引。缓冲区的位置不能为负，并且不能大于limit。
• 　　标记（mark）与重置（reset）：标记是一个索引，通过Buffer中得到mark()方法指定Buffer中的一个特定的position，之后可以调用reset()方法恢复到这个position。

 　　　　常见方法：

Buffer clear() 清空缓冲区并返回对缓冲区的引用
Buffer flip() 为 将缓冲区的界限设置为当前位置，并将当前位置重置为 0
int capacity() 返回 Buffer 的 capacity 大小
boolean hasRemaining() 判断缓冲区中是否还有元素
int limit() 返回 Buffer 的界限(limit) 的位置
Buffer limit(int n) 将设置缓冲区界限为 n, 并返回一个具有新 limit 的缓冲区对象
Buffer mark() 对缓冲区设置标记
int position() 返回缓冲区的当前位置 position
Buffer position(int n) 将设置缓冲区的当前位置为 n , 并返回修改后的 Buffer 对象
int remaining() 返回 position 和 limit 之间的元素个数
Buffer reset() 将位置 position 转到以前设置的 mark 所在的位置
Buffer rewind() 将位置设为为 0， 取消设置的 mark

　　　　读取操作：

Buffer 所有子类提供了两个用于数据操作的方法：get()put() 方法
取获取 Buffer中的数据
get() ：读取单个字节
get(byte[] dst)：批量读取多个字节到 dst 中
get(int index)：读取指定索引位置的字节(不会移动 position)
    
放到 入数据到 Buffer 中 中
put(byte b)：将给定单个字节写入缓冲区的当前位置
put(byte[] src)：将 src 中的字节写入缓冲区的当前位置
put(int index, byte b)：将指定字节写入缓冲区的索引位置(不会移动 position)

　　2）通道（channel）

　　通道（Channel）：由java.nio.channels包下定义的，表示IO源与目标打开的连接。Channel类似于传统的“流”。只不过Channel本身不能直接访问数据，Channel只能与Buffer进行交互。

　　NIO通道与流的区别：

• 　　通道可以同时进行读写，而流只能读或者只能写。
• 　　通道可以实现异步读取数据。
• 　　通道可以从缓冲中读数据，也可以写数据到缓冲。

　　Channel在NIO中是一个接口，常用的Channel实现类有：

• 　　FileChannel：用于读取、写入、映射和操作文件的通道。
• 　　DatagramChannel：通过UDP读写网络中的数据通道。
• 　　SocketChannel：通过TCP读取网络中的数据。
• 　　ServerSocketChannel：可以监听新进来的TCP连接，对每个新进来的连接都会创建一个SocketChannel。

　　3）选择器（Selector）

　　选择器（Selector）是SelectableChannle对象的多路复用器，Selector可以同时监控多个SelectorableChannel的IO状况，利用Selector可以使一个单独的线程管理多个Channel。Selector是NIO非阻塞的核心，其能检测多个注册的通道上是否有事件发生，如果有事件发生，便获取事件，然后针对每个事件作出相应的处理。

　　通过Selector.open()方法创建一个Selector：

Selector selector = Selector.open();

 　　4)入门案例

/**
  客户端
 */
public class Client {

    public static void main(String[] args) throws Exception {
        //1. 获取通道
        SocketChannel sChannel = SocketChannel.open(new InetSocketAddress("127.0.0.1", 9999));
        //2. 切换非阻塞模式
        sChannel.configureBlocking(false);
        //3. 分配指定大小的缓冲区
        ByteBuffer buf = ByteBuffer.allocate(1024);
        //4. 发送数据给服务端
        Scanner scan = new Scanner(System.in);
        while(scan.hasNext()){
            String str = scan.nextLine();
            buf.put((new SimpleDateFormat("yyyy/MM/dd HH:mm:ss").format(System.currentTimeMillis())
                    + "\n" + str).getBytes());
            buf.flip();
            sChannel.write(buf);
            buf.clear();
        }
        //5. 关闭通道
        sChannel.close();
    }
}

/**
 服务端
 */
public class Server {
    public static void main(String[] args) throws IOException {
        //1. 获取通道
        ServerSocketChannel ssChannel = ServerSocketChannel.open();
        //2. 切换非阻塞模式
        ssChannel.configureBlocking(false);
        //3. 绑定连接
        ssChannel.bind(new InetSocketAddress(9999));
        //4. 获取选择器
        Selector selector = Selector.open();
        //5. 将通道注册到选择器上, 并且指定“监听接收事件”
        ssChannel.register(selector, SelectionKey.OP_ACCEPT);
        //6. 轮询式的获取选择器上已经“准备就绪”的事件
        while (selector.select() > 0) {
            System.out.println("轮一轮");
            //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();
            }
        }
    }
}