Grundsätzliches zu Multi User Servern

D

Danny125

Grünschnabel
Hallo erstmal :D

ich möchte einen Multi User Server in JAVA realisieren, als Schulprojekt, ich habe ein paar grundlegende Fragen dazu!

Ich kenne mich schon ein wenig mit Sockets usw. aus, aber wie verwirkliche ich es, dass der Server mit mehreren Clients gleichzeitig interagieren kann? Also, dass das Programm nicht 'lagt', wenn ein User gerade z.B. einen Datensatz anfordert oder eine Berechnung durchgeführt wird.

Ich habe was von einer Thread-Klasse gelesen, bin ich da auf dem richtigen weg?

Außerdem soll das ganze ein vermittler zwischen User und MySQL datenbank sein, also der Server soll mit MySQL arbeiten um Informationen zu speichern. Ich habe vor 'JDBC' dafür zu benutzen, ist das okay?

Angenommen ich mache es so, dass jeder User in einem eigenen Thread läuft, muss ich dann auch für jeden Benutzer eine eigene MySQL verbindung aufbauen oder reicht eine Statische?

Ich hoffe hier kennt sich jemand aus und kann mir helfen,

außerdem wünsche ich ein frohes Fest :D
 
Hallo,

mit Threads bist du auf dem richtigen Weg.
Du solltest für jeden User einen eigenen Thread anlegen. Schau dir dazu mal den ExecuterService an.

Je nachdem was mit der Datenbank gemacht werden soll, kannst du dir mal die Java Persistence API (JPA) anschauen.
Wenn du das nicht brauchst, dann kannst du ruhig JDBC verwenden.
Ich würde für jeden User eine eigene Verbindung zur Datenbank aufbauen.

Gruß

Sascha
 
Hallo Sascha!

Zunächst mal danke, hast mir sehr weiter geholfen.

Was genau ist denn der Vorteil von diesem JPA? Bzw. was ist der Nachteil von JDBC?

Die MySQL verbindung Speichert die Daten der User und ruft sie ab.
 
Die JPA ist ein sogenannter OR-Mapper.
Das heißt, es speichert dir Objekte in eine relationale Datenbank, wie MySQL eine ist.

Mal ein Beispiel. Angenommen du hast eine Klasse Person mit Vorname, Nachname, Adresse.
Wenn du nur JDBC verwendest, musst du ein SQL-Statement zusammenbauen, in welches die Daten deiner Person reinkommen.
Bei der JPA musst du das nicht tun. Du gibst an welches Attribut in welche Spalte gespeichert wird. Dann brauchst du mehr oder weniger nur noch eine save-Methode aufzurufen und dein Object von Person übergeben und die Person wird richtig in der Datenbank gespeichert.

Oder wenn du eine Person aus der Datenbank laden möchtest, musst du nur eine load-Methode aufrufen und die Id der Person übergeben. Dann bekommst du ein Person-Object zurückgeliefert.
Bei JDBC müsstest du ein SQL-Statement mit der Id absetzen. Dann bekommst du alle Werte der Person und müsstest dir dein Object wieder selbst zusammenbauen.

Gruß

Sascha
 
Wow das klingt ja fast so simpel wie der umgang mit mysql in php, ich werde mich mal über JPA informieren, kennst du irgendwelche etwas simpler gehaltenen Beispielprogramme?

Vielen Dank auf jeden Fall :D
 
Ich habe mir jetzt mal überleg wie ich anfangen könnte, ich habe mir das so vorgestellt:

Code: 
main() {
// Socket setup etc.
while (true) {
  // Neue vrbindung akzeptieren
  // -> new UserSocket(Socket).run();
}
}

// UserSocket Klasse:
class UserSocket extends Thread {
  static int count = 0;
  int id;
  Socket s;

  UserSocket(Socket s) {
    this.s = s;
    id = count++;
  }

  void run() {
    // neues MySQL objekt
    // weitere objekte erzeugen
    while (s.isConnected()) {   // Weiss nicht wie die methode in java heisst 
      // Daten verarbeiten ...
    } 
  }
}

Wäre das rein von der Struktur her richtig/sinnvoll?

Und ist die position, an der ich die Objekte für jeden user (mysql..) erstelle richtig gewählt?
Wenn ich die Klassen innerhalb dieser UserSocket klasse erstelle, laufen die denke ich im selben Thread wie die UserSocket klasse, es sei denn sie selbst sind wieder eine extends-thread klasse, oder liege ich da falsch?
 
Zuletzt bearbeitet:
Hallo,

hab hier einen Denkanstoß für dich :)

hab meine Klasse TcpClient von MyThread erben lassen und dann in der Run den ThreadCode implementiert
...
Java: 
abstract class MyThread extends Thread 
{
    // führt den ThreadCode aus.
    // in der erbenden Klasse zu implementieren.
    public abstract void runCode();
    
    public void run()
    {
        runCode();
    }
    
    
    // Thread für eine zufällige Zeit pausieren lassen 
    public void sleepRandom()
    {
        try
        {
            sleep((int) (Math.random() * 1000));
        }
        catch(InterruptedException e)
        {
            e.getMessage();
        }
    }
    
    // Thread für eine bestimmte Zeit pausieren lassen
    public void sleepMillis(int milliseconds)
    {
        try
        {
            sleep(milliseconds);
        }
        catch(InterruptedException e)
        {
            e.getMessage();
        }
    }
}

So hab ich dann den Server dynamisch die Threads erstellen lassen, in diesem Fall eben mit dem blockierenden Methodenaufruf "ServerSocket".accept(); in der Parameterliste, so dass erst ein Threadobjekt erstellt wird, sobald ein Client connected am ServerSocket
...
Java: 
while(serverIsRunning)
            {
                try
                {
                    new TcpClient(svSock.accept(), this).start();
                }
                catch(SocketTimeoutException e)
                {
                    e.printStackTrace();
                }
            }


vielleicht bringt dir das ja was, um den MultiUserServer zu verwirklichen ^^

MfG
 
Um antworten zu können musst du eingeloggt sein.

Neue Beiträge

Zurück