NIO和Reactor

/**
 * Created by gaoxing on 2015-01-20 .
 */
public class ClasssicServer {
    public static void main(String[] args) {
        try {
            ServerSocket serverSocket=new ServerSocket(8888,10);
            System.out.println("server is start");
            while( ! Thread.interrupted())
            {
                new Thread(new Handler(serverSocket.accept())).start();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    static class Handler implements  Runnable
    {
        final Socket socket;

        final static int MAX_SIZE=1024;

        public Handler(Socket socket)
        {
            this.socket=socket;
        }

        @Override
        public void run() {
            //TODO
            //在这里对socket中的数据进行读取和处理，然后把结果写入到socket中去
        }

    }
}

/**
 * Created by gaoxing on 2015-01-20 .
 */
public class Reactor implements Runnable {
    final Selector selector ;
    final ServerSocketChannel serverSocketChannel;

    public Reactor(int port) throws IOException {
        this.selector=Selector.open();
        this.serverSocketChannel=ServerSocketChannel.open();
        serverSocketChannel.socket().bind(new InetSocketAddress(port));
        //一定是非阻塞的，阻塞的一个通道就只能处理一个请求了
        serverSocketChannel.configureBlocking(false);
        //把OP_ACCEPT事件和Acceptor绑定
        SelectionKey sk=serverSocketChannel.register(selector,SelectionKey.OP_ACCEPT);
        sk.attach(new Acceptor());

    }

    @Override
    public void run() {
        while(!Thread.interrupted())
        {
            try {
                selector.select();//该方法是阻塞的，只有IO事件来了才向下执行
                Set<SelectionKey> selected=selector.selectedKeys();
                Iterator<SelectionKey> it=selected.iterator();
                while(it.hasNext())
                {
                    dispatch(it.next());
                }
　　　　　　　　　 selected.clear()　　　　　　　　　　
            } catch (IOException e) {
                e.printStackTrace();
            }

        }
    }

    private void dispatch(SelectionKey next) {
        Runnable runnable= (Runnable) next.attachment();
        if(runnable!=null)
        {
            runnable.run();
        }
    }

    private class Acceptor implements Runnable{
        @Override
        public void run() {
            SocketChannel channel= null;
            try {
                channel = serverSocketChannel.accept();
                if (channel!=null){
                    new Handler(selector,channel);
                }
            } catch (IOException e) {
                e.printStackTrace();
            }

        }
    }
}

class Handler implements  Runnable
{
    final SelectionKey sk;
    final SocketChannel channel;
    final static int MAXSIZE=1024;
    ByteBuffer input=ByteBuffer.allocate(MAXSIZE);
    ByteBuffer output=ByteBuffer.allocate(MAXSIZE);

    static final int READING=0,SENDING=1;
    int state=READING;

    public Handler(Selector selector,SocketChannel channel) throws IOException {
        this.channel=channel;

            this.channel.configureBlocking(false);
            /**
             * 这个有个问题，ppt上register是0，
             */
            sk=this.channel.register(selector,SelectionKey.OP_READ);
            sk.attach(this);
            /**
             * 这里的作用是，设置key的状态为可读，然后让后selector的selector返回。
             * 然后就可以处理OP_READ事件了
             */
            sk.interestOps(SelectionKey.OP_READ);
            selector.wakeup();

    }
    @Override
    public void run() {
        if (state==READING) read();
        if (state==SENDING) write();
    }

    void read(){
        state=SENDING;
        sk.interestOps(SelectionKey.OP_WRITE);
    }

    void write()
    {
        sk.cancel();
    }
}