# Pc <- eigener Server



## Spin (26. Dez 2009)

Hallo liebe Java Gemeinde, ich hoffe ihr habt ein frohes Fest gehabt.

Ich wollte mal fragen, ob man seinen eigenen Rechner gleichzeitig zum Server und zum Client machen kann?

Ich habe entweder vor eine Client-Client verbindung aufzubauen oder einer Server -Client.
Da ich keine Lust habe mich mit zusätzlichen Frameworks auseinander zu setzen, dachte ich als an einen Echo Server, der erstmal auf eingabeströme reagiert.

Es reicht auch ein UDP-Server, mit DatagramSocket.
Links habe ich genug, doch besteht die Frage ob bei Programmstart ich gleichzeitig daten empfangen und senden kann?

Vielleicht ist die Frage doof formuliert, aber ich will die Daten nicht nur verteilen.

Im Endeffekt soll es Peer to Peer funktionieren, doch möchte ich mit Sockets arbeiten.

Daher mein Plan, einer Client klasse zu programmieren und einer serverklasse.

Kumpel bekommt das clientprogramm und ich mach mich zum server. Und will aber gleichzeitig als Client fungieren.

Mal schauen was ihr nun sagt ...gruß..

PS: Kann ich eine Peer to Peer verbindung auch ohne JxTA ( Protokollfamilie ) und ohne JGroup hinbekommen?

danke


----------



## Kr0e (26. Dez 2009)

Ich muss zugeben, JGroup und JxTA sagt mir grad garnix, aber es sei dir versichert: Es geht auch ohne 

Also, erstmal glaube ich, dass du dich ziemlich umständlich ausgedrückt hast...

JA: Dein Rechner kann gleichzeitig ein Server sein und ein Client...
Du startest dein server prog, connectest dann mit deinem client programm auf die pc-interne Adresse (127.0.0.1/localhost)
Dein Kumpel muss deine LAN Adresse dort eingeben, bzw. deinen DNS Namen....
Peer2Peer ist kein Problem im Lan, möchtest du P2P im Internet nutzen, braucht du sofern du ausschließlich TCP und Java benutzt offene Ports in deinem Router (Sofern du der Server bist...) Nimmst du UDP ? Wenn ja, dann wäre UDP Hole Punching eine gute Lösung... Es gibt viele gute Erklärungen dazu im Internet... TCP Hole Punching ist ebenfalls möglich, aber natürlich nicht mit Java.... C/C++ ist in diesem Fall dein Freund... (Java hat eben doch strikte Grenzen...)

Aber offene Ports+TCP sind meiner Meinung nach sehr komfortabel... UDP ist eben kein "sicheres" Protokoll...
Pakete können durchaus mal abhanden kommen... Also entweder du nutzt UDP und implementierst ein eigenes "TCP-Workaround" 
Oder du öffnest ein paar Ports fürs Internet... Es gibt Bibliotheken für UPNP... Das ist ein Protokoll, mit dem man Ports aus dem Programm direkt öffnen kann! Der Router msus das 1. unterstützen und 2. erlauben...

Keine Ahnung, ob das jetzt deine Fragen beantwortet, aber.... ich hoffe es zumindest...

Gruß Chris


----------



## Spin (27. Dez 2009)

Moinsen. Ich war ein wenig bei , aber irgendwie wills noch nicht.

Habe aber fleißig kommentiert 


```
public class JServer {

    public static void main(String args[]) {

        /* Die Klasse JServer kümmert sich nicht mehr um die Kommunikation, sondern
         * lediglich um den Verbindungsaufbau*/
        JServer server = new JServer();
        server.connect(55555);

    }
    /**
     * Methode connect(), die auf eine Verbindung wartet
     * @param port - einen freien Port verwenden. (Portnummer: 0 - 65535)
     */
    private void connect(int port) {

        int cnt = 0;
        /*Abfangen*/
        try {
            /* Serverklasse, die auf eine Verbindung wartet und reagiert*/
            ServerSocket serverSocket = new ServerSocket(port);

            /* Server soll ständig laufen */
            while (true) {
                /* Clientklasse, die Daten liest und sendet. (Programmierschnittstelle in einen TCP/OIP Netzwerk)*/
                Socket client = waitForSign(serverSocket);
                System.out.println("Verbindung hergestellt");
                /* Thread für den Clienten starten */
                (new ClientThread(++cnt, client)).start();
                /* Jeder Client bekommt einen eigenen Thread - der Thread kümmert sich
                um die Kommunikation zwischen Client und Server*/


            }



        } catch (IOException ex) {
        }
    }

    /**
     *
     * @param serverSocket - Übergabe eines ServerSocket Objects
     * @return -  verbundenen Clienten
     * @throws IOException - Fehler beim Senden und empfangen
     */
    private Socket waitForSign(ServerSocket serverSocket) throws IOException {
        Socket socket = serverSocket.accept(); // Warten auf eingehende Verbindung
        return socket;
    }
}

/**
 * Ein Thread ist Teil eines Prozesses ( leichtgewichtiger Prozess ) und läuft
 * sequentiell ab.
 *
 * Probleme entstehen bei der gleichzeitigen Benutzung von Betriebsmitteln. ( gleicher Adressraum )
 * @author Spin
 */
class ClientThread extends Thread {

    /* Client Membervariablen */
    private int number;
    private Socket socket;



    /**
     *
     * @param name - Nummer des Clienten
     * @param socket - neuer Client
     */
    public ClientThread(int number, Socket socket) {
        this.number = number;
        this.socket = socket;
       


    }

    /**
     * Solange run() läuft ist der Thread aktiv
     */
    @Override
    public void run() {

        try {
            String message = readMessage(socket);
            System.out.println(message);
            writeMessage(socket, message);
            
            System.out.println("Verbindung zum Clienten: " + number + "wird beendet");
            socket.close();
        } catch (IOException e) {
            System.out.println(e.toString());
        }
    }

    public String readMessage(Socket socket) throws IOException {
        /**
         * Empfangen von Daten, mithilfe eines BufferedReaders
         * BufferedReader puffert Daten und erhöht die Performance beim lesen
         */
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
        /* Max. 200 Zeichen mit einmal seichern*/
        char[] buffer = new char[200];
        /* Anzahl der Zeichen */
        int anzahlZeichen = bufferedReader.read(buffer, 0, 200);
        /* Nachricht zurückgeben von (0 - anzahl der Zeichen ) */
        return new String(buffer, 0, anzahlZeichen);
    }

    public void writeMessage(Socket socket, String nachricht) throws IOException{
        /**
         * Streambasierte Ausgabe
         */
        PrintWriter printWriter =new PrintWriter(new OutputStreamWriter(socket.getOutputStream()));
        /* Ausgabe der Nachricht*/
 	printWriter.print(nachricht);
 	printWriter.flush(); // aus dem Speicher nehmen
    }

    }
```



Das Problem ist er startet den Thread, aber irgendwie passiert nicht mehr.


```
class JClient {

    public static void main(String args[]) {

         try {
         Socket skt = new Socket("localhost", 55555);
         InputStream in = skt.getInputStream();
         int len;
         byte[]b = new byte[100];
         while((len = in.read(b)) != -1){
             System.out.write(b,0,len);
         }
         in.close();
         skt.close();
      }
      catch(Exception e) {
         System.out.print("Whoops! It didn't work!\n");
      }
```

Verbindung kann ich aufbauen, aber irgendwie gibt mein Thread nichts aus. komisch

danke für hilfe


----------



## Michael... (28. Dez 2009)

Innerhalb des ClientThreads in Zeile 89 wird die Methode readMessage() aufgerufen. 
In der wiederrum wird in Zeile 109 
	
	
	
	





```
int anzahlZeichen = bufferedReader.read(buffer, 0, 200);
```
 auf Daten aus dem InputStream des Client Sockets gewartet. Da der Client aber nur eine Verbindung aufbaut aber keine Daten sendet (der Client selbst wartet in Zeile 10 selbst auf Daten vom Server), wird ab Zeile 109 blockiert.

Wenn später eine Kommunikation stattfinden soll, muss sowohl beim Server als auch beim Client das Lesen vom InputStream und das Schreiben in den OutputStream in separaten Threads ablaufen.


----------



## ARadauer (28. Dez 2009)

> Ich wollte mal fragen, ob man seinen eigenen Rechner gleichzeitig zum Server und zum Client machen kann?


ja natürlich eine simple socket verbindung besteht ja zwischen zwei endpunkten die aus adresse und port bestehen.
localhost:80 <-> localhost:12548 ... kein problem
du kannst dir ja auch Seiten ansehen die auf einem lokalen apache laufen...


----------

