java-服务器未从客户端接收消息（reader.readLine（）== null？）

Question

so i've been making a simple chat, than has a server and a bunch of clients connected to them. On the client side i have class ConnectionManager to manage creating socket and such. Here is it's core method:

public class ConnectionManager {
    private Socket socket;
    private BufferedReader reader;
    private PrintWriter writer;

    public ConnectionManager(String URL, int port){
        tryConnectToServer(URL, port);
    }

    public BufferedReader getReader() {
        return reader;
    }

    public PrintWriter getWriter() {
        return writer;
    }
    private void tryConnectToServer(String ip, int servSocket) {
        try{
            socket = new Socket(ip, servSocket);
            writer = new PrintWriter(socket.getOutputStream());
            reader = new BufferedReader(
                    new InputStreamReader(
                            socket.getInputStream()));
        }
        catch (IOException ex){
            System.out.println("Unable to connect to specified server. Code pink");
            ex.printStackTrace();
        }
    }

Connection Manager object is a part of ChatGUI. ChatGUI's fields writer and reader are obtained and set from CM in order to pass writer along with ChatGUI's JTextField (msgInput) to SendButtonListener:

private void addSendButton() {
    JButton sendButton = new JButton("Send");
    sendButton.addActionListener(new SendButtonActionListener(writer, msgInput));
    panel.add(sendButton);
    panel.add(this.msgArea);
}

Then, actionPerformed method does:

public class SendButtonActionListener implements ActionListener{
private PrintWriter writer;
private JTextField msgInput;

public SendButtonActionListener(PrintWriter pr, JTextField mi){
    writer = pr;
    msgInput = mi;
}

public void actionPerformed(ActionEvent event){
    writer.println(msgInput.getText());
    System.out.println("Sending: " + msgInput.getText());
    flushMessageInputField();
}

private void flushMessageInputField(){
    msgInput.setText("");
}

}

On the server side on the other hand i've got this:

try{
        this.servSocket = new ServerSocket(port);
        System.out.println("Server socket established");
    }
    catch (IOException ex){
        System.out.println("Unable to establish server socket. Code pink \n");
        ex.printStackTrace();
    }

And after the above comes this:

public void waitForClients(){
    System.out.println("The gates has been opened...");
    while (true){
        try {
            Socket client = servSocket.accept();
            processClient(client);
        }
        catch (IOException ex){
            ex.printStackTrace();
        }
    }
}

private void processClient(Socket client){
    writers.add(getClientWriter(client));
    startUpdateFrom(client);
    System.out.println("New client connected: " + client.getPort());
}

private PrintWriter getClientWriter(Socket client){
    try{
        return new PrintWriter(client.getOutputStream());
    }
    catch (Exception ex){
        ex.printStackTrace();
    }
    return null;
}

And finally, a new thread starts to listen to any new messages from that client:

private void startUpdateFrom(Socket client){
    new Thread(
            new WaitAndSendToAllFrom(client))
                .start();
}

Which is:

public class WaitAndSendToAllFrom implements Runnable{
    BufferedReader reader;

    public WaitAndSendToAllFrom(Socket clientSocket){
        try{
            reader = new BufferedReader(
                    new InputStreamReader(
                            clientSocket.getInputStream()));
        }
        catch (IOException ex){
            ex.printStackTrace();
        }
    }

    public void run(){
        try{
            String message;
            System.out.println("Thread: waiting for messages to send...");
            while (true){
                message = reader.readLine();
                while (message != null){
                    System.out.println("Server: Sending message: " + message);
                    sendToAll(message);
                }
            }
        }
        catch (IOException ex){
            ex.printStackTrace();
        }
    }

    private void sendToAll(String message){
        List<PrintWriter> writers = ServerClientConnector.getWriters();
        for (PrintWriter pr : writers){
            pr.println(message + "\n");
            pr.flush();
        }
    }
}

The cycle gets to the "Thread: waiting for messages to send...", but not any further, reader.readLine() returns null (checked with a sysout :) ). I was trying to debug it, but i'm not so experienced in programing so much, especially debugging two separate codes working with each other. I've been looking at this for 3 days, and i'm seriously stuck here.

Answer 1

while (true){
    message = reader.readLine();
    while (message != null){
        System.out.println("Server: Sending message: " + message);
        sendToAll(message);
    }
}

This makes no sense. You read one line and then keep testing. It for null in a loop in which it can never change.

A proper way to write this is:

while ((message = reader.readLine()) != null){
    System.out.println("Server: Sending message: " + message);
    sendToAll(message);
}