[OOP] Pattern MVC - Observer

[mciasco]

Ho alcuni dubbi sull'utilizzo del pattern Observer con il pattern MVC.

In MVC si può implementare una View come se fosse un Observer. Nello specifico, si crea una interfaccia Observer con un metodo astratto update() e ciascuna View implementa l'interfaccia definendo questo metodo in base ai dati di cui vuole aggiornare la visualizzazione.
Contemporaneamente questi dati sono i dati che la View vuole osservare per mantenerli aggiornati, dunque si registra su ognuno di essi come Observer e attende che la classe che gestisce questi dati e le relative registrazioni degli Observer invii le notifiche di cambiamento di stato dei dati, chiamando il suddetto metodo update() su ciascun Observer. In pratica la classe o le classi che gestiscono questi dati e le relative registrazioni sono classi che implementano l'interfaccia Observerable, che rappresenta appunto un oggetto che è osservabile da un Observer.

Ecco i dubbi. Se ho una View che deve osservare più dati, implementando l'interfaccia Observer avrà a disposizione un solo metodo update() con il quale venire a conoscenza del cambiamento di uno dei dati da aggiornare. Se il dato è uno non c'è problema. Ma se sono più di uno allora la View saprà solo che qualche dato è stato modificato ma non saprà mai quale. Non mi pare una buona soluzione quella di aggiornare indiscriminatamente tutti i dati visualizzati. Oltre che poco sensato, elegante ed inutile, potrebbe pure essere costoso.

Per come è descritto il pattern Observer sembra che la via corretta sia quella di creare tante interfacce Observer quanti sono i dati da aggiornare. Ogni dato X che voglio mantenere aggiornato in una View rappresenta un oggetto osservabile e quindi implementarà l'interfaccia Observable e ci sarà una relativa interfaccia ObserverX con un metodo astratto updateX(). Ogni View che vuole osservare quel preciso dato X (più View possono essere interessate ad uno stesso oggetto) implementeranno l'interfaccia ObserverX ridefinendo il metodo updateX().
In questo modo, quando l'oggetto X cambia, chiamerà il metodo updateX() di ciascuna View che lo sta osservando. Ognuna di esse quindi saprà con esattezza che SOLO il dato X è cambiato e quindi da aggiornare. All'apparenza mi pare bello, però mi pare anche poco scalabile dal punto di vista del programmatore. I dati potrebbero essere tanti in un'applicazione, anche se semplice. Per ognuno di essi occorre creare un'interfaccia Observer ad-hoc in cui sostanzialmente quello che cambia è il nome del metodo update().

Come la pensate voi?

[mciasco]

In questo sito ho trovato un'esauriente trattazione del pattern Observer e indica chiaramente il principio con cui risolvere una situazione come quella descritta da me.

Ecco cosa dice:

Many subjects to Many observers It's not a common situation but there are cases when a there are many observers that need to observe more than one subject. In this case the observer need to be notified not only about the change, but also which is the subject with the state changed. This can be realized very simple by adding to the subjects reference in the update notification method. The subject will pass a reference to itself(this) to the when notify the observer.

Quindi un Observer (una View nel pattern MVC) implementa sempre una stessa interfaccia Observer generica che espone un unico metodo update la cui firma sarà:

update(Observable subject)

Internamente quindi il metodo update di ciascuna View/Observer implementerà un meccanismo per definire quale sia effettivamente l'Observable da aggiornare (ad esempio con una serie di if-else if, o con uno switch).