Java设计模式-观察者模式

概念

定义了对象之间的一对多依赖，当一个对象改变状态时，它的所有依赖者都会收到通知并自动更新。

角色说明

Observerable：被观察者接口。registerObserver():表示将观察者注册到被观察者中，即“订阅”；removeObserver():表示将观察者从被观察者中移除，即“取消订阅”；notifyObservers():当被观察者状态改变的时候，这个方法被调用，通知所有已经注册的观察者。
ConcreteObserverable：具体观察者。
Observer：观察者接口，其中的update()当被观察者调用notifyObservers()方法时，观察者的update()方法会被回调。
ConcreteObserver:具体观察者。

实例

创建被观察者（Observerable）和观察者（Observer）接口

public interface Observerable {
    /**
    *订阅观察者
    */
    public void registerObserver(Observer o);
    /**
    *取消订阅
    */
    public void removeObserver(Observer o);
    /**
    * 通知观察者
    */
    public void notifyObservers();
}

public interface Observer {
    public void update(int age);
}

具体被观察者

public class ConcreteObserverable implements Observerable {
    /**
    * 保存多个观察者的集合
    */
    private List<Observer> mObservers;
    private int age;
    public concreteObserverable () {
        mObservers = new ArrayList<>();
    }

    @Override
    public void registerObserver(Observer o) {
        mObservers.add(o);
    }

    @Override
    public void removeObserver(Observer o) {
        int i = mObservers.indexOf(o);
        if(i >= 0)
            mObservers.remove(i);
    }

    @Override
    public void notifyObservers() {
        for(int i = 0; i < mObservers.size(); i++){
            Observer observer = mObservers.get(i);
            //调用观察者自己的更新方法（update（））
            observer.update(age);
        }
    }

    public void setInfomation(int age){
        this.age= age;
        //信息更新完毕，通知所有观察者
        notifyObservers();
    }

}

具体的观察者

public class Customer implements Observer {
    private String name;
    private  int age；

    public Customer(String name){
        this.name = name;
    }

    @Override
    public void update(int age) {
    //更新信息
        this.age= age;
        System.out.println（"当前年龄是"+age）;    
    }

}

客户端

public class Test {
    public static void main(String[] args) {
        //1.创建 被观察者
        ConcreteObserverable concreteObserverable = new concreteObserverable ();
        //2.创建 三个不同的观察者
        Observer customerA = new Customer("张三");
        Observer customerB = new Customer("李四");
        Observer customerC = new Customer("王五");

        //3.将观察者注册到被观察者中
        concreteObserverable .registerObserver(customerA);
        concreteObserverable .registerObserver(customerB);
        concreteObserverable .registerObserver(customerC);

        //4.更新被观察者中的数据，当数据更新后，会自动通知所有已注册的观察者
        concreteObserverable .setInfomation(14);
    }

}

小结

优点：
观察者和被观察者之间抽象耦合，容易应对业务变化。
增强系统灵活性、可拓展性。
缺点：
Java中的消息默认是顺序执行，如果一个观察者卡顿，会造成整个系统效率变低，可以考虑异步。

使用场景

关联行为场景，这个关联是可拆分的。将观察者和被观察者封装在不同的对象中，可以各自独立的变化。
当一个对象改变时，有其他对象要进行相应的变化，但是他并不知道有多少个对象需要变化。
跨系统的消息交换场景，如消息队列，时事件总线等