案例研究:Transport 的迁移

为了让你想象 Transport 如何工作，我会从一个简单的应用程序开始，这个应用程序什么都不做，只是接受客户端连接并发送“Hi!”字符串消息到客户端，发送完了就断开连接。

没有用 Netty 实现 I/O 和 NIO

我们将不用 Netty 实现只用 JDK API 来实现 I/O 和 NIO。下面这个例子，是使用阻塞 IO 实现的例子：

Listing 4.1 Blocking networking without Netty

  1. public class PlainOioServer {
  3.     public void serve(int port) throws IOException {
  4.         final ServerSocket socket = new ServerSocket(port);     //1
  5.         try {
  6.             for (;;) {
  7.                 final Socket clientSocket = socket.accept();    //2
  8.                 System.out.println("Accepted connection from " + clientSocket);
  10.                 new Thread(new Runnable() {                        //3
  11.                     @Override
  12.                     public void run() {
  13.                         OutputStream out;
  14.                         try {
  15.                             out = clientSocket.getOutputStream();
  16.                             out.write("Hi!\r\n".getBytes(Charset.forName("UTF-8")));                            //4
  17.                             out.flush();
  18.                             clientSocket.close();                //5
  20.                         } catch (IOException e) {
  21.                             e.printStackTrace();
  22.                             try {
  23.                                 clientSocket.close();
  24.                             } catch (IOException ex) {
  25.                                 // ignore on close
  26.                             }
  27.                         }
  28.                     }
  29.                 }).start();                                        //6
  30.             }
  31.         } catch (IOException e) {
  32.             e.printStackTrace();
  33.         }
  34.     }
  35. }

1.绑定服务器到指定的端口。

2.接受一个连接。

3.创建一个新的线程来处理连接。

4.将消息发送到连接的客户端。

5.一旦消息被写入和刷新时就 关闭连接。

6.启动线程。

上面的方式可以工作正常，但是这种阻塞模式在大连接数的情况就会有很严重的问题，如客户端连接超时，服务器响应严重延迟，性能无法扩展。为了解决这种情况，我们可以使用异步网络处理所有的并发连接，但问题在于 NIO 和 OIO 的 API 是完全不同的，所以一个用OIO开发的网络应用程序想要使用NIO重构代码几乎是重新开发。

下面代码是使用 NIO 实现的例子：

Listing 4.2 Asynchronous networking without Netty

  1. public class PlainNioServer {
  2.     public void serve(int port) throws IOException {
  3.         ServerSocketChannel serverChannel = ServerSocketChannel.open();
  4.         serverChannel.configureBlocking(false);
  5.         ServerSocket ss = serverChannel.socket();
  6.         InetSocketAddress address = new InetSocketAddress(port);
  7.         ss.bind(address);                                            //1
  8.         Selector selector = Selector.open();                        //2
  9.         serverChannel.register(selector, SelectionKey.OP_ACCEPT);    //3
  10.         final ByteBuffer msg = ByteBuffer.wrap("Hi!\r\n".getBytes());
  11.         for (;;) {
  12.             try {
  13.                 selector.select();                                    //4
  14.             } catch (IOException ex) {
  15.                 ex.printStackTrace();
  16.                 // handle exception
  17.                 break;
  18.             }
  19.             Set<SelectionKey> readyKeys = selector.selectedKeys();    //5
  20.             Iterator<SelectionKey> iterator = readyKeys.iterator();
  21.             while (iterator.hasNext()) {
  22.                 SelectionKey key = iterator.next();
  23.                 iterator.remove();
  24.                 try {
  25.                     if (key.isAcceptable()) {                //6
  26.                         ServerSocketChannel server =
  27.                                 (ServerSocketChannel)key.channel();
  28.                         SocketChannel client = server.accept();
  29.                         client.configureBlocking(false);
  30.                         client.register(selector, SelectionKey.OP_WRITE |
  31.                                 SelectionKey.OP_READ, msg.duplicate());    //7
  32.                         System.out.println(
  33.                                 "Accepted connection from " + client);
  34.                     }
  35.                     if (key.isWritable()) {                //8
  36.                         SocketChannel client =
  37.                                 (SocketChannel)key.channel();
  38.                         ByteBuffer buffer =
  39.                                 (ByteBuffer)key.attachment();
  40.                         while (buffer.hasRemaining()) {
  41.                             if (client.write(buffer) == 0) {        //9
  42.                                 break;
  43.                             }
  44.                         }
  45.                         client.close();                    //10
  46.                     }
  47.                 } catch (IOException ex) {
  48.                     key.cancel();
  49.                     try {
  50.                         key.channel().close();
  51.                     } catch (IOException cex) {
  52.                         // 在关闭时忽略
  53.                     }
  54.                 }
  55.             }
  56.         }
  57.     }
  58. }

1.绑定服务器到制定端口

2.打开 selector 处理 channel

3.注册 ServerSocket 到 ServerSocket ，并指定这是专门意接受
连接。

4.等待新的事件来处理。这将阻塞，直到一个事件是传入。

5.从收到的所有事件中 获取 SelectionKey 实例。

6.检查该事件是一个新的连接准备好接受。

7.接受客户端，并用 selector 进行注册。

8.检查 socket 是否准备好写数据。

9.将数据写入到所连接的客户端。如果网络饱和，连接是可写的，那么这个循环将写入数据，直到该缓冲区是空的。

10.关闭连接。

如你所见，即使它们实现的功能是一样，但是代码完全不同。下面我们将用Netty 来实现相同的功能。

采用 Netty 实现 I/O 和 NIO

下面代码是使用Netty作为网络框架编写的一个阻塞 IO 例子：

Listing 4.3 Blocking networking with Netty

  1. public class NettyOioServer {
  3.     public void server(int port) throws Exception {
  4.         final ByteBuf buf = Unpooled.unreleasableBuffer(
  5.                 Unpooled.copiedBuffer("Hi!\r\n", Charset.forName("UTF-8")));
  6.         EventLoopGroup group = new OioEventLoopGroup();
  7.         try {
  8.             ServerBootstrap b = new ServerBootstrap();        //1
  10.             b.group(group)                                    //2
  11.              .channel(OioServerSocketChannel.class)
  12.              .localAddress(new InetSocketAddress(port))
  13.              .childHandler(new ChannelInitializer<SocketChannel>() {//3
  14.                  @Override
  15.                  public void initChannel(SocketChannel ch) 
  16.                      throws Exception {
  17.                      ch.pipeline().addLast(new ChannelInboundHandlerAdapter() {            //4
  18.                          @Override
  19.                          public void channelActive(ChannelHandlerContext ctx) throws Exception {
  20.                              ctx.writeAndFlush(buf.duplicate()).addListener(ChannelFutureListener.CLOSE);//5
  21.                          }
  22.                      });
  23.                  }
  24.              });
  25.             ChannelFuture f = b.bind().sync();  //6
  26.             f.channel().closeFuture().sync();
  27.         } finally {
  28.             group.shutdownGracefully().sync();        //7
  29.         }
  30.     }
  31. }

1.创建一个 ServerBootstrap

2.使用 NioEventLoopGroup 允许非阻塞模式（NIO）

3.指定 ChannelInitializer 将给每个接受的连接调用

4.添加的 ChannelHandler 拦截事件，并允许他们作出反应

5.写信息到客户端，并添加 ChannelFutureListener 当一旦消息写入就关闭连接

6.绑定服务器来接受连接

7.释放所有资源

下面代码是使用 Netty NIO 实现。

Netty NIO 版本

下面是 Netty NIO 的代码，只是改变了一行代码，就从 OIO 传输 切换到了 NIO。

Listing 4.4 Asynchronous networking with Netty

  1. public class NettyNioServer {
  3.     public void server(int port) throws Exception {
  4.         final ByteBuf buf = Unpooled.unreleasableBuffer(
  5.                 Unpooled.copiedBuffer("Hi!\r\n", Charset.forName("UTF-8")));
  6.         NioEventLoopGroup group = new NioEventLoopGroup();
  7.         try {
  8.             ServerBootstrap b = new ServerBootstrap();    //1
  9.             b.group(new NioEventLoopGroup(), new NioEventLoopGroup())   //2
  10.              .channel(NioServerSocketChannel.class)
  11.              .localAddress(new InetSocketAddress(port))
  12.              .childHandler(new ChannelInitializer<SocketChannel>() {    //3
  13.                  @Override
  14.                  public void initChannel(SocketChannel ch) 
  15.                      throws Exception {
  16.                      ch.pipeline().addLast(new ChannelInboundHandlerAdapter() {    //4
  17.                          @Override
  18.                          public void channelActive(ChannelHandlerContext ctx) throws Exception {
  19.                              ctx.writeAndFlush(buf.duplicate())                //5
  20.                                 .addListener(ChannelFutureListener.CLOSE);
  21.                          }
  22.                      });
  23.                  }
  24.              });
  25.             ChannelFuture f = b.bind().sync();                    //6
  26.             f.channel().closeFuture().sync();
  27.         } finally {
  28.             group.shutdownGracefully().sync();                    //7
  29.         }
  30.     }
  31. }

1.创建一个 ServerBootstrap

2.使用 NioEventLoopGroup 允许非阻塞模式（NIO）

3.指定 ChannelInitializer 将给每个接受的连接调用

4.添加的 ChannelInboundHandlerAdapter() 接收事件并进行处理

5.写信息到客户端，并添加 ChannelFutureListener 当一旦消息写入就关闭连接

6.绑定服务器来接受连接

7.释放所有资源

因为 Netty 使用相同的 API 来实现每个传输，它并不关心你使用什么来实现。Netty 通过操作接口Channel 、ChannelPipeline 和 ChannelHandler来实现。

现在你了解到了用 基于 Netty 传输的好处。下面就来看下传输的 API.