网络编程基础(BIO/NIO)

网络编程

Socket网络编程(基础篇)

传统的BIO编程

Socket又称为套接字，应用程序通过套接字向网络发出请求或者应答网络请求。
Socket和ServerSocket类库位于java.net包中。ServerSocket用于服务器端，Socket是建立网络连接时使用的。在连接成功是，应用程序两端会产生一个socket实例，操作这个实例完成所需的会话。对于一个网络连接来说，套接字是平等的，不因为在服务端或在客户端而产生不同级别。不管是Socket还是ServerSocket它们的工作都是通过SocketImpl及其子类完成的。
套接字之间的连接过程可以分为四个步骤：服务器监听，客户端请求服务器，服务器确认，客户端确认，进行通讯。
(1)服务器监听：是服务器端套接字并不确定具体的客户端套接字，而是处于等待连接的状态，实时监控网络状态。
(2)客户端请求：是指由客户端的套接字提出连接请求，要连接的目标是服务器端的套接字。为此，客户端的套接字必须首先描述它要连接的服务器的套接字，指出服务器端套接字的地址和端口号，然后向服务器端套接字提出连接请求。
(3)服务器端连接确认：是指当服务器端套接字监听到或者说接受到客户端套接字的连接请求，它就响应客户端套接字的请求，建立一个新的线程，把服务器端套接字的描述发给客户端。
(4)客户端确认连接：一但客户端确认了此描述，连接就建立好了。双方就开始通信。而服务器套接字继续处于监听状态，继续接收其他客户端套接字的连接请求。

网络编程的基本模型是Client/Server模型，也就是两个进程直接进行通信，其中服务器提供配置信息(绑定IP地址和监听端口),客户端通过连接操作向服务器端监听的地址发起连接请求，通过三次握手建立连接，如果连接成功，即双方可以进行通讯（网络套接字socket）

伪异步IO

采用线程池和任务队列可以实现伪异步的IO通信框架。
我们学过连接池的使用和队列的使用，其实就是将客户端的socket封装成一个task任务(实现Runnable接口的类)然后投递到线程池中，配置相应的队列进行实现。

IO(BIO)和NIO的区别

其本质就是阻塞和非阻塞的区别。
阻塞概念：应用程序在获取网络数据时，如果网络传输数据很慢。那么程序就一直等着，直到传输完毕为止。
非阻塞概念：应用程序直接可以获取已经准备就绪好的数据，无须等待。
BIO为同步阻塞形式，NIO为同步非阻塞形式。NIO并没有实现同步，在JDK1.7之后升级了NIO库包，支持异步非阻塞通信模型即NIO2.0（AIO）

同步和异步：同步和异步一般是面向操作系统和应用程序对IO操作的层面上来区别的。
同步时，应用程序会直接参与IO读写操作，并且我们的应用程序会直接阻塞到某个方法上，直到数据准备就绪；或者采用轮询的策略，实时检查数据的就绪状态，如果就绪则获取数据。
异步时，则所有的IO操作都交给操作系统处理，与我们的应用程序没有直接关系，我们的程序不需要关心IO读写，当操作系统完成了IO读写操作时，会给我们的应用程序发送通知，我们应用程序直接拿走数据即可。
同步说的是你Server端服务器端的执行方式。
阻塞说的是具体的技术，接受数据的方式、状态(IO/NIO)

NIO编程介绍

在介绍NIO之前，先澄清一个概念，有的人叫NIO为new IO,有的人把NIO叫做Non-Block IO,这里我们习惯说后者，即非阻塞IO。
学习NIO编程，我们首先要了解几个概念：Buffer(缓冲区)、channel（管道、通道）、Selector（选择器、多路复用器）

**Buffer：**Buffer是一个对象，它包含一些要写入或者要读取的数据。在NIO类库中加入Buffer对象，体现了新库和原IO的一个重要的区别。在面向流的IO中，可以将数据直接写入或读取到Stream对象中。在NIO库中，所有数据都是用缓冲区处理的读写。缓冲区实质是一个数组，通常它是一个字节数组(ByteBuffer)，也可以使用其他类型的数组。这个数组缓冲区提供了数据的访问读写等操作属性，如位置、容量、上限等概念，参考API文档。
Buffer类型：我们最常用的就是ByteBuffer，实际上内一种java基本类型都对应一种缓冲区。
ByteBuffer、CharBuffer、ShortBuffer、IntBuffer、LongBuffer、FloatBuffer、DoubleBuffer

import java.nio.IntBuffer;
public class TestBuffer {

    public static void main(String[] args) {

        //1 基本操作
        //创建指定长度的缓冲区
        /*IntBuffer buf = IntBuffer.allocate(10);
        buf.put(13);//position的位置: 0->1
        buf.put(21);//position的位置：1->2
        buf.put(35);//position的位置: 2->3
        //把位置复位为0 也就是position位置3->0，因为每次put后position的位置都会加1 
        buf.flip();
        System.out.println("使用flip复位:"+buf);
        System.out.println("容量为:"+buf.capacity());//容量一旦初始化后，不允许改变(wrap方法包裹数组除外)
        System.out.println("限制为:"+buf.limit());//由于只装载了三个元素，所以可读取或操作的元素为3，limit=3

        System.out.println("获取下标为1的元素:"+buf.get(1));
        System.out.println("get(index)方法，position位置不改变:"+buf);
        buf.put(1,4);
        System.out.println("put(index,change)方法，position位置不改变："+buf);
        for(int i=0;i<buf.limit();i++){
            //调用get方法会使其缓冲区位置(position)向后递增一位
            //当前position位置为3
            System.out.print(buf.get()+"\t");
        }
        System.out.println("buf对象遍历之后为:"+buf);*/

        //2 wrap方法使用
        //wrap方法会包裹一个数组：一般这种用法不会先初始化缓存对象的长度，因为没有意义，最后还会被wrap所包裹的数组覆盖掉
        //并且wrap方法修改缓冲区对象的时候，数组本身也会跟着发生变化
        /*int[] arr = new int[]{1,2,5};
        IntBuffer buf1 = IntBuffer.wrap(arr);
        System.out.println(buf1);

        IntBuffer buf2 = IntBuffer.wrap(arr,0,2);
        //这样使用表示容量为数组arr的长度，但是可操作的元素只有实际进入缓存区的元素长度。
        System.out.println(buf2);*/

        //3 其他方法
        IntBuffer buf1 = IntBuffer.allocate(10);
        int[] arr = new int[]{1,2,5};
        buf1.put(arr);
        System.out.println(buf1);
        //一种复制方法
        IntBuffer buf3 = buf1.duplicate();
        System.out.println(buf3);

        //设置buf1的位置属性
        buf1.position(1);
//      buf1.flip();
        System.out.println(buf1);

        System.out.println("可读数据为:"+buf1.remaining());

        int[] arr2 = new int[buf1.remaining()];
        //将缓冲区数据放入arr2数组中
        buf1.get(arr2);
        for(int i:arr2){
            System.out.print(Integer.toString(i)+",");
        }

    }

}

Channel
通道(Channel),它就像自来水管道一样，网络数据通过channel读取和写入，通道与流的不同之处在于通道是双向的，而流只在一个方向上移动(一个流必须是inputStream或者OutputStream的子类)，而通道可以用于读写或者两者同时进行，最关键的是可以与多路复用器结合起来，有多种的状态位，方便多路复用器去识别。事实上通道分为两大类，一类是网络读写的(SelectableChannel),一类是用于文件操作的(FileChannel),我们使用的SocketChannel和ServerSocketChannel都是SelectableChannel的子类。

Selector
多路复用器(Selector),它是NIO编程的基础，非常重要。多路复用器选择提供已经就绪的任务的能力。
简单的说，就是Selector会不断的轮询注册在其上的通道(Channel),如果某个通道发生了读写操作，这个通道就处于就绪状态，会被Selector轮询出来，然后通过SelectionKey可以取得就绪的Channel集合，从而进行后续的IO操作。
一个多路复用器可以负责成千上万个Channel通道，没有上限，这也是JDK使用了epoll代替了传统的select实现，获得连接句柄没有限制。这也就意味着我们只要一个线程负责Selector的轮询就可以接入成千上万个客户端，这是JDK NIO库的巨大进步。

Selector线程就类似于一个管理者(Master),管理成千上万个通道，然后轮询哪个管道的数据已经准备好，通知CPU执行IO的读写或写入操作。

Selector模式：当IO时间(管道)注册到选择器以后，selector会分配给每个管道一个key值，相当于标签。selector选择器是以轮询的方式进行查找注册的所有IO事件（管道），当我们的IO事件(管道)准备就绪后，selector就会识别，会通过key值来找到相应的管道，进行相关的数据处理操作(从管道里读或写操作，写到我们的数据缓冲区中)

每个管道都会对选择器进行注册不同的事件状态，以便选择器查找。
SelectionKey.OP_CONNECT
SelectionKey.OP_ACCEPT
SelectionKey.OP_READ
SelectionKey.OP_WRITE

Server.java

public class Server implements Runnable{

    //1 多路复用器(管理所有的通道)
    private Selector selector;
    //2 建立缓冲区
    private ByteBuffer readBuf = ByteBuffer.allocate(1024);

    public Server(int port){
        try {
            //1 打开多路复用器
            this.selector=Selector.open();
            //2 打开服务器通道
            ServerSocketChannel ssc = ServerSocketChannel.open();
            //3 设置服务器通道为非阻塞模式
            ssc.configureBlocking(false);
            //4 绑定地址
            ssc.bind(new InetSocketAddress(port));
            //5 把服务器通道注册到多路复用器上，并且监听阻塞事件
            ssc.register(this.selector, SelectionKey.OP_ACCEPT);

            System.out.println("Server start ,port:"+port);
        } catch (Exception e) {
            e.printStackTrace();
        } 

    }

    @Override
    public void run() {
        while(true){
            try {
                //1 必须让多路复用器开始监听
                this.selector.select();
                //2 返回多路复用器已经选择的结果集
                Iterator<SelectionKey> keys = this.selector.selectedKeys().iterator();
                //3 进行遍历
                while(keys.hasNext()){
                    //4 获取一个选择的元素
                    SelectionKey key = keys.next();
                    //5 直接从容器中移除就可以了
                    keys.remove();
                    //6 如果是有效的
                    if(key.isValid()){
                        //7 如果为阻塞状态
                        if(key.isAcceptable()){
                            this.accept(key);
                        }
                        //8 如果为可读状态
                        if(key.isReadable()){
                            this.read(key);
                        }
                        //9 如果为可写状态
                        if(key.isWritable()){
//                          this.write();
                        }
                    }
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    private void accept(SelectionKey key){
        try {
            //1 获取服务通道
            ServerSocketChannel ssc = (ServerSocketChannel)key.channel();
            //2 执行阻塞方法
            SocketChannel sc = ssc.accept();
            //3 设置阻塞模式
            sc.configureBlocking(false);
            //4 注册到多路复用器上，并设置读取标志
            sc.register(this.selector, SelectionKey.OP_READ);
        } catch (Exception e) { 
            e.printStackTrace();
        }

    }

    private void read(SelectionKey key){
        try {
            //1 清空缓冲区旧的数据
            this.readBuf.clear();
            //2 获取之前注册的socket通信对象
            SocketChannel sc = (SocketChannel)key.channel();
            //3 读取数据
            int count = sc.read(this.readBuf);
            //4 如果没有数据
            if(count==-1){
                key.channel().close();
                key.cancel();
                return;
            }
            //5 有数据则进行读取 读取之前需要进行复位方法(把position和limit进行复位)
            this.readBuf.flip();
            //6 根据缓冲区的数据长度创建相应大小的byte数组，接受缓冲区的数据
            byte[] bytes = new byte[this.readBuf.remaining()];
            //7 接受缓冲区的数据
            this.readBuf.get(bytes);
            //8 打印结果
            String body = new String(bytes).trim();
            System.out.println("Server:"+body);
            //9 可以写回客户端数据
        } catch (IOException e) {
            e.printStackTrace();
        }

    }

    public static void main(String[] args) {
        new Thread(new Server(8765)).start();
    }

}

Client.java

package zx.nio;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SocketChannel;

public class Client {

    public static void main(String[] args) {
        //创建连接的地址
        InetSocketAddress address = new InetSocketAddress("127.0.0.1",8765);
        //声明连接通道
        SocketChannel sc = null;
        //建立缓冲区
        ByteBuffer buf = ByteBuffer.allocate(1024);

        try {
            //打开通道
            sc = SocketChannel.open();
            //进行连接
            sc.connect(address);
            while(true){
                //定义一个字节数组，然后使用系统 录入功能
                byte[] bytes = new byte[1024];
                //将键盘录入的数据放入byte中
                System.in.read(bytes);
                //把数据放到缓冲区
                buf.put(bytes);
                //对缓冲区进行复位
                buf.flip();
                //写出数据
                sc.write(buf);
                //清空缓冲区数据
                buf.clear();
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(sc!=null){
                try {
                    sc.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }

}