观察者模式

观察者模式介绍

观察者模式是日常使用比较广泛的一种模式，它可以很有效的解耦，将被观察者和观察者解耦，使他们之间的依赖性更小。

观察者模式定义

它定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个被观察者对象。这个被观察者对象在状态变化时，会通知所有的观察者对象，使他们能够自动更新自己。
比如我们当年在学校订阅的仁爱英语报，仁爱英语报的报社就相当于被观察者，而我们向报社订阅了报纸，我们就相当于了观察者。这个时候只要仁爱英语报有更新，就会有新的报纸内容更新到我们每个观察者的手中。如果过了一段时间，张三发现自己不适合学英语，就向报社取消了订阅，这时他就不属于观察者，当有新的报纸内容更新，就不会更新到他手里。如下图：

观察者使用场景

• 一个对象状态的更新，需要其他对象同步更新，而且其他对象的数量动态可变。

观察者UML类图

UML类图

• Subject：抽象主题，也就是我们上文的被观察者（Observable），被观察者提供两个接口，可以增加和删除观察者对象。每个被观察者都可以添加任意数量的观察者。
• ConcreteSubject：具体主题（具体的被观察者），实现自Subiect，该角色将订阅的观察者保存到一个集合当中，当具体的被观察者内部状态发生改变时，给所有订阅的观察者发送更新通知。
• Observer：观察者接口，所有的观察者都实现此观察者接口，此接口定义了一个update方法，在得到主题的通知时更新自己。
• ConcreteObserver：具体的观察者，实现了观察者接口，以便被观察者状态改变时，可以及时更新自己状态。

观察者的简单实现

观察者接口（Observer）

public interface Observer {
    void updata(String msg);
}

具体观察者（ConcreteObserver）

public class LiSi implements Observer {

    private ObServerAble obServerAble;

    public LiSi(ObServerAble obServerAble) {
        this.obServerAble = obServerAble;
        obServerAble.registObserver(this);
    }


    @Override
    public void updata(String msg) {
        System.out.println("LiSi updata = " + msg);
    }
}

被观察者接口（Observable）

public interface ObServerAble {

    void registObserver(Observer observer);
    void unRegistObserver(Observer observer);
    //通知所有观察者
    void notifiAll();

}

具体被观察者（ConcreteSubject）

public class RenAiNewspaper implements ObServerAble {

    private List<Observer> list;
    private String message;

    public RenAiNewspaper() {
        list = new ArrayList<>();
    }

    @Override
    public void registObserver(Observer observer) {
        list.add(observer);
    }

    @Override
    public void unRegistObserver(Observer observer) {
        int i = list.indexOf(observer);
        if ( i >= 0){
            list.remove(i);
        }
    }

    @Override
    public void notifiAll() {
        for (int i = 0; i < list.size(); i++){
            Observer observer = list.get(i);
            observer.updata(message);
        }
    }

    //当值改变调用
    public void MessageUpdate(){
        notifiAll();
    }

    //写入更新内容
    public void setMessage(String str){
        this.message = str;
        MessageUpdate();
    }
}

测试代码

public class MainTest {

    public static void main(String[] args) {
        RenAiNewspaper renAiNewspaper = new RenAiNewspaper();
        Observer lisiObserver = new LiSi(renAiNewspaper);
        Observer wangErMaObserver = new WangErMa(renAiNewspaper);
        renAiNewspaper.setMessage("仁爱英语报，第一期内容");
    }
}

-------------------------------------------------------
Output:

LiSi updata = 仁爱英语报，第一期内容
WangErMa updata = 仁爱英语报，第一期内容

可以看到结果，LiSI和WangErMa都收到了仁爱英语报的更新。这样就完成了一对多的通知功能。因为整个系统都是依赖ObServerAble和Observer这两个接口，所以RenAiNewspaper和LiSi完全没有耦合，就算后期有新的观察者想订阅消息，只要实现Observer即可，被观察者部分不需要修改代码。

观察者模式的优缺点

优点

• 解耦，双方都依赖接口编程。
• 增强程序的灵活性，可扩展性。

缺点

• 如果一个被观察者有很多观察者，将所有观察者都通知到需要花费很多时间。
• java代码是顺序执行，一个观察者卡顿，会影响整体的执行效率，这种情况一般考虑采用异步的方式。

 
 
 

参考资料

• Android源码设计模式
• Head First 设计模式
• https://www.cnblogs.com/pjl1119/p/9727444.html
   

原文地址：https://www.jianshu.com/p/75a1b72d487a