Java server client networking

Question

Should I open - close the connection each time my client GUI sends a message or open a connection one time and keep it open ?

Im sending data using BufferedWriter but this methid just seems to work for one time only, after doing the write and the flush method Im able just to send 1 message to my server, then it just doesnt get the data im sending...

Client connects - sends data to server (1st time) - Works Client sends data again - no data echoed on server console.

Should I open a bufferedwriter each time I want to send data or keep one open all the time and never close it?

My actual code - Client side

Main

public class Main {

    public static void main(String args[]) {

        Client chat = new Client("localhost", 6111);
    }
}

Client

public class Client {

    public Client(String host, int port) {

        SwingUtilities.invokeLater(new Runnable() {

            private Socket chat;

            public void run() {

                try {

                    this.chat = new Socket("localhost", 6113);  

                } catch ( IOException e) {

                    e.printStackTrace();
                }

                Gui gui = new Gui("Chat", this.chat);
            }
        });
    }
}

GUI

public class Gui {

    private JFrame frame;
    private JTextArea area;
    private JTextField field;
    private JMenuBar menu;
    private JButton button;
    private Socket socket;
    private BufferedWriter write;

    public Gui(String title, Socket socket) {

        this.socket = socket;

        try {

            this.write = new BufferedWriter(new OutputStreamWriter(this.socket.getOutputStream()));

        } catch (IOException e) {

            e.printStackTrace();
        }

        this.frame = new JFrame(title);
        this.frame.setSize(new Dimension(400, 400));
        this.frame.setLayout(new BorderLayout());
        this.frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        this.frame.setResizable(false);

        Elements interfce = new Elements(this.frame);

        this.field = interfce.addField("Texto to send...");
        this.menu = interfce.addBar();
        this.area = interfce.addArea();
        this.button = interfce.addButton("Send");
        this.button.addActionListener(new Listener(this.field, this.socket, this.write));
        this.menu.add(this.field);
        this.menu.add(this.button);
        this.frame.setVisible(true);
    }
}

Listener (sends data)

public class Listener implements ActionListener {

    private JTextField text;
    private Socket chat;
    private BufferedWriter writer;

    public Listener(JTextField field, Socket chat, BufferedWriter write) {

        this.text = field;
        this.chat = chat;
        this.writer = write;
    }

    public void actionPerformed(ActionEvent e) {

        System.out.println(this.text.getText());

        try {

            writer.write("Hello\n");
            writer.flush();

        } catch (IOException e1) {

            e1.printStackTrace();
        }
    }
}

And the server

public class Main {

    public static void main(String args[]) {

        Server chat = new Server(6113);
    }
}

public class Server {

    private int port;
    private ServerSocket server;

    public Server(int port) {

        this.port = port;
        startServer();
    }

    public void startServer() {

        try {

            this.server = new ServerSocket(this.port);
            System.out.println("Starting chat server at port " + this.port + "...");

            while (true) {

                Socket s = this.server.accept();
                System.out.println("Client connected - " + s.getLocalAddress().getHostName());
                Thread client = new Thread(new Client(s));
                client.start();
            }

        } catch (IOException e) {

            System.out.println("Error found!");
            e.printStackTrace();
        }
    }
}


public class Client implements Runnable {

    private Socket client;

    public Client(Socket client) {

        this.client = client;
    }

    public void run() {

        try {

            BufferedReader read = new BufferedReader(new InputStreamReader(this.client.getInputStream()));
            System.out.println("Client says - " + read.readLine());

        } catch (IOException e) {

            e.printStackTrace();
        }
    }
}

You don't need to open a writer every time for each communication. Just keep it open. — Braj
– Braj, Commented Apr 28, 2014 at 22:29

Bhaskar · Accepted Answer · 2014-04-28 22:46:27Z

1

Should I open - close the connection each time my client GUI sends a message or open a connection one time and keep it open ?

Connection between a Client and Server is generally open for the entire session of messaging and not recreated for sending each message. So keep it open until the client or the Server has to go away.

Look at your Client thread that you start in your server upon accepting a Connection.

public void run() {

    try {

        BufferedReader read = new BufferedReader(new InputStreamReader(this.client.getInputStream()));
        System.out.println("Client says - " + read.readLine());

    } catch (IOException e) {

        e.printStackTrace();
    }
}

Does this give you a hint ? Well - you have to arrange for some sort of looping here within your run() - listening for more inputs from that client.

edited Apr 28, 2014 at 22:46

answered Apr 28, 2014 at 22:39

Bhaskar

7,5235 gold badges42 silver badges52 bronze badges

Sign up to request clarification or add additional context in comments.

1 Comment

Raggaer Over a year ago

The thing is... why my client can just send data just one time to the server?, looks like the connection is getting closed? or the server is not doing well?

Braj · Accepted Answer · 2014-04-28 22:45:09Z

Just do some changes

Server side:

public void run() {

    try {
        BufferedReader read = new BufferedReader(new InputStreamReader(
                this.client.getInputStream()));
        while (true) {
            System.out.println("Client says - " + read.readLine());
        }
    } catch (IOException e) {

        e.printStackTrace();
    }
}

Client side:

use PrintWriter instead of BufferedWriter that provide print new line functionality and auto flush property.

this.write = new PrintWriter(new OutputStreamWriter(this.socket.getOutputStream()),
                true);

 ....

public void actionPerformed(ActionEvent e) {

    System.out.println(this.text.getText());

    try {
        writer.write(this.text.getText());
        writer.println();
    } catch (Exception e1) {
        e1.printStackTrace();
    }
}

Collectives™ on Stack Overflow

Java server client networking

2 Answers 2

1 Comment

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

1 Comment

Comments

Your Answer

Sign up or log in

Post as a guest

Related