观察者模式

定义

观察者模式定义了对象间一对多的依赖关系，使得对象状态发生变化时，所有依赖它的对象都会受到通知并且自动更新自己。通俗来说就是多个观察者订阅了一个被观察者的时候，被观察者发生改变时，会自动通知观察者，而不需要观察者去询问被观察者是否发生改变。

观察者模式中的角色组成

• 抽象被观察者角色：定义了添加，删除和通知观察者的方法。
• 具体被观察者角色：继承抽象被观察者的抽象类，实现自身的业务逻辑，当状态发生改变时，发起通知。
• 抽象观察者角色：提供一个接口，定义了观察者收到通知时更新自己的方法。
• 具有观察者角色：实现抽象观察者接口，处理不同具体观察者的不同业务逻辑。

实例

现在有一个读书平台，有很多个读者订阅了一个作者的说，但是这个作者更新时间是不一定的，读者们都想第一去读到最新的章节，但是读者又不能时刻去关注作者是否已经更新，因此很多读者要求作者在更新小说的时候。并且当读者不想订阅的时候，可以取消订阅。这个时候我们就可以使用观察者模式解决这个问题。

被观察者的抽象类：

这个类是抽象类，是所有被观察者都要求继承的，其中提供了添加，删观察者，支持只通知个别的观察者，或者所有的观察者的功能。

/**
 * 被观察者的抽象类
 *
 */
abstract class Subject{
    private List<Observer> observers=new ArrayList<Observer>();
    
    
    /**
     * 订阅的方法
     * @param observer
     */
    public void subscribe(Observer observer) {
        if (observer!=null) {
            if (!observers.contains(observer)) {
                observers.add(observer);
                System.out.println(observer.getObserverName()+"订阅了");
            }
            
        }
    }
    /**
     * 取消订阅
     */
    public void unSubscribe(Observer observer) {
        if (observers.contains(observer)) {
            observers.remove(observer);
            System.out.println(observer.getObserverName()+"取消订阅了");
        }
    }
    /**
     * 通知一个观察者
     * @param observer
     */
    public void notifyObserver(Observer observer) {
        if (observer!=null) {
            observer.update(" 已经更新: "+notifyUpadteContext());
        }
    }
    /**
     * 通知所有的观察者
     *
     */
    public void notifyAllObserver() {
        for(Observer observer:observers) {
            notifyObserver(observer);
        }
    }
    /**
     * 子类要实现的更新小说的方法，返回更新的内容
     * @return
     */
    public abstract String  notifyUpadteContext();
}

被观察者的实现类

被观察者的实现类，在这个案例当中，小说作者就是被观察者，发布更新的消息，并通知观察者。

/**
 * 小说作者，即是被观察者
 *
 */
class WriterSubject extends Subject{
    private String mUpdateContext;
    
    public void write(String context) {
        mUpdateContext=context;
        //通知更新所有的观察者
       notifyAllObserver();
    }
    public void write(String context,Observer observer) {
        mUpdateContext=context;
        //通知更新个别的观察者
         notifyObserver(observer);
    }
    
    /**
     * 返回更新的内容，只有父类去调用获得的内容通知观察者
     */
    @Override
    public String notifyUpadteContext() {
        return mUpdateContext;
    }
}

观察者的接口

观察者的接口，最重要的方法是收到被观察者的更新消息之后去做相关的逻辑处理。

/**
 * 观察者的接口
 *
 */
interface  Observer{
    /**
     * 返回观察者的名称
     * @return
     */
    String getObserverName();
    
    /**
     * 进行更新的操作
     * @param message
     */
    void update(String message);
}

具体的观察者

具体的观察者，等到更新的做出具体的处理。

class XiaoMing implements Observer{
    @Override
    public String getObserverName() {
        
        return "小明";
    }

    @Override
    public void update(String message) {
        System.out.println("小明收到小说更新的通知:"+message);
    }
    
}
class XiaoHong implements Observer{
    @Override
    public String getObserverName() {
        
        return "小红";
    }

    @Override
    public void update(String message) {
        System.out.println("小红收到小说更新的通知:"+message);
    }
    
}
class XiaoBai implements Observer{
    @Override
    public String getObserverName() {
        
        return "小白";
    }

    @Override
    public void update(String message) {
        System.out.println("小白收到小说更新的通知:"+message);
    }
    
}

调用代码：

public static void main(String[] args) {
        WriterSubject  writerSubject=new WriterSubject();
        XiaoMing xiaoMing=new XiaoMing();
        XiaoHong xiaoHong=new XiaoHong();
        XiaoBai xiaoBai=new XiaoBai();
        writerSubject.subscribe(xiaoMing);
        writerSubject.subscribe(xiaoBai);
        writerSubject.subscribe(xiaoHong);
        writerSubject.write("第10章");
        writerSubject.write("第11章",xiaoMing);
        writerSubject.unSubscribe(xiaoBai);
        writerSubject.write("第12章");
    }

结果：

image.png

从结果可以看到当被观察者更新了小说之后，订阅的观察者们将会作出相应的处理，观察者模式在我看来的核心就是Android开发中用到的接口回调的思路。