观察者模式：对象间的一种一对多的依赖关系

BUG弄潮儿

发布于 2020-12-17 11:21:41

1.2K00

代码可运行

文章被收录于专栏：JAVA乐园JAVA乐园

运行总次数：0

代码可运行

0x01：观察者模式入门

观察者模式[ 又称发布(publish)-订阅(Subscribe)模式 ]，它定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。其实就是一种通知机制，让发送通知的一方（被观察方）和接收通知的一方（观察者）能彼此分离，互不影响。UML类图如下：

从类图上看主要包含如下角色：

Subject（抽象主题）: 被观察者, 抽象主题角色把所有观察者对象保存在一个集合里，每个主题都可以有任意数量的观察者，抽象主题提供一个接口，可以增加和删除观察者对象。
ConcreteSubject（具体主题）：被观察者，该角色将有关状态存入具体观察者对象，在具体主题的内部状态发生改变时，给所有注册过的观察者发送通知。
Observer（抽象观察者）：是观察者者的抽象类，它定义了一个更新接口，使得在得到主题更改通知时更新自己。
ConcrereObserver（具体观察者）：实现抽象观察者定义的更新接口，以便在得到主题更改通知时更新自身的状态。

Subject（抽象主题）：

public interface ISubject{

    public void addObserver(Observer observer);

    public void deleteObserver(Observer observer) ;

    public void notifyObserver() ;
}

ConcreteSubject（具体主题）：

public class Subject  implements ISubject{

    //观察者数组
    private Vector<Observer> observers = new Vector<>();

    //增加一个观察者
    @Override
    public void addObserver(Observer observer) {
        this.observers.add(observer);
    }

    //删除一个观察者
    @Override
    public void deleteObserver(Observer observer) {
        this.observers.remove(observer);
    }

    //通知所有观察者
    @Override
    public void notifyObserver() {
        for(Observer observer : this.observers ) {
            observer.update();
        }
    }
}

Observer（抽象观察者）

public interface Observer {
     //更新
     public void update();
 }
}

ConcrereObserver（具体观察者)

public class ConcrereObserver implements Observer {

    private String name;

    public ConcrereObserver(String name) {
        this.name = name;
    }
      @Override
    public void update() {
        System.out.println(name);
    }


}

客户端Client：

public class Client {
    public static void main(String[] args) {
        ISubject subject=new Subject();
        //创建观察者
        Observer observer1=new ConcrereObserver("subject1");
        Observer observer2=new ConcrereObserver("subject2");
        Observer observer3=new ConcrereObserver("subject3");
        //添加观察者
        subject.addObserver(observer1);
        subject.addObserver(observer2);
        subject.addObserver(observer3);
        //被观察者发生变更，通知所有观察者
        subject.notify();
    }
}

0x02：JDK提供的观察者模式接口

以上是观察者模式的最简单介绍，其实如果大家留意的话，发现JDK已经内置了观察者模式的抽象实现，对应的类是：

java.util.Observer
java.util.Observable

java.util.Observer（观察者抽象）

package java.util;

public interface Observer {

    void update(Observable o, Object arg);
}

java.util.Observable（被观察者抽象）

package java.util;

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();
    }

   synchronized void setChanged() {
        changed = true;
    }

    protected synchronized void clearChanged() {
        changed = false;
    }

    public synchronized boolean hasChanged() {
        return changed;
    }


    public synchronized int countObservers() {
        return obs.size();
    }
}

可以看出来与自己的设计大体一致。不过也不能不感叹JDK的设计者考虑的问题还是不自己考虑的多。JDK多设计了一个标识位，同时考虑了线程安全问题。

0x03：观察者模式的思考

从抽象被观察者代码看，里面定义了一个容器存放观察者。当被观察者发生变更时，需要循环通知观察者。如果使用观察者模式处理这样一个业务场景：观察者非常多，而且观察者的update()方法调用时间可能非常长。那一定出现业务延时的问题，这样的话就不在适合使用观察者模式了。那这样的业务场景需要采用什么解决方案呢？我觉得采用消息队列MQ非常适合

本文参与腾讯云自媒体同步曝光计划，分享自微信公众号。

原始发表：2020-12-03，如有侵权请联系 cloudcommunity@tencent.com 删除

jdk