Socket Server - Client Dauerverbindung

[g0ser]

Hallo Leute,

ich habe eine Server Anwendung die Daten (Text und Zahlen) an eine Client Anwendung senden soll und auch vom Client Daten empfangen soll.
Dies soll solange dauern bis entwender die Server Anwendung oder die Client Anwendung beendet wird.
Beide Anwendungen sollen dann bei bestimmten Nachrichten irgendwelche Aktionen ausführen und dem Benutzer z.b. irgendwelche Auswahlen anbieten die er per Eingabe treffen kann.

Ich hab bereits einiges im Internet gelesen und habe auch einige Beispiele gefunden. Eins davon benutzt dazu beim Server einen Thread damit ständig gelesen werden kann.
Allerdings ist der Client ohne Thread so das er jedes mal gestartet werden muss um eine Nachricht an den Server zu senden. Ich habe versucht den Client auch als Thread anzulegen hab es aber irgendwie nicht geschafft.


Server

public class ServerSocketExample {
    private ServerSocket server;
    private int port = 7777;

    public ServerSocketExample() {
        try {
            server = new ServerSocket(port);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        ServerSocketExample example = new ServerSocketExample();
        example.handleConnection();
    }

    public void handleConnection() {
        System.out.println("Waiting for client message...");

        //
        // The server do a loop here to accept all connection initiated by the
        // client application.
        //
        while (true) {
            try {
                Socket socket = server.accept();
                new ConnectionHandler(socket);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

class ConnectionHandler implements Runnable {
    private Socket socket;

    public ConnectionHandler(Socket socket) {
        this.socket = socket;

        Thread t = new Thread(this);
        t.start();
    }

    public void run() {
        try
        {
            //
            // Read a message sent by client application
            //
            ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());
            String message = (String) ois.readObject();
            System.out.println("Message Received: " + message);

            //
            // Send a response information to the client application
            //
            ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream());
            oos.writeObject("Hi...");

            ois.close();
            oos.close();
            socket.close();

            System.out.println("Waiting for client message...");
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

Client

public class ClientSocketExample {
    public static void main(String[] args) {
        try {
            //
            // Create a connection to the server socket on the server application
            //
            InetAddress host = InetAddress.getLocalHost();
            Socket socket = new Socket(host.getHostName(), 7777);

            //
            // Send a message to the client application
            //
            ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream());
            oos.writeObject("Hello There...");

            //
            // Read and display the response message sent by server application
            //
            ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());
            String message = (String) ois.readObject();
            System.out.println("Message: " + message);

            ois.close();
            oos.close();
        } catch (UnknownHostException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

 

[Empire Phoenix]

du brachst nen while(!socket.isClosed(()) sonst wird der Thread auch nur eine Nachricht lesen und danach sich beenden.

(Dann braucht man auch net mehere Threads, solange es ok ist das der Client blockiert wenn er auf Nachrichten wartet)

 

[Murray]

Der Thread im Server hat primär die Aufgabe, mehrere parallele Verbindungen zuzulassen - der Server soll also bereits einen neuen Client bedienen können, auch wenn ein anderer noch "in Arbeit" ist.

Im Client brauchst du nicht zwingend einen Thread, sondern zunächst mal etwas wie eine Schleife, wenn du Aktionen wiederholt ausführen willst.

 

[g0ser]

Hi,

danke für eure Antworten.
Dann hab ich das Beispiel irgendwie falsch verstanden.
Also ich benötige eigentlich keine parallele Verbindungen von mehreren Clients da es sich immer nur ein Client verbinden soll.
Dann hab ich jetzt mal beim Client eine for-Schleife beim "writeObject" damit er mal öfters eine Nachricht sendet. Das funktioniert mit dieser Lösung bisher nicht man muss sich jedes mal ganz neu Verbinden mit dem Client. Also Anwendung neu starten.

Wenn das funktionieren würde könnte ich ja sozusagen eine endlos Schleife erstellen die die ganze Zeit liest auf den Inhalt verarbeitet und eine Antwort schreibt und dann wieder liest usw.

 

[Murray]

Zeig mal den aktuellen Client-Code (aber nicht oben editieren)

 

[g0ser]

Ich hatte jetzt nur zum Testen eine for-Schleife eingefügt. Er sollte eigentlich mehrmals die Nachricht an den Server senden. Ich erhalte aber einen "socket write error".
Ich vermute weil der Server mit dem oben gezeigten Code jedes mal den Socket beendet nachdem die Nachricht erhalten wurde.
Ich möchte es aber so das die Verbindung bestehen bleibt.

Sieht nun so aus:

public class ClientSocketExample {
    public static void main(String[] args) {
        try {
            //
            // Create a connection to the server socket on the server application
            //
            InetAddress host = InetAddress.getLocalHost();
            Socket socket = new Socket(host.getHostName(), 7777);

            //
            // Send a message to the client application
            //
            ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream());
            oos.writeObject("Hello There...");

            //
            // Read and display the response message sent by server application
            //
            ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());
            String message = (String) ois.readObject();
            System.out.println("Message: " + message);
            for(int i = 0; i < 5; i++)
            {
                 oos.writeObject("Hello There...");
            }

            ois.close();
            oos.close();
        } catch (UnknownHostException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

 

[g0ser]

Hab das jetzt hingekriegt.
Hab nun beim Server und beim Client einfach eine Schleife die erst bei einer bestimmten Nachricht beendet wird.
So bleibt die Verbindung bestehen.

Jetzt hab ich aber ein anderes Problem.
Und zwar möchte ich das er bei bestimmten Nachrichten bestimmte Aktionen ausführt. Siehe Server Klasse Beispiel "bye".
Da ich das nun objektorientiert programmieren möchte weiß ich nicht wie ich das machen kann damit nicht alles in die Server Klasse schreiben muss.
Kann mir da jemand vielleicht einen Tipp geben?


Server Klasse:

public class Server{
	ServerSocket providerSocket;
	Socket connection = null;
	ObjectOutputStream out;
	ObjectInputStream in;
	String message;
	Provider(){}
	void run()
	{
		try{
			//1. creating a server socket
			providerSocket = new ServerSocket(2004, 10);
			//2. Wait for connection
			System.out.println("Waiting for connection");
			connection = providerSocket.accept();
			System.out.println("Connection received from " + connection.getInetAddress().getHostName());
			//3. get Input and Output streams
			out = new ObjectOutputStream(connection.getOutputStream());
			out.flush();
			in = new ObjectInputStream(connection.getInputStream());
			sendMessage("Connection successful");
			//4. The two parts communicate via the input and output streams
			do{
				try{
					message = (String)in.readObject();
					System.out.println("client>" + message);
					if (message.equals("bye"))
						sendMessage("bye");
				}
				catch(ClassNotFoundException classnot){
					System.err.println("Data received in unknown format");
				}
			}while(!message.equals("bye"));
		}
		catch(IOException ioException){
			ioException.printStackTrace();
		}
		finally{
			//4: Closing connection
			try{
				in.close();
				out.close();
				providerSocket.close();
			}
			catch(IOException ioException){
				ioException.printStackTrace();
			}
		}
	}
	void sendMessage(String msg)
	{
		try{
			out.writeObject(msg);
			out.flush();
			System.out.println("server>" + msg);
		}
		catch(IOException ioException){
			ioException.printStackTrace();
		}
	}
	public Server()
	{		
		while(true){
			this.run();
		}
	}
}

Client Klasse:

public class Client{
	Socket requestSocket;
	ObjectOutputStream out;
 	ObjectInputStream in;
 	String message;
	Requester(){}
	void run()
	{
		try{
			//1. creating a socket to connect to the server
			requestSocket = new Socket("localhost", 2004);
			System.out.println("Connected to localhost in port 2004");
			//2. get Input and Output streams
			out = new ObjectOutputStream(requestSocket.getOutputStream());
			out.flush();
			in = new ObjectInputStream(requestSocket.getInputStream());
			//3: Communicating with the server
			do{
				try{
					message = (String)in.readObject();
					System.out.println("server>" + message);
					sendMessage("Hi my server");
					InputStreamReader isr = new InputStreamReader(System.in);
					BufferedReader br = new BufferedReader(isr);
					String E1 = br.readLine();
					sendMessage(E1);
				}
				catch(ClassNotFoundException classNot){
					System.err.println("data received in unknown format");
				}
			}while(!message.equals("bye"));
		}
		catch(UnknownHostException unknownHost){
			System.err.println("You are trying to connect to an unknown host!");
		}
		catch(IOException ioException){
			ioException.printStackTrace();
		}
		finally{
			//4: Closing connection
			try{
				in.close();
				out.close();
				requestSocket.close();
			}
			catch(IOException ioException){
				ioException.printStackTrace();
			}
		}
	}
	void sendMessage(String msg)
	{
		try{
			out.writeObject(msg);
			out.flush();
			System.out.println("client>" + msg);
		}
		catch(IOException ioException){
			ioException.printStackTrace();
		}
	}
	public Client()
	{
		this.run();
	}
}

 

[tuxedo]

Da ich das nun objektorientiert programmieren möchte ...

Nimm eine RPC Technik:

* Remote Method Invocation Home
* SIMON - Overview - root1.de - Software Engineering
* ...

- Alex