设计模式-观察者

---

简介

观察者模式是一种对象行为模式。它定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。在观察者模式中，主体是通知的发布者，它发出通知时并不需要知道谁是它的观察者，可以有任意数目的观察者接收通知并自行处理。

结构图

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

简单示例

代码如下：

/**
 * 观察者模式：抽象被观察者
 *
 * 一个欠了很多钱的家伙，能力是 借钱 和 通知债主还钱
 */
public interface Debit {

    void borrow(Credit credit);

    void notifyCredit();
}

/**
 * 观察者模式：具体被观察者
 * 欠钱是大爷啊
 */
public class DaYeDebit implements Debit {
    // 债主集合
    List<Credit> creditList = new ArrayList<>();


    @Override
    public void borrow(Credit credit) {
        // 借钱啊
        System.out.println("找 " + credit + " 借钱");
        creditList.add(credit);
    }

    @Override
    public void notifyCredit() {
        for (Credit credit : creditList) {
            credit.taskMoney();
        }
    }
}

/**
 * 观察者模式：抽象观察者
 *
 * 被借钱的债主，能力是 要钱
 */
public interface Credit {

    void taskMoney();

}

/**
 * 观察者模式：具体观察者
 *
 * 被借钱的债主，能力是 要钱
 */
public class Creditor1 implements Credit {

    @Override
    public void taskMoney() {
        System.out.println(" Creditor1 要钱");
    }
}

/**
 * 观察者模式：具体观察者
 *
 * 被借钱的债主，能力是 要钱
 */
public class Creditor2 implements Credit {

    @Override
    public void taskMoney() {
        System.out.println(" Creditor2 要钱");
    }
}

/**
 * 观察者模式：具体观察者
 *
 * 被借钱的债主，能力是 要钱
 */
public class Creditor3 implements Credit {

    @Override
    public void taskMoney() {
        System.out.println(" Creditor3 要钱");
    }
}

    @SneakyThrows
    private static void observer_1() {
        Debit debit = new DaYeDebit();
        // 借钱
        debit.borrow(new Creditor1());
        debit.borrow(new Creditor2());
        debit.borrow(new Creditor3());

		// 奋斗一些时日好还钱
        TimeUnit.SECONDS.sleep(5);

        // 触发还钱
        debit.notifyCredit();
    }

输出结果：

找 com.king.test.mode.observer.impl.Creditor1@44e81672 借钱
找 com.king.test.mode.observer.impl.Creditor2@4ca8195f 借钱
找 com.king.test.mode.observer.impl.Creditor3@61baa894 借钱

 Creditor1 要钱
 Creditor2 要钱
 Creditor3 要钱

使用场景

• 当一个抽象模型有两个方面，其中一个方面依赖于另一方面。将这二者封装在独立的对象中以使它们可以各自独立地改变和复用。

• 当对一个对象的改变需要同时改变其他对象，而不知道具体有多少对象需要被改变。

• 当一个对象必须通知其他对象，而它又不能假定其他对象是谁。换言之，不希望这些对象是紧密耦合的。

优缺点

优点

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

缺点

1. 如果一个被观察者对象有很多的直接和间接的观察者的话，将所有的观察者都通知到会花费很多时间。
2. 如果在观察者和观察目标之间有循环依赖的话，观察目标会触发它们之间进行循环调用，可能导致系统崩溃。
3. 通知一般是顺序执行，那么一个观察者卡顿，会影响整体的执行效率。
4. 程序中包括一个被观察者、多个观察者，开发、调试等内容会比较复杂。

对比 发布订阅 模式

很长一段时间，我都以为是同一个模式，后来现实狠狠打脸

观察者模式里面，被观察者（Subject），它只需维护一套观察者（Observer）的集合，这些 Observer实现相同的接口，Subject只需要知道，通知Observer时，需要调用那个统一方法就可以了。

在发布订阅模式里，发布者，并不会直接通知订阅者，换句话说，发布者和订阅者，彼此互不相识。通过第三方来通知。

解释下：
发布者只需告诉Broker，我要发的消息，topic是AAA；
订阅者只需告诉Broker，我要订阅topic是AAA的消息。

区别在于：
发布订阅模式里，发布订阅模式，而是完全解耦的。而观察者模式是松耦合。