• Java design patterns: Observer

    by  • 5 giugno 2011 • JAVA, Programmazione • 2 Comments

    Eccoci ad una nuova puntata della serie dedicata ai design patterns, implementati in particolare utilizzando il linguaggio JAVA, parleremo dell’Observer pattern.

    Con questo pattern un oggetto, definito “il soggetto”, mantiene una lista di oggetti dipendenti, definiti “osservatori”, che vengono notificati istantaneamente di ogni cambiamento nello stato del “soggetto” stesso, normalmente chiamando uno dei loro metodi.

    Principalmente è utilizzato per implementare sistemi distribuiti di gestione degli eventi.

    Nella figura che segue lo schema UML relativo al pattern “Observer”.

    Schema UML dell'Observer design pattern

    Nell’esempio pratico di implementazione in JAVA del pattern, l’input ogni linea di input da tastiera viene trattata come un evento, l’esempio è basato sulla libreria di classi java.util.Observer e java.util.Observable.

    Quando viene acquisita una stringa tramite System.in, viene chiamato il metodo notifyObservers, per notificare gli oggetti osservatori dell’avvenuto evento, mediante l’invocazione del loro metodo update, vediamo il codice:

    Iniziamo con il file ObservableObject.java che implementa il Soggetto “osservato”.

    1. package org.bonadonna.patterns.examples;
    2.  
    3. import java.util.Observable;
    4. import java.io.BufferedReader;
    5. import java.io.IOException;
    6. import java.io.InputStreamReader;
    7.  
    8. public class ObservableObject extends Observable implements Runnable {
    9.    public void run() {
    10.       try {
    11.          final InputStreamReader isr = new InputStreamReader(System.in);
    12.          final BufferedReader br = new BufferedReader(isr);
    13.          while(true) {
    14.             String response = br.readLine();
    15.             setChanged();
    16.             notifyObservers(response);
    17.          }
    18.       }
    19.       catch (IOException e) {
    20.          e.printStackTrace();
    21.       }
    22.    }

    vediamo poi il file ObserverObject.java che implementa un osservatore.

    1. package org.bonadonna.patterns.examples;
    2.  
    3. import java.util.Observable;
    4. import java.util.Observer;
    5.  
    6. public class ObserverObject implements Observer {
    7.    private String resp;
    8.    public void update (Observable obj, Object arg) {
    9.       if (arg instanceof String) {
    10.         resp = (String) arg;
    11.         System.out.println("\nReceived Response: " + resp);
    12.       }
    13.    }
    14. }

    e per finire il file AppExample.java che contiene il metodo main per l’esecuzione dell’esempio

    1. package org.bonadonna.patterns.examples;
    2.  
    3. public class AppExample {
    4.    public static void main(String args[]) {
    5.       System.out.println("Inserisci un testo :");
    6.       final ObservableObject observableObj = new ObservableObject();
    7.       final ObserverObject observerObj = new ObserverObject();
    8.       observableObj.addObserver(observerObj);
    9.       Thread thread = new Thread(observableObj);
    10.       thread.start();
    11.    }
    12. }

    2 Responses to Java design patterns: Observer

    1. 6 settembre 2012 at 16:08

      Ottima spiegazione grazie.
      Saluti

      • Andrea Bonadonna
        7 settembre 2012 at 09:28

        Saluti a te e grazie per l’interesse! 🙂

    Lascia un commento

    Il tuo indirizzo email non sarà pubblicato. I campi obbligatori sono contrassegnati *