GofPatterns GofPatterns


Behavioral Patterns  «Prev  Next»

Observer Pattern Code

Implementation Issues

  1. How does the subject keep track of its observers?
  2. What if an observer wants to observe more than one subject?
    Have the subject tell the observer who it is via the update interface
  3. Who triggers the update?
    The subject whenever its state changes
    The observers after they cause one or more state changes
    Some third party object(s)
  4. Make sure the subject updates its state before sending out notifications
  5. How much info about the change should the subject send to the observers?
    a) Push Model - Lots, b) Pull Model - Very Little

  1. Can the observers subscribe to specific events of interest?
  2. Can an observer also be a subject?
  3. What if an observer wants to be notified only after several subjects have changed state?
    1. Use an intermediary object which acts as a mediator
    2. Subjects send notifications to the mediator object which performs any necessary processing before notifying the observers

Known Uses

  1. Smalltalk Model/View/Controller user interface framework
    Model = Subject, View = Observer, Controller is whatever object changes the state of the subject
  2. Java 1.1 AWT/Swing Event Model

Related Patterns

Mediator: To encapsulate complex update semantics

Java Implementation Of Observer

We could implement the Observer pattern “from scratch” in Java
  1. But Java provides the Observable/Observer classes as built-in support for the Observer pattern
  2. The java.util.Observable class is the base Subject class. Any class that wants to be observed extends this class.
    1. Provides methods to add/delete observers
    2. Provides methods to notify all observers
    3. A subclass only needs to ensure that its observers are notified in the appropriate mutators
    4. Uses a Vector for storing the observer references
  3. The java.util.Observer interface is the Observer interface. It must be implemented by any observer class.

java.util.Observable Class Methods

  1. public Observable() - Construct an Observable with zero Observers
  2. public synchronized void addObserver(Observer o) - Adds an observer to the set of observers of this object
  3. public synchronized void deleteObserver(Observer o) - Deletes an observer from the set of observers of this object
  4. protected synchronized void setChanged() - Indicates that this object has changed
  5. protected synchronized void clearChanged() - Indicates that this object has no longer changed, or that it has already notified all of its observers of its most recent change. This method is called automatically by notifyObservers().
  6. public synchronized boolean hasChanged() : Tests if this object has changed. Returns true if setChanged() has been called more recently than clearChanged() on this object; false otherwise.
  7. public void notifyObservers(Object arg) - If this object has changed, as indicated by the hasChanged() method, then notify all of its observers and then call the clearChanged() method to indicate that this object has no longer changed. Each observer has its update() method called with two arguments: this observable object and the arg argument. The arg argument can be used to indicate which attribute of the observable object has changed.
  8. public void notifyObservers() - Same as above, but the arg argument is set to null. That is, the observer is given no indication what attribute of the observable object has changed.
  9. public abstract void update(Observable o, Object arg) - This method is called whenever the observed object is changed. An application calls an observable object's notifyObservers method to have all the object's observers notified of the change.
    Parameters: 1) o - the observable object, 2) arg - an argument passed to the notifyObservers method

/** A subject to observe! */
public class ConcreteSubject extends Observable {
 private String name;
 private float price;
 public ConcreteSubject(String name, float price) {
  this.name = name;
  this.price = price;
  System.out.println("ConcreteSubject created: " + name + " at " + price);
 }
 public String getName() {return name;}
 public float getPrice() {return price;}
 public void setName(String name) {
  this.name = name;
  setChanged();
  notifyObservers(name);
 }
 public void setPrice(float price) {
  this.price = price;
  setChanged();
  notifyObservers(new Float(price));
 }
}
// An observer of name changes.
public class NameObserver implements Observer {
 private String name;
 public NameObserver() {
  name = null;
  System.out.println("NameObserver created: Name is " + name);
 }
 public void update(Observable obj, Object arg) {
  if (arg instanceof String) {
   name = (String)arg;
   System.out.println("NameObserver: Name changed to " + name);
  } 
  else {
   System.out.println("NameObserver: Some other change to subject!");
  }
 }
}
// An observer of price changes.
public class PriceObserver implements Observer {
 private float price; 
 public PriceObserver() {
  price = 0;
  System.out.println("PriceObserver created: Price is " + price);
 }
 public void update(Observable obj, Object arg) {
  if (arg instanceof Float) {
   price = ((Float)arg).floatValue();
   System.out.println("PriceObserver: Price changed to" + price);
  }
  else {
   System.out.println(”PriceObserver: Some other change to subject!");
  }
 }
// Test program for ConcreteSubject, NameObserver and PriceObserver
public class TestObservers {
 public static void main(String args[]) {
 // Create the Subject and Observers.
  ConcreteSubject s = new ConcreteSubject("Corn Pops", 1.29f);
  NameObserver nameObs = new NameObserver();
  PriceObserver priceObs = new PriceObserver();
  // Add those Observers!
  s.addObserver(nameObs);
  s.addObserver(priceObs);
  // Make changes to the Subject.
  s.setName("Frosted Flakes");
  s.setPrice(4.57f);
  s.setPrice(9.22f);
  s.setName("Sugar Crispies");
 }
}