Sei sulla pagina 1di 1

Architetture e Sistemi Software Distribuiti (A. A.

2020/21)
Esercitazione n. 1 del 15 marzo 2021
Prof. Eugenio Zimeo

Esercizio 1.1
Implementare un tipo di oggetti remoti (PrintService) dotato di un metodo void print(String s) che visualizzi
sullo standard output del server una stringa passata dal client all'atto dell'invocazione del metodo. Istanziare un oggetto
di tipo PrintService in un processo server e registrarlo con il nome printservice.
Implementare un client che legge continuamente linee dallo standard input (fino ad incontrare il “.” per la terminazione)
e le invia al server, invocando il metodo print(…) dell’oggetto remoto ospitato dal server.
Implementare una variante dell’esercizio aggiungendo un metodo all’interfaccia PrintService che produca in remoto
la stampa sullo standard output di un oggetto Person passato come argomento del metodo print(). La casse Person
dovrà prevedere le variabili di istanza firstName, lastName, age, i costruttori e i metodi get e set. Implementare una
variante del client che invia un’istanza di Person al server invocando il metodo print().

Esercizio 1.2
L’operatore new non può essere usato per creare oggetti remoti rispetto al nodo su cui new è eseguito. E’ necessario
ricorrere ad un pattern. Il pattern Factory può essere di supporto perché consente di spostare il problema della creazione
sui metodi. Poiché Java RMI consente di invocare un metodo da remoto, se la creazione di un oggetto è realizzata con
un tale metodo essa può essere realizzata da remoto.
Implementare una Factory di oggetti remoti di tipo PrintService. Il diagramma delle classi del pattern factory è
riportato di seguito.

Esercizio 1.3
Si realizzi un tipo di oggetti remoti (Math) per il calcolo del fattoriale. Il tipo deve fornire il metodo int
getFactOf(int n) che riceve un numero n e il fattoriale di tale numero.
Il fattoriale di n può essere calcolato in modo ricorsivo come:
fact (n) = n*fact(n-1);
fact (0) = 1;

Si realizzi anche una versione asincrona del metodo precedente attraverso l’impiego di una call-back. Una call-back è
una chiamata (di ritorno) di un metodo (o di una funzione) passato dal chiamante al chiamato per essere invocato. Può
essere usata per realizzare invocazioni asincrone che prevedono valori di ritorno, sfruttando la chiamata sincrona.
Allo scopo, si scomponga il metodo chiamante in due parti e si usi una call-back per raggruppare le istruzioni del
chiamante che dipendono dal valore di ritorno della chiamata. Si chiami void getAsynchFactOf(int v,
CallBack cont) il metodo che dà vita all’invocazione asincrona, dove cont è la call-back da invocare quando il
risultato è disponibile.

------------------------------------------------------------------------------------------------------------------------------------------------
La scadenza per la consegna degli esercizi è mercoledì 17 marzo 2021.