设计模式|观察者模式的深入实践

观察者模式

       一句话简单概括：定义了对象之间的一对多关系，当一个对象发生改变时，它的所有依赖都会收到通知并且自动更新状态，在观察者模式中，发生改变的对象叫做观察目标，而被通知更新的对象称为观察者

场景描述

       生活中，当有警报响起，猫狗的反应

具体实现

       依据上图的UML,我们发现观察者一般是一个类型集合，可以根据需要动态增加和删除，易于扩展，一般发生通知，是通过遍历该类型集合，调用该集合下的每个元素方法执行不同的变化，我们可以简单的梳理如下代码

public interface Observer {
    void update();
}

public interface TargetObserver {
    void notifyObserver();
    void removeObserver(Observer observer);
    List<Observer> addObserver(Observer observer);
}

public class AlarmTargetObserver implements TargetObserver {

    private List<Observer> observerList;

    public AlarmTargetObserver() {
        observerList = new ArrayList<>();
    }

    @Override
    public void notifyObserver() {
        if (observerList.size() != 0) {
            observerList.forEach(Observer::update);
        }
    }

    @Override
    public void removeObserver(Observer observer) {
        if (observerList.contains(observer)) {
            observerList.remove(observer);
        }
    }

    @Override
    public List<Observer> addObserver(Observer observer) {
        observerList.add(observer);
        return observerList;
    }
}

public class CatObserver implements Observer {
    @Override
    public void update() {
        System.out.println("喵喵喵喵。。。。");
    }
}

public class DogObserver implements Observer{
    @Override
    public void update() {
        System.out.println("汪汪汪汪汪。。。。");
    }
}

public class Test {
    public static void main(String[] args) {
        AlarmTargetObserver alarmTargetObserver = new AlarmTargetObserver();
        alarmTargetObserver.addObserver(new CatObserver()).add(new DogObserver());
        //此处警报响起
        alarmTargetObserver.notifyObserver(); //输出：汪汪汪汪汪。。。。 喵喵喵喵。。。。
    }
}

拓展实现：JDK自带观察者模式

java.util.Observable

       Observable类包含对各种观察者操作，添加add,删除delete,值得注意的是JDK中的Observable的观察者保存集合，选择是是Vector(集合List中的一种，初始容量为 10，加载因子是 1。扩容增量：原容量的 1 倍，线程安全类)，较上文简易的实现观察者模式而言，Observable显然考虑的更加全面，支持线程安全

       我们着重查看notifyObservers方法，可见大致的逻辑为，启用观察目标对象的引用作为锁，在锁范围内完成通知标识的变更，最后再通过for循环完成对Vector集合元素内的通知，通知所有arg为null。

       ps:之所以在变更标识时添加锁，是防止变更标识的情况下，有多个线程变更标识（标识为全局变量，线程共享），导致需要通知的消息被return或者被错误的执行下去，之所以不在for循环加同步锁，主要原因为Vector本身就是线程安全的集合

       那么我们继续延续上一场景，看代码实现上有什么变化

public class AlarmTargetObserver extends Observable {

    public void alarmAll(){
        this.setChanged();
        this.notifyObservers();
    }

    public void alarmDog(DogObserver dogObserver){
        this.setChanged();
        this.notifyObservers(dogObserver);
    }
}

public class CatObserver implements Observer {
    @Override
    public void update(Observable o, Object arg) {
        if (arg ==null || arg instanceof CatObserver){
            System.out.println("喵喵喵喵。。。");
        }
    }
}

public class DogObserver implements Observer {

    @Override
    public void update(Observable o, Object arg) {
        if (arg ==null || arg instanceof DogObserver){
            System.out.println("汪汪汪。。。。");
        }
    }
}

public class Test {
    public static void main(String[] args) {
        AlarmTargetObserver alarmTargetObserver = new AlarmTargetObserver();
        DogObserver dogObserver = new DogObserver();
        alarmTargetObserver.addObserver(dogObserver);
        alarmTargetObserver.addObserver(new CatObserver());
        alarmTargetObserver.alarmAll();//输出：汪汪汪汪汪。。。。 喵喵喵喵。。。。
        alarmTargetObserver.alarmDog(dogObserver);//输出：汪汪汪汪汪。。。。
    }
}

       通过上述代码，我们可以发现，我们不需要去定义顶层的接口与父类，JDK已经抽象出观察者模式，帮我们实现了公共部分的代码（update更新方法，添删列表等），减少重复造轮子