Socket Kann ein Socket server 2 dimensionale Arrays empfangen und versenden?

Hannah *

Mitglied
Java:
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
//import java.io.StringReader;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import java.util.Iterator;

public class Server
{
    ServerSocket server;
    
    ArrayList<PrintWriter> list_clientWriter;   //  Liste user
    
    final int LEVEL_ERROR = 1;                  // Konstanten f�r Errors
    final int LEVEL_NORMAL = 0;

    public static void main(String[] args)
    {
        Server serv = new Server();
      
        if (serv.runServer())
        {
            serv.listenToClients();
        }
        
        // else Do nothing     
    
    }
    
    
    public boolean runServer()
    {
        try
        {
             server = new ServerSocket(5555);
             appendTextToConsole("Server wurde gestartet!", LEVEL_ERROR);   // Der Server wurde gestartet
            
             list_clientWriter = new ArrayList<PrintWriter>();              // user werden in einer Liste gespeichert
             return true;
        }
        catch (IOException e)
        {
             appendTextToConsole("Server konnte nicht gestartet werden!", LEVEL_ERROR);  // damit Server nicht gestartet wird
             e.printStackTrace();
             return false;
         }
    }
        
    
    public void appendTextToConsole(String nachricht, int level)
    {
        if(level == LEVEL_ERROR)
        {
            System.err.println(nachricht+ "\n");     // wenn Error wird rot ausgegeben
        }
        else
        {
            System.out.println(nachricht + "\n");    // wenn normal, normale ausgabe
        }
    }
  
    
    public class ClientHandler implements Runnable
    {
        Socket client;
        BufferedReader reader;
    
        public ClientHandler(Socket client)
        {
            try
            {
                this.client = client;  // client wird �bergeben
                reader = new BufferedReader(new InputStreamReader(client.getInputStream())); // BufferedReader(char) /InputStreamReader(bytes) //alles was client schreibt landet im reader
            }
            catch (IOException e)
            {
                e.printStackTrace();
            }
        }
    
        @Override
        public void run()
        {
            // alles auflisten das gesendet wird an alle Clients
            String nachricht;
            int [][] textÜbertrag; //= new int [] [] {} {};
          
            try
            {
                while((nachricht = reader.readLine()) != null )
                {
                    
                    
                    
                    while((textÜbertrag =  reader.read()) != null)
                    {
                        /*
                        for (int j=0; j<textÜbertrag.length; j++)
                         for (int i=0; i<textÜbertrag[0].length; i++)
                         {
                            
                            textübertrag = [i][j];
                            
                         }
                    */
                        appendTextToConsole("Vom Client: \n" + textÜbertrag, LEVEL_NORMAL);      // anzeige Server                                   
                    }
                    
                    appendTextToConsole("Vom Client: \n" + nachricht, LEVEL_NORMAL);            // anzeige Server
                    sendToAllClients(nachricht,textÜbertrag);                                   // Verteiler an alle clients
                
                }
            }
            catch (IOException e)
            {
                e.printStackTrace();
            }
            /*
            try
            {
            while((textÜbertrag = reader.hasNext()) != null)
                    {
                        appendTextToConsole("Vom Client: \n" + textÜbertrag, LEVEL_NORMAL);      // anzeige Server                                   
                    }
                    
                    appendTextToConsole("Vom Client: \n" + nachricht, LEVEL_NORMAL);            // anzeige Server
                    sendToAllClients(nachricht,textÜbertrag);                     
            }
            catch (IOException e)
            {
                e.printStackTrace();
            }*/
        }
    }
    
    
    public void listenToClients()  // Metode laeuft endlos
    {
        while(true)
        {
            try
            {
                Socket client = server.accept();                                        // neues Socket wird erzeugt und wartet
              
                PrintWriter writer = new PrintWriter(client.getOutputStream());         // Objekt dass der Client sendet wird geholt
                list_clientWriter.add(writer);
              
                Thread clientThread = new Thread(new ClientHandler(client));            // fuer jeden aufgenommenen Client wird ein eigener Thread gestartet
                clientThread.start();                                                   // jeder Client laeuft einzeln in Threads damit alles parallel laeuft
            }
            catch (IOException e)
            {
                e.printStackTrace();
            }             
        }
    }
    

    public void sendToAllClients(String nachricht, int[] [] textÜbertrag)
    {
        Iterator<PrintWriter> it = list_clientWriter.iterator();        // Iterator erzeugen und von liste holen // zeiger
      
        while(it.hasNext())                                // solange wie der operator ein naechsten hat
        {
            PrintWriter writer = (PrintWriter) it.next();  // erzeugen neuen print writer // type cast
            writer.println(nachricht);                     // nachricht an den client senden
            writer.flush();   
            writer.println(textÜbertrag);
            writer.flush();                                // nachricht senden //puffer leeren // client der als erstest in der liste ist, bekommt zuerst die nachricht
        }
    } 
    
}   


//---------------Ende----------------------------------------------------------------------------------------------------------
 
Generell kann man mit Streaming-Sockets nur geordnete Bytes übertragen. Du kannst dir natürlich ein Protokoll ausdenken, um zu signalisieren, dass ein folgender Wert einen bestimmten Typ hat bzw. auf eine gewisse Weise interpretiert werden soll. So zum Beispiel nutzt Java Serialization ObjectOutputStream und ObjectInputStream ein solches Protokoll, mit dem du Objekte (unter anderen Arrays) versenden kannst.
 
Davon hab ich leider nicht so viel Ahnung. Ich erkläre dir mal kurz mein Vorhaben. Geplant ist ein Chat zwischen zwei Clienten. Der Chat an sich funktioniert. Als weiteres wird die eingegebene Nachricht mit einer Extraklasse verschlüsselt, mit dem Hill Chiffre Verfahren und der ASCII Tabelle dann war geplant das Array wieder in ein String zu wandeln und über den Server zu geben. Das hat auch funktioniert. Das Problem tritt auf wenn der String beim anderen Client wieder zum Array gewandelt wird das das Array nicht mehr gleich ist und der Text nicht richtig entschlüsselt wird. Woran könnet das liegen?
 
Also der auskommentierte Code war ja nicht einmal übersetzbar....

Daher wäre die Frage: Was hattest Du an Code, der etwas übertragen hat und was war unterschiedlich?

Dann ist mir die Aufgabe noch nicht wirklich klar: Du erzeigst eine Chiffre und die wird jedem Client mitgeteilt? Das macht keinen Sinn, denn dann kann man die Verschlüsselung auch ganz weglassen! Somit sollte man davon ausgehen, dass die Clients, die miteinander reden wollen, den Schlüssel bereits haben.

Das vereinfacht dann die Chat Applikation so, dass Du nur noch verschlüsselte Nachrichten übermitteln musst -> Also alles ganz einfach!

Wenn Du mehrere Sachen übertragen willst, dann musst Du Dir Überlegen, was das alles sein kann. Du könntest jeder Zeile voran stellen, was es ist;

ENCMSG wäre eine Verschlüsselte Nachricht.
NEW wäre evtl. eine Nachricht, das ein Client sich neu verbunden hat. Das wäre dann ein Signal, dass der Client den Verschlüsselungskey benötigt (So Du den wirklich übertragen willst ... was wie gesagt keinen Sinn macht!)
KEY wäre dann evtl. der Verschlüsselungskey

Du musst natürlich überall überlegen, das da noch mitgesendet wird und was Trennzeichen sind. Bei so Textnachrichten kann ein Zeilenumbruch der Trenner sein.
ENCMSG bekommt natürlich die verschlüsselte Nachricht.
NEW bekommt ggf. nichts mit, aber evtl. willst DU ja sowas wie Usernamen und so haben?
KEY bekommt den Key in irgend einer Form mit. Wie kannst Du ein zweidimensionales int Array als String darstellen? Überlege es Dir einfach - da gibt es ja mehrere Möglichkeiten ...

Das kann dann aber noch weiter ausgebaut werden. Wie so ein Protokoll dann letzten Endes aussehen könnte sieht man z.B. am Internet Relay Chat (IRC). RFC 1459.
 

Zurück
Oben