socket server

[korcs]

Hi,

I am quite a newby with socket programing and encountered a problem:

I have a small socket server application, thet echoes the received
strings back to the client.

It works fine, but when the client stops running, the server stops
running as well ("Read Failed").

How should I change the code, that I can handle several client
connections, one-after-another.
(I suppose one should reset the server somehow...)

Is it possible, that I can handle several clients on the same port (I
suppose one should listen on one socket for clients and redirect them
to different server objects listening on different ports...am I
right?)

The code of the Server is the following:


import java.awt.Color;
import java.awt.BorderLayout;
import java.awt.event.*;
import javax.swing.*;

import java.io.*;
import java.net.*;
import java.util.Vector;

class SocketServer extends JFrame
implements ActionListener {

/**
*
*/
private static final long serialVersionUID = 1L;

JButton button;
JLabel label = new JLabel("Zuletzt empfangene Daten:");
JPanel panel;
JTextArea textArea = new JTextArea();
ServerSocket server = null;
Socket client = null;
BufferedReader in = null;
PrintWriter out = null;
String line;


SocketServer(){ //Begin Constructor
button = new JButton("Zuletzt empfangene Daten ausgeben");
button.addActionListener(this);

panel = new JPanel();
panel.setLayout(new BorderLayout());
panel.setBackground(Color.white);
getContentPane().add(panel);
panel.add("North", label);
panel.add("Center", textArea);
panel.add("South", button);



} //End Constructor

public void actionPerformed(ActionEvent event) {
Object source = event.getSource();

if(source == button){
textArea.setText(line);
}
}

public void listenSocket(){

try{
server = new ServerSocket(4444);
} catch (IOException e) {
System.out.println("Could not listen on port 4444");
System.exit(-1);
}

try{
client = server.accept();
} catch (IOException e) {
System.out.println("Accept failed: 4444");
System.exit(-1);
}

try{
in = new BufferedReader(new
InputStreamReader(client.getInputStream()));
out = new PrintWriter(client.getOutputStream(), true);
} catch (IOException e) {
System.out.println("Accept failed: 4444");
System.exit(-1);
}

while(true){
try{
line = in.readLine();
//Send data back to client
out.println(line);

// Write data into the database


} catch (IOException e) {
System.out.println("Read failed");
System.exit(-1);
}
}
}



protected void finalize(){
//Clean up
try{
in.close();
out.close();
server.close();
} catch (IOException e) {
System.out.println("Could not close.");
System.exit(-1);
}
}

public static void main(String[] args){
SocketServer frame = new SocketServer();
frame.setTitle("Server Programm");
WindowListener l = new WindowAdapter() {
public void windowClosing(WindowEvent e) {
System.exit(0);
}
};
frame.addWindowListener(l);
frame.pack();
frame.setVisible(true);
frame.listenSocket();
}
}


Thanks for your help!

Best,

korcs

 

[korcs]

I have solved the problem of resetting the server:

In the while loop:

while(true){
try{
line = in.readLine();
//Send data back to client
out.println(line);

// Write data into the database

} catch (IOException e) {
System.out.println("Read failed");
System.exit(-1);
}
}

I replaced the catch block with:

//System.exit(-1);
finalize();
listenSocket();

SO it works.

But the question is still there, how can I handle multiple clients on
the same port?

Best,

korcs

 

[Gordon Beaton]

I replaced the catch block with:

//System.exit(-1);
finalize();
listenSocket();

SO it works.

In finalize() you close not only the client socket, but also the
ServerSocket. It's sufficient to close the client socket if you intend
to handle additional clients, and reuse the same Serversocket.

Also, by calling listenSocket recursively, you will run into stack
depth problems after some number of clients have been handled. Use a
loop instead.

But the question is still there, how can I handle multiple clients
on the same port?

Your server loop should look like this:

ServerSocket ss = new ServerSocket(...);

while (!done) {
Socket s = ss.accept();
MyClient c = new MyClient(s); // extends Runnable
Thread t = new Thread(c);
t.start();
}

By spawning a thread to handle each client, the server loop can
immediately go back to waiting for the next client to connect. This
lets you handle multiple clients simultaneously. If you only need to
handle them one at a time, you don't need the Thread, just call a
method in the client object and wait until it returns.

In your MyClient class, keep whatever state you need to handle one
client, including the client socket. When you are finished handling
the client, close the socket!

/gordon

--