Reactor反应器模式（Netty 学习五）

什么是Reactor反应器模式

由Reactor反应器（线程）来负责响应IO事件，分发事件，由Handler处理器（线程）来负责处理事件。Reactor和若干的Handler组成了反应器模式。传统的OIO是采用一个线程处理一个网络连接的方式来增加吞吐量，Reactor模式与传统的OIO类似，换成了NIO模型，相应的增加了Reactor来监听分发事件，Handler由原来的处理链接，变成对监听事件的处理。

单线程Reactor示例

知道了Reactor模式的定义，来写一个实例，从单线程Reactor反应器开始，Reactor和Handler在一个线程中。
下面是Reactor的示例

public class Reactor implements Runnable {

    //单个选择器，单个链接
    private Selector selector;
    private ServerSocketChannel serverSocketChannel;

    public Reactor(int port) throws IOException {
        //打开选择器，Server，注册accept事件
        selector = Selector.open();
        serverSocketChannel = ServerSocketChannel.open();
        serverSocketChannel.configureBlocking(false);
        serverSocketChannel.bind(new InetSocketAddress(port));
        SelectionKey sk = serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
        //绑定handler
        sk.attach(new AcceptHandler());
    }


    @Override
    public void run() {
        try {
            //轮询就绪事件
            while (!Thread.interrupted()) {
                selector.select();
                Set<SelectionKey> set = selector.selectedKeys();
                Iterator<SelectionKey> iterator = set.iterator();
                while (iterator.hasNext()){
                    this.dispatch(iterator.next());
                    iterator.remove();
                }
            }
        }catch (IOException e){
            e.printStackTrace();
        }
    }

    private void dispatch(SelectionKey sk){
        Runnable handler = (Runnable) sk.attachment();
        if(null != handler){
            //单线程模式
            handler.run();
        }
    }

    class AcceptHandler implements Runnable {

        @Override
        public void run() {
            try {
                //获取客户连接
                SocketChannel socketChannel = serverSocketChannel.accept();
                //注意非空判断
                if(null != socketChannel) {
                    //初始化读操作
                    new ReadHandler(selector, socketChannel);
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

其中有一个AcceptHandler，是对应Accept事件的handler，使用内部类可以方便的引用Selector和ServerSocketChannel，他的职责就是讲IO事件注册到Selector中。这里一定要注意非空判断，这里会经常取到空的SocketChannel。下面看一下读事件的handler。

public class ReadHandler implements Runnable {

    private Selector selector;
    private SocketChannel socketChannel;

    ReadHandler(Selector selector, SocketChannel socketChannel){
        this.selector = selector;
        this.socketChannel = socketChannel;
        try {
            //注册可读事件
            this.socketChannel.configureBlocking(false);
            SelectionKey sk = socketChannel.register(selector, SelectionKey.OP_READ);
            //绑定读Handler(this)
            sk.attach(this);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void run() {
        ByteBuffer byteBuffer = ByteBuffer.allocate(24);
        try {
            socketChannel.read(byteBuffer);
            byteBuffer.flip();
            //打印内容
            System.out.println(new String(byteBuffer.array()));
            //socketChannel.write(byteBuffer);
            //关闭链接，一定要关闭
            socketChannel.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

这个是读事件的handler，逻辑比较简单就是把客户端发送的内容打印到控制台，注意一定要关闭链接，否则会不停的读取。至此就写了一个简单的单线程Reactor示例。本来想Reactor和Handler分开，但是直接启动线程执行Handler会有问题。把这个问题放到多线程Reactor的实现里面一并处理吧，下一篇来看一下多线程的Reactor模式实现。