Java NIO如何分解消息？(How does Java NIO break up messages?)

 我正在编写一个玩具Java NIO服务器与普通的Java客户端配对。 客户端使用普通Socket向服务器发送字符串消息。 服务器接收消息并将内容转储到终端。 
 
 我注意到来自客户端的相同消息每次都被分解为字节缓冲区。 我理解这是NIO的预期行为，但是想大致了解NIO如何决定切断消息？ 
 
 示例：向服务器发送字符串“this is test message”。 以下是服务器日志记录的摘录（每行代表收到1个字节缓冲区）。 
 
Run 1:
Server receiving: this is a test message

Run 2:
Server receiving: t
Server receiving: his is a test message

Run 3:
Server receiving: this is 
Server receiving: a test message
 
 
 更新 - 问题已解决 
 
 我已经安装了Wireshark来分析数据包，很明显随机“分解”是因为我使用DataOutputStream作为DataOutputStream器，它逐字符地发送消息！ 所以每个角色都有一个数据包...... 
 
 将BufferedWriter更改为BufferedWriter ，我的短消息现在按预期发送为单个数据包。 事实上，Java NIO实际上做了聪明的事情并将我的小数据包合并为1到2个字节的缓冲区！ 
 
 
 UPDATE2 - 澄清 
 
 谢谢大家的回复。 感谢@StephenC指出，除非我自己编码消息（是的，我在写入BufferedWriter后调用了flush() ），总是有可能我的消息到达多个数据包。 
 
 
 
 
  
 所以事实是Java NIO实际上做了聪明的事情并且合并了我的小事 
 
 
 
 
 实际上，没有。 合并发生在BufferedWriter层中。 当应用程序刷新或关闭DataOutputStream或BufferdWriters缓冲区填满时，缓冲的写入器将仅向NIO层提供“一堆”字节。 
 
 
 我实际上指的是我第一次尝试使用DataOutputStream （我从网上的一个例子中得到了它，显然这是你已经指出它的不正确的类使用）。 BufferedWriter没有参与。 在那种情况下我的简单作家就像 
 
DataOutputStream out = new DataOutputStream(socket.getOutputStream());
out.writeBytes("this is a test message");
 
 Wireshark确认此消息已发送（localhost上的服务器）1个字符一个数据包（总共22个数据包用于实际消息，不包括所有ACK等）。 
 
 我可能错了，但这种行为似乎表明NIO服务器将这22个数据包组合成1-2个字节的缓冲区？ 
 
 
 我试图在这里实现的最终游戏是一个简单的Java NIO服务器，它能够使用来自不同客户端的TCP接收请求和数据流，有些可能由第三方用C ++或C＃编写。 这不是时间关键，因此客户端可以一次性发送所有数据，服务器可以按照自己的节奏处理它们。 这就是为什么我使用普通的Socket而不是NIO客户端用Java编写玩具客户端的原因。 因此，在这种情况下客户端不能直接操作ByteBuffer ，所以我可能需要某种消息格式。 我可以做这个吗？ 

I'm writing a toy Java NIO server paired with a normal Java client. The client sends a string message to the server using plain Socket. The server receives the message and dumps the content to terminal.
 
I've noticed that the same message from client is broken up into bytebuffers differently every single time. I understand this is intended behaviour of NIO, but would like to find out roughly how the NIO decides to chop up a message?
 
Example: Sending string "this is a test message" to server. The following are excerpts of server loggings (each line represents 1 bytebuffer received).
 
Run 1:
Server receiving: this is a test message

Run 2:
Server receiving: t
Server receiving: his is a test message

Run 3:
Server receiving: this is 
Server receiving: a test message
 
 
UPDATE - Issue Resolved
 
I have installed Wireshark to analyse the packets and it has become apparent that the random "break up" was due to me using DataOutputStream for the writer, which sends the message character by character! So there was a packet for each character...
 
After changing the writer to BufferedWriter, my short message is now sent as a single packet, as expected. So the truth is Java NIO actually did the clever thing and merged my tiny packets to 1 to 2 bytebuffers!
 
 
UPDATE2 - Clarification
 
Thank you all for your replies. Thank you @StephenC for pointing out that unless I encode the message myself(yes, I did call flush() after writing to BufferedWriter), there's always the possiblity of my message arriving across multiple packets.
 
 
 
 
  
So the truth is Java NIO actually did the clever thing and merged my tiny
 
 
 
 
Actually, no. The merging is happening in the BufferedWriter layer. The buffered writer will only deliver a "bunch" of bytes to the NIO layer when either the application flushes or closes the DataOutputStream or the BufferdWriters buffer fills up.
 
 
I was in fact referring to my first attempt with DataOutputStream (I got it from an example online, which obviously is incorrect use of the class now that you've pointed it out). BufferedWriter was not involved. My simple writer in that case went like
 
DataOutputStream out = new DataOutputStream(socket.getOutputStream());
out.writeBytes("this is a test message");
 
Wireshark confirmed that this message was sent(server on localhost) 1 character a packet(22 packets in total for the actual message not including all the ACK and etc). 
 
I'm probably wrong, but this behaviour seems to suggest that the NIO server combined these 22 packets into 1-2 bytebuffers?
 
 
The end game I'm trying to achieve here is a simple Java NIO server capable of receiving request and data stream using TCP from various clients, some may be written in C++ or C# by third party. It's not time critical so the clients can send all data in one go and the server can process them at its own pace. That's why I've written a toy client in Java using plain Socket rather than a NIO client. Therefore the client in this case can't really manipulate the ByteBuffer directly, so I probably need some sort of message format. Could I make this work?

原文：https://stackoverflow.com/questions/42581185