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

Apache MINA is a network application framework which helps users develop high performance and high scalability network applications easily. It provides an abstract event-driven asynchronous API over various transports such as TCP/IP and UDP/IP via Java NIO.

Netty is an asynchronous event-driven network application framework for rapid development of maintainable high performance protocol servers & clients.

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

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

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

# -*- coding:utf-8 –*-

from twisted.internet.protocol import Protocol
from twisted.internet.protocol import Factory
from twisted.internet import reactor

class TcpServerHandle(Protocol):

    # 新的连接建立
    def connectionMade(self):
        print 'connectionMade'

    # 连接断开
    def connectionLost(self, reason):
        print 'connectionLost'

    # 接收到新数据
    def dataReceived(self, data):
        print 'dataReceived', data
        self.transport.write('你好')

factory = Factory()
factory.protocol = TcpServerHandle
reactor.listenTCP(8080, factory)
reactor.run()

public class TcpClient {

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


    Socket socket = null;
    OutputStream out = null;
    InputStream in = null;

    try{

      socket = new Socket("localhost", 8080);      
      out = socket.getOutputStream();
      in = socket.getInputStream();

        // 请求服务器
        out.write("第一次请求".getBytes("UTF-8"));
        out.flush();

        // 获取服务器响应，输出
        byte[] byteArray = new byte[1024];
        int length = in.read(byteArray);
        System.out.println(new String(byteArray, 0, length, "UTF-8"));

        Thread.sleep(5000);

        // 再次请求服务器
        out.write("第二次请求".getBytes("UTF-8"));
        out.flush();

        // 再次获取服务器响应，输出
        byteArray = new byte[1024];
        length = in.read(byteArray);
        System.out.println(new String(byteArray, 0, length, "UTF-8"));


    } finally {
      // 关闭连接
      in.close();
      out.close();
      socket.close();
    }

  }

}

sessionCreated

messageReceived:第一次请求

messageReceived:第二次请求

sessionClosed

channelActive

channelRead:第一次请求

channelRead:第二次请求

channelInactive

connectionMade

dataReceived: 第一次请求

dataReceived: 第二次请求

connectionLost