设计模式之观察者模式

观察者模式的定义：是定义对象的一种一对多的依赖关系，当一个对象的状态发生改变的时候，所有依赖于它的对象都得到通知并被自动更新，在这里被观察者是“一".观察者是”多

“

组成：抽象被观察者类Observable(也成之为目标类）,具体的被观察者类（extends Observable），抽象的观察者类（Observable),具体的观察者类

就好像一个商品Goods，与超市A,B，C等是一对多的关系，当商品Goods的价格（状态）发生改变，比如说生产成本降低了，这样超市A B C里的该商品的价格也都得得到相应的更新，在这里被观察者是Goods,观察者是超市 A B C

 

在java里要实现观察者模式，就需要实现Observer接口，继承Observable类，其中观察者实现Observer接口，被观察者继承Observable类。它们的源码如下所示：

public class Observable {

    private boolean changed = false;
    private Vector obs;

    public Observable() {
        obs = new Vector();
    }

    /**
     * 添加观察者类
     * @param o
     */
    public synchronized void addObserver(Observer o) {
        if (null == o) {
            throw new NullPointerException();
        }

        if (!obs.contains(o)) {
            this.obs.add(o);
        }
    }

    /**
     * 删除观察者
     * @param o
     */
    public synchronized void removeObserver(Observer o) {
        this.obs.remove(o);
    }

    /**
     * 通知观察者
     */
    public void notifyObservers() {
        notifyObservers(null);
    }

    /**
     * 通知观察者
     * @param object
     */
    public void notifyObservers(Object object) {
        Object[] observers;

        synchronized (this) {
            //判断是否执行更新操作
            if (!this.changed) {
                return;
            }

            observers = obs.toArray();
            this.clearChanged();
        }

        //所有观察者执行更新操作
        for (int i = observers.length - 1; i >= 0; i--) {
            Observer observer = (Observer) observers[i];
            observer.update(this, object);
        }
    }

    /*
     * 不执行更新操作
     */
    protected synchronized void clearChanged() {
        this.changed = false;
    }

    /**
     * 是否执行更新操作
     * @return
     */
    public synchronized boolean hasChanged() {
        return this.changed;
    }

    /**
     * 执行观察的更新方法
     */
    public synchronized void setChanged() {
        this.changed = true;
    }

    /**
     * 返回观察者的数量
     * @return
     */
    public synchronized int countObservsers() {
        return obs.size();
    }
}

 

public interface Observer {
    /**
     * 当被观察者的对象发生变化时，会调用该方法
     * @param o 被观察的对象
     * @param args
     */
    void update(Observable o,Object args);
}

 

下面是具体的是实现类，在这里提供了两个观察者类ObserverA,ObserverB，代表A B超市，分别是实现了Observer接口，和一个被观察者类Computer，继承了Observable类当Computer的价格发生变化的时候，通知两个观察者，打印输出相关信息

 

public class ObserverA implements Observer {

    @Override
    public void update(Observable o, Object args) {
        String updateInfo = (String) args;
        System.out.println(updateInfo + this);

    }

    @Override
    public String toString() {
        return "在市场A的价格信息发生变化";
    }

    public ObserverA() {
    }
}

public class ObserverB implements Observer {

    @Override
    public void update(Observable o, Object args) {
        String updateInfo = (String) args;
        System.out.println(updateInfo + this);

    }

    @Override
    public String toString() {
        return "在市场B的价格信息发生变化";
    }

    public ObserverB() {
    }
}

public class Computer extends Observable {

    public void changePrice() {
        this.setChanged();
        notifyObservers("X品牌电脑");
    }
}

测试类如下：

public class Test {
    public static void main(String[] args){
        Computer computer = new Computer();
        computer.addObserver(new ObserverA());
        computer.addObserver(new ObserverB());
        computer.changePrice();
    }
}

结果：

X品牌电脑在市场B的价格信息发生变化
X品牌电脑在市场A的价格信息发生变化

 

可以发现，被观察者和观察者的耦合度降低了，因为被观察者并不知道具体的观察者；观察者模式就像一个广播，被观察者会向所有观察者通过notifyObservers方法发出相应的通知，