netty框架1

Netty与NIO的关系

在NIO中有几个核心对象需要掌握：

缓冲区 Buffer
选择器 Selector
信道    Channel

Buffer缓冲区

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

在NIO中，所有缓冲区类型都继承抽象类Buffer，最常用的就是ByteBuffer。对于java的基本类型，基本都有一个具体的Buffer类型与之对应。

eg：使用IntBuffer例子

public class IntBufferDemo {
    public static void main(String[] args) {
        //分配新的int缓冲区，参数为缓冲区容量capacity
        //新缓冲区的当前位置为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 4 6 8 10 12 14 16 

Buffer基本原理

谈到缓冲区时候，我们说缓冲区对象本质上是一个数组，但它其实是一个特殊的数组。缓冲区对象内置了一些机制，能够跟踪和记录缓冲区的状态变化情况，如果我们使用get()方法从缓冲区获取数据或者使用put()方法把数据写入缓冲区，都会引起缓冲区状态的变化。
在缓冲区中，最重要的属性有下面3个，它们一起合作完成缓冲区内部状态的变化跟踪。
position：指定下一个要被写入或者读取的元素索引，它的值由get()/put()方法自动更新，在新创建一个Buffer对象时，position被初始化为0；
limit：指定还有多少数据需要取出（在从缓冲区写入通道时），或者还有多少空间可以放入数据（在从通道读入缓冲区时）。
capacity：指定了可以存储在缓冲区的最大数据容量，实际上，他指定了数组的容量大小。
以上三个属性值之间有一些相对大小的关系：0<=position<=limit<=capacity。
eg：我们验证position、limit、capacity的变化过程。

public class BufferDemo {
    public static void main(String[] args) throws Exception {
        //用的是文件的IO处理
        FileInputStream fin = new FileInputStream("/Users/guangdongshengguangzhoushiliyang/Desktop/面试安排2");
        //创建文件的操作管道
        FileChannel fc = fin.getChannel();
        //分配一个10个大小缓冲区，说白了就是分配一个10个大小的byte数组
        ByteBuffer buffer = ByteBuffer.allocate(1000);
        output("初始化",buffer);
        //读取buffer数据
        fc.read(buffer);
        output("调用read()",buffer);
        //准备操作之前，先锁定操作范围
        buffer.flip();
        output("调用flip()",buffer);
        //判断有无可读的数据
        while(buffer.remaining()>0){
            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()+",");
        System.out.print("limit:"+buffer.limit());
        System.out.println();
    }
}

输出结果：

初始化:
capacity:1000,position:0,limit:1000
调用read():
capacity:1000,position:12,limit:1000
调用flip():
capacity:1000,position:0,limit:12
调用get():
capacity:1000,position:12,limit:12
调用clear():
capacity:1000,position:0,limit:1000

缓冲区的分配

在创建一个缓冲区对象时，会调用静态方法allocate()来指定缓冲区的容量，其实调用allocate()相当于创建了一个指定大小的数组，并把它包装成缓冲区对象。或者我们可以直接将一个现有的数组，包装为缓冲区对象。
eg：

public class BufferWrap {
    public static void main(String[] args) {

    }
    public void mymethod(){
        //分配指定缓冲区大小
        ByteBuffer buffer = ByteBuffer.allocate(10);
        //包装一个现有的数组
        byte array[] = new byte[10];
        ByteBuffer buffer2 = ByteBuffer.wrap(array);
    }
}

缓冲区分片

在NIO中。除了可以分配或者包装一个缓冲区对象外，还可以根绝现有的缓冲区对象来创建一个子缓冲区，即在现有缓冲区上切出来一片作为一个新的缓冲区，但现有的缓冲区与创建的子缓冲区在底层数组层面上数据共享，也就是红说，子缓冲区相当于是现有缓冲区的一个视图窗口。调用slice()方法可以创建一个子缓冲区，让我们通过例子看一下。

public class BufferSlice {
    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);
        }
        //创建子缓冲区slice
        buffer.position(3);
        buffer.limit(7);
        ByteBuffer slice = buffer.slice();
        //改变子缓冲区的内容（3、4、5、6）
        for(int i=0;i<slice.capacity();++i){
            byte b = slice.get(i);
            System.out.println(i+":"+b);
            b*=10;
            slice.put(i,b);
        }
        System.out.println("======================");
        buffer.position(0);
        buffer.limit(buffer.capacity());
        while(buffer.hasRemaining()){
            System.out.println(buffer.get());
        }
    }
}

输出结果：

0:3
1:4
2:5
3:6
======================
0
1
2
30
40
50
60
7
8
9

Process finished with exit code 0

只读缓冲区

只读缓冲区，可以读取他们，但是不能向他们写入数据。可以通过调用缓冲区的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 readOnly = buffer.asReadOnlyBuffer();
        //改变原缓冲区的内容。
        for(int i=0;i<buffer.capacity();++i){
            byte b = buffer.get(i);
            b*=10;
            buffer.put(i,b);
        }
        readOnly.position(0);
        readOnly.limit(buffer.capacity());
        //只读缓冲区的内容随之改变
        while (readOnly.hasRemaining()){
            System.out.println(readOnly.get());
        }
    }
}

如果尝试修改只读缓冲区的内容，则会报ReadOnlyBufferException异常。只读缓冲区对于保护数据很有用。

直接缓冲区（直接内存开辟缓冲区）

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

public class DirectBuffer {
    public static void main(String[] args) throws IOException {
        //1、从磁盘读取我们的文件
        String infile = "/Users/guangdongshengguangzhoushiliyang/Desktop/面试安排2";
        FileInputStream fin = new FileInputStream(infile);
        FileChannel fileChannelIn = fin.getChannel();
        //2、把我们刚刚读取的内容写入一个新的文件
        String outfile = String.format("/Users/guangdongshengguangzhoushiliyang/Desktop/面试安排copy");
        FileOutputStream fout = new FileOutputStream(outfile);
        FileChannel fileChannelOut = fout.getChannel();
        //3、使用allocateDirect，而不是allocate
        ByteBuffer buffer = ByteBuffer.allocateDirect(1024);
        while (true) {
            buffer.clear();
            int r = fileChannelIn.read(buffer);
            if (r == -1) {
                break;
            }
            buffer.flip();
            fileChannelOut.write(buffer);
        }

    }
}

内存映射

内存映射是一种读和写文件数据的方法，它可以比常规的基于流或者通道的I/O快的多。内存映射文件IO是通过使文件中的数据出现为内存数组的内容来完成的，这起初听起来似乎不过是将整个文件读到内存中，但是事实上并不是这样。一般来说，只有文件中实际读取或者写入部分才会映射到内存中。
eg：

public class MappedBuffer {
    static private final int start = 0;
    static private final int size = 1024;
    public static void main(String[] args) throws IOException {
        RandomAccessFile raf = new RandomAccessFile("/Users/guangdongshengguangzhoushiliyang/Desktop/面试安排2","rw");
        FileChannel fc = raf.getChannel();
        //把缓冲区跟文件系统进行一个映射关联
        //只要操作缓冲区里面的内容，文件内容也会改变
        MappedByteBuffer mbb = fc.map(FileChannel.MapMode.READ_WRITE,start,size);
        mbb.put(0,(byte)97);
        mbb.put(1023,(byte)122);
        raf.close();
    }
}

选择器Selector

传统的server/client模式会基于TPR（Thread per Request），服务器会为每个客户端请求建立一个线程，🈶该线程单独处理一个客户请求。这种模式带来的一个问题就是线程数量的剧增，大量的线程会增大服务器的开销。大多数的实现为了避免这个问题，都采用了线程池的模型，并设置最大线程数量。这又带来新的问题，如果线程池有200个线程，而有200个用户都在进行大文件的下载，会导致第201个用户请求无法及时处理。

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

图中可以看出，当有读或写任何事件发生时，可以从Selector中获得相应的SelectionKey，同时从SelectionKey中可以找到发生的事件和该事件所发生的具体的SelectableChannel，以获得客户端发送过来的数据。
使用NIO中非阻塞IO编写服务器处理程序，大体分为3个步骤：

1、向Selector对象注册感兴趣的事件
2、从Selector中获取感兴趣的事件
3、根据不同的事件进行相应的处理

eg：

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

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

eg：从selector中获取感兴趣的事件，即开始监听，进入内部循环：

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

在非阻塞IO中，内部循环模式都是遵循这种方式。首先调用select()方法，该方法会进行阻塞，直到有一个事件发生，然后再使用selectKeys()方法获取发生事件的SelectionKey，再使用迭代器循环。

//根据不同的事件进行处理
    private void process(SelectionKey key) throws IOException {
        if(key.isAcceptable()){
            ServerSocketChannel server = (ServerSocketChannel) key.channel();
            SocketChannel channel = server.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 selectionKey = channel.register(selector,SelectionKey.OP_WRITE);
                selectionKey.attach(content);
            }else {
                channel.close();
            }
            buffer.clear();
        }else if(key.isWritable()){
            SocketChannel channel = (SocketChannel) key.channel();
            String content = (String)key.attachment();
            ByteBuffer block = ByteBuffer.wrap(("输出内容："+content).getBytes());
            if(block != null){
                channel.write(block);
            }else{
                channel.close();
            }
        }
    }
}

此处判断是接受请求、读数据还是写事件，分别做不同的处理。

在java1.4之前的IO中，提供面向流的IO系统，系统一次一个字节的处理数据，一个输入流产生一个字节数据，一个输出流消费一个字节的数据，面向流的IO速度非常慢。
而在java1.4中推出了NIO，这是一个面向快的IO系统，系统以块的方式处理，每一个操作在一步中产生或消费一个数据块，按块处理要比字节处理数据快的多。

通道Channel

通道是一个对象，通过它可以读取和写入数据，当然所有数据都通过Buffer对象来处理。我们永远不会将字节直接写入通道中，相反是将数据写入一个或多个字节的缓冲区。同样不会直接从通道读取字节，而是将数据从通道读入缓冲区，再从缓冲区获取这个字节。
在NIO中，提供了多种通道对象，而所有的通道对象都实现了Channel接口，他们之间的关系如下：

使用NIO读取（写入）数据

在前面我们说过，任何时候读取数据，都不是直接从通道读取，而是从通道读取到缓冲区。
所以使用NIO读取数据分为下面3个步骤：

1、从FileInputStream获取channel
2、创建Buffer
3、将数据从Channel读取到Buffer中。

public class FileInputDemo {
    public static void main(String[] args) throws IOException {
        FileInputStream fin = new FileInputStream("/Users/guangdongshengguangzhoushiliyang/Desktop/test.txt");
        //获取通道
        FileChannel fc = fin.getChannel();
        //创建缓冲区
        ByteBuffer buffer = ByteBuffer.allocateDirect(1024);
        //读取数据到缓冲区
        fc.read(buffer);
        buffer.flip();
        while(buffer.hasRemaining()){
            byte b = buffer.get();
            System.out.println((char)b);
        }
        fin.close();
    }
}

使用NIO写入数据

1、从FileInputStream获取channel
2、创建Buffer
3、将数据从Channel写入到Buffer中。

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

反应堆Reactor

我们已经对阻塞IO有了一定了解，我们知道阻塞IO在调用InputStream.read()方法时是阻塞的，它会一直等到数据到来时（或超时）才会返回；同样，在调用ServerSocket.accept()方法时，也会一直阻塞到有客户端连接才会返回，每个客户端连接过来后，服务端都会启动一个线程去处理该客户端的请求。
细细分析，一定会发现阻塞IO的缺点。根据阻塞IO通信模型，总结2个缺点：

1、当客户端多时，会创建大量的处理线程。且每个线程都要占用栈空间和一些CPU时间。
2、阻塞可能带来频繁的上下文切换，且大部分时间上下文切换毫无意义。

java NIO是在jdk1.4开始使用的，可以说成“新I/O”，也可以说非阻塞IO。
下面是Java NIO工作原理：
1、由一个专门线程来处理所有IO事件，并负责分发。
2、事件驱动机制：事件到的时候触发，而不是同步的去监听事件。
3、线程通讯：线程之间通过wait、notify等方式通信。保证每次上下文切换都是有意义的。减少无谓的线程切换。

Netty架构图

1、绿色的部分Core核心模块，包括零拷贝、API库、可扩展的事件模型。

2、橙色部分Protocol Support协议支持，包括Http协议、webSocket、SSL安全认证(安全套接字协议)、谷歌Protobuf编解码、zlib/gzip压缩与解压缩、Large File Transfer大文件传输协议、流媒体传输。

3、红色的部分Transport Services传输服务，管道通信；包括Socket（TCP）、Datagram（UDP）、Http 隧道 等等。