观察者模式

引言

今天开车出去有事，还挺赶时间的，突然遇到了一个红灯，这红灯时间可真长，等了好久终于看到变绿灯了，赶紧开车过去。

正文

观察者模式是指多个对象之间存在一对多的依赖关系，当一个对象的状态发生改变时，所有依赖它的对象都会收到它的通知，然后做出改变。

核心思想

通过对目标和观察者之间建立了一套触发机制，降低了两者间的耦合关系，因为这两者仅仅都是抽象耦合。

代码实现

讲解

//抽象观察者
public interface Observer {
    void response();
}

//抽象目标
public abstract class Subject {
    protected List<Observer> observers = new ArrayList<>();

    public void add(Observer observer) {
        observers.add(observer);
    }

    public void remove(Observer observer) {
        observers.remove(observer);
    }

    //通知
    public abstract void notifyObserver();
}

//具体目标
public class ConcreteSubject extends Subject {
    @Override
    public void notifyObserver() {
        System.out.println("此时发生了一些变化...");
        for (Object obj : observers) {
            ((Observer) obj).response();
        }
    }
}

//具体观察者
public class ConcreteObserver implements Observer {
    @Override
    public void response() {
        System.out.println("具体观察者对变化作出反应");
    }
}

实例

//抽象交通信号灯类（目标）
public abstract class TrafficLights {
    protected List<Driver> drivers = new ArrayList<>();

    public void add(Driver driver) {
        drivers.add(driver);
    }

    public void remove(Driver driver) {
        drivers.remove(driver);
    }

    public abstract void notifyDriver();
}

public class RedLight extends TrafficLights {
    @Override
    public void notifyDriver() {
        System.out.println("红灯变成绿灯了...");
        for (Driver driver : drivers) {
            driver.response();
        }
    }
}

//司机接口（观察者）
public interface Driver {
    void response();
}

public class MeDriver implements Driver {
    @Override
    public void response() {
        System.out.println("红灯告诉我变成绿灯了,我得开车走了");
    }
}

//调用
public class Main {
    public static void main(String[] args) {
        TrafficLights redLight = new RedLight();
        MeDriver meDriver = new MeDriver();
        redLight.add(meDriver);
        redLight.notifyDriver();
    }
}

输出结果

红灯变成绿灯了...
红灯告诉我变成绿灯了,我得开车走了

总结

观察者模式很好的处理了一对多对象之间的耦合关系，但并没有完全解除之间的依赖关系，处理不好可能会造成循环引用，同时如果观察者对象过多时，通知的发布会效率变低（参考一个高速堵车）。