23种设计模式—— 观察者设计模式

本次继续更新java23中设计模式之一——观察者模式。
　　观察者模式（有时又被称为发布（publish ）-订阅（Subscribe）模式、此模式中通常分为观察者(Observer)、被观察者(Subject)。实现被观察状态发生改变时，观察者会监听到改变。实际上状态发生改变的信息是由被观察者发送给观察者的。
　　模拟案例：现有警察3名，嫌疑犯两名，警察为了找出幕后的大佬，对现有的2名嫌疑犯进行监察：

抽象观察者，警察（Observer）

里面定义了一个更新的方法：

// 观察者
public interface Observer {
    void update(String message, String name);
}

具体观察者（ConcrereObserver）

定义三名便衣观察者：Police1、Police2、Police3

/*
 * 警察余小二
 */
public class Police1 implements Observer {
    String policeName = "余小二";

    @Override
    public void update(String message, String SubName) {
         System.out.println(policeName+":"+SubName+"那里有新动态："+ message);

    }

}


/*
 * 警察关宏峰
 */
public class Police2 implements Observer {
    String policeName = "关宏峰";

    @Override
    public void update(String message, String SubName) {
         System.out.println(policeName+":"+SubName+"那里有新动态："+ message);

    }

}

/*
 * 警察严良
 */
public class Police3 implements Observer {
    String policeName = "严良";

    @Override
    public void update(String message, String SubName) {
         System.out.println(policeName+":"+SubName+"那里有新动态："+ message);

    }

}

抽象被观察者，嫌疑犯（Subject）

//主题（坏人、被观察者）
public interface Subject {

    // 注册观察者（警察）

    void registerObserver(Observer observer);

    // 移除观察者（警察）

    void removeObserver(Observer observer);

    // 通知观察者（警察）
    void notice(String message);
}

具体被观察者（ConcreteSubject）

定义两个嫌疑犯：BadPerson1、BadPerson2

/*
 * 嫌疑犯李丰田
 */
public class BadPerson1 implements Subject {

    private String subName = "李丰田";
    // 定义观察者集合
    private List<Observer> observerList = new ArrayList<Observer>();

    // 增加观察者
    @Override
    public void registerObserver(Observer observer) {
        if (!observerList.contains(observer)) {
            observerList.add(observer);
        }
    }

    // 移除观察者
    @Override
    public void removeObserver(Observer observer) {
        if (observerList.contains(observer)) {
            observerList.remove(observer);
        }
    }

    // 通知观察者
    @Override
    public void notice(String message) {
        for (Observer observer : observerList) {
            observer.update(message, subName);
        }
    }

}


/*
 * 嫌疑犯老傅
 */
public class BadPerson2 implements Subject {

    private String subName = "老傅";
    // 定义观察者集合
    private List<Observer> observerList = new ArrayList<Observer>();

    // 增加观察者
    @Override
    public void registerObserver(Observer observer) {
        if (!observerList.contains(observer)) {
            observerList.add(observer);
        }
    }

    // 移除观察者
    @Override
    public void removeObserver(Observer observer) {
        if (observerList.contains(observer)) {
            observerList.remove(observer);
        }
    }

    // 通知观察者
    @Override
    public void notice(String message) {
        for (Observer observer : observerList) {
            observer.update(message, subName);
        }
    }

}

测试类

public class Test {

    public static void main(String[] args) {
        // 定义两个嫌犯
        Subject badPerson1 = new BadPerson1();
        Subject badPerson2 = new BadPerson2();
        // 定义三个监视警察
        Observer p1 = new Police1();
        Observer p2 = new Police2();
        Observer p3 = new Police3();
        // 为嫌犯增加监视警察
        badPerson1.registerObserver(p1);
        badPerson1.registerObserver(p2);
        badPerson2.registerObserver(p1);
        badPerson2.registerObserver(p3);
        // 定义嫌犯1的情况
        String message1 = "离开了火葬场";
        String message2 = "正在与某人进行通话";
        badPerson1.notice(message1);
        badPerson2.notice(message2);

    }

}

打印结果：

流程总结：

1.针对观察者与被观察者分别抽象出接口，有利于后期进行扩展。
2.被观察者具体实现类中,定义观察者集合，并定义添加与移除观察者方法
3..被观察者具体实现类中,定义通着方法，并提供通知观察者状态改变的方法
4.观察中种要定义接收被观察者通知的方法

使用观察者模式的场景和优缺点

优点：

解除耦合，让耦合的双方都依赖于抽象，从而使得各自的变换都不会影响另一边的变换。

缺点：

在应用观察者模式时需要考虑一下开发效率和运行效率的问题，程序中包括一个被观察者、多个观察者，开发、调试等内容会比较复杂，而且在Java中消息的通知一般是顺序执行，那么一个观察者卡顿，会影响整体的执行效率。