RMI - Remote Method Invocation

Transkript

1 RMI - Remote Method Invocation JOHANNES KEPLER UNIVERSITY LINZ Research and teaching network Pratikum SWE 2 Institut für Systemsoftware, Johannes Kepler Universität Linz

2 RMI Motivation Grundarchitektur Implementierung von Remote-Objekten Parameterübergabe Callbacks Distributed Garbage Collection Verteilung und Nachladen von Code Pratikum SWE 2 Institut für Systemsoftware, Johannes Kepler Universität Linz 2

3 Motivation Methodenaufruf bei einer VM Objekte innerhalb einer JVM Methodenaufruf über VM Grenzen hinweg Objekte sind auf mehreren JVMs (Rechnern) verteilt Pratikum SWE 2 Institut für Systemsoftware, Johannes Kepler Universität Linz 3

4 Probleme bei Remote-Objekten Objektreferenzen: Was ist eine Remote-Referenz? Wie finde ich ein Objekt? Wie spreche ich Objekte an? Methodenaufruf: Wie wird die Sprungadresse für die Methode ermittelt? Parameterübergabe und Rückgabewerte: Wie werden Parameterwerte und Rückgabewerte verschickt? Objekterzeugung: Wie kann der Client ein Remote-Objekt erzeugen? Garbage Collection: Wann kann ein Objekt am Server frei gegeben werden? Laden der Klassen: Von wo wird die Klasse für ein vom Client benötigtes Objekt geladen? Pratikum SWE 2 Institut für Systemsoftware, Johannes Kepler Universität Linz 4

5 RMI Motivation Grundarchitektur Implementierung von Remote-Objekten Parameterübergabe Callbacks Distributed Garbage Collection Verteilung und Nachladen von Code Pratikum SWE 2 Institut für Systemsoftware, Johannes Kepler Universität Linz 5

6 Proxy-Pattern request() Client Interface: definiert eine allgemeine Schnittstelle, die Client sieht und Server implementieren muss Implementierung für den Server hat Interface entsprechend zu implementieren Proxy für den Client wird vom Client angesprochen implementiert die Schnittstelle, d.h. stellt sich dar wie ein wirkliches Objekt delegiert alle Requests an die wirkliche Objektimplementierung Pratikum SWE 2 Institut für Systemsoftware, Johannes Kepler Universität Linz 6

7 Proxy-Pattern bei Remote-Objekten Proxy Stub stellt das Proxy-Objekt auf der Seite des Client dar Proxy leitet die Anforderungen über die VM-Grenzen an Server weiter Skeleton empfängt die Requests und baut eigentlichen Request an den Server auf Server bedient den Request Ergebnis wird an Skeleton zurückgegeben Ergebnis wird über Netzwerk an Stub weitergeleitet Stub gibt das Ergebnis an Client zurück Pratikum SWE 2 Institut für Systemsoftware, Johannes Kepler Universität Linz 7

8 Kommunikationsarchitektur Client und Server Stubs und Skeletons Remote Reference Layer Netzwerkverbindung Netzwerkverbindung zwischen JVMs immer über Network Layer des Host OS JVM JVM JVM JVM Pratikum SWE 2 Institut für Systemsoftware, Johannes Kepler Universität Linz 8

9 Kommunikationsarchitektur: Aufgaben der Schichten Client und Server sind die eigentlichen Anwendungsobjekte kommunizieren über virtuelle Kommunikation Stubs und Skeletons Stub (Achtung: ab Java 1.5 nicht mehr nötig; mittels Dynamic-Proxies gelöst) ist das Proxy-Objekt auf der Client-Seite und stellt sich wie Server-Objekt dar leitet Requests des Client an die unteren RMI-Services weiter Skeleton (Achtung: ab Java 1.2 nicht mehr nötig!!!) empfängt die Requests von unteren RMI-Services und setzt diese für Requests an Server-Objekt um Remote Reference Layer verwaltet die Remote-Referenzen (Klasse RemoteRef) der Server-Objekte RemoteRef bietet Methode invoke für Methodenaufrufe abzusetzen (wird von Stubs verwendet) dient zur Registrierung von Remote-Objekts Netzwerkverbindung eigentliche Netzwerkverbindung über TCP/IP stream-basierte Verbindung standardmäßig auf Port 1099 Kommunikationsprotokoll oberhalb TCP/IP (nicht standardisiert) Java Remote Method Protocol (JRMP) IIOP und weitere Pratikum SWE 2 Institut für Systemsoftware, Johannes Kepler Universität Linz 9

10 Objektregistrierung und Objektsuche RMI ermöglicht Registrierung von Remote-Objekten durch Server mit einer RMI-URL Aufsuchen von Remote-Objekten durch Client Dazu dienen RMI-Registrierungsprogramm rmiregistry RMI-Service Klassen Naming, Registry, LocateRegistry Pratikum SWE 2 Institut für Systemsoftware, Johannes Kepler Universität Linz 10

11 Objektregistrierung und Objektsuche: Vorgehen LocateRegistry: Zugriff auf Registry Service Registry: bind oder rebind ein Server-Objekt registriert. Es muss dabei ein eindeutiger Name für das Server-Objekt vergeben werden. try { Bank bank = new BankImpl(); Registry reg = LocateRegistry.createRegistry(1099); reg.bind("bank", bank);... default port 1099; andere möglich Das Server-Objekt wird dabei unter der RMI-URL mit eingetragen. rmi://<hostcomputer>:1099/bank Damit hat ein Client eine eindeutige URL, um auf ein Server-Objekt zuzugreifen; // Client try { Registry reg = LocateRegistry.getRegistry("<Hostcomputer>", 1099); Bank bank = (Bank) reg.lookup("bank"); Pratikum SWE 2 Institut für Systemsoftware, Johannes Kepler Universität Linz 11

12 RMI Motivation Grundarchitektur Implementierung von Remote-Objekten Parameterübergabe Callbacks Distributed Garbage Collection Verteilung und Nachladen von Code Pratikum SWE 2 Institut für Systemsoftware, Johannes Kepler Universität Linz 13

13 Realisierung eines Remote-Objekts Interfaces und Klassen Interface Spezifikation für Remote-Objekt muss java.rmi.remote erweitern definiert die sichtbaren Methoden des Remote-Objekts jede Methode muss eine RemoteException werfen Server-Objekt muss Interface implementieren muss an das RMI System exportiert werden Stub-Objekt (kann ab Java 1.5 durch Dynamic- Proxy ersetzt werden) wird mit rmic erzeugt implementiert Interface Skeleton-Objekt (nur bei Java 1.1 verwendet) wird mit rmic erzeugt erweitert Basisklasse java.rmi.server.skeleton ab Java 1.5 auch mittels Dynamic-Proxy Pratikum SWE 2 Institut für Systemsoftware, Johannes Kepler Universität Linz 14

14 Beispiel Bank-Server Im folgenden Beispiel wird anhand eines einfachen Bank-Servers die Realisierung eines Client-Server-Programms veranschaulicht Folgende Schritte sind dabei durchzuführen: Erstellen Starten Definition eines Interfaces für das Remote-Objekt Implementierung des Interfaces für den Server Generierung von Stub- und Skeleton-Klassen mit rmic (ab 1.5 nicht mehr nötig) Implementierung des Server-Programms, welches das Server-Objekt anlegt und beim RMI registriert Realisierung eines Client-Programms, welches auf das Server-Objekt zugreift und dieses verwendet Starten des rmiregistry (ab 1.5 nicht mehr nötig) Starten des Server-Programms Starten des Client-Programms Pratikum SWE 2 Institut für Systemsoftware, Johannes Kepler Universität Linz 15

15 Beispiel Bank-Server: Interface Bank Interface Bank definiert Methoden für Zugriffe auf Konten package bank.common; import java.rmi.remote; import java.rmi.remoteexception; public interface Bank extends Remote { public static final int PORT = 1099; public long getbalance(int account) throws RemoteException; RemoteExceptions für alle Remote-Methods notwendig! public void deposit(int account, long amount) throws RemoteException; public void transfer(int from, int to, long amount) throws RemoteException; Pratikum SWE 2 Institut für Systemsoftware, Johannes Kepler Universität Linz 16

16 Beispiel Bank-Server: BankImpl Klasse BankImpl stellt eine entsprechende Implementierung von Bank bereit package bank.server; import java.rmi.remoteexception; import java.rmi.server.unicastremoteobject; import bank.common.bank; Constructor mit RemoteException! public class BankImpl extends UnicastRemoteObject implements Bank { private long[] accounts = new long[100]; protected BankImpl() throws RemoteException { super(); public synchronized long getbalance(int account) throws RemoteException { return accounts[account]; public synchronized void deposit(int account, long amount) throws RemoteException { accounts[account] += amount; public synchronized void transfer(int from, int to, long amount) throws RemoteException { accounts[from] -= amount; accounts[to] += amount; Pratikum SWE 2 Institut für Systemsoftware, Johannes Kepler Universität Linz 17

17 Beispiel Bank-Server: Stub und Skeleton Stub- und Skeleton-Klassen müssen nicht geschrieben werden Sie können durch das Programm rmic automatisch generiert werden rmic wird mit Server- Implementierungsklasse aufgerufen Microsoft Windows XP rmic <options> <class names> where <options> includes: -keep Do not delete intermediate generated source files -g Generate debugging info -depend Recompile out-of-date files recursively -nowarn Generate no warnings -verbose Output messages about what the compiler is doing -classpath <path> Specify where to find input source and class files -d <directory> Specify where to place generated class files -J<runtime flag> Pass argument to the java interpreter -v1.1 Create stubs/skeletons for JDK 1.1 stub protocol version -vcompat (default) Create stubs/skeletons compatible with both JDK 1.1 and Java 2 stub protocol versions -v1.2 Create stubs for Java 2 stub protocol version only > rmic keep BankImpl public final class BankImpl_Stub extends java.rmi.server.remotestub implements Bank, java.rmi.remote {... public final class BankImpl_Skel implements java.rmi.server.skeleton {... Achtung: kann ab Java 1.5 gänzlich entfallen! Pratikum SWE 2 Institut für Systemsoftware, Johannes Kepler Universität Linz 18

18 Beispiel Bank-Server: Server-Programm Server-Programm hat folgende Aufgaben: erzeugen des Server-Objekts exportieren des Server-Objekts an das RMI Registrieren des Server-Objekts unter einem RMI-URL mit Registry package bank.server; import java.rmi.registry.locateregistry; import java.rmi.registry.registry; import bank.common.bank; public class BankServer { public BankServer() { try { Bank bank = new BankImpl(); Registry reg = LocateRegistry.createRegistry(Bank.PORT); reg.bind("bank", bank); catch (Exception e) { System.out.println("Trouble: " + e); public static void main(string args[]) { new BankServer(); Pratikum SWE 2 Institut für Systemsoftware, Johannes Kepler Universität Linz 19

19 Beispiel Bank-Server: Client-Programm Client-Programm wird: sich über den Registry mit dem URL das Remote-Objekt holen das Remote-Objekt verwenden (dabei direkt den Stub aufrufen) eine Reihe von Exceptions abfangen package bank.client; import java.rmi.*; import bank.common.bank; public class BankClient { Name des Servers, z.b. "localhost" public static void main(string[] args) { try { Registry reg = LocateRegistry.getRegistry( Server Adr ", Bank.PORT); Bank bank = (Bank) reg.lookup("bank"); bank.deposit(1, 10000); bank.deposit(2, 20000); bank.transfer(1, 2, 3000); System.out.println(bank.getBalance(1)); System.out.println(bank.getBalance(2)); catch (Exception re) { Pratikum SWE 2 Institut für Systemsoftware, Johannes Kepler Universität Linz 20

20 Exportieren von Server-Objekten Server-Objekte müssen bei ihrer Erzeugung an das RMI exportiert (bekannt gemacht) werden Dies kann auf zwei Arten passieren Ableiten von Klasse UnicastRemoteObject (wie im letzten Beispiel) mit static-methode exportobject von Klasse UnicastRemoteObject static RemoteStub exportobject(remote obj) throws RemoteException static Remote exportobject(remote obj, int port) throws RemoteException Port 0 bedeutet, dass Port vom System gewählt wird. public class BankImpl implements Bank {... public class BankServer { public BankServer() { try { Bank bank = new BankImpl(); Registry reg = LocateRegistry.createRegistry(PORT); RemoteStub bstub = UnicastRemoteObject.export(bank); reg.bind("bank", bstub); catch (Exception e) { System.out.println("Trouble: " + e);... Pratikum SWE 2 Institut für Systemsoftware, Johannes Kepler Universität Linz 21

21 rmiregistry und Naming (alte Version) Starten des RMIRegistry-Programms Server: import java.rmi.registry.locateregistry; import java.rmi.registry.registry; public class BankServer { public BankServer() { try { Bank bank = new BankImpl(); Naming.rebind("rmi://localhost:1099/ Bank", bank);... Client: Microsoft Windows XP > rmiregistry public class BankClient { public static void main(string[] args) { try { Bank bank = (Bank) Naming.lookup( "rmi://localhost:1099/"bank");... Pratikum SWE 2 Institut für Systemsoftware, Johannes Kepler Universität Linz 22

22 RMI Exkurs: Dynamic Proxy Pratikum SWE 2 Institut für Systemsoftware, Johannes Kepler Universität Linz 24

23 Exkurs: Dynamic Proxy package java.lang.reflect dynamisch erzeugter Proxy implementiert Liste von Interfaces wird durch statischer Methode Proxy.newProxyInstance erzeugt public class Proxy { public static Object newproxyinstance(classloader loader, Class<?>[] interfaces, InvocationHandler h) throws IllegalArgumentException; Implementierte Interfaces InvocationHandler Anwendung: Foo f = (Foo)Proxy.newProxyInstance(null, new Class[] {Foo.class, handler); Erzeugtes Proxy-Objekt implementiert Interfaces, ruft aber InvocationHandler auf public interface InvocationHandler { Object invoke(object proxy, Method method, Object[] args) throws Throwable InvocationHandler soll Indirektion realisieren Reflection API Pratikum SWE 2 Institut für Systemsoftware, Johannes Kepler Universität Linz 25

24 Beispiel Dynamic Proxy: TraceHandler (1/2) TraceHandler realisiert InvocationHandler zuerst Trace-Ausgabe dann Aufruf der eigentlichen Methode class TraceHandler implements InvocationHandler { private Object target; private PrintStream tracelog; public TraceHandler(Object target, PrintStream tracelog) { this.target = target; this.tracelog = tracelog; public Object invoke(object proxy, Method m, Object[] args) throws Throwable { tracelog.print(target + "." + m.getname() + "("); if (args!= null) { for (int i = 0; i < args.length; i++) { tracelog.print(args[i]); if (i < args.length 1) tracelog.print(", "); tracelog.println(")"); return m.invoke(target, args); Ausgabe der Traceinfo Aufruf der eigentlichen Methode Pratikum SWE 2 Institut für Systemsoftware, Johannes Kepler Universität Linz 26

25 Beispiel Dynamic Proxy: TraceHandler (2/2) Test mit Proxy für Integer-Werte mit Trace der compareto-methode des Comparable-Interfaces public class ProxyTest { public static void main(string[] args) { Object[] elements = new Object[1000]; // fill elements with proxies for the integers for (int i = 0; i < elements.length; i++) { Integer value = i + 1; Class[] interfaces = value.getclass().getinterfaces(); InvocationHandler handler = new TraceHandler(value, System.out); Object proxy = Proxy.newProxyInstance(null, interfaces, handler); elements[i] = proxy; Integer key = 547; // search for the key int result = Arrays.binarySearch(elements, key); // print match if found if (result >= 0) System.out.println(elements[result]); { Comparable.class 500.compareTo(547) 750.compareTo(547) 625.compareTo(547) 562.compareTo(547) 531.compareTo(547) 546.compareTo(547) 554.compareTo(547) 550.compareTo(547) 548.compareTo(547) 547.compareTo(547) Pratikum SWE 2 Institut für Systemsoftware, Johannes Kepler Universität Linz 27

26 RMI Motivation Grundarchitektur Implementierung von Remote-Objekten Parameterübergabe Callbacks Distributed Garbage Collection Verteilung und Nachladen von Code Pratikum SWE 2 Institut für Systemsoftware, Johannes Kepler Universität Linz 28

27 Parameterübergabe und Rückgabewerte Bei RMI sind folgende Arten der Parameterübergabe und Rückgabewerte zu unterscheiden: Basisdatentypen (int, double, boolean, etc.) Werte werden über das Netzwerk übertragen Serialisierbare Objekte (implementieren Interface Serializable) Objekte werden serialisiert über das Netzwerk übertragen und auf der anderen Seite eine Kopie aufgebaut Remote-Objekte (implementieren Interface Remote) Es wird auf der empfangenden Seite ein Stub für das Objekt aufgebaut alle anderen (nicht serialisierbar, nicht Remote) diese können nicht als Parameter übergeben werden Pratikum SWE 2 Institut für Systemsoftware, Johannes Kepler Universität Linz 29

28 Basisdatentypen Auf Senderseite werden Werte gemarshaled und über das Netzwerk gesendet Auf der Empfängerseite werden die Werte wieder entpackt und an Client geliefert client server_stub server_skeleton server getvalue() getvalue() JVM 1 JVM 2 Pratikum SWE 2 Institut für Systemsoftware, Johannes Kepler Universität Linz 30

29 Serialisierbare Objekte Inhalt des Objekts wird über den Java-Serialisierungsmechanismus serialisiert und über das Netzwerk übertragen auf der Empfängerseite wird ein neues Objekt mit gleichem Inhalt aufgebaut Problem, wenn Klasse des serialisierten Objekts auf Empfängerseite nicht bekannt ist! siehe Nachladen von Code client server_stub server_skeleton server getlist() getlist() ArrayList (id = 37) ArrayList (id = 14) ArrrayList <1, 2, 3, > JVM 1 JVM 2 Pratikum SWE 2 Institut für Systemsoftware, Johannes Kepler Universität Linz 31

30 Remote-Objekte Es wird kein Wert übergeben sondern über das RMI-System wird eine Remote-Referenz auf das Server- Objekt übermittelt auf der Clientseite wird dafür ein Stub erzeugt und eine Referenz auf den Stub dem Empfänger übergeben client server_stub server_skeleton server getremotemember() getremotemember() create() remote_stub remote_stub remote remote Remote-Reference to remote JVM 1 JVM 2 Pratikum SWE 2 Institut für Systemsoftware, Johannes Kepler Universität Linz 32

31 Beispiel: Car und CarStore Remote-Interfaces Car und CarStore public interface Car extends Remote { public int getnr() throws RemoteException; public interface CarStore extends Remote { public Car getcar(int nr) throws RemoteException; public void returncar(car car) throws RemoteException; Implementierungen CarImpl und CarStoreImpl public class CarImpl extends UnicastRemoteObject implements Car { private final int nr; protected CarImpl(int nr) throws RemoteException { this.nr = nr; public int getnr() throws RemoteException { return nr; public class CarStoreImpl extends UnicastRemoteObject implements CarStore { private final Car[] cars; public CarStoreImpl() throws RemoteException {... public synchronized Car getcar(int nr) throws RemoteException { return cars[nr]; public synchronized void returncar(car car) throws RemoteException {... Pratikum SWE 2 Institut für Systemsoftware, Johannes Kepler Universität Linz 33

32 Beispiel: Car und CarStore CarStoreServer Applikation public class CarStoreServer { private static CarStore store; public static void main(string[] args) throws Exception { store = new CarStoreImpl(); store.cars[0] = new CarImpl(0); store.cars[1] = new CarImpl(1); store.cars[2] = new CarImpl(2); Registry reg = LocateRegistry.createRegistry(Registry.REGISTRY_PORT); reg.bind("carstore", store); CarStoreClient public class CarStoreClient { public static void main(string[] args) { try { Registry reg = LocateRegistry.getRegistry(Registry.REGISTRY_PORT); CarStore cs = (CarStore) reg.lookup("carstore"); Car c1a = cs.getcar(1);... Remote-Objekt catch (Exception e) {... Pratikum SWE 2 Institut für Systemsoftware, Johannes Kepler Universität Linz 34

33 == und equals bei Remote-Referenzen (1/2) == bei Remote-Referenzen bei jedem Remote-Zugriff werden neue Stub-Objekte angelegt Objekte sind nicht == public class CarStoreClient { public static void main(string[] args) { try {... Car c1a = cs.getcar(1); Car c1b = cs.getcar(1); false!!! equals if (c1a == c1b)... Stub implementiert equals entsprechend Objekte sind equals, wenn selbes Server-Objekt public class CarStoreClient { public static void main(string[] args) { try {... Car c1a = cs.getcar(1); Car c1b = cs.getcar(1); true!!! if (c1a.equals(c1b))... Pratikum SWE 2 Institut für Systemsoftware, Johannes Kepler Universität Linz 35

34 == und equals bei Remote-Referenzen (2/2) Car implementiert equals public class CarImpl extends UnicastRemoteObject implements Car {... public synchronized boolean equals(object obj) { if (obj instanceof CarImpl) { return nr == ((CarImpl) obj).nr; return false; Server CarStore erzeugt immer neue CarImpl-Objekte public class CarStoreImpl extends UnicastRemoteObject implements CarStore{... public synchronized Car getcar(int nr) throws RemoteException { return new CarImpl(nr); Diese Objekte werden am Client nicht als equals erkannt public class Client { neue Car-Objekt mit new erzeugt public static void main(string[] args) throws RemoteException { Registry reg = LocateRegistry.getRegistry(2222); CarStore cs = (CarStore) reg.lookup("carstore"); Car c1a = cs.getcar(1); Car c1b = cs.getcar(1); if (c1a.equals(c1b)) false!!! Pratikum SWE 2 Institut für Systemsoftware, Johannes Kepler Universität Linz 36

35 Remote-Referenz als Parameter Remote-Referenz als Parameter von Remote-Methode Client ruft Remote-Methode mit Remote-Referenz auf am Server wird ein Stub für das Remote-Stub am Client erzeugt Verbindung zum ursprünglichen Remote-Objekt am Server nicht vorhanden!! Pratikum SWE 2 Institut für Systemsoftware, Johannes Kepler Universität Linz 37

36 Beispiel: Car und CarStore Client ruft returncar mit Remote-Referenz auf public class Client { public static void main(string[] args) throws RemoteException { Registry reg = LocateRegistry.getRegistry(2222); CarStore cs = (CarStore) reg.lookup("carstore"); Car c1a = cs.getcar(1); cs.returncar(c1a); Remote-Stub!! Am Server wird Stub aufgebaut public class CarStoreImpl extends UnicastRemoteObject implements CarStore { public synchronized Car getcar(int nr) throws RemoteException { return cars[nr]; public v synchronized oid returncar(car car) throws RemoteException { if (car.equals(cars[car.getnr()]))... Keine Remote-Stubs als Parameter übergeben! Besser mit IDs, etc. arbeiten! false!! Pratikum SWE 2 Institut für Systemsoftware, Johannes Kepler Universität Linz 38

37 Erweitertes Beispiel BankManager BankManager ist ein Remote-Objekt, das Zugriff auf Kunden (Customer) und Konten (Accounts) bietet Sowohl Account als auch Customer sind Remote-Objekte BankManager bietet den Einstiegspunkte und wird als einziges Objekt registiert Vom BankManager holt sich das Client-Programm die weiteren Remote- Objekte Pratikum SWE 2 Institut für Systemsoftware, Johannes Kepler Universität Linz 39

38 Beispiel BankManager: Remote Interfaces public interface Account extends Remote { public int getid() throws RemoteException; public BankManager getbankmanager() throws RemoteException; public Customer getcustomer() throws RemoteException; public long getbalance() throws RemoteException; public long withdraw(long amount) throws RemoteException; public void deposit(long diff) throws RemoteException; public interface Customer extends Remote { public BankManager getbankmanager() throws RemoteException; public String getname() throws RemoteException; public Account[] getaccounts() throws RemoteException; public interface BankManager extends Remote { public Customer getcustomer(string name) throws RemoteException; public Customer createcustomer(string name) throws RemoteException; public Account getaccount(int accountnumber) throws RemoteException; public Account createaccount(customer customer) throws RemoteException; public void transfer(int from, int to, long amount) throws RemoteException; Remote-Objekte Pratikum SWE 2 Institut für Systemsoftware, Johannes Kepler Universität Linz 40

39 Beispiel BankManager: BankManagerImpl BankManager verwaltet Mengen von Kunden und Konten BankManager erlaubt Zugriff auf Konto und Kunde public class BankManagerImpl extends UnicastRemoteObject implements BankManager { private static int id = 0; private final Map<Integer, Account> accounts; private final Map<String, CustomerImpl> customers; public BankManagerImpl() throws RemoteException { accounts = new HashMap<Integer, Account>(); customers = new HashMap<String, public synchronized Customer getcustomer(string name) throws RemoteException { return public synchronized Customer createcustomer(string name) throws RemoteException { CustomerImpl c = new CustomerImpl(name, this); customers.put(name, c); return customers.get(name);... Pratikum SWE 2 Institut für Systemsoftware, Johannes Kepler Universität Linz 41

40 Beispiel BankManager: BankManagerImpl BankManager verwaltet Mengen von Kunden und Konten BankManager erlaubt Zugriff auf Konto und public synchronized Account getaccount(int id) throws RemoteException { return public synchronized Account createaccount(customer c) throws RemoteException { id++; CustomerImpl customer = customers.get(c.getname()); Account a = new AccountImpl(id, this, customer); accounts.put(id, a); customer.accounts.add(a); return public synchronized void transfer(int from, int to, long amount) throws RemoteException { Account afrom = getaccount(from); Account ato = getaccount(to); afrom.withdraw(amount); ato.deposit(amount); Pratikum SWE 2 Institut für Systemsoftware, Johannes Kepler Universität Linz 42

41 Beispiel BankManager: CustomerImpl public class CustomerImpl extends UnicastRemoteObject implements Customer { private final String name; private final BankManager bank; final List<Account> accounts; protected CustomerImpl(String name, BankManager bank) throws RemoteException { super(); this.name = name; this.bank = bank; this.accounts = new public BankManager getbankmanager() throws RemoteException { return public String getname() throws RemoteException { return public synchronized Account[] getaccounts() throws RemoteException { return accounts.toarray(new Account[0]); Pratikum SWE 2 Institut für Systemsoftware, Johannes Kepler Universität Linz 43

42 Beispiel BankManager: AccountImpl public class AccountImpl extends UnicastRemoteObject implements Account { private final int id; private final BankManager bank; private final Customer customer; private long balance; public AccountImpl(int id, BankManager bank, Customer customer) throws RemoteException { super(); this.id = id; this.bank = bank; this.customer = customer; balance = 0L; listeners = new public int getid() throws RemoteException { return public synchronized BankManager getbankmanager() throws RemoteException { return public synchronized Customer getcustomer() throws RemoteException { return customer;... Pratikum SWE 2 Institut für Systemsoftware, Johannes Kepler Universität Linz 44

43 Beispiel BankManager: public synchronized long getbalance() throws RemoteException { return public synchronized long withdraw(long diff) throws RemoteException { synchronized (this) { balance = balance - diff; fireaccountchangedevent(); return public synchronized void deposit(long diff) throws RemoteException { synchronized (this) { balance = balance + diff; fireaccountchangedevent(); Pratikum SWE 2 Institut für Systemsoftware, Johannes Kepler Universität Linz 45

44 Beispiel BankManager: Server-Programm Server-Programm legt BankManager an und registriert diesen als einziges Objekt public class BankServer { private static BankManager bank; private static void start() throws Exception { bank = new BankManagerImpl(); Registry reg = LocateRegistry.createRegistry(Registry.REGISTRY_PORT); reg.bind("bank", bank); System.out.println("Server started on port " + Registry.REGISTRY_PORT); public static void main(string[] args) throws Exception { start(); BufferedReader in = new BufferedReader(new InputStreamReader(System.in)); do { System.out.println("Press x for exit."); while (!"x".equals(in.readline())); System.exit(0); Pratikum SWE 2 Institut für Systemsoftware, Johannes Kepler Universität Linz 46

45 Beipiel BankManager: Client-Programm Client-Programm holt sich BankManager greift damit auf Account-Objekte und Customer-Objekte zu public class BankClient { static final String serverip = "localhost"; static final int serverport = Registry.REGISTRY_PORT; static private BankManager bank; public static void main(string[] args) { try { Registry reg = LocateRegistry.getRegistry(serverIP, serverport); bank = (BankManager)reg.lookup("Bank"); Customer c1 = bank.createcustomer("hans"); Customer c2 = bank.createcustomer("franz"); Account a1 = bank.createaccount(c1); Account a2 = bank.createaccount(c2); Account a1 = c1.getaccounts()[0]; Account a2 = c2.getaccounts()[0]; a1.deposit(1000); a2.deposit(2000); bank.transfer(a1.getid(), a2.getid(), 100); catch (Exception exc) { exc.printstacktrace(); Pratikum SWE 2 Institut für Systemsoftware, Johannes Kepler Universität Linz 47

46 RMI Motivation Grundarchitektur Implementierung von Remote-Objekten Parameterübergabe Callbacks Distributed Garbage Collection Verteilung und Nachladen von Code Pratikum SWE 2 Institut für Systemsoftware, Johannes Kepler Universität Linz 48

47 Callbacks In machen Fällen ist es notwendig, dass der Server dem Client eine Meldung schickt. z.b. Benachrichtung über Änderungen In diesem Fall sind die Rolle von Client und Server zu vertauschen am Client muss ein Remote-Objekt existieren eine Remote-Referenz wird dem Server übergeben am Server wird ein Stub für das Remote-Client-Objekt angelegt Pratikum SWE 2 Institut für Systemsoftware, Johannes Kepler Universität Linz 49

48 Beispiel BankManager: Remote Change Notification Remote-Listener-Interface für Client public interface RemoteAccountListener extends Remote { public void accountchanged(remoteaccountevent e) throws RemoteException; Account wird um Remote-Methode addaccountlistener erweitert public interface Account extends Remote { public void addremoteaccountlistener(remoteaccountlistener l) throws RemoteException; public void removeremoteaccountlistener(remoteaccountlistener l) throws RemoteException; public class AccountImpl extends UnicastRemoteObject implements Account public void addaccountlistener(accountlistener l) throws RemoteException { synchronized (listeners) { public void removeaccountlistener(accountlistener l) throws RemoteException Pratikum SWE 2 Institut für Systemsoftware, Johannes Kepler Universität Linz 50

49 Beispiel BankManager: Remote Change Notification Der Client muss RemoteAccountListener implementieren und anmelden public class BankClient extends UnicastRemoteObject { public BankClient(BankManager bm) throws RemoteException { super(); this.bm = bm; // add client as account listener at the bank manager Account a = bm.getaccount(1); a.addremoteaccountlistener(accountwatcher); a.removeremoteaccountlistener(accoutwatcher); private AccountWatcher accountwatcher = new AccountWatcher(); private static class AccountWatcher extends UnicastRemoteObject implements AccountListener { public AccountWatcher() throws RemoteException { super(); public void accountchanged(accountchangedevent evt) throws RemoteException { ; Nicht vergessen: Abmelden am Ende! (siehe Distributed Garbage Collection) Pratikum SWE 2 Institut für Systemsoftware, Johannes Kepler Universität Linz 51