我使用ServerSocket创建了一个服务器。之后，我使用Socket创建了客户端，并连接到此服务器。
之后，我使用InputStream执行“some stuff”，并从Socket Object获取OutputStream。但是，我真的不太了解inputStream和outputStream。这是我的简单代码：
private Socket sock = null;
private InputStream sockInput = null;
private OutputStream sockOutput = null;
...
String msg = "Hello World";
byte[] buffer = null;
try {
sockOutput.write(msg.getBytes(), 0, test.length());
sockOutput.write("Hello StackOverFlow".getBytes(), 0, test.length());
buffer = new byte[test.length()];
sockInput.read(buffer, 0, test.length());
System.out.println(new String(buffer));
sockInput.read(buffer, 0, test.length());
System.out.println(new String(buffer));
} catch (IOException e1) {
e1.printStackTrace();
}
结果将是：“Hello World”和“Hello StackOverFlow”。
这是服务器端代码：
private int serverPort = 0;
private ServerSocket serverSock = null;
public VerySimpleServer(int serverPort) {
this.serverPort = serverPort;
try {
serverSock = new ServerSocket(this.serverPort);
}
catch (IOException e){
e.printStackTrace(System.err);
}
}
// All this method does is wait for some bytes from the
// connection, read them, then write them back again, until the
// socket is closed from the other side.
public void handleConnection(InputStream sockInput, OutputStream sockOutput) {
while(true) {
byte[] buf=new byte[1024];
int bytes_read = 0;
try {
// This call to read() will wait forever, until the
// program on the other side either sends some data,
// or closes the socket.
bytes_read = sockInput.read(buf, 0, buf.length);
// If the socket is closed, sockInput.read() will return -1.
if(bytes_read < 0) {
System.err.println("Server: Tried to read from socket, read() returned < 0, Closing socket.");
return;
}
System.err.println("Server: Received "+bytes_read
+" bytes, sending them back to client, data="
+(new String(buf, 0, bytes_read)));
sockOutput.write(buf, 0, bytes_read);
// This call to flush() is optional - we're saying go
// ahead and send the data now instead of buffering
// it.
sockOutput.flush();
}
catch (Exception e){
System.err.println("Exception reading from/writing to socket, e="+e);
e.printStackTrace(System.err);
return;
}
}
}
public void waitForConnections() {
Socket sock = null;
InputStream sockInput = null;
OutputStream sockOutput = null;
while (true) {
try {
// This method call, accept(), blocks and waits
// (forever if necessary) until some other program
// opens a socket connection to our server. When some
// other program opens a connection to our server,
// accept() creates a new socket to represent that
// connection and returns.
sock = serverSock.accept();
System.err.println("Server : Have accepted new socket.");
// From this point on, no new socket connections can
// be made to our server until we call accept() again.
sockInput = sock.getInputStream();
sockOutput = sock.getOutputStream();
}
catch (IOException e){
e.printStackTrace(System.err);
}
// Do something with the socket - read bytes from the
// socket and write them back to the socket until the
// other side closes the connection.
handleConnection(sockInput, sockOutput);
// Now we close the socket.
try {
System.err.println("Closing socket.");
sock.close();
}
catch (Exception e){
System.err.println("Exception while closing socket.");
e.printStackTrace(System.err);
}
System.err.println("Finished with socket, waiting for next connection.");
}
}
public static void main(String argv[]) {
int port = 54321;
VerySimpleServer server = new VerySimpleServer(port);
server.waitForConnections();
}
我的问题是：
当我使用sockOutput.write时，我可以通过sockInput.read取回这些消息。那么，那些消息已被保存，对吧？如果这是真的，它是保存在我创建的服务器上还是仅保存在Socket Object等其他内容中。
如果我已经写入套接字字符串A1，A2，......那么我将分别收到A1，A2，...一个字符串，对吗？
答案 0 :(得分：36)
套接字是一种抽象，用于与网络中的某些内容进行通信。见下图......
在Java中，要通过套接字发送数据，从中获取OutputStream（1），并写入OutputStream（输出一些数据）。
要从套接字读取数据，您将获得其InputStream，并从第二个流中读取输入。
您可以将流视为连接到墙上插座的一对单向管道。在墙的另一边发生的事情不是你的问题！
在您的情况下，服务器有另一个套接字（连接的另一端）和另一对流。它使用其InputStream（2）从网络读取，并使用其OutputStream（3）将相同的数据通过网络写回客户端，并将其读取再次通过其InputStream（4）完成往返。
Client Server
1. OutputStream -->\ /--> 2. InputStream -->
Socket <--> network <--> ServerSocket |
4. InputStream <--/ \<--3. OutputStream <--
更新：以回复评论：
请注意，流和套接字只发送原始字节;他们在这个抽象层面上没有“信息”的概念。因此，如果您发送X个字节和另外X个字节，然后读取X个字节并读取另外X个字节，那么您的系统就像有两个消息一样，因为这就是您如何划分字节。
如果您发送X个字节和另外X个字节，然后读取长度为2X的回复，那么您可能能够读取单个组合的“消息”，但正如您所注意到的那样，流的底层实现可以选择何时传递字节块，因此它可能返回X字节，然后是X字节，稍后，或者一次返回2X，或者返回0.5X四次......
答案 1 :(得分：5)
InputStream和OutputStream是两个完全独立的流。你写入的内容与你从另一个中读到的内容没有先验关系。 InputStream为您提供服务器决定发送给您的任何数据。我还想对你的代码进行评论：
sockOutput.write(msg.getBytes(), 0, test.length());
sockOutput.write("Hello StackOverFlow".getBytes(), 0, test.length());
使用字符串test的长度（代码中未显示），这与您作为第一个参数传递的字节数组无关。这可能会导致ArrayIndexOutOfBoundsException或截断您的预期信息。
检查服务器端代码时，编写的代码写得不正确。您需要try { handleConnection(...); } finally { socket.close(); }以确保在出错后以及正常完成时正确清理。您的代码永远不会关闭服务器端的任何内容。
最后，最重要的是，您的整个代码的编写方式可能会导致死锁。通常，您需要一个单独的线程来读取和写入;否则可能发生以下情况：