设计模式之观察者模式

观察者模式的介绍

观察者模式主要是用于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中消息的通知默认是顺序执行，一个观察者卡顿，会影响整体的执行效率，在这种情况下，一般考虑采用异步的方式。