ich bin sicher nicht der Kennzeichnung „// Server“ in Ihrer Frage angezeigt werden, aber ich bin den folgenden Code unter der Annahme, ist der Server-Code:
InputStream in = client.getInputStream();
ByteArrayOutputStream bOut = new ByteArrayOutputStream();
int i = 0;
while((i = in.read()) >= 0) {
bOut.write(i);
}
String complete = new String(bOut.toByteArray(), "UTF-8");
Dies wird weiter lesen, blockiert jedes Mal, bis es einen Wert von read() kleiner als Null erhält. Das passiert nur, wenn der Stream geschlossen ist.
Es sieht wirklich wie Sie benötigen ein eigenes Protokoll zu etablieren. Suchen Sie statt nach "< = 0" nach einem konstanten Wert, der das Ende der Nachricht signalisiert.
Hier ist eine kurze Demonstration dessen, was ich meine (ich hatte gestern keine Zeit). Ich habe 3 Klassen, Message, MyClient (das ist auch die main Klasse) und MyServer. Beachten Sie, dass es nichts gibt, wenn Sie einen Zeilenumbruch senden oder empfangen. Nichts setzt tcpNoDelay. Aber es funktioniert gut. Einige andere Hinweise:
- Dieser Code sendet und empfängt nur eine einzige Anfrage und Antwort.
- Das Senden mehrerer Instanzen
Message wird nicht unterstützt. Das würde erfordern, für den Anfang eines Message sowie das Ende zu überprüfen.
Message Klasse:
public class Message {
public static final String MSG_START = "<message>";
public static final String MSG_END = "</message>";
private final String content;
public Message(String string){
content = string;
}
@Override
public String toString(){
return MSG_START + content + MSG_END;
}
}
MyServer Klasse
public class MyServer implements Runnable{
public static final int PORT = 55555;
@Override
public void run(){
try {
ServerSocket serverSocket = new ServerSocket(PORT);
Socket socket = serverSocket.accept();
String message = getMessage(socket);
System.out.println("Server got the message: " + message);
sendResponse(socket);
}catch (IOException e){
throw new IllegalStateException(e);
}
}
private void sendResponse(Socket socket) throws IOException{
Message message = new Message("Ack");
System.out.println("Server now sending a response to the client: " + message);
OutputStream out = socket.getOutputStream();
out.write(message.toString().getBytes("UTF-8"));
}
private String getMessage(Socket socket) throws IOException{
BufferedInputStream in = new BufferedInputStream(socket.getInputStream());
StringBuilder sb = new StringBuilder(100);
byte[] bytes = new byte[1024<<8];
while(sb.lastIndexOf(Message.MSG_END) == -1){
int bytesRead = in.read(bytes);
sb.append(new String(bytes,0,bytesRead,"UTF-8"));
}
return sb.toString();
}
}
MyClient Klasse
public class MyClient {
public static void main(String[] args){
MyClient client = new MyClient();
Thread server = new Thread(new MyServer());
server.start();
client.performCall();
}
public void performCall(){
try {
Socket socket = new Socket("127.0.0.1",MyServer.PORT);
sendMessage(socket, "Why hello there!");
System.out.println("Client got a response from the server: " + getResponse(socket));
} catch (IOException e) {
throw new IllegalStateException(e);
}
}
public String getResponse(Socket socket) throws IOException{
String response;
StringBuilder sb = new StringBuilder(100);
InputStream in = socket.getInputStream();
byte[] bytes = new byte[1024];
while(sb.lastIndexOf(Message.MSG_END) == -1){
int bytesRead = in.read(bytes);
sb.append(new String(bytes,0,bytesRead,"UTF-8"));
}
response = sb.toString();
return response;
}
public void sendMessage(Socket socket, String message) throws IOException{
Message msg = new Message(message);
System.out.println("Client now sending message to server: " + msg);
OutputStream out = socket.getOutputStream();
out.write(msg.toString().getBytes("UTF-8"));
}
}
Der Ausgang
Wie sieht der Servercode aus? – Dan
Wie haben Sie bestätigt, dass die Ausgabe nicht gesendet wurde? – Simon
Nun, wissen Sie, ein 'OutputStream' hat' .flush() '. Außerdem ist die Art und Weise, wie Sie Ihre JSON schreiben, gebrochen: Sie verwendet die Standardcodierung der JRE. Warum verwenden Sie nicht stattdessen eine JSON-Bibliothek? – fge