Lezione 12 - Observer

Problema introduttivo

• Una fabbrica di sensori anti-incendio, di movimento e altri
tipi di dispositivi di sicurezza produce una nuova linea di
prodotti.
• I dispositivi possono inviare un segnale ad una scheda
hardware che può essere istallata su molti computer.
Le schede possono inviare segnali di tipo: Alarm, Low Power
e Diagnostic.
• Per poter sviluppare software di controllo che utilizzano tali
dispositivi è necessario fornire API semplici da utilizzare e
che siano facilmente integrabili nei programmi di controllo
già esistenti.
• I software di controllo reagiscono ai segnali dei sensori
invocando i metodi opportuni (es. allarmeIncendio())

Come progettare le API in modo tale che ad un segnale
Come progettare le API in modo tale che ad un segnale
venga associato un insieme di operazioni non note a priori?
venga associato un insieme di operazioni non note a priori?
Ingegneria del Software - A.A. 2003/2004

Soluzione al problema introduttivo

Nota:
Il pattern Adapter converte l’interfaccia di una classe in un’altra
interfaccia più “comoda” per il client. Il pattern permette di far
lavorare insieme delle classi altrimenti incompatibili.


Presentazione del pattern
Observer

Il pattern Observer (1/11)

• Nome Observer
Originariamente presentato nel [GoF95], il
pattern si è evoluto nel tempo.

• Synopsis Consente di definire la dipendenza di molti
oggetti verso di uno, in modo che se quest’ultimo
cambia il suo stato tutti gli altri sono avvisati e
aggiornati automaticamente.

• Context cfr. esempio introduttivo



Class Class
• Forces - s o
S O

Le classi S e O non sono progettate per lavorare
insieme e non hanno conoscenza diretta l’una
dell’altra.

- Class o1 Class
S1
s O1
: : :
Class : Class
Sn
s On
on



Contratto che regola
le modalità di iscrizione
Solution e rimozione degli
osservatori

Contratto che
regola le
modalità di
notifica

Gestore delle
registrazioni e
delle notifiche



• Solution - Gli attori del pattern Observer sono:
– ObserverIF: Interfaccia che definisce un metodo tipicamente chiamato
notify o update. Un oggetto Observable richiama questo metodo quando
intende notificare il cambiamento del suo stato, passando se previsto un
argomento. In molti casi l’argomento passato è un riferimento che identifica
l’oggetto Observable che ha richiamato il metodo
– Observer: Le istanze di questa classe ricevono le notifiche di cambiamento
di stato degli oggetti Observable
– ObservableIF: Interfaccia che definisce i metodi necessari alla registrazione
e de-registrazione degli oggetti Observer
– Observable: Classe di oggetti in grado di notificare i loro cambiamenti di
stato a tutti gli oggetti interessati
– Multicaster: Le sue istanze che gestisce le registrazioni di un oggetto
ObserverIF e le notifiche verso Observable. Delegare queste
responsabilità a Multicaster favorisce la riusabilità del codice.



Fase di registrazione

Fase di notifica



• Consequences

- Permette ad un oggetto di inoltrare notifiche ad altri oggetti
senza che queste si conoscano a priori.

- Situazioni indesiderabili:
- Tempi di notifica troppo lunghi:
- Observer direttamente registrati troppo numerosi
- Observer indirettamente interessati “troppo lontani”
- Dipendenze cicliche (rischio di StackOverFlowError)

- Pattern semplice ed elegante fin quando una notifica fa capire
che un oggetto ha cambiato stato senza dare dettagli sul come
tale stato è cambiato.



• Implementation

- In molti casi l’oggetto Observer, dopo aver ricevuto una
notifica, ha bisogno di accedere agli attributi dell’oggetto
Observable. In questi casi si può:
a) Aggiungere appositi metodi in ObservableIF
b) Passare per parametro nel metodo notify() gli attributi
interessanti
c) Passare per parametro nel metodo notify() l’intero
l’oggetto Observable

• Java API usage

Il modello ad eventi di Java è una forma specializzata del
pattern Observer.



• Code example

/** Classes that implement this interface can register to receive
* security notifications from SecurityNotifier objects. */

public interface SecurityObserver
SecurityObserver {

public final int ALARM = 1;
public final int LOW_POWER = 2;
public final int DIAGNOSTIC = 3;

public void notify(int device, int event);
}



import java.util.ArraySet;
import java.util.Iterator;
/** When an instance of this class receives a notification from a
* security device, it passes it on to all of its registered observers. */
class SecurityNotifier {
private ArraySet observers = new ArraySet();
//...
public void addObserver(SecurityObserver observer) {
observers.add(observer);
}
public void removeObserver(SecurityObserver observer) {
observers.remove(observer);
}
private void notify(int device, int event) {
Iterator iterator = observers.iterator();
while (iterator.hasNext()) {
((SecurityObserver)iterator.next()).notify(device, event);
}
}
}


/** Instances of this class receive a notification from an object that is can only
* deliver it to an object the implements the SecurityObserver interface and
* apsses it on to a SecurityMonitor object that does not implemen SecurityObserver. */

class SecurityAdapter implements SecurityObserver {
private SecurityMonitor sm;
SecurityAdapter(SecurityMonitor sm) {
this.sm = sm;
}
public void notify(int device, int event) {
switch (event) {
case ALARM:
sm.securityAlert(device);
break;
case LOW_POWER:
case DIAGNOSTIC:
sm.diagnosticAlert(device);
break;
}
}
}


• Related Patterns

Adapter, Delegation, Mediator, Publisher-Subscriber


Domande?


Lezione 12 - Observer

Recomendados

Recomendados

Más contenido relacionado

Similar a Lezione 12 - Observer

Similar a Lezione 12 - Observer (20)

Lezione 12 - Observer