Java NIO的总结

Java的NIO是非阻塞式的IO

（non-blocking io）

一、理解同步与异步、阻塞与非阻塞

（1）同步和异步

​ 　　同步和异步描述的是一种消息通知的机制，主动等待消息返回还是被动接受消息。同步io指的是调用方通过主动等待获取调用返回的结果来获取消息通知，而异步io指的是被调用方通过某种方式（如，回调函数）来通知调用方获取消息。 

（2）阻塞非阻塞

​ 　　阻塞和非阻塞描述的是调用方在获取消息过程中的状态，阻塞等待还是立刻返回。阻塞io指的是调用方在获取消息的过程中会挂起阻塞，直到获取到消息，而非阻塞io指的是调用方在获取io的过程中会立刻返回而不进行挂起。 

Java NIO是基于IO多路复用模型，也就是我们经常提到的select，poll，epoll。IO 多路复用本质是同步IO，其需要调用方在读写事件就绪时主动去进行读写。在Java NIO中，通过selector来获取就绪的事件，当selector上监听的channel中没有就绪的读写事件时，其可以直接返回，或者设置一段超时后返回。可以看出Java NIO可以实现非阻塞，而不像传统IO里必须阻塞当前线程直到可读或可写。

所以理解阻塞与非阻塞其实是理解传统IO区别于NIO的对于线程的阻塞与否。 

　　Java NIO 处理连接和 Java socket 处理连接的方式：

//java nio
while(true) {
  ......
  selector.select(1);
  Set<SelectionKey> selectionKeySet= selector.selectedKeys();
  ......
  //处理selectionKeySet中事件,线程没有阻塞
}

//java socket处理连接，线程会阻塞
while(true) {
  ......
  Socket socket = serverSocket.accept();
  InputStream in = socket.getInputStream(); 
  ......
  //处理in中内容
}

二、NIO的常用操作（对文件的读写）

（1）写操作

　　通过NIO的操作能达到和IO一样的效果，但是读写的操作是通过通道来完成的，但是通道是通过流获取的。（注意标准的步骤）

　　而且里面的通道比如FileChannel都是从流中获取到的。

　　通道中后面要读取数据并存入缓冲区，同时要分配缓冲区以一定的大小。可以认为这个通道是直接搭在数据上的。

　　缓冲区里得存放字节数组。

package NIOTest;

import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;

import org.junit.Test;

//通过NIO实现文件IO
public class TestNio {
    @Test
    // 往本地文件中写数据
    public void test1() throws IOException {
        // 1、创建输出流
        FileOutputStream fileOutputStream = new FileOutputStream("C:\Users\Administrator\Desktop\1.txt");
        // 2、从流中得到一个通道
        FileChannel fileChannel = fileOutputStream.getChannel();
        // 3、提供一个缓冲区
        ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
        // 4、往缓冲区中存入数据(将字符串转换成字节数组并存储到缓冲区中)
        String string = "hello,nio";
        byteBuffer.put(string.getBytes());
        // 5、反转缓冲区
        byteBuffer.flip();
        // 6、把缓冲区写到通道中
        fileChannel.write(byteBuffer);
        // 7、关闭流（关闭流即可关闭通道）
        fileOutputStream.close();
    }
}

效果：

（2）读操作

　　输入输出流里面放的一般认为是文件的路径，但是实际上可以看作是一个file。

　　其中的file.length()是为了获得文件的数据内容的大小，但是默认返回的是长整型，所以需要通过int转换一下。关闭流就相当于关闭了通道。

@Test
    public void test2() throws IOException {

        // 封装成一个文件对象（为了返回文件中的数据内容的长度和大小）
        File file = new File("C:\Users\Administrator\Desktop\1.txt");
        // 创建输入流
        FileInputStream fileInputStream = new FileInputStream(file);
        // 创建文件通道
        FileChannel fileChannel = fileInputStream.getChannel();
        // 创建缓冲区(设置文件有多少数据缓冲区就有多大引入File)
        ByteBuffer buffer = ByteBuffer.allocate((int) file.length());
        // 从通道中读取数据并存到缓冲区中
        fileChannel.read(buffer);
        // 把缓冲区中的数据转换成字节数组并转换成String对象
        System.out.println(new String(buffer.array()));
        fileInputStream.close();
    }

（3）文件的复制操作

　　文件从一个文件复制到另一个文件中去，通过通道流的数据的复制来完成。

@Test
    public void test3() throws IOException {
        // 创建两个流
        FileInputStream fileInputStream = new FileInputStream("C:\Users\Administrator\Desktop\1.txt");
        FileOutputStream fileOutputStream = new FileOutputStream("C:\Users\Administrator\Desktop\2.txt");
        // 得到两个通道
        FileChannel fileChannel_read = fileInputStream.getChannel();
        FileChannel fileChannel_write = fileOutputStream.getChannel();
        // 复制(从读通道流中复制数据到写通道流)
        fileChannel_write.transferFrom(fileChannel_read, 0, fileChannel_read.size());
        // 关闭
        fileChannel_read.close();
        fileChannel_write.close();
    }

　　这就是数据的交换，不需要通过缓冲区把数据取出来单独处理，而是直接通过搭建两个流通道进行复制操作就可以完成数据的转移。

三、NIO的常用操作（数据的交换）

　　Java NIO里面最为重要也是常用的是四大类，选择器，事件，服务端通道，客户端通道。类比处理连接区别于Socket，最大的不同就是通道的概念的引进。

　　主要是四大类：

　　（1）Selector

　　（2）SelectionKey

　　（3）ServerSocketChannel

　　（4）SocketChannel

（1）网络客户端程序：

//网络客户端程序
public class NIOClient {
    public static void main(String[] args) throws IOException {

        // 1、得到一个网络通道
        SocketChannel socketChannel = SocketChannel.open();

        // 2、设置非阻塞的方式
        socketChannel.configureBlocking(false);

        // 3、提供服务器端的IP地址和端口号
        InetSocketAddress inetSocketAddress = new InetSocketAddress("127.0.0.1", 9999);

        // 4、连接服务器端
        if (socketChannel.connect(inetSocketAddress) == false) {
            while (!socketChannel.finishConnect()) {
                System.out.println("客户端重连......");
            }
        }

        // 5、得到一个用于读写的缓冲区，并存入数据
        String msg = "hello Server";
        ByteBuffer byteBuffer = ByteBuffer.wrap(msg.getBytes());

        // 6、发送数据到通道
        socketChannel.write(byteBuffer);
        System.in.read();
    }
}

　　当socketChannel.connect(inetSocketAddress) = false时再次想要连接就得使用socketChannel.finishConnect()，而有可能连接不能顺利的连接上，所以要一直判断，故while (!socketChannel.finishConnect())就可以当连接失败的时候一直处于重连的情况。

不能立即把socketChannel立即关闭，不然服务器端会报异常，所以用等待控制台系统输入阻断程序完毕。

（2）服务器端程序

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

        // 1、得到一个ServerSocketChannel对象 老大
        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();

        // 2、得到一个Selector对象
        Selector selector = Selector.open();

        // 3、绑定一个端口号（设置服务器的端口号）
        serverSocketChannel.bind(new InetSocketAddress(9999));

        // 4、设置非阻塞的方式
        serverSocketChannel.configureBlocking(false);

        // 5、ServerSocketChannel注册的事件就是SelectionKey.OP_ACCEPT看是否有连接,连接到ServerSocketChannel
        // 这些注册的通道与事件的关系都是统一由selector调度的
        serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);

        // 6、服务器的业务逻辑
        while (true) {
            // select当有注册的IO可以进行操作(操作其对应的注册时的方式时)时，将对应的SelectionKey加入到内部集合并返回(非阻塞)
            // 监控客户端(看是否有通道的事件被触发)
            if (selector.select(2000) == 0) {
                System.out.println("等待连接......");
                continue;
            }
            // 得到SelectionKey，判断通道里的事件
            Iterator<SelectionKey> Iterator = selector.selectedKeys().iterator();
            while (Iterator.hasNext()) {
                SelectionKey key = Iterator.next();
                if (key.isAcceptable()) {
                    // 客户端连接事件
                    System.out.println("OP_READ");
                    SocketChannel socketChannel = serverSocketChannel.accept();
                    socketChannel.configureBlocking(false);
                    socketChannel.register(selector, SelectionKey.OP_READ, ByteBuffer.allocate(1024));
                }
                if (key.isReadable()) {
                    // 读取客户端事件
                    SocketChannel socketChannel = (SocketChannel) key.channel();
                    ByteBuffer buffer = (ByteBuffer) key.attachment();
                    // 从通道里面读取数据然后存放在buffer里面
                    socketChannel.read(buffer);
                    // 然后将buffer里面的数据转换成字节数组之后通过String包装起来后打印
                    System.out.println("客户端发来数据：" + new String(buffer.array()));
                }
                Iterator.remove();
                if (key.isWritable()) {
                    // 写到客户端事件

                }
            }
        }
    }
}

三、NIO的常用操作（多人聊天室实现多通道数据的连接）

（1）服务器ChatServer

　　接收客户端发来的数据，同时还要把这个数据广播给另外的其他的所有客户端。服务器最重要的代码是进行业务处理，也就是集中在服务器代码中处理selector，通过筛选selector的Keys来判断每一个注册到selector的所有的通道是否发生了事件，发生的事件是什么。

public class ChatServer {
    private ServerSocketChannel listenerChannel;// 监听通道
    private Selector selector;// 选择器对象
    private static final int port = 9999;// 服务器端口

    public ChatServer() {
        try {
            // 1、得到监听通道
            listenerChannel = ServerSocketChannel.open();
            // 2、得到选择器
            selector = Selector.open();
            // 3、绑定端口
            listenerChannel.bind(new InetSocketAddress(port));
            // 4、设置为非阻塞模式
            listenerChannel.configureBlocking(false);
            // 5、将选择器绑定到监听通道并监听accept事件
            listenerChannel.register(selector, SelectionKey.OP_ACCEPT);
            printInfo("Chat Server is ready......");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    // 6、干活儿
    public void start() throws IOException {
        // 一直监控
        while (true) {
            if (selector.select(2000) == 0) {
                System.out.println("等待连接......");
                continue;
            }
            // 我的所有的key都在selector.selectedKeys()里面，利用key触发监听事件来确定进行怎样的操作
            Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
            while (iterator.hasNext()) {
                SelectionKey key = iterator.next();
                if (key.isAcceptable()) {
                    // 连接请求
                    SocketChannel socketChannel = listenerChannel.accept();
                    socketChannel.configureBlocking(false);
                    // 返回了连接之后注册读取监听事件
                    socketChannel.register(selector, SelectionKey.OP_READ);
                    System.out.println(socketChannel.getRemoteAddress().toString().substring(1) + "上线了......");
                }
                if (key.isReadable()) {
                    // 读取数据请求
                    readMsg(key);
                }
                iterator.remove();
            }
        }
    }

    // 读取客户端发来的消息并广播出去
    private void readMsg(SelectionKey key) throws IOException {
        SocketChannel socketChannel = (SocketChannel) key.channel();
        ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
        int count = socketChannel.read(byteBuffer);
        if (count > 0) {
            String msg = new String(byteBuffer.array());
            printInfo(msg);
            // 发广播(排除掉当前的通道，自己发的广播再给自己就没有意义了)
            // 意思就是说一个客户端发送了消息到服务器之后，经
            // 服务器读取之后转发到所有的客户端去,以这种逻辑实现聊天室
            broadCast(socketChannel, msg);
        }

    }

    // 给所有的客户端发广播
    public void broadCast(SocketChannel socketChannel, String msg) throws IOException {
        System.out.println("服务器发送了广播......");
        // selector.keys()得到所有就绪的通道，即连接上服务器的通道（返回的值是SelectionKey）
        for (SelectionKey selectionKey : selector.keys()) {
            //通过key得到的通道有可能不是SocketChannel类型的不能直接强转
            Channel targetChannel = selectionKey.channel();
            if (targetChannel instanceof SocketChannel && targetChannel != socketChannel) {
                SocketChannel destChannel = (SocketChannel) selectionKey.channel();
                ByteBuffer byteBuffer = ByteBuffer.wrap(msg.getBytes());
                destChannel.write(byteBuffer);
            }
        }
    }

    // 和当前系统的时间进行一个拼接输入到控制台
    private void printInfo(String str) {
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        System.out.println("[" + simpleDateFormat.format(new Date()) + "] ->->" + str);
    }

    public static void main(String[] args) throws IOException {
        new ChatServer().start();
    }
}

（2）客户端Client

public class ChatClient {
    private final String HOST = "127.0.0.1";// 服务器地址
    private int PORT = 9999;// 服务器端口
    private SocketChannel socketChannel;// 网络通道
    private String userName;// 聊天用户名

    public ChatClient() throws IOException {
        // 得到一个网络通道
        socketChannel = SocketChannel.open();
        // 设置非阻塞
        socketChannel.configureBlocking(false);
        // 提供服务器的IP地址和端口号
        InetSocketAddress inetSocketAddress = new InetSocketAddress(HOST, PORT);
        // 连接服务器端
        if (!socketChannel.connect(inetSocketAddress)) {
            while (!socketChannel.finishConnect()) {
                System.out.println("Client:连接中...");
            }
        }
        // 得到客户端IP地址和端口信息，作为聊天用户名使用
        userName = socketChannel.getLocalAddress().toString().substring(1);
        System.out.println("----------Client(" + userName + ") is ready----------");
    }

    // 向服务器发送数据
    public void sendMsg(String msg) throws IOException {
        // 首先进行判断，如果客户端发送的消息是“bye”的话就关闭这个连接通道
        if (msg == "bye") {
            socketChannel.close();
            return;
        }
        msg = userName + " "+"发送：" + msg;
        // 无论是读还是写都得通过ByteBuffer缓冲区来完成
        ByteBuffer byteBuffer = ByteBuffer.wrap(msg.getBytes());
        // 调用write方法就完成了写的操作
        socketChannel.write(byteBuffer);
    }

    // 从服务器读取数据
    public void receiveMsg() throws IOException {
        ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
        /**
         * 通道就会读取数据然后存放到byteBuffer里面 同时read方法会返回一个int类型的整数值
         */
        int count = socketChannel.read(byteBuffer);
        if (count > 0) {
            String mString = new String(byteBuffer.array());
            System.out.println("您收到一条消息：" + mString.trim());
        }
    }
}

（3）测试

public class TestChat {
    public static void main(String[] args) throws IOException {
        ChatClient chatClient = new ChatClient();
        /**
         * 发数据还比较好，直接sendMsg就可以了
         *
         * 但是收数据的话就得一直循环去接收服务器发来的数据，所以考虑开一个线程
         */
        new Thread() {
            public void run() {
                while (true) {
                    try {
                        chatClient.receiveMsg();
                        Thread.sleep(2000);
                    } catch (Exception e) {
                        // TODO: handle exception
                        e.printStackTrace();
                    }
                }
            }
        }.start();
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNextLine()) {
            String msg = scanner.nextLine();
            chatClient.sendMsg(msg);
        }
    }
}