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