Java NIO框架Netty教程(四) ChannelBuffer（转）

在学字符串消息收发(http://www.it165.net/pro/html/201207/3174.html)的时候，已经提到过。ChannelBuffer是Netty中非常重要的概念。所有消息的收发都依赖于这个Buffer。我们通过Netty的官方的文档来了解一下，基于流的消息传递机制。

 

In a stream-based transport such as TCP/IP, received data is stored into a socket receive buffer.
Unfortunately, the buffer of a stream-based transport is not a queue of packets but a queue of bytes. It
means, even if you sent two messages as two independent packets, an operating system will not treat them
as two messages but as just a bunch of bytes. Therefore, there is no guarantee that what you read is exactly
what your remote peer wrote. For example, let us assume that the TCP/IP stack of an operating system has
received three packets:
+—–+—–+—–+
| ABC | DEF | GHI |
+—–+—–+—–+
Because of this general property of a stream-based protocol, there's high chance of reading them in the
following fragmented form in your application:
+—-+——-+—+—+
| AB | CDEFG | H | I |
+—-+——-+—+—+
Therefore, a receiving part, regardless it is server-side or client-side, should defrag the received data into one
or more meaningful frames that could be easily understood by the application logic. In case of the example
above, the received data should be framed like the following:
+—–+—–+—–+
| ABC | DEF | GHI |
+—–+—–+—–+

 

 

不知道您理解了没，简单翻译一下就是说。在TCP/IP这种基于流传递的协议中。他识别的不是你每一次发送来的消息，不是分包的。而是，只认识一个整体的流，即使分三次分别发送三段话：ABC、DEF、GHI。在传递的过程中，他就是一个具有整体长度的流。在读流的过程中，如果我一次读取的长度选择的不是三个，我可以收到类似AB、CDEFG、H、I这样的信息。这显然是我们不想看到的。所以说，在你写的消息收发的系统里，需要预先定义好这种解析机制，规定每帧(次)读取的长度。通过代码来理解一下：

 

Java代码   

1. /**  
2.  
3. * @author lihzh  
4.  
5. * @alia OneCoder  
6.  
7. * @blog http://www.it165.net  
8.  
9. */  
10.   
11. public class ServerBufferHandler extends SimpleChannelHandler {   
12.   
13.    
14.   
15. /**  
16.  
17. * 用户接受客户端发来的消息，在有客户端消息到达时触发  
18.  
19. *  
20.  
21. * @author lihzh  
22.  
23. * @alia OneCoder  
24.  
25. */  
26.   
27. @Override  
28.   
29. public void messageReceived(ChannelHandlerContext ctx, MessageEvent e) {   
30.   
31. ChannelBuffer buffer = (ChannelBuffer) e.getMessage();   
32.   
33. // 五位读取   
34.   
35. while (buffer.readableBytes() >= 5) {   
36.   
37. ChannelBuffer tempBuffer = buffer.readBytes(5);   
38.   
39. System.out.println(tempBuffer.toString(Charset.defaultCharset()));   
40.   
41. }   
42.   
43. // 读取剩下的信息   
44.   
45. System.out.println(buffer.toString(Charset.defaultCharset()));   
46.   
47. }   
48.   
49.    
50.   
51. }  
52.   
53.   
54.   
55.   
56. w source  
57.   
58. nt?  
59.   
60. /**  
61.  
62. * @author lihzh  
63.  
64. * @alia OneCoder  
65.  
66. * @blog http://www.it165.net  
67.  
68. */  
69.   
70. public class ClientBufferHandler extends SimpleChannelHandler {   
71.   
72.    
73.   
74. /**  
75.  
76. * 当绑定到服务端的时候触发，给服务端发消息。  
77.  
78. *  
79.  
80. * @alia OneCoder  
81.  
82. * @author lihzh  
83.  
84. */  
85.   
86. @Override  
87.   
88. public void channelConnected(ChannelHandlerContext ctx, ChannelStateEvent e) {   
89.   
90. // 分段发送信息   
91.   
92. sendMessageByFrame(e);   
93.   
94. }   
95.   
96.    
97.   
98. /**  
99.  
100. * 将<b>"Hello, I'm client."</b>分成三份发送。 <br>  
101.  
102. * Hello, <br>  
103.  
104. * I'm<br>  
105.  
106. * client.<br>  
107.  
108. *  
109.  
110. * @param e  
111.  
112. *            Netty事件  
113.  
114. * @author lihzh  
115.  
116. */  
117.   
118. private void sendMessageByFrame(ChannelStateEvent e) {   
119.   
120. String msgOne = "Hello, ";   
121.   
122. String msgTwo = "I'm ";   
123.   
124. String msgThree = "client.";   
125.   
126. e.getChannel().write(tranStr2Buffer(msgOne));   
127.   
128. e.getChannel().write(tranStr2Buffer(msgTwo));   
129.   
130. e.getChannel().write(tranStr2Buffer(msgThree));   
131.   
132. }   
133.   
134.    
135.   
136. /**  
137.  
138. * 将字符串转换成{@link ChannelBuffer}，私有方法不进行字符串的非空判断。  
139.  
140. *  
141.  
142. * @param str  
143.  
144. *            待转换字符串，要求非null  
145.  
146. * @return 转换后的ChannelBuffer  
147.  
148. * @author lihzh  
149.  
150. */  
151.   
152. private ChannelBuffer tranStr2Buffer(String str) {   
153.   
154. ChannelBuffer buffer = ChannelBuffers.buffer(str.length());   
155.   
156. buffer.writeBytes(str.getBytes());   
157.   
158. return buffer;   
159.   
160. }   
161.   
162.    
163.   
164. }  

 

服务端输出结果：

Hello
, I'm
clie
nt.

这里其实，服务端是否分段发送并不会影响输出结果，也就是说，你一次性的把"Hi, I'm client."这段信息发送过来，输出的结果也是一样的。这就是开头说的，传输的是流，不分包。而只在于你如何分段读写。