vsys2

Aufwand an Anpassungen bei steigenden Anforderungen.

Von Außen nicht erkennbare Struktur/Eigenschaft eines Systems.

Was wird Kommuniziert: Zeichen, Nachrichten, Funktionen, Objekte, Applikationen

Ein Load Balancer ist ein Koordinator in einem Verteiltem System. Er leitet Requests von Clienten

An die Server Weiter und sendet entsprechende Replys.

Vorteile:

• Einfache Realisierung
• Fairness (wenn mit warteschlange)
• Anzahl der Nachrichten: 3 Nachrichten für Ressourcenzugang (Request, Reply, Release)

Nachteile:

• Koordinator ist Flaschenhals
• Zentraler Fehlerpunkt (Koordinator fällt aus)
• Unklare Ursache bei verzögertem Reply

Satus oder Werteveränderung durch zyklisches abfragen ermitteln.

Im Prinzip Polling mit geringerer frequenz, Falls der Server noch keine neuen Informationen für den Client

Besitzt wird allerdings keine leere Antwort gesendet. Der server behält den Request des Clients und sendet

Informationen sobalt er welche hat.

Es wird in einem seperaten Thread auf die Antwort des Servers gewartet. Die Callback Funktion ist die Funktion,

Die nach erhalt der Antwort (z.B. mit Antwort-Daten) ausgeführt wird.

Aufgaben einer Applikation werden in Schichten unterteilt. So können z.B. auch Aufgaben auf Server und Client verteilt werden.

Bezeichnet Middleware, die auf der asynchronen oder synchronen Übertragung von Nachrichten basiert

• Enterprise Service Bus: Verbindung von beliebigen Applikationen (Komponenten eines Verteilten Systems)
• Service Oriented Architecture: Architekturparadigma
• Enterprise Application Integration: Gesamtkonzept zur Integration von Einzelapplikationen oder Geschäftsfunktionen

SOA :  Übergeordnete Architektur

ESB  : Verbindung der Services

EAI   :   Integrationskonzept einzelner Applikationen in Architektur

Softwarearchitektur in dem das Zusammenspiel der Komponenten durch Ereignisse gesteuert wird

 class X extends Thread …

X thread = X();   x.start();

Oder

 class X implements Runnable …

X thread = X(); new Thread(thread).start();

TaskQueue -> nächster anstehender Task wird von freistehendem Thread aus Thread-Pool bearbeitet.

ThreadPoolExecutor fixedExecutor = (ThreadPoolExecutor) Executors.newFixedThreadPool(FIXEDSIZE);

ThreadPoolExecutor cachedExecutor = (ThreadPoolExecutor) Executors.newCachedThreadPool();

Thread t = new Thread();

 …Executor.execute(t);

Object monitor = new Object();

// thread 1

 synchronized(lock) {

while(bedingung) {

 lock.notify(); lock.wait();

}

}

// thread 2

 bedingung = true;

 synchronized(lock) {

 lock.notify();

}

try {

    Thread.sleep(1000);

} catch (InterruptedException e) {}

Ergebnis der beiden Threads hängt von Verteilung der CPU-Zeit auf Threads ab 

Verklemmung: Zwei Threads blockieren sich gegenseitig in dem sie auf eine Ressource warten die der jeweils anderen Threads reserviert hat.

z.B. Deadlock falsche Reihenfolge von wait(), notify()

Rechenleistung unfair/unzureichend verteilt für mindestens einen Thread. Dieser verhungert.

Repräsentation eines Objektes als Sequenz von Bytes

• Implements Serializable
• Oder Superklasse ist serialisierbar
• transient: Vorraussetzung Wert nach Deserialisierung unnötig oder wiederherstellbar

OutputStream oStream;

ObjectOutputStream myStream = new ObjectOutputStream (oStream);

myStream.writeObject(myObject);

InputStream iStream;

ObjectInputStream myStream = new ObjectInputStream (iStream);

MyClass myObject = (MyClass) myStream.readObject();

• Endpunkt einer Verbindung.
• Zwei Sockets definieren eine Verbindung.
• Speicherbereich für Konfigurationsparameter Ankommende und abgehende Daten
• Plattformunabhängig
• Eindeutige Definition durch IP-Adresse und Portnummer

Server                                                                        Client

socket() : New ServerSocket()                        

bind() : x  

                                                                                      socket() : new Socket()

listen() : x                                                                     connect() : socket.connect()

accept() : socket.accept()

read() : objectInputStream readObject                  write(): objectOutputStream.writeObject()

write(): ObjectOutputStream.writeObject()            read(): objectInputStream.readObject()

                                                                                       close()

Import java.net.*;

// ServerSocket

ServerSocket socket = new ServerSocket(port);

// ClientSocket

Socket socket = new Socket();

//Server

Socket socket = serverSocket.accept();

//client

 socket.connect(new InetSocketAddress(hostname,port));

objectInputStream=new ObjectInputStream(socket.getInputStream());

objectOutputStream=new ObjectOutputStream(socket.getOutputStream());

//schreiben

objectOutputStream.writeObject(new String("hey"));

//lesen

String received = (String) objectInputStream.readObject();

 socket.close(); // wirft IOException

• Implement Interface das von Remote erbt
• Funktionen müssen RemoteException werfen
• Rückgabetyp von Funktionen muss Serializable sein

Konvertierung der Daten für Transfer -> Serializing

• Klasse muss Serializable implementieren
• Nicht serialisierbare Membervariablen mit Keyword "transient" kennzeichnen

// code kann remote exception werfen

RemoteInterface remObj = new RemoteObject();

RemoteInterface remObjStub = (RemoteInterface) ;

java.rmi.server.UnicastRemoteObject.exportObject(remObj, 0); // port 0 : Laufzeit wählt portnummer

Registry registry=LocateRegistry.createRegistry(port);

registry.rebind("remObj", remObj);

// code kann remote exception werfen

String remotename = "remObj";

Registry registry = LocateRegistry.getRegistry("localhost", 8900);

rmi = (ClientListener) registry.lookup(remotename);

• Programmierschnittstelle zur Ansteuerung einer Message Oriented Middleware.
• Client kann JMS zum Senden und Empfangen von Nachrichten verwenden.
• Lose gekoppelte, verlässliche und asynchrone Kommunikation zwischen Komponenten verteilter Anwendung

• Unidirektional: Client A produziiert MSG -> QUEUE -> Client B konsumiert MSG und bestätigt
• Bidirektional: Unidirektional in beide Richtungen also 2 Queues
• Multidirektional: Client A produziiert MSG -> QUEUE -> ein Client X aus Menge von Clienten konsumiert MSG und bestätigt

• Entkopplung: Zeitlich und örtlich
• Persistenz: Nachrichten verbleiben bis zur Abholung in der Warteschlange
• Einmaliger Konsum: Nachricht nur einmalig abholbar
• Prioritäten für Nachrichten
• FIFO bei identischen Prioritäten (vgl. Pipe bei UNIX)

• Client produziert MSG und veröffentlicht mit Topic
• MSG wird über Message Broker  an alle Clienten versendet die Topic aboniert haben
• Neue Nachrichten überschreiben alte Nachrichten