java NIO 随笔

一，NIO入门

　 NIO 是new io的缩写，说实话，nio api比较难用，所用大家需要采用网络通信的时候，普通首先想到的是netty，不直接使用NIO，但是你不了解NIO，说实话，你也理解不了netty

好多人不理解socket 是干啥的，只知道socket是Java 用来通信的。应用层协议（HTTP 协议）如何发送数据，这个协议使我们自己定义的，我们需要和其他机器通信，就必须通过

TCP协议来完成数据传输。你可以理解socket就是应用层和传输层的适配器，负责将应用层的数据转换为TCP协议需要的数据。

　　我们先来一个demo，通过TCP 协议发送一个文件我们先学会用，在来考虑细节。

package com.ppdai.user.weixin.controller.test;

import com.ppdai.common.collect.Lists;

import lombok.extern.slf4j.Slf4j;

import org.springframework.core.Constants;

import java.io.File;

import java.io.FileInputStream;

import java.io.IOException;

import java.net.InetSocketAddress;

import java.nio.ByteBuffer;

import java.nio.channels.FileChannel;

import java.nio.channels.SelectionKey;

import java.nio.channels.Selector;

import java.nio.channels.SocketChannel;

import java.nio.charset.Charset;

import java.util.Iterator;

import java.util.List;

import java.util.Scanner;

/**

 * Created by huxuhong on 2020/3/11.

 */

@Slf4j

public class TcpClient {

    /**

     * @param args

     */

    public static void main(String[] args) {

        try {

            startClient("localhost",8080);

        } catch (IOException e) {

            e.printStackTrace();

        }

    }

    public static void startClient(String serverIp, int serverPort) throws IOException{

        log.info("创建一个SocketChannel，指定为非阻塞模式");

        /*

         * 创建一个SocketChannel，指定为非阻塞模式

         * A selectable channel for stream-oriented connecting sockets.

         */

        SocketChannel socketChannel = SocketChannel.open();

        socketChannel.configureBlocking(false);

        /*

         * 创建一个事件选择器Selector

         */

        Selector selector = Selector.open();

        /*

         * 将创建的SocketChannel注册到指定的Selector上，并指定关注的事件类型为OP_CONNECT

         */

       SelectionKey selectionKey = socketChannel.register(selector,SelectionKey.OP_CONNECT);

          /*

         * 连接到指定的服务地址,这里有坑socketChannel.connect 异步接口，但是有可能理解返回为true，这里不引申怎么处理啦，等分析kafka-client源码的时候在做解析

         * （具体啥时候返回false,true，请看API说明），此时不会触发监控（即selector.select(),此方法可能返回0）

         */

      Boolean connection =  socketChannel.connect(new InetSocketAddress(serverIp, serverPort));

      System.out.println("链接结果："+connection);

        /**

         * 顾名思义，针对文件的一种channel，类似IO中的FileInputStream,

         * 这个类很重要，kafak broker的顺序存储，查找，以及数据推送的客户端都是通过类似的技术mmap(内存映射)，sendfile实现的

         *  java 方式的内存映射（kafka broker 是scala写的）

         *  fileChannel.map(FileChannel.MapMode.READ_WRITE, 0, 5);

         *  有兴趣的话，可以去扩展开研究一下

         *  fileChannel 写入的操作 不一定比FileInputStream 快，它的优势在于如果大数据写入，每次写入4KB和pageCache大小一致，此时速度最快

         *  想知道fileChannel mmap 普通IO 读写速度，以及啥时候能够最大利用他们的优势可以看看下面2篇文章

         *  https://yq.aliyun.com/articles/673567

         *  https://blog.csdn.net/alex_xfboy/article/details/90174840

         */

      FileChannel inputChannel = new FileInputStream(new File("E:\\huhu\\hudad.txt")).getChannel();

      int sendCount = 0;

        /*

         * 发送文件

         */

        while(true){

            if(socketChannel.isConnected() && sendCount < 1){

                ++sendCount;

                /**

                 * 这里在linux环境下采用零拷贝技术（send_file）

                 */

                inputChannel.transferTo(0,inputChannel.size(),socketChannel);

                log.info("connect就绪");

            }

            /*

             * 设置1sec的超时时间，进行IO事件选择操作

             */

            int nSelectedKeys = selector.select();

            if(nSelectedKeys > 0){

                for(SelectionKey skey: selector.selectedKeys()){

                    /*

                     * 判断检测到的channel是不是可连接的，将对应的channel注册到选择器上，指定关心的事件类型为OP_READ

                     */

                    if(skey.isConnectable()){

                        log.info("key connect就绪");

                        SocketChannel connChannel = (SocketChannel) skey.channel();

                        connChannel.configureBlocking(false);

                        /**

                         * 这里connection成功，直接监控OP_READ,其实一种偷懒方法，应该是先监控OP_WRITE,然后在OP_WRITE处理方法中监控OP_READ

                         * OP_WRITE 是指channel对应的ByteBuffer 还有空间可以写入

                         * OP_READ 是指channel对应的ByteBuffer 还存在数据可以读

                         */

                        connChannel.register(selector, SelectionKey.OP_READ);

                        /**

                         * 目的是为了校验是否和服务器连接成功

                         * SelectionKey.OP_CONNECT触发条件是链接成功或者链接失败抛出异常，所以需要通过finishConnect校验，如果失败，此方法会抛出异常

                         */

                        connChannel.finishConnect();

                    }

                    /*

                     * 若检测到的IO事件是读事件，则处理相关数据的读相关的业务逻辑

                     */

                    else if(skey.isReadable()){

                        log.info("key read就绪");

                        SocketChannel readChannel = (SocketChannel) skey.channel();

                        StringBuilder sb = new StringBuilder();

                        /*

                         * 定义一个ByteBuffer的容器，容量为1k

                         */

                        ByteBuffer byteBuffer = ByteBuffer.allocate(1024);

                        int readBytes = 0;

                        int ret = 0;

                        /*

                         * 注意，对ByteBuffer的操作，需要关心的是flip，clear等。

                         */

                        while ((ret = readChannel.read(byteBuffer)) > 0) {

                            readBytes += ret;

                            byteBuffer.flip();

                            sb.append(Charset.forName("UTF-8").decode(byteBuffer).toString());

                            byteBuffer.clear();

                        }

                        if (readBytes == 0) {

                            System.err.println("handle opposite close Exception");

                            readChannel.close();

                        }

                        System.out.println("服务器返回信息"+sb.toString());

                    }

                }

                /*

                 * 一次监听的事件处理完毕后，需要将已经记录的事件清除掉，准备下一轮的事件标记

                 */

                selector.selectedKeys().clear();

            }else{

                System.err.println("handle select timeout Exception");

            }

        }

    }

}

package com.ppdai.user.weixin.controller.test;

import lombok.extern.slf4j.Slf4j;

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.ServerSocketChannel;

import java.nio.channels.SocketChannel;

import java.nio.charset.Charset;

import java.util.HashSet;

import java.util.Iterator;

import java.util.Set;

/**

 * Created by hxh on 2020/3/11.

 */

@Slf4j

public class TcpServer {

    /**

     * @param args

     */

    public static void main(String[] args) {

        try {

            startServer(8080);

        } catch (IOException e) {

            e.printStackTrace();

        }

     /*  Set<String> key = new HashSet<String>();

       key.add("11");

       key.add("22");

       Set<String> publicKey = new HashSet<String>();

       publicKey = key;

       key.add("33");

       publicKey.stream().forEach(keyName->{

           System.out.println(keyName);

       });

       //key.clear();

        publicKey.stream().forEach(keyName->{

            System.out.println("+"+keyName);

        });*/

    }

    public static void startServer(int port) throws IOException {

        log.info("开启一个服务channel");

        /*

         *开启一个服务channel，

         *A selectable channel for stream-oriented listening sockets.

         */

        ServerSocketChannel serverChannel = ServerSocketChannel.open();

        serverChannel.configureBlocking(false);

        serverChannel.bind(new InetSocketAddress(port));

        /*

         * 创建一个selector

         */

        Selector selector = Selector.open();

        /*

         * 将创建的serverChannel注册到selector选择器上，指定这个channel只关心OP_ACCEPT事件

         */

        serverChannel.register(selector, SelectionKey.OP_ACCEPT);

        while (true) {

            /*

             * select()操作，默认是阻塞模式的，即，当没有accept或者read时间到来时，将一直阻塞不往下面继续执行。

             */

            int readyChannels = selector.select();

            if (readyChannels <= 0) {

                continue;

            }

            /*

             * 从selector上获取到了IO事件，可能是accept，也有可能是read

             */

            Set<SelectionKey> SelectonKeySet = selector.selectedKeys();

            Iterator<SelectionKey> iterator = SelectonKeySet.iterator();

            /*

             * 循环遍历SelectionKeySet中的所有的SelectionKey

             */

            while (iterator.hasNext()) {

                SelectionKey key = iterator.next();

                if (key.isAcceptable()) {          //处理OP_ACCEPT事件

                    log.info("OP_ACCEPT事件就绪");

                    SocketChannel socketChannel = serverChannel.accept();

                    socketChannel.configureBlocking(false);

                    socketChannel.register(selector, SelectionKey.OP_READ);

                } else if (key.isReadable()) {  //处理OP_READ事件

                    log.info("OP_READ事件就绪");

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

                    StringBuilder sb = new StringBuilder();

                    ByteBuffer byteBuffer = ByteBuffer.allocate(1024);

                    int readBytes = 0;

                    int ret = 0;

                    /*

                     * 注意读数据的时候，ByteBuffer的操作，需要flip,clear进行指针位置的调整

                     */

                    while ((ret = socketChannel.read(byteBuffer)) > 0) {

                        readBytes += ret;

                        byteBuffer.flip();

                        sb.append(Charset.forName("UTF-8").decode(byteBuffer).toString());

                        byteBuffer.clear();

                    }

                    if (readBytes == 0) {

                        System.err.println("handle opposite close Exception");

                        socketChannel.close();

                    }

                    String message = sb.toString();

                    System.out.println("Message from client: " + message);

                    if ("client_close".equalsIgnoreCase(message.toString().trim())) {

                        System.out.println("Client is going to shutdown!");

                        socketChannel.close();

                    } else if ("server_close".equalsIgnoreCase(message.trim())) {

                        System.out.println("Server is going to shutdown!");

                        socketChannel.close();

                        serverChannel.close();

                        selector.close();

                        System.exit(0);

                    } else {

                        String outMessage = "Server response：我已收到";

                        socketChannel.write(Charset.forName("UTF-8").encode(outMessage));

                    }

                }

                /*

                 * 将selector上当前已经监听到的且已经处理了的事件标记清除掉。

                 */

                iterator.remove();

            }

        }

    }

}

　　上面是一个简单的利用TCP协议，发送一个文件的demo，代码基本上都有注释，就不过多解释

二，理论知识

NIO必然存在2个元素，channel，byteBuffer。他们和stream 有啥区别，或者说NIO和IO的区别。channel有很多种

IO和NIO区别

https://www.cnblogs.com/aspirant/p/8630283.html（理论参考这篇文章）

文件NIO（FileChannle 标准文件channel 不可以设置为非阻塞）

stream,底层是一个一个从磁盘读取字节，然后上层封装起来进行业务处理，而且分为inputstream和outputStream，也就说是单向的。

文件NIO channel 和ByteBuffer 的效果，就像，在目的地和磁盘直接开了一个通道（channel）然后利用卡车（ByteBuffer）一次性传送大量数据，双向，可读可写。

网络NIO

　　　　SocketChannel 是一个连接到TCP网络套接字的通道
　　　　ServerSocketChannel 可以监听新进来的TCP连接, 就像标准IO中的ServerSocket一样。
　　　　DatagramChannel 是一个能收发UDP包的通道

下面以SocketChannel为例，给大家列出来SocketChannel 的上下文，然后熟悉一下每个interface的作用，对后面的kafka-client 发送报文很有帮助

GatheringByteChannel，将多个ByteBuffer 聚合到一个channel中
ScatteringByteChannel 将从channel读初数据，按此存储到多个ByteBuffer中
AbstractSelectableChannel 这个类是用来管理channel的注册，注销和close，主要是配合selector才有效果
ByteChannel  用来实现channel读写ByteBuffer的interface 

ByteBuffer 是NIO另外一个最重要的接口
https://blog.csdn.net/mrliuzhao/article/details/89453082（ByteBuffer用法小结，很详细，看完写个demo,你就入门啦）

PS:NIO没用过没关系，现在学习起来也不迟，熟悉一下主要的类，写个demo就入门啦。学无之境，一天不进步就是退步。
PS:NIO使用TCP发送报文会出现沾包和黏包具体原因以及解决方法（https://blog.csdn.net/fgx_123456/article/details/80031821）

巴特西

java NIO 随笔

最新文章

热门文章