Java Socket程序从服务器读回

Question

I am trying to implement a simple java server and client - where client sends "hey" and server sends "hello" back. The problem I am having is even though the server sees hey but client never receives hello. Here is the server code

 try {
                    InputStream input = clientSocket.getInputStream();

                    System.out.println("client's request"+ IOUtils.toString(input));

                    OutputStream output = clientSocket.getOutputStream();
                    PrintWriter pw = new PrintWriter(output);
                    pw.write("hello");
                    pw.flush();
                    /*BufferedOutputStream bf = new BufferedOutputStream(output);
                    bf.write("hello".getBytes());*/
                    /*output.write(("hello").getBytes());*/

                    long time = System.currentTimeMillis();

                    System.out.println("Request processed: " + time);

 } 
 catch (IOException e) 
 {
                    // report exception somewhere.
                    e.printStackTrace();
 }

Client program

Socket s = new Socket("localhost",9000);

OutputStream out = s.getOutputStream();
out.write("hey".getBytes());
/*PrintWriter pw = new PrintWriter(out);
pw.write("hey");
pw.flush(); */

BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream()));


String line;
while((line =br.readLine())!= null)
{
    System.out.println(line);
}
s.close();

I have different variations of reading and writing the input/output but with no luck. Suggestions please.

Thanks

Answer 1

This won't work. IOUtils.toString(input) will read from the input until end of stream, which won't occur until the peer closes the connection, which won't occur at all because he is blocked in readLine() trying to read the response to the request that you are blocked forever reading.

Use BufferedReader.readLine() , but without the loop you have in the client.

Answer 2

This

void writeLine(BufferedWriter writer, String text) throws IOException {
    writer.write(text); // the actual characters we want to send
    writer.newLine();   // something that signals the end of the message.
    writer.flush();     // and we must enforce that these bytes are sent and not buffered locally.
}

can be read by

String readLine(BufferedReader reader) throws IOException {
    // reads characters until it finds either a newline or end of stream
    // returns data or null when the stream has already ended
    return reader.readLine();
}

When you send messages over sockets you must make sure that you have some kind of "protocol" to delimit your messages. For example by sending a newline after each message. That way both sides know where messages in a continuous stream of data ends.

Besides sending the right kind message, you also have to make sure to actually send it. BufferedWriter for example has a data-buffer and will not send data until the buffer is full enough. This will in most cases mean that messages will remain in the buffer instead of being sent over the wire. To do that call flush() once you have written everything you need.

I have different variations of reading and writing the input/output but with no luck.

In your case you don't send a newline but wait for it via readLine . The client should have actually received the "hello" part but it's not going to return from readLine without newline/end of stream (which should happen if you stop the server at this point). The same should apply to the message you send to your server but I guess you do kill the client at this point and therefore see the message.

Here is also the code I made while playing around with this

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.concurrent.CountDownLatch;

class Hello {

    static int port = 12345;

    private static void writeLine(BufferedWriter writer, String line) throws IOException {
        System.out.println(">> " + line);
        writer.write(line); // the actual characters that we want to send
        writer.newLine();   // something that signals the end of the message.
        writer.flush();     // and we must enforce that these bytes are sent and not buffered locally.
    }

    private static String readLine(BufferedReader reader) throws IOException {
        // reads characters until it finds either a newline or the end of the stream
        // returns data or null when the stream has already ended
        return reader.readLine();
    }

    static void handle(Socket cs, boolean controlling) {
        try (Socket socket = cs) {
            try (BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
                 BufferedReader reader = new BufferedReader(new InputStreamReader(socket.getInputStream()))) {

                if (controlling) {
                    writeLine(writer, "hey");
                }

                loop: while (!Thread.currentThread().isInterrupted()) {

                    String readLine = readLine(reader);
                    System.out.println("<< " + readLine);

                    if (readLine == null)
                        break;

                    switch (readLine) {
                        case "hey":
                            writeLine(writer, "ho");
                            break;
                        case "ho":
                            writeLine(writer, "bye");
                            break;
                        case "bye":
                            break loop;
                    }
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    static void server(CountDownLatch latch) {
        try (ServerSocket ss = new ServerSocket(port)) {
            System.out.println("Listening.");
            latch.countDown();
            while (!Thread.currentThread().isInterrupted()) {
                Socket clientSocket = ss.accept();
                // spawn a new thread per client
                new Thread(() -> handle(clientSocket, false)).start();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    static void client() {
        System.out.println("Connecting.");
        try (Socket socket = new Socket("localhost", port)) {
            System.out.println("Connected.");
            handle(socket, true);
        } catch (UnknownHostException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        CountDownLatch latch = new CountDownLatch(1);
        new Thread(() -> server(latch)).start();
        latch.await();
        new Thread(() -> client()).start();
    }
}