invocazione remota ottobre Fonti [CDK/4e] Chapter 5, Distributed Objects and Remote Invocation [Liu] Chapter 8, Advanced RMI

Transcript

1 Luca Cabibbo Architetture Software Oggetti distribuiti e invocazione remota Dispensa MW 3 ottobre Fonti [CDK/4e] Chapter 5, Distributed Objects and Remote Invocation [Liu] Chapter 7, Distributed Objects [Liu] Chapter 8, Advanced RMI The Java Tutorial RMI 2

2 Obiettivi - Obiettivi e argomenti comprendere alcuni aspetti fondamentali della programmazione ad oggetti distribuiti introdurre Java RMI Argomenti premessa: chiamata di procedure remote oggetti distribuiti Java RMI confronto tra RMI e socket ulteriori aspetti callback 3 * Chiamata di procedure remote I sistemi distribuiti sono stati inizialmente programmati sulla base di meccanismi di programmazione ad hoc in particolare, la comunicazione i interprocesso basata su socket si tratta di strumenti di basso livello difficili da usare il programmatore deve tenere in considerazione tutti gli aspetti della distribuzione ad es., gestione delle connessioni e dei fallimenti comunicazione orientata, in modo generico, allo scambio di dati/messaggi Successivamente, la programmazione dei sistemi distribuiti è stata supportata da strumenti per la comunicazione strutturata in particolare, la chiamata di procedure remote RPC viene alzato il livello di astrazione orientato alle azioni, ovvero all invocazione di sottoprogrammi 4

3 Esempio: RPC RPC (Remote Procedure Call) Remote Procedure Call (RPC) is a technology that allows a computer program to cause a subroutine or procedure to execute in another address space (commonly on another computer) without the programmer explicitly coding the details for this remote interaction [en.wikipedia.org] 5 Chiamata di procedure (locale) process A call procy(arg1, arg2) procy procx return value 6

4 Paradigma dell RPC process A process B call procy(arg1, arg2) procy procx return value 7 Paradigma dell RPC La procedura remota procy viene chiamata (sintatticamente) da procx come se fosse una chiamata locale in realtà, la procedura procy vive in un processo diverso da quello di procx in prima approssimazione, la modalità di esecuzione è basata su legame dei parametri esecuzione della procedura chiamata restituzione del risultato 8

5 Realizzazione di RPC procx stub skeleton procy call procy(...) marshalling send request unmarshalling return value call procy(...) return value marshalling send replay unmarshalling local proc. call call procy(...) execute return value 9 Realizzazione di RPC stub La comunicazione tra le procedure procx e procy viene realizzata sulla base di due moduli intermediari che si occupano degli aspetti della distribuzione ib i il chiamante procx fa una chiamata locale ad una procedura locale (anch essa di nome procy) ad un modulo (stub) cheè un rappresentante locale della vera procedura procy del server remoto lo stub si occupa di effettuare la chiamata remota alla procedura remota procy effettua il marshalling dei parametri invia un messaggio di richiesta al server tramite socket inoltre lo stub riceve il messaggio di risposta alla chiamata remota effettua l unmarshalling dei risultati restituisce questi risultati alla procedura chiamante procx 10

6 Realizzazione di RPC skeleton In realtà, il messaggio inviato dallo stub non viene ricevuto direttamente dalla procedura remota procy piuttosto, il messaggio di richiesta viene ricevuto da un modulo (skeleton) che è un rappresentante locale (lato server) della procedura chiamante lo skeleton si occupa di effettuare la chiamata alla procedura (per lui locale) procy effettua l unmarshalling della richiesta e dei parametri effettua la chiamata locale alla procedura procy e riceve i risultati della chiamata effettua il marshalling dei risultati invia i un messaggio di risposta al client tramite socket 11 Discussione Lo stub e lo skeleton sono intermediari nella comunicazione chiamati anche proxy proxy lato client e proxy lato server proxy è un design pattern un intermediario, rappresentante di un altro oggetto, di cui ha la stessa interfaccia i un proxy [GoF] fornisce un surrogato o un segnaposto per un altro oggetto per controllarne l accesso l uso dello stub e dello skeleton nascondono al programmatore il fatto che la comunicazione sia distribuita i proxy si occupano dei dettagli della comunicazione distribuita nella tecnologia RPC (e successive) stub e skeleton vengono generati automaticamente sulla base dell interfaccia del modulo server tramite un compilatore d interfacce 12

7 Discussione Uso (pragmatico) di RPC scrivo l interfaccia del server quali operazioni? quali i tipi usati per i parametri ed i valori restituiti? un compilatore d interfacce produce del codice lato client (stub) e del codice lato server (skeleton) per le varie procedure questo codice deve essere completato il client dovrà fare le sue chiamate di procedure allo stub nello skeleton in opportuni segnaposti vanno scritte le chiamate alla procedure effettive il programma server va mandato in esecuzione sul server ed il servizio deve essere registrato presso il sistema operativo 13 * Oggetti distribuiti I modelli a oggetti distribuiti fornisco un astrazione di programmazione distribuita orientata agli oggetti una collezione di oggetti distribuiti gli oggetti possono risiedere in processi diversi ciascun oggetto può offrire servizi pubblici tramite un interfaccia incapsulare uno stato privato gli oggetti cooperano mediante l invocazione di metodi RMI Remote Method Invocation un sistema RMI consente agli oggetti di un processo di invocare metodi di oggetti di altri processi evoluzione orientata agli oggetti di RPC esiste anche un accezione specifica Java RMI 14

8 - Modello a oggetti Ciascun oggetto incapsula stato e comportamento Gli oggetti solitamente risiedono in un singolo processo Ciascun oggetto implementa un interfaccia (definita implicitamente o esplicitamente) it t specifica dei metodi che possono essere invocati Un oggetto può essere usato conoscendone il riferimento univoco ad es., usato in un invocazione come destinatario 15 - Modello a oggetti distribuiti Ciascun oggetto incapsula stato e comportamento Oggetti locali e oggetti remoti gli oggetti locali sono visibili localmente ad un processo gli oggetti remoti possono essere distribuiti in più calcolatori/processi Ciascun oggetto remoto implementa un interfaccia remota (definita esplicitamente) specifica dei metodi che possono essere invocati remotamente Un oggetto remoto può essere usato conoscendone il riferimento remoto univoco ad es., usato in un invocazione remota come destinatario 16

9 Oggetti e metodi remoti e locali process A remote invocation B local C invocation local E invocation local invocation D remote invocation F host 17 Oggetto remoto e sue interfacce remoteobject Data remote interface m1 m2 implementation m4 m5 { m6 m3 of methods local interface 18

10 - Architettura per RMI object registry client object client proxy runtime support network support server object server proxy runtime support network support logical data path physical data path 19 RMI Un processo (server) può esportare un oggetto distribuito gli oggetti distribuiti sono caratterizzati da un interfaccia remota e identificati da un riferimento remoto Gli oggetti distribuiti sono registrati presso un object registry servizio distribuito che gestisce le corrispondenze tra identificatori simbolici e riferimenti remoti Un processo (client) può consultare l object registry per ottenere un riferimento remoto ad un oggetto distribuito in realtà ottiene un client proxy che fornisce il supporto runtime che consente al client di interagire con l oggetto remoto 20

11 * Java RMI Java Remote Method Invocation (Java RMI) consente ad un oggetto in esecuzione in una macchina virtuale Java di invocare metodi di oggetti in esecuzione in altre macchine virtuali Java Java RMI fornisce un meccanismo per la comunicazione remota tra programmi Java Java RMI viene mostrato a partire da un semplice esempio un oggetto Hello che sa calcolare l un saluto personalizzato 21 - Interfaccia remota import java.rmi.*; public interface HelloInterface extends Remote { public String sayhello(string name) throws RemoteException; Un oggetto è considerato distribuito se implementa un interfaccia remota l interfaccia Remote èun interfaccia marker non dichiara metodi i metodi remoti devono sollevare RemoteException 22

12 -Servente import java.rmi.*; import java.rmi.server.*; public class HelloImpl extends UnicastRemoteObject implements HelloInterface { public HelloImpl() throws RemoteException { super(); public String sayhello(string name) throws RemoteException { return "Hello, " + name + "!"; Un servente (servant) è un istanza di una classe che implementa un interfaccia remota deve estendere UnicastRemoteObject 23 -Server Il server per un oggetto distribuito è un oggetto o applicazione che istanzia l oggetto remoto servente registra il servente presso l object registry 24

13 Server import java.rmi.*; import java.rmi.server.*; public class HelloServer { public static void main(string[] args) { try { System.out.println("### Creating and Binding Hello"); HelloImpl exportedobj = new HelloImpl(); String registryurl = "rmi://localhost/hello"; Naming.rebind(registryUrl, exportedobj); System.out.println("### Hello bound"); catch (Exception e) { System.err.println("### HelloServer exception: " + e.getmessage()); // e.printstacktrace(); 25 - Client Un client che vuole usare un oggetto distribuito deve cercare ed ottenere un riferimento remoto dall object registry in realtà ottiene un proxy all oggetto distribuito usare l oggetto distribuito tramite il proxy 26

14 Client import java.rmi.*; 27 public class HelloClient { public static void main(string args[]) { try { String registryurl ="rmi://localhost/hello"; HelloInterface hello = (HelloInterface) Naming.lookup(registryUrl); /* in realtà hello èunproxy al servente registrato */ System.out.println("### Lookup complete"); String message = hello.sayhello("luca"); System.out.println("### t tl HelloClient: "+ message); catch (Exception e) { System.err.println("### HelloClient exception: " + e.getmessage()); // e.printstacktrace(); Java RMI, in pratica (1) Compilazione ed esecuzione di un applicazione Java RMI sono diverse rispetto a quella di un applicazione Java qui illustrato con riferimento alla piattaforma Windows Compilazione lato server javac HelloInterface.java compila l interfaccia javac HelloImpl.java compila il servente rmic HelloImpl genera il proxy HelloImpl_Stub.class lato client javac HelloServer.java compila il server 28

15 Java RMI, in pratica (2) Copia dal lato server al lato client dei seguenti file HelloInterface.class HelloImpl_Stub.class Compilazione lato client javac HelloClient.java 29 Java RMI, in pratica (3) Avvio dell RMI registry sull host incaricato, con i file del server cd nella cartella con i file del server set CLASSPATH= start rmiregistry Avvio del server java HelloServer Avvio del client java HelloClient 30

16 Architettura di Java RMI Directory service supports the interface with the application program object client object server maps the platform-independent stub/skeleton layer to the platform-dependent transport layer; carries out remote reference protocols sets up, maintains, and shuts down connections; and carries out the transport protocol stub remote reference layer transport layer skeleton remote reference layer transport layer logical data path physical data path 31 Interazione tra client e server time stub skeleton marshal parameters; send Request unmarshal parameters Invoke method unmarshall reply; return value receive return value marshal reply send reply Remote Method execute code and return a value (based on 32

17 - Implementazione di RMI L implementazione di RMI richiede diversi oggetti e moduli object A client proxy for B Request server skeleton & dispatcher for B s class remote object B Reply Remote Communication reference module module Communication module Remote reference module alcuni sono moduli standard altri sono generati automaticamente da rmic 33 Implementazione di RMI (1) Modulo di comunicazione il protocollo richiesta-risposta viene eseguito da una coppia di moduli di comunicazione cooperanti trasmettono messaggi richiesta e risposta responsabili per fornire una semantica per l invocazione i di metodi remoti ad es., at most once Modulo dei riferimenti remoti responsabile delle corrispondenze tra riferimenti locali e remoti e della creazione di riferimenti remoti tavola degli oggetti remoti elenco degli oggetti remoti offerti elenco dei proxy conosciuti 34

18 Proxy Implementazione di RMI (2) rappresentante locale di un oggetto remoto tramite il proxy, l oggetto client comunica logicamente con l oggetto server implementa l interfaccia i remota per adattare e inoltrare le richieste all oggetto remoto e gestire le sue risposte ha lo scopo di nascondere gli aspetti della comunicazione fisica ad es., la posizione dell oggetto server (viene visto dal client mediante il proxy), marshalling dei dati e unmarshalling dei risultati, invio e ricezione di messaggi 35 Implementazione di RMI (3) Dispatcher il server ha un dispatcher per ogni classe di oggetto remoto il dispatcher riceve messaggi richiesta dal modulo di comunicazione seleziona l operazione da eseguire ne delega la gestione allo skeleton 36

19 Skeleton Implementazione di RMI (4) proxy del client nel lato server il server ha uno skeleton per ogni classe di oggetto remoto implementa metodi corrispondenti a quelli dell interfaccia remota ha lo scopo di estrarre i parametri dal messaggio richiesta e invocare il metodo corrispondente nell oggetto remoto aspetta l esecuzione del metodo, quindi costruisce il messaggio risposta dal suo risultato Nella versione attuale di Java RMI viene utilizzato un componente dispatcher/skeleton generico per tutte le classi di oggetti remoto basato su meccanismi di riflessione 37 Implementazione di RMI (5) Compilatore di interfacce responsabile della generazione delle classi per i proxy eventualmente anche di dispatcher e skeleton queste classi vengono generate automaticamente a partire dall interfaccia remota Binder consente di ottenere riferimenti a oggetti remoti gestisce una corrispondenza tra nomi simbolici (stringhe) e riferimenti remoti 38

20 * Confronto tra RMI e socket Alcune differenze distintive di RMI e socket le socket lavorano più vicine al sistema operativo l overhead a runtime è minore RMI richiede del software di supporto addizionale RMI richiede un certo overhead a runtime l astrazione offerta da RMI facilita lo sviluppo del software programmi più facili da comprendere, mantenere e verificare le socket sono indipendenti dal linguaggio e dalla piattaforma Java RMI è chiaramente dipendente dal linguaggio ma è indipendente dalla piattaforma altre implementazione di RMI indipendenti dal linguaggio gg ad es., CORBA 39 * Ulteriori aspetti Vengono ora discussi ulteriori aspetti relativi a Java RMI 40

21 - Semantica dell invocazione remota (1) Le operazioni del protocollo richiesta-risposta possono essere implementate in modi diversi ripetizione del messaggio di richiesta lato client fino a quando non arriva una risposta filtraggio di richieste duplicate lato server tenendo una storia delle richieste ritrasmissione di risultati lato server tenendo una storia delle richieste-risposte 41 Semantica dell invocazione remota (2) Combinazioni di scelte diverse forniscono diverse semantiche per l invocazione di metodi remoti maybe non ripetere richieste l operazione potrebbe venire eseguita o meno è un opzione per Corba at least once ritrasmetti richieste, non filtrare duplicati, riesegui procedura l operazione viene eseguita almeno una volta potrebbe venire eseguita più volte at most once ritrasmetti richieste, filtra duplicati, ritrasmetti risposta l operazione viene eseguita al massimo una volta potrebbe non venire mai eseguita è il default per Java RMI e Corba La semantica dell invocazione di metodi locali è exactly once 42

22 - Concorrenza Le esecuzioni dei metodi remoti avvengono in modo concorrente uno stesso oggetto distribuito può essere condiviso da più client ciascuna invocazione remota viene eseguita nell ambito di un thread (lato server) separato dunque è possibile che uno stesso oggetto sia incaricato dell esecuzione esecuzione concorrente di più metodi possibilità di dichiarare synchronized un metodo remoto i metodi sincronizzati di uno stesso oggetti vengono eseguiti in modo mutuamente esclusivo da thread separati bisogna gestire in modo opportuno lo stato di oggetti condivisi 43 - Gestione dello stato Un oggetto servente registrato presso l object registry è condiviso da tutti i suoi client quindi può mantenere informazioni di stato condivise da tutti i client 44

23 Esempio: Counter (1) import java.rmi.*; public interface CounterInterface extends Remote { public int getcounter() throws RemoteException; 45 Esempio: Counter (2) import java.rmi.*; import java.rmi.server.*; public class CounterImpl extends UnicastRemoteObject implements CounterInterface { private int counter; public CounterImpl() throws RemoteException { super(); counter = 0; public synchronized int getcounter() throws RemoteException { counter++; return counter; 46

24 Esempio: Counter (3) import java.rmi.*; import java.rmi.server.*; public class CounterServer { public static void main(string[] args) { try { System.out.println("### Binding Counter"); CounterImpl exportedobj = new CounterImpl(); p() String registryurl = "rmi://localhost/counter"; Naming.rebind(registryUrl, exportedobj); System.out.println("### Counter bound"); catch (Exception e) { System.err.println("### CounterServer exception: " + e.getmessage()); // e.printstacktrace(); 47 Esempio: Counter (4) import java.rmi.*; public class CounterClient { public static void main(string args[]) { try { String registryurl ="rmi://localhost/counter"; CounterInterface counter = (CounterInterface) Naming.lookup(registryUrl); for (int i=0; i<10; i++) { int result = counter.getcounter(); System.out.println("### CounterClient: " + result);... introduci un ritardo... catch (Exception e) { System.err.println("### CounterClient exception: " + e.getmessage()); ciascuna esecuzione concorrente ottiene numeri diversi sia se eseguita da uno stesso host che da un diverso host 48

25 - Stato della sessione Un possibile modo (è comune, ma non è l unico!) per gestire lo stato di ciascuna sessione indipendentemente da quello delle altre sessioni i viene condiviso un oggetto distribuito che è una factory la factory fornisce un operazione per creare, ogni volta, un nuovo servente remoto il client userà l object registry per accedere alla factory per prima cosa, chiederà alla factory di creargli un servente dedicato alla sua sessione successivamente, comunicherà solo con il servente a lui dedicato ciascun servente remoto è dunque legato strettamente al suo client, e può mantenere informazioni di stato della sessione 49 Esempio: SessionCounter (1) import java.rmi.*; public interface SessionCounterInterface extends Remote { public int getcounter() throws RemoteException; 50

26 Esempio: SessionCounter (2) import java.rmi.*; import java.rmi.server.*; public class SessionCounterImpl extends UnicastRemoteObject implements SessionCounterInterface { private int counter; public SessionCounterImpl() throws RemoteException { super(); counter = 0; public int getcounter() throws RemoteException { counter++; return counter; 51 Esempio: SessionCounter (3) import java.rmi.*; public interface SessionCounterFactoryInterface extends Remote { public SessionCounterInterface getsessioncounter() throws RemoteException; 52

27 Esempio: SessionCounter (4) import java.rmi.*; import java.rmi.server.*; public class SessionCounterFactoryImpl extends UnicastRemoteObject implements SessionCounterFactoryInterface { public SessionCounterFactoryImpl() throws RemoteException { super(); public synchronized SessionCounterInterface getsessioncounter() throws RemoteException { return new SessionCounterImpl(); /* essendo un oggetto remoto, restituisce un riferimento remoto */ 53 Esempio: SessionCounter (5) import java.rmi.*; import java.rmi.server.*; public class SessionCounterServer { public static void main(string[] args) { try { System.out.println("### Creating and binding SessionCounterFactory"); SessionCounterFactoryImpl factory = new SessionCounterFactoryImpl(); String registryurl = "rmi://localhost/sessioncounterfactory"; Naming.rebind(registryUrl, factory); System.out.println("### SessionCounterFactory bound"); catch (Exception e) { System.err.println("### SessionCounterServer exception: " + e.getmessage()); // e.printstacktrace(); 54

28 import java.rmi.*; Esempio: SessionCounter (6) public class SessionCounterClient { public static void main(string args[]) { try { String registryurl = "rmi://localhost/sessioncounterfactory"; SessionCounterFactoryInterface sessioncounterfactory = (SessionCounterFactoryInterface) Naming.lookup(registryUrl); System.out.println("### Factory lookup complete"); SessionCounterInterface sessioncounter = sessioncounterfactory.getsessioncounter(); System.out.println("### Session counter lookup complete"); for (int i=1; i<=100; i++) { int counter = sessioncounter.getcounter(); System.out.println("### SessionCounterClient[" + i + "]: " + counter); catch (Exception e) {... ogni client ottiene una sequenza di numeri da 1 e consecutivi 55 - Gestione dello stato Quali le possibilità per la gestione dello stato dell applicazione? Quali le possibilità per la gestione dello stato della sessione? Quali le possibilità se bisogna gestire sia stato dell applicazione che stato t della sessione? Quali i possibili ruoli nella gestione dello stato per l oggetto client? l oggetto servente? eventuali altri oggetti remoti? eventuali altri oggetti remoti condivisi? l eventuale base di dati? 56

29 - Legame dei parametri In Java RMI, in un metodo remoto i parametri sono di input il risultato è considerato l unico parametro di output viene usato il legame per valore-risultato Il legame dei parametri (e del risultato) avviene con modalità diverse, a secondo del tipo del parametro tipo primitivo legato per valore riferimento remoto il riferimento remoto viene legato per valore come effetto collaterale l è possibile modificare lo stato t dell oggetto remoto riferimento locale l oggetto viene serializzato (insieme a tutti gli oggetti serializzabili da esso raggiungibili) e legato per valore 57 Legame dei parametri Si consideri il seguente metodo di un oggetto o public void aumentastipendio(impiegato i) { i.setstipendio( i.getstipendio()*1.1 ); ed una sua chiamata o.aumentastipendio(imp); Che succede nelle seguenti situazioni? imp ed o sono oggetti locali, li il metodo è locale l imp è locale al client, ma o è remoto imp ed o sono oggetti remoti, anche i metodi get e set sono remoti 58

30 Legame dei parametri Si consideri il seguente metodo di un oggetto o public Impiegato trovaimpiegato(matricola m) {... return i; ed una sua chiamata Impiegato imp = o.trovaimpiegato(m); imp.setstipendio(0); Che succede nelle seguenti situazioni? imp ed o sono oggetti locali, i metodi sono locali o è remoto, ma il tipo Impiegato è locale imp ed o sono oggetti remoti, anche i metodi get e set sono remoti 59 Value Object e Value Object Assembler Due design pattern [Core J2EE Patterns] per applicazioni ad oggetti distribuiti noti anche con nomi diversi Value Object Data Transfer Object un oggetto che trasporta i dati di uno o più Domain Object tra processi Value Object Assembler un oggetto che sa trasformare i dati di uno o più Domain Object in un Value Object può anche offrire le funzionalità (complementari) di creare DO da un VO oppure aggiornare dei DO a partire da un VO Sono pattern utili per rappresentare in un processo informazioni di oggetti che vivono in altri processi usandoli, si è coscienti che si stanno gestendo delle copie i VOA sostengono la gestione delle copie 60

31 - Java RMI e APS Il corso di Analisi e progettazione del software non prende in considerazione lo sviluppo di applicazioni client-server si consideri proprio lo sviluppo di un applicazione client-server basata su Java RMI quale interpretazione del pattern Controller? quale interpretazione per l architettura a strati? attenzione si potrebbero ricavare conclusioni sbagliate quale potrebbe essere il ruolo dello strato Application tra Presentazione e Dominio? 61 - Esercizio Scrivere un applicazione client-server RMI, in cui il client legge dalla tastiera una sequenza di numeri, e li comunica al server, uno alla volta, per farli sommare, ed alla fine chiede al server la somma calcolata deve poter essere eseguita da più client, tra loro indipendenti, in modo concorrente Osservazione per descrivere l interfaccia i del server non è sufficiente descrivere il prototipo di ciascun metodo remoto è necessario definire un opportuno protocollo (contrattuale) per un uso corretto del servizio 62

32 - Download dello stub Il client ha bisogno di poter interagire localmente con lo stub del servente noi abbiamo copiato a mano lo stub generato da rmic Possibile effettuare il download dinamico dello stub da un sito remoto ad es., da un web server utile per fare uso, in modo trasparente, di nuove classi necessario usare un security manager raccomandato in ogni caso un istruzione in più nel client e nel server necessario specificare un file di security policy il client deve conoscere (ad es., tramite un servizio di directory) l URL per il download dello stub vedi HelloSDServer e HelloSDClient 63 - Garbage collection e gestione della memoria Per gli oggetti distribuiti, viene usato un meccanismo di garbage collection distribuito ogni oggetto distribuito sa quanti oggetti ne conoscono il riferimento può essere deallocato se non è referenziato da nessuno Possibili anche meccanismi di attivazione/passivazione di oggetti 64

33 - Callback Abbiamo visto come un oggetto client può richiedere servizi ad un oggetto servente talvolta è utile poter consentire ad un servente di contattare il proprio client ad es., per realizzare una comunicazione publisher/subscriber il servente notifica degli eventi ai propri client l alternativa è il polling effettuato dai client ad es., per consentire al servente di accedere allo stato della sessione se questo è memorizzato presso il client con un meccanismo, ad es., analogo a quello dei cookie La soluzione è offerta dalla possibilità di realizzare un meccanismo di callback in cui il servente richiama il client consente la comunicazione i bidirezionale i 65 Callback Il callback può essere implementato in questo modo il client crea un oggetto remoto (oggetto callback) che implementa un interfaccia remota che il servente può richiamare il servente fornisce un operazione che consente al client di specificare il proprio oggetto callback quando il servente ne ha bisogno, può contattare l oggetto callback 66

34 Publisher/subscriber con callback Implementazione di publisher/subscriber il servente registra una lista di tutti gli oggetti callback offre operazioni per registrare e per cancellare oggetti callback 67 Publisher/subscriber con callback Alcuni possibili problemi se un client non cancella la registrazione del proprio oggetto callback? una soluzione registrazioni a tempo se i subscriber registrati i sono molti e l operazione di notifica è sincrona, la notifica di un evento può essere molto onerosa per il servente soluzioni? 68

35 Esempio Servente CallbackHello registra i propri client con un meccanismo di callback offre un metodo di business quando viene invocato notifica tutti i propri client Client per CallbackHello si registra presso il servente fa un numero casuale di richieste del metodo di business cancella la propria registrazione 69 CallbackHelloClientInterface import java.rmi.*; public interface CallbackHelloClientInterface extends Remote { /* Metodo invocato dal callback server per effettuare * una callback a un client remoto. */ public String notifyme(string message) throws RemoteException; 70

36 CallbackHelloClientImpl import java.rmi.*; import java.rmi.server.*; public class CallbackHelloClientImpl extends UnicastRemoteObject implements CallbackHelloClientInterface { /* crea un nuovo callback client */ public CallbackHelloClientImpl() throws RemoteException { super(); /* metodo che può essere richiamato dal servente */ public String notifyme(string message) throws RemoteException { String returnmessage = "Call back received: " + message; System.out.println("### " + returnmessage); return returnmessage; 71 CallbackHelloClient (1) import java.rmi.*; public class CallbackHelloClient { public static void main(string args[]) { try {... vedi (2) e (3)... catch (Exception e) { System.err.println("### HelloClient exception: " + e.getmessage()); // e.printstacktrace(); 72

37 CallbackHelloClient (2) /* ricerca il callback server */ System.out.println("### Lookup CallbackHelloServer"); String registryurl ="rmi://localhost/callbackhelloserver"; CallbackHelloServerInterface h = (CallbackHelloServerInterface) Naming.lookup(registryUrl); System.out.println("### Lookup CallbackHelloServer complete"); /* si registra per il callback */ System.out.println("### Registering for callback"); CallbackHelloClientInterface callbackobj = new CallbackHelloClientImpl(); h.registerforcallback(callbackobj); System.out.println("### Registering for callback complete"); /* accesso al server - fa una serie casuale di 5-15 richieste */ int n = (int) (Math.random()*10+5); for (int i=0; i<n; i++) { String message = h.sayhello("io faccio " + n + " richieste"); System.out.println("### HelloClient: " + message); Thread.sleep(1500); 73 CallbackHelloClient (3) /* cancella la registrazione per il callback */ System.out.println("### Unregistering for callback"); h.unregisterforcallback(callbackobj); System.out.println("### Unregistering for callback complete"); System.exit(0); 74

38 CallbackHelloServerInterface import java.rmi.*; public interface CallbackHelloServerInterface extends Remote { /* metodo di business */ public String sayhello(string name) throws RemoteException; /* registrazione per il callback */ public void registerforcallback(callbackhelloclientinterface callbackclient) throws RemoteException; /* cancella registrazione per il callback */ public void unregisterforcallback(callbackhelloclientinterface kh Cli ti t callbackclient) throws RemoteException; 75 CallbackHelloServerImpl (1) import java.rmi.*; import java.rmi.server.*; import java.util. *; public class CallbackHelloServerImpl extends UnicastRemoteObject implements CallbackHelloServerInterface { /* lista dei client registrati */ private List<CallbackHelloClientInterface> clients; /* crea un nuovo servente */ public CallbackHelloServerImpl() p() throws RemoteException { super(); clients = new ArrayList<CallbackHelloClientInterface>(); 76

39 CallbackHelloServerImpl (2) /* registrazione per il callback */ public void registerforcallback(callbackhelloclientinterface callbackclient) throws RemoteException { if (!clients.contains(callbackclient)) { clients.add(callbackclient); System.out.println( println("### New client registered. "); /* annulla registrazione per il callback */ public synchronized void unregisterforcallback( CallbackHelloClientInterface callbackclient) throws RemoteException { if (clients.remove(callbackclient)) { System.out.println("### Client unregistered."); else { System.out.println("### Unable to unregister client."); 77 CallbackHelloServerImpl (3) /* metodo di business * quando viene richiamato, fa il callback a tutti i client registrati */ public String sayhello(string name) throws RemoteException { docallbacks(); return "Hello, " + name + "!"; 78

40 CallbackHelloServerImpl (4) /* gestione dei callback * viene richiamato ogni volta che si registra un nuovo client */ private synchronized void docallbacks() throws RemoteException { System.out.println("### Starting callbacks."); Iterator i = clients.iterator(); iterator(); int numeroclienti = clients.size(); int n = 1; while (i.hasnext()) { CallbackHelloClientInterface client = (CallbackHelloClientInterface) i.next(); client.notifyme("sei il client #" + n + " di " + numeroclienti); n++; System.out.println("### Callbacks complete."); 79 CallbackHelloServer 80 import java.rmi.*; import java.rmi.server.*; public class CallbackHelloServer { public static void main(string[] args) { try y{ /* registrazione presso il registry */ System.out.println("### Binding CallbackHello"); CallbackHelloServerInterface server = new CallbackHelloServerImpl(); String registryurl = "rmi://localhost/callbackhelloserver"; Naming.rebind(registryUrl, server); System.out.println("### CallbackHello bound"); catch (Exception e) { System.err.println("### CallbackHelloServer exception: " + e.getmessage()); // e.printstacktrace();