# Socket Programmierung



## blue_devil86 (17. Jun 2007)

Hallo meine Götter,

ich mache gerade einen Socket. Geht alles gut soweit ich mach in der Klasse _Server_:

```
while(true) {
socketc = this.serversocket.accept();
Thread thread = new Thread(new ClientHaendler(socketc));
thread.start();
}
```

so also ich starte pro Client ein neues Thread.

Jetzt das Problem:

Es funktioniert zwar jedoch bekommt der Client der eine Nachricht sendet auch diese zurück wie es sein soll aber die anderen verbunden nicht.

ich wollte eine Membervariable machen
ArrayList clientausgabestroem;

PrintWriter writer = new PrintWriter(socketc.getOutputStream) //socketc kommt aus der Klasse _Server_
und es dann so machen das clientausgabestroem.add(writer); ist.

und die Nachrichten so verteilen:

Iterator iterator = clientausgabestroem.iterator();
while(ist.hasNext()){
    try{
        PrintWriter writer = (PrintWriter) it.next();
        writer.println(nachricht); //nachricht ist das was zu senden ist vom Typ string
        writer.flush();
   } catch....
}

Ich glaube es liegt einfach nur an clientausgabestroem das die nicht in _Server _gespeichert werden und jeden Thread nimmt sich im augenblick des verteilens das neue array clientausgabestroem.

Ich hoffe mir kann bei diesen Problem jemand helfen.
Schon mal danke im voraus


----------



## FelixR (18. Jun 2007)

Hi

ein sehr komplexes Problem, was ich so nicht beantworten kann, da ich auch zum Teil gar nicht verstehe wo genau das Problem liegt. Entweder du stellst mal den gesamten Code oder ein Klassendiagramm zur verfügung, damit man sioch mal ein genaueres Bild machen kann wie du den Ablauf geplant hast.
Ansonsten einfach den Debugmodus benutzen und schritt für schritt durchlaufen lassen. Wenn du verstehst (wovon ich mal ausgehe) was alles im einzelnen geschieht, sollte es auch nicht schwer sein die Logic zu erkennen wartum nicht alle eine Nachricht bekommen. 

gruß Felix


----------



## Guest (18. Jun 2007)

ChatServer

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

public class ChatServer {

    //Memvervariablen
    ServerSocket serversocket;
    Socket socketc  = null;
    final ArrayList userarray = new ArrayList();
    
    /**
     * Konstruktor
     */
    public ChatServer() {
        System.out.println("ChatServer wird gestartet!");
        
        try {
            System.out.println("Server Socket wird angelegt!");
            this.serversocket = new ServerSocket(2004);
            System.out.println("Serversocket: "+serversocket);
        } catch(IOException e) {
            System.out.println("Fehler beim Socket erstellen!");
        }
        
        while(true) {
            try {                             
                socketc = this.serversocket.accept();
                System.out.println("Client Socket: "+socketc);
                Thread thread = new Thread(new ClientHaendler(socketc));
                thread.start();
            } catch (Exception e) {
                System.out.println("Fehler beim ChatServer starten!");
            }           
        }
    }  
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here
        System.out.println("rennt glei loss..");
        ChatServer chatserver = new ChatServer();
    }
}
```

ClientHaendler

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

public class ClientHaendler implements Runnable{
    
    //Membervariablen
    Socket socketc ;
    
    

    public ClientHaendler(Socket socketc) {
        this.socketc = socketc;
    }
    
    public void run() {
        String nachricht;
        try {
            PrintWriter printwriter = new PrintWriter(socketc.getOutputStream());
            BufferedReader bufferedreader = new BufferedReader(new InputStreamReader(socketc.getInputStream()));
            
            printwriter.println("Hallo\n");
            printwriter.flush();
            while((nachricht = bufferedreader.readLine()) != null) {
                System.out.println(nachricht);
                printwriter.println(nachricht);
                printwriter.flush();
                nachrichtverteilen(nachricht);
            }            
        } catch (Exception ex) {
            System.out.println("Fehler in run()");
        }
    }
    public void nachrichtverteilen(String nachricht) {
 	Iterator it = clientAusgabeStroeme.iterator();
        while(it.hasNext()) {
            try {
                PrintWriter writer = (PrintWriter) it.next();
                writer.println(nachricht);
                writer.flush();
            } catch (Exception ex) { ex.printStackTrace(); }
        }

    
    }
}
```

so ich hab mal den ganzen Code gepostet.

Man sieht mein Problem das die clientAusgabeStroeme nur pro ein Client gilt.
Es sollten aber alle verbunden Clients darin gespeichert sein.

Ich denk mal ich muss die clientAusgabeStroeme in ChatServer speichern und dann beim verteilen immer wieder von da hollen. Ich hoffe ihr versteht das Problem jetzt besser.


----------



## Guest (18. Jun 2007)

```
public class ChatServer{
    
    ArrayList clientAusgabeStroeme;
    
    public class ClientHandler implements Runnable {
    ...
    }
}
```

wenn ich den Code so aufbauen wirde müste es gehen aber ich will die Klassen nicht so verbasteln.
Es muss doch einen anderen Weg geben clientAusgabeStroeme überall zur verfügung zu haben.


----------



## Guest (19. Jun 2007)

Lösung: Schnittstelle lol ganz vergessen das es ja noch sowas gibt


----------

