Lezione 12 - Observer

Ingegneria del Software

Introduzione al pattern…

Ingegneria del Software - A.A. 2003/2004

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 Powere 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 venga associato un insieme di operazioni non note a priori?

Come progettare le API in modo tale che ad un segnale venga associato un insieme di operazioni non note a priori?


Soluzione al problema introduttivo

Nota:Il pattern Adapter converte l’interfaccia di una classe in un’altrainterfaccia 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 ObserverOriginariamente 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



ClassS1

ClassSn

:

ClassO1

ClassOn

:

• Forces -

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

-

ClassO

ClassS os

o1s::

son



Solution

Contratto che regola le modalità di notifica

Contratto che regola le modalità di iscrizionee rimozione degli osservatori

Gestore delle registrazioni edelle 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 distato 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 capireche un oggetto ha cambiato stato senza dare dettagli sul cometale 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 ObservableIFb) Passare per parametro nel metodo notify() gli attributi

interessantic) 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 {

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

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

SecurityObserver



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

Education

Transcript of Lezione 12 - Observer