设计模式之观察者模式

观察者模式的介绍

观察者模式主要是用于UI层和业务逻辑解耦，它是一种订阅–发布过程。

观察者模式的优点

• 观察者和被观察者之间是抽象耦合，应对业务变化。
• 增强系统灵活性、可扩展性。

观察者模式的缺点

一个观察者卡顿会影响整体的执行效率，可以采用异步的方式。

观察者模式的定义

定义对象间一种一对多的依赖关系，使得每当一个对象改变状态，则所有依赖于它的对象都会得到通知并被自动更新。

使用场景

• 关联行为场景
• 事件多级触发场景
• 跨系统的消息交换场景

UML类图

* Subject：抽象主题，即被观察者角色，将所有观察者对象的引用保存在一个集合中，每个主题可以有任意数量的观察者，抽象主题提供了一个接口，可以增加和删除观察者对象。
* ConcreteSubject：具体主题，即具体被观察者角色，改角色将有关状态存入具体观察者对象，在具体主题的内部状态发生改变时，给所有注册过的观察者发出通知。
* Observer：抽象观察者，该角色是观察者的抽象类，定义了一个更新接口，在得到更改通知时更新自己。
* ConcreteObserver：具体的观察者，实现了抽象观察者角色所定义的更新接口，在状态发生变化时更新自身的状态。

观察者模式代码实现

//Observer接口

public interface Observer {       void update(Observable o, Object arg);}

//Observable类

public class Observable {    private boolean changed = false;    private Vector<Observer> obs;    public Observable() {        obs = new Vector<>();    }    public synchronized void addObserver(Observer o) {        if (o == null)            throw new NullPointerException();        if (!obs.contains(o)) {            obs.addElement(o);        }    }    public synchronized void deleteObserver(Observer o) {        obs.removeElement(o);    }    public void notifyObservers() {        notifyObservers(null);    }    public void notifyObservers(Object arg) {        Object[] arrLocal;        synchronized (this)             if (!changed)                return;            arrLocal = obs.toArray();            clearChanged();        }        for (int i = arrLocal.length-1; i>=0; i--)            ((Observer)arrLocal[i]).update(this, arg);    }    public synchronized void deleteObservers() {        obs.removeAllElements();    }    protected synchronized void setChanged() {        changed = true;    }    protected synchronized void clearChanged() {        changed = false;    }    public synchronized boolean hasChanged() {        return changed;    }    public synchronized int countObservers() {        return obs.size();    }}

//被观察者

public class Publish extends Observable {    public void postNotify(String content){        setChanged();        notifyObservers(content);    }}

//观察者

public class Subscribe implements Observer {    private String name;    public Subscribe(String name) {        this.name = name;    }    @Override    public void update(Observable o, Object arg) {        System.out.println("更新++++++++" + name + "内容：" + arg);    }}

//执行订阅

public class Test {    public static void main(String[] args) {        Publish publish=new Publish();        Subscribe subscribe1=new Subscribe("订阅者1");        Subscribe subscribe2=new Subscribe("订阅者2");        publish.addObserver(subscribe1);        publish.addObserver(subscribe2);        publish.postNotify("消息来了");    }}

//运行结果

上述代码中，Observer和Observable是jdk的内置类型，不需要重新定义，其中Publish类代表着被观察者，Subscribe代表着观察者，Subscribe订阅了Publish，当有更新时Subscribe会遍历所有的观察者发送更新，这样就实现了一对多通知更新。

优点

• 观察者和被观察者之间是抽象耦合，应对业务变化
• 增强系统灵活性、可扩展性。

缺点

• 需要考虑一下开发效率和运行效率问题，程序中包括一个被观察者、多个观察者、开发和调试等内容会比较复杂，而且在java中消息的通知默认是顺序执行，一个观察者卡顿，会影响整体的执行效率，在这种情况下，一般考虑采用异步的方式。