Netty系列教程（一）IO与NIO

我们简单模拟以下场景：客户端每隔2秒向服务端发送“hello，world"，然后服务端接收并打印。

IO编程

下面是传统IO编程服务端代码：

IOServer.java

public class IOServer {
    public static void main(String[] args) throws Exception {
        ServerSocket serverSocket = new soc(8000);
        System.out.println("server is starting...");
        // 接收新连接线程
        new Thread(() -> {
            while (true) {
                try {
                    // (1) 阻塞方法获取新的连接
                    Socket socket = serverSocket.accept();
                   System.out.println(socket.getInetAddress()+":"+socket.getPort()+"加入连接");
                    // (2) 每一个新的连接都创建一个线程，负责读取数据
                    new Thread(() -> {
                        try {
                            byte[] data = new byte[1024];
                            InputStream inputStream = socket.getInputStream();
                            while (true) {
                                int len;
                                // (3) 按字节流方式读取数据
                                while ((len = inputStream.read(data)) != -1) {
                                    System.out.println(new String(data, 0, len));
                                }
                            }
                        } catch (IOException e) {
                        }
                    }).start();
                } catch (IOException e) {
                }
            }
        }).start();
    }
}

server端首先初始化一个8000监听端口的serverSocket，然后开启一个线程不断地去调用堵塞方法accept去获取新的连接，当获取到新的连接后，就给每条连接创建一条线程，该线程就去负责以流的方式读取该连接所带过来的数据。

下面是传统IO编程客户端代码：

IOClient.java

public class IOClient {
    public static void main(String[] args) {
        new Thread(() -> {
            try {
                Socket socket = new Socket("127.0.0.1", 8000);
                while (true) {
                    try {
                        socket.getOutputStream().write((new Date() + ": hello world").getBytes());
                        socket.getOutputStream().flush();
                        Thread.sleep(2000);
                    } catch (Exception e) {
                    }
                }
            } catch (IOException e) {
            }
        }).start();
    }
}

客户端的代码比较简单，连上服务端的8000端口，然后每隔2秒发送一条信息。

理解模型

咱们简单举个例子，你就能很快理解IO工作流程。有一个餐厅，大门那有一个接待员，每来一个客人，接待员就叫一个服务员到客人桌前去等待客人点菜。来一个客户人就需要一个服务员过去接待，十个客人就需要十个服务员过去接待，那么问题来了，这个餐厅能赚到钱吗？

JDK1.4提供了NIO（New IO）API

NIO编程

下面是NIO编程服务端代码：

NIOServer.java

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();
	}
}

这段代码比较复杂，所以我都加了注释。我们还是先对照NIO来解释一下几个核心思路。
先简单说一下NIO核心三要素：

• Channel：通道，可以理解为水管，用来传递消息的
• Buffer：缓冲区，用于和NIO通道进行交互。如你所知，数据是从通道读入缓冲区，从缓冲区写入到通道中的
• Selector：选择器，能够检测一到多个NIO通道(channel)，并能够知晓通道是否为诸如读写事件做好准备的组件。这样，一个单独的线程可以管理多个channel，从而管理多个网络连接。
  关于这三部分相关的API，后面会继续分析，现在暂时了解。

理解了这三个要素，那上面的代码看起来就没那复杂了。
1.首先，初始化一个通道ServerSocketChannel，给该通道注册SelectionKey.OP_ACCEPT事件，然后与轮询器selector绑定；
2.接着，当新连接过来后就判断SelectionKey的事件类型，如果是isAcceptable可连接事件，则表示是新的通道，需要给该通道绑定SelectionKey.OP_READ事件，以便传递消息；如果是isReadable可读事件，则去缓冲区buffer去读取客户端发过来的消息，当然，也可以给客户端回写消息。

理解模型

同样是餐厅，当客人来了之后，接待员安排一个服务员，服务员给客人一张菜单后，然后回到大门处等待，当客人选完菜之后在喊服务员过去。这样，一个服务员可以同时服务几位甚至十几位客户，大大节约了餐厅成本。

总结

IO	NIO
面向流	面向缓冲
阻塞IO	非阻塞IO
无	选择器

NIO可让您只使用一个（或几个）单线程管理多个通道（网络连接或文件），但付出的代价是解析数据可能会比从一个阻塞流中读取数据更复杂。
如果需要管理同时打开的成千上万个连接，这些连接每次只是发送少量的数据，例如聊天服务器，实现NIO的服务器可能是一个优势。同样，如果你需要维持许多打开的连接到其他计算机上，如P2P网络中，使用一个单独的线程来管理你所有出站连接，可能是一个优势。
Java NIO: 单线程管理多个连接

如果你有少量的连接使用非常高的带宽，一次发送大量的数据，也许典型的IO服务器实现可能非常契合。
Java IO: 一个典型的IO服务器设计- 一个连接通过一个线程处理