Netty学习——入门篇2 Netty基础篇

1 Java NIO三件套

        在NIO中有三个核心对象需要掌握：缓冲区(Buffer)、选择器(Selector)、通道(Channel)。

2 缓冲区

        2.1 Buffer操作基本API

        缓冲区实际上是一个容器对象，更直接的说，其实就是一个数组，在NIO库中，所有数据都是用缓冲区处理的。在读取数据时，它是直接读到缓冲区中的；在写入数据时，也是写入缓冲区的；任何时候访问NIO中的数据，都是将它放在缓冲区中。而面向流I/O系统中，所有数据都是直接写入或者直接将数据读取到Stream对象中。

        在NIO中，所有的缓冲区类型都继承于抽象类Buffer，最常用的就是ByteBuffer，对于Java中的基本类型，基本都有一个具体Bluffer类型与之相对应，它们之间的继承关系如下：

        下面是一个简单的使用IntBuffer的例子。

public class IntByteDemo {
    public static void main(String[] args) {
        //为分配的int缓冲区，参数为缓冲区容量
        //新缓冲区的当前位置为0，其界限（限制位置）为其容量的一个底层来实现
        //其数组偏移量为0
        IntBuffer buffer = IntBuffer.allocate(8);
        for (int i = 0; i < buffer.capacity(); ++i) {
            int j = 2 * (i + 1);
            //将给定整数写入此缓冲区的当前位置，当前位置递增
            buffer.put(j);
        }
        //重设此缓冲区，将限制我只设置为当前位置，然后将当前位置设置为0
        buffer.flip();
        //查看在当前位置和限制位置之间是否有元素
        while(buffer.hasRemaining()){
            //读取此缓冲区当前位置的整数，然后当前位置递增
            int j = buffer.get();
            System.out.print(j + " ");
        }
    }
}

2.2 Buffer的基本原理

        在谈到缓冲区时，上面提到缓冲区对象本质上是一个数组，但它其实是一个特殊的数组，缓冲区对象内置了一些机制，能够跟踪和记录缓冲区的状态变化情况，如果使用get()方法从缓冲区获取数据，使用put()方法把数据写入缓冲区，都会引起缓冲区状态的变化。

        在缓冲区中，最重要的属性有下面三个，它们在一起合作完成对缓冲区内部状态的变化跟踪。

        1、position：指定下一个将要被写入或者读取的元素索引，它的值由get/put方法自动更新，在新创建一个Buffer对象时，position被初始化为0.

        2、limit：指定还要多少数据需要取出（再从缓冲区写入通道时），或者还有多少空间可以放入数据（再从通道读入缓冲区时）。

        3、capacity：指定了可以存储在缓冲区中的最大数据容量，实际上，它指定了底层数组的大小，或者至少是指定了准许我们使用的底层数组的容量。

        以上三个属性值之间有一些相对大小的关系：0 <= position <= limit <= capacity。如果创建一个新的容量大小为10的ByteBuffer对象，在初始化的时候，position设置为0，limit和capacity设置为10，在以后使用ByteBuffer对象过程中，capacity的值不会再发生变化，而其他两个将会随着使用而变化。

        使用代码来验证position、limit和capacity三个值的变化。首先本地准备一个文档，文档内容是：Tom.

public class BufferDemo {
    public static void main(String[] args) throws Exception{
        //这里用的是文件I/O处理
        FileInputStream fin = new FileInputStream("H:\\testdoc\\netty\\demo01.txt");
        //创建文件的操作管道
        FileChannel channel = fin.getChannel();
        //分配一个10个大小的缓冲区，其实就是分配一个10字节大小的Byte[]数组
        ByteBuffer buffer = ByteBuffer.allocate(10);
        output("初始化",buffer);
        //先读一下
        channel.read(buffer);
        output("调用read()方法，",buffer);
        buffer.flip();
        output("调用flip()方法",buffer);
        //判断还有没有可读数据
        while(buffer.hasRemaining()){
            byte b = buffer.get();
            //System.out.println((char) b);
        }
        output("调用get()方法",buffer);
        //可以理解为解锁
        buffer.clear();
        output("调用clear()方法",buffer);
        //最后把通道关闭
        fin.close();
    }
    //打印缓冲区的实时状态
    public static void output(String step, Buffer buffer){
        System.out.println(step + " : ");
        //容量，数组大小
        System.out.print("capacity:" + buffer.capacity() + ",");
        //当前操作数据所在的位置，也可以叫作坐标
        System.out.print("position:" + buffer.position() + ",");
        //锁定值后，flip,数据操作范围索引只能在position - limit之间
        System.out.println("limit:" + buffer.limit());
    }
}

        运行结果如下图：

        下面对以上运行结果进行图解，初始化时，三个属性值分别如下图所示：

 

        可以从通道中读取一些数据到缓冲区中，注意从通道读取数据，相当于往缓冲区写入数据。如果读取4个字节的数据，则此时position的值为4，即下一个将要被写入的字节索引也是4，而limit仍然是10。如下图所示。

 

        下一步把读取的数据写入输出通道，相当于从缓冲区中读取数据，在此之前，必须调用flip()方法。该方法将会完成以下两件事：一是把limit设置为当前的position值。二是把position设置为0。

        由于position被设置为0，所以可以保证在下一步输出时读取的是缓冲区的第一个字节，而limit设置为当前的position，可以保证读取的数据正好是之前写入缓冲区的数据，如下图所示：

 

        现在调用get方法，从缓冲区中读取数据写入输出通道，这会导致position的值增加而limit保持不变，但position不会超过limit的值，所以在读取之前写入缓冲区的4个字节，position和limit的值都是4，如下图所示。

        在从缓冲区读取数据完毕后，limit的值仍然保持在调用flip()方法时的值，调用clear方法能够把所有的状态设置为初始化时的值，如下图所示。

2.3 缓冲区的分配

        前面的几个例子中，已经看到，在创建一个缓冲区对象时，会调用静态方法来执行缓冲区的容量，其实调用allocate方法相当于创建一个指定大小的数组，并把它封装为缓冲区对象。或者也可以直接将一个现有的数组封装为缓冲区对象，示例代码如下：

public void test01(){
        ByteBuffer buffer = ByteBuffer.allocate(10);
        byte array[] = new byte[10];
        ByteBuffer buffer1 = ByteBuffer.wrap(array);
    }

2.4 缓冲区分片

        在NIO中，除了可以分配或者封装也一个缓冲区对象，还可以根据现有的缓冲区对象创建一个子缓冲区，即在现有缓冲区上切出一片作为一个新的缓冲区，但现有的缓冲区与创建的子缓冲区在底层数组层面上是数据共享的，也就是说，子缓冲区相当于现有缓冲区的一个视图窗口。调用slice()方法可以创建一个子缓冲区，示例代码如下：

public class BufferSlice {
    public static void main(String[] args) {
        ByteBuffer buffer = ByteBuffer.allocate(10);
        for (int i = 0; i < buffer.capacity(); ++i) {
            buffer.put((byte) i);
        }
        //创建子缓冲区
        buffer.position(3);
        buffer.limit(7);
        ByteBuffer slice = buffer.slice();
        for (int i = 0; i < slice.capacity(); ++i) {
            byte b = slice.get(i);
            b *= 10;
            slice.put(b);
        }
        buffer.position(0);
        while(buffer.remaining() > 0){
            System.out.println(buffer.get());
        }
    }
}

 

2.5 只读缓冲区 

        只读缓冲区非常简单，可以读取它们，但是不能向它们写入数据。可以通过调用缓冲区的asReadOnlyBuffer()方法，将任何常规缓冲区转换成只读缓冲区，这个返回一个与原缓冲区完全相同的缓冲区，并与原缓冲区共享数据，只不是它是只读的。如果原缓冲区的内容发生了变化，只读缓冲区的内容也随着发生变化。

public class ReadOnlyBuffer {
    public static void main(String[] args) {
        ByteBuffer buffer = ByteBuffer.allocate(10);
        //缓冲区的数据0~9
        for (int i = 0; i < buffer.capacity(); i++) {
            buffer.put((byte) i);
        }
        //创建只读缓冲区
        ByteBuffer readOnlyBuffer = buffer.asReadOnlyBuffer();
        //改变原缓冲区的内容
        for (int i = 0; i < buffer.capacity(); ++i) {
            byte b = buffer.get(i);
            b *= 10;
            buffer.put(i,b);
        }
        readOnlyBuffer.position(0);
        readOnlyBuffer.limit(buffer.capacity());
        //只读缓冲区的内容也随之改变
        while(readOnlyBuffer.remaining() > 0){
            System.out.println(readOnlyBuffer.get());
        }
    }
}

        如果尝试修改只读缓冲区的内容，则会抛出“ReadOnlyBufferException”异常。只读缓冲区对于保护数据很有用。在将缓冲区传递给某个对象的方法时，无法知道这个方法是否会修改缓冲区中的数据。创建一个只读缓冲区可以保证该缓冲区不会被修改。只可以把常规缓冲区转换为只读缓冲区，而不能将只读缓冲区转换为可写的缓冲区。

2.6 直接缓冲区

        直接缓冲区是为了加快I/O速度，使用一种特殊方式为其分配内存的缓冲区，JDK文档中的描述为：给定一个直接缓冲区，Java虚拟机将尽最大努力直接对它执行本机I/O操作。也就是说，它会在每一次调用底层操作系统的本机I/O操作之前（或之后），尝试避免将缓冲区的内容拷贝到一个中间缓冲区或者从一个中间缓冲区拷贝数据。要分配直接缓冲区，需要调用allocateDirect()方法，而不是allocate方法，使用方式与普通缓冲区并无区别。

3 选择器

        传统的CS模式会基于TPR，服务器会为每个客户端请求建立一个线程，由该线程负责处理一个客户端请求。这种模式带来的一个问题就是线程数量的剧增，大量的线程会增大服务器的开销。大多数的实现为了避免这个问题，都采用了线程池模型，并设置线程池中线程的最大数量，这又带来了新的问题，如果线程池中有200个线程，而有200个用户都在进行大文件下载，会导致第201个用户的请求无法及时处理，即便第201个用户只想请求一个几KB大小的页面。传统的CS模式如下图：

         NIO中非阻塞I/O采用了基于Reactor模式的工作方式，I/O调用不会被阻塞，而是注册感兴趣的特定I/O事件，如可读数据到达、新的套接字连接等，在发生特定事件时，系统在通知我们。NIO中实现非阻塞I/O的核心对象是Selector，Selector是注册各种I/O事件的载体，而且当那些事件发生时，就是Selector告诉我们所发生的事件，如下图所示：

        从图中可以看出，当有读或写等任何注册的事件发生时，可以从Selector中获得相应的SelectionKey，同时从 SelectionKey 中可以找到发生的事件和该事件所发生的具体的SelectableChannel，以获得客户端发送过来的数据。

        使用NIO中非阻塞I/O编写服务器处理程序，大体上可以分为下面三个步骤。

        1、向Selector对象注册感兴趣的事件。

        2、从Selector中获取该兴趣的事件。

        3、根据不同的事件进行相应的处理。

        下面用一个简答的实例来说明整个过程。首先向Selector对象注册感兴趣的事件。

private int port;
    //注册事件
    private Selector getSelector() throws IOException{
        //创建Selector对象
        Selector selector = Selector.open();
        //创建可选择通道，并配置为非阻塞模式
        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
        serverSocketChannel.configureBlocking(false);
        //绑定通道到指定端口
        ServerSocket socket = serverSocketChannel.socket();
        InetSocketAddress address = new InetSocketAddress(port);
        socket.bind(address);
        //向Selector注册感兴趣的事件
        serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
        return selector;
    }

        上述代码中线创建了ServerSoketChannel对象，并调用configureBlocking方法，配置为非阻塞模式。接下来的三行代码把该通道绑定到指定端口，最后向Selector注册事件。此处指定的OP_ACCEPT，即指定想要监听accept事件，也就是新的连接发生时所产生的事件。对于ServerSocketChannel通道来说，唯一可以指定的参数就是OP_ACCEPT。从Selector中获取感兴趣的事件，即开始监听，进入内部循环。

 public void listen(){
        System.out.println("正在监听的端口号是： " + port);
        try {
            while(true){
                //该调用会阻塞，直到至少有一个事件发生
                selector.select();
                Set<SelectionKey> keys = selector.selectedKeys();
                Iterator<SelectionKey> iter = keys.iterator();
                while(iter.hasNext()){
                    SelectionKey key = iter.next();
                    iter.remove();
                    process(key);
                }
            }
        }catch (IOException e){
            e.printStackTrace();
        }
    }

        在非阻塞I/O中，内部循环哦是基本都遵循这种方式。首先调用select方法，该方法会阻塞，直到至少有一个事件发生，然后使用SelectedKeys方法获取发生事件的SelectionKey，在使用迭代器进行循环。最后一步就是根据不同的事件，编写相应的处理代码。

//根据不同的事件处理
    private void process(SelectionKey key) throws Exception{
        ByteBuffer buffer = ByteBuffer.allocate(10);
        //接受请求
        if(key.isAcceptable()){
            ServerSocketChannel serverSocketChannel = (ServerSocketChannel) key.channel();
            SocketChannel channel = serverSocketChannel.accept();
            channel.configureBlocking(false);
            channel.register(selector,SelectionKey.OP_READ);
        }
        //读数据
        else if(key.isReadable()){
            SocketChannel channel = (SocketChannel) key.channel();
            int len = channel.read(buffer);
            if(len > 0){
                buffer.flip();
                String content = new String(buffer.array(), 0, len);
                SelectionKey skey = channel.register(selector,SelectionKey.OP_WRITE);
                skey.attach(content);
            }else{
                channel.close();
            }
            buffer.clear();
        }
        //写事件
        else if(key.isWritable()){
            SocketChannel channel = (SocketChannel) key.channel();
            String content = (String)key.attachment();
            ByteBuffer.wrap(("输出内容:" +content).getBytes());
            if(block != null){
                channel.write(block) ;
            
            }else{
                channel.close();
            }
        }
    }

4 通道

        通道是一个对象，通过它可以读取和写入数据，当然所有数据都通过Buffer对象来处理。不会讲字节直接写入通道，而是将数据写入包含一个或者多个字节的缓冲区。同样也不会直接从通道读取字节，而是将数据从通道读入缓冲区，在从缓冲区获取字节。

        NIO提供了多种通道实现，所有的通道对象都实现了Channel接口。它们之间的继承关系如下图

4.1 使用NIO写入数据

        前面说过，任何时候写入数据，都不是直接写入通道的，而是写入缓冲区。所以使用NIO写入数据可以分为三个步骤：

        1、从FileOutputStream获取Channel。

        2、创建Buffer。

        3、将数据从Channel读取到Buffer中。

        下面是一个简单的使用NIO写入数据到文件中。

public class FileOutPutDemo {
    static private final byte message[] = {83,111,109,101,32,98,121,116,101,115,46};
    public static void main(String[] args) throws Exception{
        FileOutputStream fout = new FileOutputStream("/Users/jay/Documents/files/netty/nio/test.txt");
        FileChannel channel = fout.getChannel();
        ByteBuffer buffer = ByteBuffer.allocate(1024);
        for (int i = 0; i < message.length; i++) {
            buffer.put(message[i]);
        }
        buffer.flip();
        channel.write(buffer);
        fout.close();
    }
}

4.2 使用NIO读取数据

        原理从NIO写入数据相似。

public class FileInPutDemo {
    public static void main(String[] args) throws Exception{
        FileInputStream fileInputStream = new FileInputStream("/Users/jay/Documents/files/netty/nio/test.txt");
        FileChannel channel = fileInputStream.getChannel();
        ByteBuffer buffer = ByteBuffer.allocate(1024);
        channel.read(buffer);
        buffer.flip();
        while(buffer.remaining() > 0){
            byte b = buffer.get();
            System.out.println((char) b);
        }
        fileInputStream.close();

    }
}