观察者模式

观察者模式结构

• 一个软件系统常常要求在某一个对象的状态发生变化的时候，某些其他的对象做出相应的改变。做到这一点的设计方案有很多，但是为了使系统能够易于复用，应该选择低耦合度的设计方案。减少对象之间的耦合有利于系统的复用，但是同时设计师需要使这些低耦合度的对象之间能够维持行动的协调一致，保证高度的协作。观察者模式是满足这一要求的各种设计方案中最重要的一种。
• 类图
  
• 观察者模式所涉及的角色有：
  • 被观察者(Observable):被观察者把所有对观察者对象的引用保存在一个集合里，每个被观察者可以有任何数量的观察者。被观察者提供一个接口，可以增加和删除观察者对象。
  • 观察者(Observer):为所有的具体观察者定义一个接口，在得到主题的通知时更新自己，这个接口叫做更新接口。
  • 具体的被观察者(ConcreteObservale): 将有关状态存入具体观察者对象；在具体的被观察者的内部状态改变时，给所有登记过的观察者发出通知。
  • 具体观察者(ConcreteObserver)角色：存储与主题的状态自恰的状态。具体观察者角色实现观察者角色所要求的更新接口，以便使本身的状态与被观察者的状态 像协调。如果需要，具体观察者角色可以保持一个指向具体被观察者的引用。

代码实现

/**
 * 被观察者
 */
public class Observable {
    //观察者集合
    private List<Observer> observers = new ArrayList<>();

    /**
     * 添加观察者
     *
     * @param observer 观察者对象
     */
    public void addObserver(Observer observer) {
        if (!observers.contains(observer)) {
            observers.add(observer);
        }
    }

    /**
     * 移除观察者
     *
     * @param observer 观察者对象
     */
    public void removeObserver(Observer observer) {
        observers.remove(observer);
    }

    /**
     * 通知观察者更新
     *
     * @param state 更新的数据
     */
    void notifyObserver(String state) {
        for (Observer o : observers) {
            o.update(this, state);
        }
    }

}

/**
 * 观察者
 */
public interface Observer {
    /**
     * 更新观察者的方法
     * @param observable 被观察者对象
     * @param newState 更新的数据
     */
    void update(Observable observable,Object newState);
}

/**
 * 具体的被观察者
 */
public class ConcreteObservable extends Observable {
    //更新的数据
    private String state;

    public String getState() {
        return state;
    }

    /**
     * 设置新的数据
     *
     * @param state 新数据
     */
    public void setState(String state) {
        this.state = state;
        //通知观察者更新
        notifyObserver(state);

    }
}

/**
 * 具体的观察者
 */
public class ConcreteObserver implements Observer {
    private String observerState;//观察者中的数据

    @Override
    public void update(Observable observable, Object newState) {
        /*
        若传入的更新数据不为空，则将观察者的数据更新为新数据，否则更新为通知更新的被观察的数据。
        这里涉及到 推送和拉取两种不同的模式
         */

        if (newState != null) {
            this.observerState = String.valueOf(newState);
        } else {
            this.observerState = ((ConcreteObservable) observable).getState();
        }
        System.out.println("new state is" + observerState);
    }
    
}

public class Main {

    public static void main(String[] args) {
        ConcreteObservable subject = new ConcreteObservable();
        Observer o1 = new ConcreteObserver();
        Observer o2 = new ConcreteObserver();
        subject.addObserver(o1);
        subject.addObserver(o2);
        subject.setState("111");
    }
}

推送模型和拉取模型

• 推送模式
  • 被观察者对象向观察者推送主题的详细信息，不管观察者是否需要，推送的信息通常是被观察者对象的全部或部分数据。
• 拉取模型
  • 被观察者对象在通知观察者的时候，只传递少量信息。如果观察者需要更具体的信息，由观察者主动到被观察者对象中获取，相当于是观察者从被观察者对象中拉数据。一般这种模型的实现中，会把被观察者对象自身通过update()方法传递给观察者，这样在观察者需要获取数据的时候，就可以通过这个引用来获取了。

上述代码中若update方法中的arg参数为null时，则使用拉取模式，若不为null则使用推送模式。

java中提供的观察者

• 在java.util包中提供了Observable类和Observer接口，开发者通过继承Observable类以实现具体的被观察者，实现Observer接口以实现具体的观察者。

• 具体实现

/**
* 具体被观察者
*/
public class JavaObserable extends Observable {
   private String data;

   public String getData() {
       return data;
   }

   public void setData(String data) {
       this.data = data;
       //Observable类中的方法，通知父类有更新
       setChanged();
       //Observable类中的方法，更新观察者
       notifyObservers(data);
   }
}

/**
* 具体观察者
*/
public class JavaObserver implements Observer {
   @Override
   public void update(Observable o, Object arg) {
       String data = (String) arg;
       if (arg == null) {
            data = ((JavaObserable) o).getData();
       }
       System.out.println("data:" + data);
   }
}

   public static void main(String[] args) {
       JavaObserable javaObserable = new JavaObserable();
       JavaObserver javaObserver = new JavaObserver();
       javaObserable.addObserver(javaObserver);
       javaObserable.setData("1233");
   }
}