MINA、Netty、Twisted為什麼放在一起學習？首先，不妨先分別看一下它們官方網站對其的介紹：

MINA：

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：

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

Twisted：

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

（Twisted官網的文案不專業啊，居然不寫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伺服器。當接收到客戶端發過來的字串後，向客戶端回寫一個字串作為響應。

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

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

# -*- 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()

下面是Java寫的一個TCP客戶端用作測試，客戶端沒有使用這三個框架，也沒有使用NIO，只是一個普通的BIO的TCP客戶端。

TCP在建立連線到關閉連線的過程中，可以多次進行傳送和接收資料。下面的客戶端傳送了兩個字串到伺服器並兩次獲取伺服器迴應的資料，之間通過Thread.sleep(5000)間隔5秒。

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

}

MINA伺服器輸出結果：

sessionCreated
messageReceived:第一次請求
messageReceived:第二次請求
sessionClosed

Netty伺服器輸出結果：

channelActive
channelRead:第一次請求
channelRead:第二次請求
channelInactive

Twisted伺服器輸出結果：

connectionMade
dataReceived: 第一次請求
dataReceived: 第二次請求
connectionLost

MINA、Netty、Twisted一起學系列

原始碼