案例对照

  1. 在Netty中使用OIO ```java public void start() throws InterruptedException { final EchoServerHandler serverHandler = new EchoServerHandler(); // 创建EventLoopGroup EventLoopGroup group = new OioEventLoopGroup();

    try {

    1.  // 创建ServerBootstrap
    2.  ServerBootstrap b = new ServerBootstrap();
    4.  b.group(group).channel(OioServerSocketChannel.class) // 指定所使用的的OIO传输Channel
    5.      .localAddress(new InetSocketAddress(port)) // 使用指定的端口设置套接字地址
    6.      // 添加一个EchoServerHandler到子Channel的ChannelPipeline
    7.      .childHandler(new ChannelInitializer<SocketChannel>() {
    8.          @Override
    9.          protected void initChannel(SocketChannel ch) throws Exception {
    10.              // EchoServerHandler被标注为@Sharaable，所以我们可以总是使用同样的实例
    11.              // 这里对于所有的客户端连接来说，都会使用同一个EchoServerHandler，因为其被标注为@Sharable。
    12.              ch.pipeline().addLast(serverHandler);
    13.          }
    14.      });
    15.  // 异步地绑定服务器；调用sync()方法阻塞等待知道绑定完成
    16.  ChannelFuture f = b.bind().sync();
    17.  // 获取Channel的CloseFuture，并且阻塞当前线程直到它完成
    18.  f.channel().closeFuture().sync();

    } finally {

    1.  // 关闭EventLoopGroup，释放所有资源
    2.  group.shutdownGracefully().sync();

    }

}

  2. 2. 将OIO传输策略修改为NIO
  3. ```java
  4. public void start() throws InterruptedException {
  5.     final EchoServerHandler serverHandler = new EchoServerHandler();
  6.     // 创建EventLoopGroup
  7.     EventLoopGroup group = new NioEventLoopGroup();
  9.     try {
  10.         // 创建ServerBootstrap
  11.         ServerBootstrap b = new ServerBootstrap();
  13.         b.group(group).channel(NioServerSocketChannel.class) // 指定所使用的的NIO传输Channel
  14.             .localAddress(new InetSocketAddress(port)) // 使用指定的端口设置套接字地址
  15.             // 添加一个EchoServerHandler到子Channel的ChannelPipeline
  16.             .childHandler(new ChannelInitializer<SocketChannel>() {
  17.                 @Override
  18.                 protected void initChannel(SocketChannel ch) throws Exception {
  19.                     // EchoServerHandler被标注为@Sharaable，所以我们可以总是使用同样的实例
  20.                     // 这里对于所有的客户端连接来说，都会使用同一个EchoServerHandler，因为其被标注为@Sharable。
  21.                     ch.pipeline().addLast(serverHandler);
  22.                 }
  23.             });
  24.         // 异步地绑定服务器；调用sync()方法阻塞等待知道绑定完成
  25.         ChannelFuture f = b.bind().sync();
  26.         // 获取Channel的CloseFuture，并且阻塞当前线程直到它完成
  27.         f.channel().closeFuture().sync();
  28.     } finally {
  29.         // 关闭EventLoopGroup，释放所有资源
  30.         group.shutdownGracefully().sync();
  31.     }
  32. }

对比可以发现，整体的代码结构是没有变化的，唯一变化的区在在于EventLoopGroup的实现以及指定了通道创建时指定了不同的类

  2. // 创建EventLoopGroup
  3. EventLoopGroup group = new OioEventLoopGroup();
  4. b.group(group).channel(OioServerSocketChannel.class)
  6. // 创建EventLoopGroup
  7. EventLoopGroup group = new NioEventLoopGroup();
  8. b.group(group).channel(NioServerSocketChannel.class)