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

ByteBuffer，存储字节数据到缓冲区,进行网络通信使用最频繁
 
ShortBuffer，存储字符串数据到缓冲区 
 
CharBuffer，存储字符数据到缓冲区 
 
IntBuffer，存储整数数据到缓冲区 
 
LongBuffer，存储长整型数据到缓冲区 
 
DoubleBuffer，存储小数到缓冲区 
 
FloatBuffer，存储小数到缓冲区

public final int capacity( )//返回此缓冲区的容量
public final int position( )//返回此缓冲区的位置
public final Buffer position (int newPositio)//设置此缓冲区的位置
public final int limit( )//返回此缓冲区的限制
public final Buffer limit (int newLimit)//设置此缓冲区的限制
public final Buffer mark( )//在此缓冲区的位置设置标记
public final Buffer reset( )//将此缓冲区的位置重置为以前标记的位置
public final Buffer clear( )//清除此缓冲区, 即将各个标记恢复到初始状态，但是数据并没有真正擦除, 后面操作会覆盖
public final Buffer flip( )//反转此缓冲区
public final Buffer rewind( )//重绕此缓冲区
public final int remaining( )//返回当前位置与限制之间的元素数
public final boolean hasRemaining( )//告知在当前位置和限制之间是否有元素
public abstract boolean isReadOnly( );//告知此缓冲区是否为只读缓冲区
 
public abstract boolean hasArray();//告知此缓冲区是否具有可访问的底层实现数组
public abstract Object array();//返回此缓冲区的底层实现数组
public abstract int arrayOffset();//返回此缓冲区的底层实现数组中第一个缓冲区元素的偏移量
public abstract boolean isDirect();//告知此缓冲区是否为直接缓冲区

public abstract class ByteBuffer {
    //缓冲区创建相关api
    public static ByteBuffer allocateDirect(int capacity)//创建直接缓冲区
    public static ByteBuffer allocate(int capacity)//设置缓冲区的初始容量
    public static ByteBuffer wrap(byte[] array)//把一个数组放到缓冲区中使用
    //构造初始化位置offset和上界length的缓冲区
    public static ByteBuffer wrap(byte[] array,int offset, int length)
     //缓存区存取相关API
    public abstract byte get( );//从当前位置position上get，get之后，position会自动+1
    public abstract byte get (int index);//从绝对位置get
    public abstract ByteBuffer put (byte b);//从当前位置上添加，put之后，position会自动+1
    public abstract ByteBuffer put (int index, byte b);//从绝对位置上put
 }

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)，把数据从当前通道复制给目标通道
代码实践：

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();
        }
 
    }

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

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();  //事件处理完毕，要记得清除
            }
        }
 
    }

public static void main(String[] args) throws Exception{
        SocketChannel socketChannel = SocketChannel.open();
        socketChannel.configureBlocking(false);
        InetSocketAddress inetSocketAddress = new InetSocketAddress("127.0.0.1", 5555);
 
        if(!socketChannel.connect(inetSocketAddress)) {
            while (!socketChannel.finishConnect()) {
                System.out.println("客户端正在连接中，请耐心等待");
            }
        }
 
        ByteBuffer byteBuffer = ByteBuffer.wrap("hello,world".getBytes());
        socketChannel.write(byteBuffer);
        socketChannel.close();
    }