Netty、MINA、Twisted一起学系列01：实现简单的TCP服务器

Twisted is an event-driven networking engine written in Python and licensed under the open source MIT license.

Twisted 官从上面简短的介绍中，就可以发现它们的共同特点：event-driven 以及 asynchronous。它们都是事件驱动、异步的网络编程框架。由此可见，它们之间的共同点还是很明显的。所以我这里将这三个框架放在一起，实现相同的功能，不但可以用少量的精力学三样东西，而且还可以对它们之间进行各方面的对比。网的文案不专业啊，居然不写 asynchronous。

从上面简短的介绍中，就可以发现它们的共同特点：event-driven 以及 asynchronous。它们都是事件驱动、异步的网络编程框架。由此可见，它们之间的共同点还是很明显的。所以我这里将这三个框架放在一起，实现相同的功能，不但可以用少量的精力学三样东西，而且还可以对它们之间进行各方面的对比。

其中 MINA 和 Netty 是基于 Java 语言的，而 Twisted 是 Python 语言的。不过语言不是重点，重点的是理念。

使用传统的 BIO（Blocking IO/阻塞IO）进行网络编程时，进行网络 IO 读写时都会阻塞当前线程，如果实现一个 TCP 服务器，都需要对每个客户端连接开启一个线程，而很多线程可能都在傻傻的阻塞住等待读写数据，系统资源消耗大。

而 NIO（Non-Blocking IO/非阻塞IO）或 AIO（Asynchronous IO/异步IO）则是通过 IO 多路复用技术实现，不需要为每个连接创建一个线程，其底层实现是通过操作系统的一些特性如 select、poll、epoll、iocp 等。这三个网络框架都是基于此实现。

下面分别用这三个框架实现一个最简单的 TCP 服务器。当接收到客户端发过来的字符串后，向客户端回写一个字符串作为响应。

Netty：

public class TcpServer {

  public static void main(String[] args) throws InterruptedException {
    EventLoopGroup bossGroup = new NioEventLoopGroup();
    EventLoopGroup workerGroup = new NioEventLoopGroup();
    try {
      ServerBootstrap b = new ServerBootstrap();
      b.group(bossGroup, workerGroup)
          .channel(NioServerSocketChannel.class)
          .childHandler(new ChannelInitializer() {
            @Override
            public void initChannel(SocketChannel ch)
                throws Exception {
              ch.pipeline().addLast(new TcpServerHandler());
            }
          });
      ChannelFuture f = b.bind(8080).sync();
      f.channel().closeFuture().sync();
    } finally {
      workerGroup.shutdownGracefully();
      bossGroup.shutdownGracefully();
    }
  }

}

class TcpServerHandler extends ChannelInboundHandlerAdapter {

  // 接收到新的数据
  @Override
  public void channelRead(ChannelHandlerContext ctx, Object msg) throws UnsupportedEncodingException {
    try {
      // 接收客户端的数据
      ByteBuf in = (ByteBuf) msg;
      System.out.println("channelRead:" + in.toString(CharsetUtil.UTF_8));

      // 发送到客户端
      byte[] responseByteArray = "你好".getBytes("UTF-8");
      ByteBuf out = ctx.alloc().buffer(responseByteArray.length);
      out.writeBytes(responseByteArray);
      ctx.writeAndFlush(out);

    } finally {
      ReferenceCountUtil.release(msg);
    }
  }

  @Override
  public void channelActive(ChannelHandlerContext ctx) {
    System.out.println("channelActive");
  }

  @Override
  public void channelInactive(ChannelHandlerContext ctx){
    System.out.println("channelInactive");
  }

  @Override
  public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
    cause.printStackTrace();
    ctx.close();
  }
}

MINA：

public class TcpServer {

  public static void main(String[] args) throws IOException {
    IoAcceptor acceptor = new NioSocketAcceptor();
    acceptor.setHandler(new TcpServerHandle());
    acceptor.bind(new InetSocketAddress(8080));
  }

}

class TcpServerHandle extends IoHandlerAdapter {

  @Override
  public void exceptionCaught(IoSession session, Throwable cause) throws Exception {
    cause.printStackTrace();
  }

  // 接收到新的数据
  @Override
  public void messageReceived(IoSession session, Object message) throws Exception {

    // 接收客户端的数据
    IoBuffer ioBuffer = (IoBuffer) message;
    byte[] byteArray = new byte[ioBuffer.limit()];
    ioBuffer.get(byteArray, 0, ioBuffer.limit());
    System.out.println("messageReceived:" + new String(byteArray, "UTF-8"));

    // 发送到客户端
    byte[] responseByteArray = "你好".getBytes("UTF-8");
    IoBuffer responseIoBuffer = IoBuffer.allocate(responseByteArray.length);
    responseIoBuffer.put(responseByteArray);
    responseIoBuffer.flip();
    session.write(responseIoBuffer);
  }

  @Override
  public void sessionCreated(IoSession session) throws Exception {
    System.out.println("sessionCreated");
  }

  @Override
  public void sessionClosed(IoSession session) throws Exception {
    System.out.println("sessionClosed");
  }
}

channelActive

channelRead:第一次请求

channelRead:第二次请求

channelInactive

Twisted服务器输出结果：