Netty效能測試

Netty是由JBOSS提供的一個Java開源框架。Netty提供非同步的、事件驅動的網路應用程式框架和工具，用以快速開發高效能、高可靠性的網路伺服器和客戶端程式。Netty 是一個基於NIO的客戶，伺服器端程式設計框架，使用Netty 可以確保你快速和簡單的開發出一個網路應用，例如實現了某種協議的客戶，服務端應用。Netty相當簡化和流線化了網路應用的程式設計開發過程，例如，TCP和UDP的socket服務開發。

Netty簡化socket程式設計，並沒有使寫出來的Socket效率變低，我寫了一個所有都使用預設配置的服務端，模擬最常用的RPC方案，傳輸協議使用4位元組長度加json串的方式來傳輸，

從測試結果看，Netty效能是非常高的，在所有使用預設配置的情況下，單臺伺服器能夠達到4萬次請求解析，作為RPC框架是足夠用的。還有一個有趣的現象是每次都建立連線和重用連線的差別不大，效能損耗對應用層幾乎沒影響，但是大家如果在應用環境中使用每次新建的情況，一定要進行壓測，確認沒影響後再使用。

測試用例說明

1. 部署1臺Netty伺服器，部署8臺併發測試客戶端，每個客戶端跑1024個併發；
2. 分為1次連線請求1000次資料和1次連線請求1次資料迴圈1000次；
3. Netty伺服器為Cent OS 6.5 64位，阿里雲8核16G記憶體，JVM使用預設配置，沒有進行任何調優；
4. 併發客戶端為Windows Server 2008 R2  64位企業版，阿里雲8核16G記憶體，NET Framework 4.5執行環境，沒有進行任何調優；
5. 通訊資料格式為：4位元組長度+JSON串，伺服器負責接收JSON串，進行解析和返回；

Netty服務端程式碼

1. publicclass AppNettyServer {  
2.     publicstaticvoid main(String[] args) throws Exception {  
3.         System.out.print("Hello Netty\r\n");  
4.         int port = 9090;  
5.         if (args != null && args.length > 0) {  
6.             try
    {  
7.                 port = Integer.valueOf(args[0]);  
8.             } catch (NumberFormatException e) {  
9.                 System.out.print("Invalid Port, Start Default Port: 9090");  
10.             }  
11.         }  
12.         try {  
13.             NettyCommandServer commandServer = new NettyCommandServer();  
14.             System.out.print("Start listen socket, port " + port + "\r\n");  
15.             commandServer.bind(port);  
16.         } catch (Exception e) {  
17.             System.out.print(e.getMessage());  
18.         }  
19.     }  
20. }  

1. publicclass NettyCommandServer {  
2.     publicstatic InternalLogger logger = InternalLoggerFactory.getInstance(NettyCommandServer.class);  
3.     publicvoid bind(int port) throws Exception {  
4.         EventLoopGroup bossGroup = new NioEventLoopGroup();  
5.         EventLoopGroup workerGroup = new NioEventLoopGroup();  
6.         try {  
7.             ServerBootstrap serverBootstrap = new ServerBootstrap();  
8.             serverBootstrap.group(bossGroup, workerGroup);  
9.             serverBootstrap.channel(NioServerSocketChannel.class);  
10.             serverBootstrap.option(ChannelOption.SO_BACKLOG, 1024);  
11.             serverBootstrap.handler(new LoggingHandler());  
12.             serverBootstrap.childHandler(new NettyChannelHandler());  
13.             ChannelFuture channelFuture = serverBootstrap.bind(port).sync();  
14.             channelFuture.channel().closeFuture().sync();  
15.         } finally {  
16.             bossGroup.shutdownGracefully();  
17.             workerGroup.shutdownGracefully();  
18.         }  
19.     }  
20.     privateclass NettyChannelHandler extends ChannelInitializer<SocketChannel> {  
21.         @Override
22.         protectedvoid initChannel(SocketChannel socketChannel)  
23.                 throws Exception {  
24.             socketChannel.pipeline().addLast(new LengthFieldBasedFrameDecoder(ByteOrder.BIG_ENDIAN, 64 * 1024, 0, 4, 0, 4, true));  
25.             socketChannel.pipeline().addLast(new StringDecoder(Charset.forName("UTF-8")));  
26.             socketChannel.pipeline().addLast(new NettyCommandHandler());  
27.         }  
28.     }  
29. }  

1. publicclass NettyCommandHandler extends ChannelHandlerAdapter {  
2.     privateint counter = 0;  
3.     @Override
4.     publicvoid channelRead(ChannelHandlerContext ctx, Object msg) {  
5.         try {  
6.             String body = (String) msg;  
7.             JsonDataObject request = JsonUtil.fromJson(body, JsonDataObject.class);  
8.             counter = counter + 1;  
9.             JsonDataObject response = new JsonDataObject();  
10.             response.setCode(0);  
11.             response.setMsg("Success");  
12.             response.setData(counter+"");  
13.             String respJson = JsonUtil.toJson(response);  
14.             byte[] respUtf8 = respJson.getBytes("UTF-8");  
15.             int respLength = respUtf8.length;  
16.             ByteBuf respLengthBuf = PooledByteBufAllocator.DEFAULT.buffer(4);  
17.             respLengthBuf.writeInt(respLength);  
18.             respLengthBuf.order(ByteOrder.BIG_ENDIAN);  
19.             ctx.write(respLengthBuf);  
20.             ByteBuf resp = PooledByteBufAllocator.DEFAULT.buffer(respUtf8.length);  
21.             resp.writeBytes(respUtf8);  
22.             ctx.write(resp);  
23.         } catch (Exception e) {  
24.             NettyCommandServer.logger.error(e.getMessage() + "\r\n");  
25.             StringWriter sw = new StringWriter();  
26.             PrintWriter pw = new PrintWriter(sw);  
27.             e.printStackTrace(pw);  
28.             pw.flush();  
29.             sw.flush();  
30.             NettyCommandServer.logger.error(sw.toString());  
31.         }  
32.     }  
33.     @Override
34.     publicvoid channelReadComplete(ChannelHandlerContext ctx) {  
35.         ctx.flush();  
36.     }  
37.     @Override
38.     publicvoid exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {  
39.         ctx.close();  
40.     }  
41. }  

1. publicclass SocketClient : Object  
2. {  
3.     private TcpClient tcpClient;  
4.     public SocketClient()  
5.     {  
6.         tcpClient = new TcpClient();  
7.         tcpClient.Client.Blocking = true;  
8.     }  
9.     publicvoid Connect(string host, int port)  
10.     {  
11.         tcpClient.Connect(host, port);  
12.     }  
13.     publicvoid Disconnect()  
14.     {  
15.         tcpClient.Close();  
16.     }  
17.     publicstring SendJson(string json)  
18.     {  
19.         byte[] bufferUTF8 = Encoding.UTF8.GetBytes(json);  
20.         int jsonLength = System.Net.IPAddress.HostToNetworkOrder(bufferUTF8.Length); //轉換為網路位元組順序，大頭結構
21.         byte[] bufferLength = BitConverter.GetBytes(jsonLength);  
22.         tcpClient.Client.Send(bufferLength, 0, bufferLength.Length, SocketFlags.None); //傳送4位元組長度
23.         tcpClient.Client.Send(bufferUTF8, 0, bufferUTF8.Length, SocketFlags.None); //傳送Json串內容
24.         byte[] bufferRecvLength = newbyte[sizeof(int)];  
25.         tcpClient.Client.Receive(bufferRecvLength, sizeof(int), SocketFlags.None); //獲取長度
26.         int recvLength = BitConverter.ToInt32(bufferRecvLength, 0);  
27.         recvLength = System.Net.IPAddress.NetworkToHostOrder(recvLength); //轉為本地位元組順序
28.         byte[] bufferRecvUtf8 = newbyte[recvLength];  
29.         tcpClient.Client.Receive(bufferRecvUtf8, recvLength, SocketFlags.None);  
30.         string recvCommand = Encoding.UTF8.GetString(bufferRecvUtf8, 0, recvLength);  
31.         return recvCommand;  
32.     }  
33. }