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 RMI und Threads 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 RMI und Threads 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 RMI und Threads 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 RMI und Threads 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 = new Car[3]; 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 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 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(string 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 BankManagerImpl instance; public synchronized static BankManager getinstance() { if (instance == null) { try { instance = new BankManagerImpl(); catch (RemoteException e) { return instance; private static int id = 0; private final Map<Integer, Account> accounts; private final Map<String, Customer> customers; private BankManagerImpl() throws RemoteException { accounts = new HashMap<Integer, Account>(); customers = new HashMap<String, public synchronized Customer getcustomer(string name) throws RemoteException { return customers.get(name);... Pratikum SWE 2 Institut für Systemsoftware, Johannes Kepler Universität Linz 41

40 Beispiel BankManager: public synchronized Customer createcustomer(string name) throws RemoteException { CustomerImpl c = new CustomerImpl(name, this); customers.put(name, c); return public synchronized Account getaccount(int id) throws RemoteException { return public synchronized Account createaccount(string customer) throws RemoteException { id++; Customer customer = customers.get(customer); 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; final List<Account> accounts; protected CustomerImpl(String name) throws RemoteException { super(); this.name = name; this.accounts = new 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 String customer; private long balance; public AccountImpl(int id, String customer) throws RemoteException { super(); this.id = id; this.customer = customer; balance = 0L; listeners = new public int getid() throws RemoteException { return public Customer getcustomer() throws RemoteException { return BankManager.getInstance().getCustomer(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 long withdraw(long diff) throws RemoteException { synchronized (this) { balance = balance - diff; fireaccountchangedevent(); return public 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 registriert BankManager als einziges Objekt public class BankServer { private static BankManager bank; private static void start() throws Exception { bank = BankManagerImpl.getInstance(); 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()[1]; 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 RMI und Threads 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 private void fireaccountchanged() { 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 { public BankClient(BankManager bm) { 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

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

51 RMI und Threads Jeder Request wird in eigenem Thread ausgeführt client 1 client 2 request1() Server Thread request2() request3() Synchronisation notwendig Synchronisation der Zugriffe von mehreren Clients Pratikum SWE 2 Institut für Systemsoftware, Johannes Kepler Universität Linz 53

52 Synchronisation Z.B. durch Synchronisation der Remote Methods public class BankManagerImpl extends UnicastRemoteObject implements BankManager public synchronized Customer getcustomer(string name) throws RemoteException { return public synchronized Customer createcustomer(string name) throws RemoteException public synchronized Account getaccount(int id) throws RemoteException public synchronized Account createaccount(string c) throws RemoteException {... Pratikum SWE 2 Institut für Systemsoftware, Johannes Kepler Universität Linz 54

53 Probleme: Lang laufenden Methoden Lang laufender synchronisierter Code blockiert alle Client- Requests public class BankManagerImpl extends UnicastRemoteObject implements BankManager {... public synchronized void makeannualbalance() { // long lasting activity... Lang laufender Prozess blockiert alle Client-Requests Lösung: lang-laufende Request durch den Client im eigenem Thread asynchron ausführen! Pratikum SWE 2 Institut für Systemsoftware, Johannes Kepler Universität Linz 55

54 Probleme: Reentrancy Java Locks sind reentrant d.h. ein Thread, der den Lock auf ein Objekt hat, kann Code der auf gleiches Objekt gelockt ist trotzdem ausführen public class BankManagerImpl extends UnicastRemoteObject implements BankManager public synchronized void transfer(int from, int to, long amount) throws RemoteException { Account afrom = getaccount(from); Account ato = getaccount(to); Mit Lock auf BankManagerImpl Mit Lock auf BankManagerImpl public synchronized Account getaccount(int id) throws RemoteException { Pratikum SWE 2 Institut für Systemsoftware, Johannes Kepler Universität Linz 56

55 Probleme: Reentrancy Werden Methoden aber Remote mit Zyklus über Client (Callback) ausgeführt, gilt das nicht mehr, weil unterschiedliche Threads client 1 Server callback() request1() request2() synchronized(this) synchronized(this) Blockiert synchron bis Callback zurückkehrt Deadlock, weil unterschiedliche Threads Pratikum SWE 2 Institut für Systemsoftware, Johannes Kepler Universität Linz 57

56 Probleme: Reentrancy Beispiel public class BankClient extends UnicastRemoteObject { private static class AccountWatcher extends UnicastRemoteObject implements AccountListener { public void accountchanged(accountchangedevent evt) throws RemoteException { bankmanager.getaccount()... ; public class BankManagerImpl extends UnicastRemoteObject... Thread public synchronized void transfer(int from, int to, long am Account afrom = getaccount(from); Account ato = getaccount(to); ato.fireaccountchanged(); Thread public synchronized Account getaccount(int id) throws Remot Pratikum SWE 2 Institut für Systemsoftware, Johannes Kepler Universität Linz 58

57 Probleme: Reentrancy Lösung: Asynchrone Callbacks Callbacks asynchron ausgeführt erlaubt, dass Server-Methode zu Ende läuft public class AccountImpl extends UnicastRemoteObject implements Account { private final ExecutorService executor = public void deposit(long diff) throws RemoteException { synchronized (this) { balance = balance + diff; fireaccountchangedevent(); Methode wartet damit nicht mehr, dass Callbacks zurückkehren private void fireaccountchanged() { final AccountChangedEvent evt = new AccoutChangedEvent( ); for (final AccountListener l : listeners) { executor.submit(() -> { l.accountchanged(evt); ); Erzeugen und absetzen von asynchronen Callbacks Pratikum SWE 2 Institut für Systemsoftware, Johannes Kepler Universität Linz 59

58 Probleme: Reentrancy Lösung: Asynchrone Callbacks client Server request1() callback() request2() synchronized(this) synchronized(this) Asynchron, nicht blockierend nicht synchronized(this) Pratikum SWE 2 Institut für Systemsoftware, Johannes Kepler Universität Linz 60

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

60 Distributed Garbage Collection Garbage Collector gibt Objekte frei, wenn sie nicht mehr referenziert werden Bei Remote-Objekten ist es dem Garbage Collector aber nicht möglich zu entscheiden, ob Remote-Clients das Objekt noch referenzieren Distributed Garbage Collector arbeitet mit: Reference Counting: Es werden die Zugriffe von Remote-Clients auf die Remote-Objekte gezählt Lease Time: Greift ein Client eine bestimmte Zeit der Lease Time nicht auf das Remote-Objekt zu, wird angenommen, dass der Client das Objekt nicht mehr benötigt. Konsequenz: Beim Client ist es möglich, dass Remote-Objekte verschwinden und er mit ungültigen Remote-Referenzen umgehen können muss. Lease Time: System Property java.rmi.dgc.leasevalue Standardwert 10 min Einstellung als Option bei java: java Djava.rmi.dgc.leaseValue=20000 Pratikum SWE 2 Institut für Systemsoftware, Johannes Kepler Universität Linz 62

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

62 Verteilung und Nachladen von Klassen Bei Zugriff auf Remote-Objekte ist es nötig, dass Code vom Server nachgeladen wird für Stubs für Parameter und Rückgabewerte Beispiel: Stub Pratikum SWE 2 Institut für Systemsoftware, Johannes Kepler Universität Linz 64

63 Motivation Nachladen von Klassen public interface BankManager extends Remote { public Customer getcustomer(string customername) throws RemoteException; PrivateCustomer Customer BusinessCustomer Es existieren Spezialisierungen von Customer! Diese sind Client eventuell nicht bekannt! public class BankManagerImpl extends UnicastRemoteObject implements BankManager { public synchronized Customer getcustomer(string customername) throws RemoteException { if ( ) return privateclients.get(customername); else return businessclients.get(customername); Client: Müsste alle Spezialisierungen von Customer kennen Konretes Objekt vom Typ PrivateCustomer_Stub oder BusinessCustomer_Stub try { Customer customer = account.getcustomer(name); catch (RemoteException remoteexception) { System.err.println(remoteException); Pratikum SWE 2 Institut für Systemsoftware, Johannes Kepler Universität Linz 65

64 Nachladen von Code Um Code von einer externen Site nachladen zu können, ist folgendes zu tun es muss beim Client ein RMISecurityManager installiert sein (sonst kann kein externer Code geladen werden) Es müssen Permissions für den Client gesetzt werden: Socketverbindung zum Server für RMI über Port 1099 Socketverbindung zum Nachladen von Code hier über Webserver, d.h. Port 80 (oder 8080) Beispiel: Clientprogramm: public class MyClient { public static void main(string[] args) { System.setSecurityManager(new RMISecurityManager()); System.setProperty("java.security.policy", "client.policy");... Policy-Datei für Client: grant { permission java.net.socketpermission server-url: , connect ; permission java.net.socketpermission server-url:80, connect ; permission java.net.socketpermission server-url:8080, connect ; Pratikum SWE 2 Institut für Systemsoftware, Johannes Kepler Universität Linz 66

65 Verteilung des Klassencodes Die Klassen sollen zur Verteilung auf 3 Teile aufgeteilt werden: server: alle Klassendateien, die für die Ausführung des Servers erforderlich sind alle Stub-Klassen download: alle Klassendateien, die dynamisch vom Client nachgeladen werden sollen inklusive alle abhängigen (z.b. Basisklassen und Interfaces) client: alle Klassendateien, die unmittelbar vom Client verwendet werden die Policy-Datei (z.b. client.policy) Die 3 Teile werden dann folgend verteilt: server: auf dem Rechner des Servers download: bei Verwendung eines Webservers ins download-verzeichnis des Webserver client: auf den Rechern des Client Pratikum SWE 2 Institut für Systemsoftware, Johannes Kepler Universität Linz 67

66 Starten der verteilten Programme Am Server Starten des RMIRegistry-Programms (oder Verwendung von Registry-Klasse) Microsoft Windows XP > rmiregistry Starten des Server-Programms mit Angabe des Download-Verzeichnisses als Codebase > java Djava.rmi.server.codebase= MyServerApp Am Client Starten des Client-Programms, hier zusätzlich unter Angabe einer Policy-Datei > java Djava.security.policy=client.policy MyClientApp Pratikum SWE 2 Institut für Systemsoftware, Johannes Kepler Universität Linz 68

67 Literatur Horstmann, Cornell, Core Java 2, Band 2 Expertenwissen, Markt und Technik, 2002: Kapitel 5 Krüger, Handbuch der Java-Programmierung, 3. Auflage, Addison-Wesley, 2003, Kapitel 46 Fundamentals of RMI, Short Course, Pratikum SWE 2 Institut für Systemsoftware, Johannes Kepler Universität Linz 69