Netty系列| Netty创始人告诉你为什么选择NIO

常见channel类

1.FileChannel    //文件io操作

2.DatagramChannel    //UDP数据读写

3.ServerSocketChannel和SocketChannel  //TCP数据读写

FileChannel 常用方法

public int read(ByteBuffer dst) ，从通道读取数据并放到缓冲区中 
 
public int write(ByteBuffer src) ，把缓冲区的数据写到通道中 
 
public long transferFrom(ReadableByteChannel src, long position, long count)，从目标通道中复制数据到当前通道 
 
public long transferTo(long position, long count, WritableByteChannel target)，把数据从当前通道复制给目标通道
代码实践：

通过FileChannel和ByteBuffer读写文件

public void writeToFile() {
 
        try {
            //1.创建一个输出流，并通过输出流获取channel
            FileOutputStream out = new FileOutputStream("D:\\fileChannelTest.txt");
            final FileChannel channel = out.getChannel();
            //2.通过byteBuffer读取字符串并写入到channel中
            ByteBuffer buffer = ByteBuffer.allocate(1024);
            buffer.put(("hello,world!").getBytes());
            buffer.flip(); //反转buffer的流向
            channel.write(buffer);
            channel.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
 
    public void readFromFile() {
 
        try {
            //1.获取输入流，并转化成channel
            File file = new File("D:\\fileChannelTest.txt");
            FileInputStream inputStream = new FileInputStream(file);
            final FileChannel channel = inputStream.getChannel();
 
            //2.从通道中读取数据到buffer,并输出到控制台
            ByteBuffer buffer = ByteBuffer.allocate(1024);
            while(true) {  //循环读取直到全部读取到buffer中
                buffer.clear(); //清空缓存区，只是把标记初始化，数据不会清楚
                int read = channel.read(buffer);
                if (read == -1) {  //读取完毕，退出循环
                    break;
                }
            }
            System.out.println("content is " + new String(buffer.array()));
            channel.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
 
    }

文件拷贝

public void readFromFile() {
 
        try {
            //1.获取输入流，并获取对应的FileChannel
            File file = new File("D:\\fileChannelTest.txt");
            FileInputStream inputStream = new FileInputStream(file);
            final FileChannel channel = inputStream.getChannel();
 
            //2.从通道中读取数据到buffer,并输出到控制台
            ByteBuffer buffer = ByteBuffer.allocate(1024);
            while(true) {  //循环读取直到全部读取到buffer中
                buffer.clear(); //清空缓存区，只是把标记初始化，数据不会清楚
                int read = channel.read(buffer);
                if (read == -1) {  //读取完毕，退出循环
                    break;
                }
            }
            System.out.println("content is " + new String(buffer.array()));
            channel.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
 
    }

注意事项：通过 ByteBuffer 进行对象的传输时，写入的类型和读取的类型必须一致，否则可能会出现 BufferUnderFlowException 异常

Selector 能够检测多个注册的通道上是否有事件发生(注意:多个 Channel 以事件的方式可以注册到同一个 Selector )，如果有事件发生，便获取事件然后针对每个事件进行相应的处理,如果没有事件发生时，当前线程可以处理其他事情

常见方法

public abstract class Selector implements Closeable { 
public static Selector open();//得到一个选择器对象
public int select(long timeout);//监控所有注册的通道，当其中有 IO 操作可以进行时，将
对应的 SelectionKey 加入到内部集合中并返回，参数用来设置超时时间
public Set<SelectionKey> selectedKeys();//从内部集合中得到所有的 SelectionKey 
}

实现流程

构建NIO服务端

1.创建ServerSocketChannel,并绑定5555端口

2.创建selector对象，并将ServerSocketChannel注册到seletor中，监听accept事件

3.通过selectKey.isAcceptable判断是否有客户端建立连接，并注册连接的SocketChannel到selector,监听对应的read事件

4.通过selectKey.isReadable判断通道是否发生读事件，并获取对应的socketChannel读到缓冲区中，并输出数据

代码实现：

public static void main(String[] args) throws  Exception{
        //创建ServerSocketChannel，-->> ServerSocket
        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
        InetSocketAddress inetSocketAddress = new InetSocketAddress(5555);
        serverSocketChannel.socket().bind(inetSocketAddress);
        serverSocketChannel.configureBlocking(false); //设置成非阻塞
 
        //开启selector,并注册accept事件
        Selector selector = Selector.open();
        serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
 
        while(true) {
            selector.select(2000);  //监听所有通道
            //遍历selectionKeys
            Set<SelectionKey> selectionKeys = selector.selectedKeys();
            Iterator<SelectionKey> iterator = selectionKeys.iterator();
            while (iterator.hasNext()) {
                SelectionKey key = iterator.next();
                if(key.isAcceptable()) {  //处理连接事件
                    SocketChannel socketChannel = serverSocketChannel.accept();
                    socketChannel.configureBlocking(false);  //设置为非阻塞
                    System.out.println("client:" + socketChannel.getLocalAddress() + " is connect");
                    socketChannel.register(selector, SelectionKey.OP_READ); //注册客户端读取事件到selector
                } else if (key.isReadable()) {  //处理读取事件
                    ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
                    SocketChannel channel = (SocketChannel) key.channel();
                    channel.read(byteBuffer);
                    System.out.println("client:" + channel.getLocalAddress() + " send " + new String(byteBuffer.array()));
                }
                iterator.remove();  //事件处理完毕，要记得清除
            }
        }
 
    }