# Chatprogramm zwischen zwei ChatClients (aktiv/passiv)



## Daniel@Java (13. Mai 2014)

Hallo zusammen,

ich bin gerade dabei, mich für eine Übung in die Netzwerkprogrammierung einzuarbeiten, stoße aber nun am meine Grenzen. Ziel ist es, ein Programmpaar aus Client und Server zu erstellen, mit dem Textnachrichten vom Client an den Server übermittelt werden können. Soweit so gut. Ich habe sowohl einen ChatClient und ChatServer erstellt, welche nach Start nun auch die vom Client eingegebenen Nachrichten in der Konsole des Servers ausgeben.

*Jetzt kommt allerdings der Haken:* 

Ich soll nun das ChatClient- und -Serverprogramm zu einem "echten" Chatprogramm ausbauen, sodass eine Kommunikation zwischen zwei ChatClients ermöglicht wird, ich habe hierzu noch folgende Anweisungen bekommen:


> Das Chat-Programm erhält über die Kommandozeile einen weiteren Parameter der angibt, ob es auf einen Verbindungsaufbau seitens eines anderen Chat-Programms warten soll (passive open), oder aber aktiv eine Verbindung zu einem anderen Chat-Programm aufbauen soll (active open).
> 
> Nachdem die TCP-Verbindung hergestellt ist, werden Eingaben von der Konsole (System.in) entgegen genommen und auf der Konsole (System.out) ausgegeben.




_Nun meine Frage, wisst ihr wie man sowas aufbaut, geschweige denn programmiert? _


Hier ist mein *Chatclient*:


```
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;
import java.net.UnknownHostException;

public class ChatClient implements Runnable {
        
        final int PORT = 8888;
        Socket client;
        
        public ChatClient(String ip){
                try {
                        client = new Socket(ip,PORT);
                } catch (UnknownHostException e) {
                        System.out.println("Der Hostname ist mir nicht bekannt. Kann nicht weiter machen");
                        System.exit(1);
                } catch (IOException e) {
                        e.printStackTrace();
                        System.exit(1);
                }
        }
        
        public ChatClient() {
                this("localhost");
        }

        @Override
        public void run() {
                boolean blank = false;
                System.out.println("Verbindung wird bei Eingabe von zwei leeren Zeilen beendet.");
                while (true) {
                        try {
                                BufferedReader data = new BufferedReader(new InputStreamReader(System.in));
                                PrintWriter sendData = new PrintWriter(client.getOutputStream());
                                String test = data.readLine();
                                if(test.equals("")){
                                        if(blank){
                                                sendData.println();
                                                if(sendData.checkError()) System.out.println("Fehler beim Senden an " + client.getInetAddress());
                                                break;
                                        }
                                        blank = true;
                                        continue;
                                }
                                sendData.println(test);
                                if(sendData.checkError()) System.out.println("Fehler beim Senden an " + client.getInetAddress());
                                Thread.sleep(10);
                        } catch (InterruptedException e) {
                                System.out.println("Problem bei der Verbindung zum Server. Vermutlich wurde sie getrennt.");
                                try {
                                        client.close();
                                } catch (IOException e1) {}
                                System.exit(1);
                        } catch (IOException e) {
                                e.printStackTrace();
                        }
                }
                try {
                        client.close();
                } catch (IOException e) {
                        e.printStackTrace();
                }
        }

        /**
         * @param args
         */
        public static void main(String[] args) {
                new Thread(args.length == 1 ? new ChatClient(args[1]) : new ChatClient()).run();
        }

}
```

Hier noch mein *ChatServer*:


```
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;

public class ChatServer implements Runnable {
        
        final int PORT = 8888;
        ServerSocket server;

        /**
         * @param args
         */
        public static void main(String[] args) {
                new Thread(new ChatServer()).run();
        }
        
        public ChatServer() {
                try {
                        server = new ServerSocket(PORT);
                } catch (IOException e) {
                        e.printStackTrace();
                }
        }

        @Override
        public void run() {
                Socket recv;
                try {
                        recv = server.accept();
                        System.out.println(recv.getInetAddress() + " hat sich verbunden.");
                        while (recv.isConnected()) {
                                BufferedReader reader = new BufferedReader(new InputStreamReader(recv.getInputStream()));
                                String data = reader.readLine();
                                if (data.equals("")){
                                        recv.close();
                                        break;
                                }
                                System.out.println(data);
                                Thread.sleep(10);
                        }
                        System.out.println("Verbindung wurde getrennt.");
                } catch (IOException e) {
                        e.printStackTrace();
                } catch (InterruptedException e) {
                        System.out.println("Problem bei der Verbindung zum Server. Vermutlich wurde sie getrennt.");
                        System.exit(1);
                }
        }

}
```


----------



## Chloroplast (17. Mai 2014)

um Nachrichten aus dem stream zu lesen sind Threads notwendig, auf jeder seite einer, welche die Nachrichten aus dem Stream lesen und ausgeben. Dass ist auf beiden seiten möglich, genauso wie das senden. wenn die verbindung einmal geschaffen wurde, ist es egal auf welcher seite man sich befindet.
Also musst du nur entweder einen ServerSocket schaffen, welcher auf andere Clients wartet und mit diesem dann kommuniziert, oder ob er sich direkt verbinden soll, und das ergebnis dann weitergibt


----------

