Design Patterns (11) - Observer Pattern

Observer pattern

1. Definition

       Defines a one-to-many dependency between objects. When an object's state changes, all objects that depend on it are notified and updated automatically.

2. Sample code

  

/* The target object, which knows the observers that observe it, provides an interface for registering and deleting observers */
public class Subject{
    /* Used to save the registered observer object */
    private List<Observer> observers = new ArrayList<Observer>();
    /* register observer */
    public void attach(Observer observer){
        observers.add(observer);
    }
    /* delete observer */
    pubic void detach(Observer observer){
        observers.remove(observer);
    }
    /* Notify all registered observer objects */
    protected void notifyObservers(){
       for(Observer observer){
          observer.update(this);
       }
    }
}

/*Definition of specific target object*/
public class ConceteSubject extends Subject{
   /* Indicates the state of the target object */
   private String subjectState;
   public String getSubjectState(){
       return subjectState;
   }
   public void setSubjectState(String subjectState){
       this.subjectState = subjectState;
       //The target object has changed, notify the observer
       this.notifyObservers();
   }
}

   

/* Observer interface definition */
public interface Observer{
   /*Updated interface, sync target object state*/
   public void update(Subject subject);
}

/* Concrete observer implementation */
public class ConcreteObserver implements Observer{
    /* Indicates the state of the observer */
    private String observerState;
    public String getObserverState(){
       return observerState;
    }
    public void update(Subject subject){
        observerState = (ConcreteSubject)subject.getSubjectState();
    }
}

   

/* Client call indication */
public class Client{
   public static void main(String args[]){
       //create the observable object
       ConcreteSubject subject = new ConcreteSubject ();
       //create observer object
       Observer observer1 = new ConcreteObserver();
       Observer observer2 = new ConcreteObserver();
       Observer observer3 = new ConcreteObserver();
       // register observer
       subject.attach(observer1);
       subject.attach(observer2);
       subject.attach(observer3);
       //change the state of the observer       
       subject.setSubjectState("1");
       // get the state of the observer
       System.out.println("observer1 = " + observer1.getObserverState());
       System.out.println("observer2 = " + observer2.getObserverState());
       System.out.println("observer3 = " + observer3.getObserverState());
   }
}

 

3. Practical application

     The observer pattern realizes the abstract coupling between the observer and the target object, realizes dynamic linkage, and supports broadcast communication.

The essence of observer mode: trigger linkage