public class OioServer {

    @SuppressWarnings("resource")

    public static void main(String[] args) throws Exception {

        ExecutorService newCachedThreadPool = Executors.newCachedThreadPool();

        //创建socket服务,监听10101端口

        ServerSocket server=new ServerSocket(10101);

        System.out.println("服务器启动！");

        while(true){

            //获取一个套接字（阻塞）

            final Socket socket = server.accept();

            System.out.println("来个一个新客户端！");

            newCachedThreadPool.execute(new Runnable() {

                @Override

                public void run() {

                    //业务处理

                    handler(socket);

                }

            });

        }

    }

    /**

     * 读取数据

     * @param socket

     * @throws Exception

     */

    public static void handler(Socket socket){

            try {

                byte[] bytes = new byte[1024];

                InputStream inputStream = socket.getInputStream();

                while(true){

                    //读取数据（阻塞）

                    int read = inputStream.read(bytes);

                    if(read != -1){

                        System.out.println(new String(bytes, 0, read));

                    }else{

                        break;

                    }

                }

            } catch (Exception e) {

                e.printStackTrace();

            }finally{

                try {

                    System.out.println("socket关闭");

                    socket.close();

                } catch (IOException e) {

                    e.printStackTrace();

                }

            }

    }

}

public class NIOServer {

    // 通道管理器

    private Selector selector;

    /**

     * 获得一个ServerSocket通道，并对该通道做一些初始化的工作

     *

     * @param port

     *            绑定的端口号

     * @throws IOException

     */

    public void initServer(int port) throws IOException {

        // 获得一个ServerSocket通道

        ServerSocketChannel serverChannel = ServerSocketChannel.open();

        // 设置通道为非阻塞

        serverChannel.configureBlocking(false);

        // 将该通道对应的ServerSocket绑定到port端口

        serverChannel.socket().bind(new InetSocketAddress(port));

        // 获得一个通道管理器

        this.selector = Selector.open();

        // 将通道管理器和该通道绑定，并为该通道注册SelectionKey.OP_ACCEPT事件,注册该事件后，

        // 当该事件到达时，selector.select()会返回，如果该事件没到达selector.select()会一直阻塞。

        serverChannel.register(selector, SelectionKey.OP_ACCEPT);

    }

    /**

     * 采用轮询的方式监听selector上是否有需要处理的事件，如果有，则进行处理

     *

     * @throws IOException

     */

    public void listen() throws IOException {

        System.out.println("服务端启动成功！");

        // 轮询访问selector

        while (true) {

            // 当注册的事件到达时，方法返回；否则,该方法会一直阻塞

            selector.select();

            // 获得selector中选中的项的迭代器，选中的项为注册的事件

            Iterator<?> ite = this.selector.selectedKeys().iterator();

            while (ite.hasNext()) {

                SelectionKey key = (SelectionKey) ite.next();

                // 删除已选的key,以防重复处理

                ite.remove();

                handler(key);

            }

        }

    }

    /**

     * 处理请求

     *

     * @param key

     * @throws IOException

     */

    public void handler(SelectionKey key) throws IOException {

        // 客户端请求连接事件

        if (key.isAcceptable()) {

            handlerAccept(key);

            // 获得了可读的事件

        } else if (key.isReadable()) {

            handelerRead(key);

        }

    }

    /**

     * 处理连接请求

     *

     * @param key

     * @throws IOException

     */

    public void handlerAccept(SelectionKey key) throws IOException {

        ServerSocketChannel server = (ServerSocketChannel) key.channel();

        // 获得和客户端连接的通道

        SocketChannel channel = server.accept();

        // 设置成非阻塞

        channel.configureBlocking(false);

        // 在这里可以给客户端发送信息哦

        System.out.println("新的客户端连接");

        // 在和客户端连接成功之后，为了可以接收到客户端的信息，需要给通道设置读的权限。

        channel.register(this.selector, SelectionKey.OP_READ);

    }

    /**

     * 处理读的事件

     *

     * @param key

     * @throws IOException

     */

    public void handelerRead(SelectionKey key) throws IOException {

        // 服务器可读取消息:得到事件发生的Socket通道

        SocketChannel channel = (SocketChannel) key.channel();

        // 创建读取的缓冲区

        ByteBuffer buffer = ByteBuffer.allocate(1024);

        int read = channel.read(buffer);

        if(read > 0){

            byte[] data = buffer.array();

            String msg = new String(data).trim();

            System.out.println("服务端收到信息：" + msg);

            //回写数据

            ByteBuffer outBuffer = ByteBuffer.wrap("好的".getBytes());

            channel.write(outBuffer);// 将消息回送给客户端

        }else{

            System.out.println("客户端关闭");

            key.cancel();

        }

    }

    /**

     * 启动服务端测试

     *

     * @throws IOException

     */

    public static void main(String[] args) throws IOException {

        NIOServer server = new NIOServer();

        server.initServer(8000);

        server.listen();

    }

}