我正在编写一个大型 Java 应用程序的服务器部分,用于使用 Java 套接字通过 TCP/IP 与客户端进行通信。客户端(用 PHP 编写)连接到服务器,发送 XML 格式的查询,然后服务器发回响应。查询-响应可以在单个连接中重复多次。
服务器端非常简单。它应该允许多个客户端连接,因此有一个线程正在监听并为每个接受的连接生成一个 session 。该 session 由一个对象组成,该对象包含两个用于传输和接收的 LinkedBlockingQueue、两个用于使用这些队列传输和接收消息的线程以及一个处理线程。
问题在于只有在套接字关闭后才会真正传输任何消息。响应消息可以毫无问题地进入消息队列和 PrintStream.println() 方法,但只有当客户端关闭其一侧的连接时,wireshark 才会报告传输情况。启用自动刷新或使用flush()创建PrintStream不起作用。在服务器端关闭套接字也不起作用,服务器仍然正常工作并接收消息。
此外,当前在服务器端接收查询的客户端实现也可以正常工作,echo -e "test"| 也可以正常工作。 socat - 来自本地 Linux 虚拟机的 TCP4:192.168.37.1:1337
,但是当我 telnet 到服务器并尝试发送某些内容时,服务器不会收到任何内容,直到我关闭 telnet 客户端,与所描述的问题相同如上所述。
相关的服务器代码(整个应用程序太大,无法粘贴所有内容,而且我正在使用很多其他人的代码):
package Logic.XMLInterfaceForClient;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.net.Socket;
import java.util.HashSet;
import java.util.concurrent.LinkedBlockingQueue;
import Data.Config;
import Logic.Log;
public class ClientSession {
/**
* @author McMonster
*
*/
public class MessageTransmitter extends Thread {
private final Socket socket;
private final ClientSession parent;
private PrintStream out;
/**
* @param socket
* @param parent
*/
public MessageTransmitter(Socket socket, ClientSession parent) {
this.socket = socket;
this.parent = parent;
}
/*
* (non-Javadoc)
*
* @see java.lang.Runnable#run()
*/
@Override
public void run() {
try {
out = new PrintStream(socket.getOutputStream(), true);
while (!socket.isClosed()) {
try {
String msg = parent.transmit.take();
// System.out.println(msg);
out.println(msg);
out.flush();
}
catch(InterruptedException e) {
// INFO: purposefully left empty to suppress spurious
// wakeups
}
}
}
catch(IOException e) {
parent.fail(e);
}
}
}
/**
* @author McMonster
*
*/
public class MessageReceiver extends Thread {
private final Socket socket;
private final ClientSession parent;
private BufferedReader in;
/**
* @param socket
* @param parent
*/
public MessageReceiver(Socket socket, ClientSession parent) {
this.socket = socket;
this.parent = parent;
}
/*
* (non-Javadoc)
*
* @see java.lang.Runnable#run()
*/
@Override
public void run() {
try {
in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
while (!socket.isClosed()) {
String message = "";
String line;
while ((line = in.readLine()) != null) {
message = message + line + "\n";
}
if(message != "") {
parent.receive.offer(message.toString());
}
}
}
catch(IOException e) {
parent.fail(e);
}
}
}
public final LinkedBlockingQueue<String> transmit = new LinkedBlockingQueue<>();
public final LinkedBlockingQueue<String> receive = new LinkedBlockingQueue<>();
private final XMLQueryHandler xqh;
private final Socket socket;
private String user = null;
private HashSet<String> privileges = null;
/**
* @param socket
* @param config
* @throws IOException
* @throws IllegalArgumentException
*/
public ClientSession(Socket socket, Config config)
throws IOException,
IllegalArgumentException {
// to avoid client session without the client
if(socket == null) throw new IllegalArgumentException("Socket can't be null.");
this.socket = socket;
// we do not need to keep track of the two following threads since I/O
// operations are currently blocking, closing the sockets will cause
// them to shut down
new MessageReceiver(socket, this).start();
new MessageTransmitter(socket, this).start();
xqh = new XMLQueryHandler(config, this);
xqh.start();
}
public void triggerTopologyRefresh() {
xqh.setRefresh(true);
}
public void closeSession() {
try {
xqh.setFinished(true);
socket.close();
}
catch(IOException e) {
e.printStackTrace();
Log.write(e.getMessage());
}
}
/**
* Used for reporting failures in any of the session processing threads.
* Handles logging of what happened and shuts down all session threads.
*
* @param t
* cause of the failure
*/
synchronized void fail(Throwable t) {
t.printStackTrace();
Log.write(t.getMessage());
closeSession();
}
synchronized boolean userLogin(String login, HashSet<String> privileges) {
boolean success = false;
if(!privileges.isEmpty()) {
user = login;
this.privileges = privileges;
success = true;
}
return success;
}
public synchronized boolean isLoggedIn() {
return user != null;
}
/**
* @return the privileges
*/
public HashSet<String> getPrivileges() {
return privileges;
}
}
最佳答案
它与发送完全没有任何关系。更准确的说法是,如果您读取直到流结束,则在对等方通过关闭套接字结束流之前,您不会获得流结束。
这是一个同义反复。
关于java - 无法通过 Java 套接字发送消息而不关闭它,我们在Stack Overflow上找到一个类似的问题: https://stackoverflow.com/questions/10472486/