一、观察者模式定义:

定义对象间一种一对多的依赖关系，使得每当一个对象改变状态，则所有依赖于它的对象都会得到通知并被自动更新。

1. 使用场景

1. 当一个对象的改变需要同时改变其他对象的时候，可以考虑使用观察者模式。例如，当一个订单状态改变时，需要同时更新库存和订单列表。

2. 当一个对象需要通知其他对象，但又不希望知道其他对象的具体实现时，可以考虑使用观察者模式。例如，一个新闻发布者需要通知多个订阅者，但不知道每个订阅者具体的实现。

3. 微信朋友圈动态通知、消息通知、广播通知、发布订阅等等

2. 角色定义

2.1 Subject 被观察者:

定义被观察者必须实现的职责，它必须能够动态地增加、取消观察者。它一般是抽象类或者是实现类，仅仅完成作为被观察者必须实现的职责: 管理观察者并通知观察者。

2.2 Observer 观察者:

观察者接收到消息后，即进行 update (更新方法)操作对接收到的信息进行处理。

2.3 ConcreteSubiect 具体的被观察者:

定义被观察者自己的业务逻辑，同时定义对哪些事件进行通知。

2.4 ConcreteObserver 具体的观察者:

每个观察在接收到消息后的处理反应是不同，各个观察者有自己的处理逻辑

3. 需求背景

使用观察者模式实现一个某博主发布消息，关注他的人可以正常接收消息。

3.1 抽象主题（Subject）：

定义了被观察者的基本操作，包括添加、删除、通知观察者等。

public interface Subject {
    
    void attach(Observer observer);
    void detach(Observer observer);
    void notifyObservers(String message);
}

3.2 具体主题（ConcreteSubject）：

实现抽象主题接口，维护观察者列表，并在状态发生变化时通知观察者。

public class Blogger implements Subject {
    
    private List<Observer> observers = new ArrayList<>();
    private String message;

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

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

    @Override
    public void notifyObservers(String message) {
    
        for (Observer observer : observers) {
    
            observer.update(message);
        }
    }

    public void postMessage(String message) {
    
        this.message = message;
        notifyObservers(message);
    }
}

3.3 抽象观察者（Observer）：

定义了观察者的基本操作，包括更新状态等。

public interface Observer {
    
    void update(String message);
}

3.4 具体观察者（ConcreteObserver）：

实现抽象观察者接口，保存观察者状态，并在被观察者状态发生变化时更新状态。

public class Follower implements Observer {
    
    private String name;

    public Follower(String name) {
    
        this.name = name;
    }

    @Override
    public void update(String message) {
    
        System.out.println(name + " received new message: " + message);
    }
}

3.5 使用示例：

public static void main(String[] args) {
    
        Blogger blogger = new Blogger();
        Observer follower1 = new Follower("Follower1");
        Observer follower2 = new Follower("Follower2");

        blogger.attach(follower1);
        blogger.attach(follower2);

        blogger.postMessage("New blog post!");

        blogger.detach(follower1);

        blogger.postMessage("Another blog post!");
    }

3.6 示例分析：

在以上示例中，Blogger 充当了抽象主题角色，Follower 充当了抽象观察者角色，具体主题 Blogger 实现了 Subject 接口并维护观察者列表，具体观察者 Follower 实现了 Observer 接口并在被观察者状态发生变化时更新状态。在使用时，Blogger 发布了新的消息，通知所有关注他的人接收消息。同时，Follower 可以随时取消关注，不再接收博主的消息。

4. 小结

• 观察者模式是一种行为型设计模式，它定义了一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都会得到通知并自动更新。

• 观察者模式由主题（Subject）、观察者（Observer）、具体主题（ConcreteSubject）和具体观察者（ConcreteObserver）等角色组成。

• 主题对象维护了一个观察者对象的列表，通过注册和删除观察者对象的方法，实现了对观察者的管理。当主题对象的状态发生改变时，它会遍历观察者列表，并调用每个观察者对象的更新方法，将状态改变的通知传递给观察者。

• 观察者对象实现了一个更新的接口，当接收到主题对象的通知时，会执行相应的操作。具体观察者对象是观察者的具体实现，它定义了自己的更新逻辑。

• 观察者模式的优点包括松耦合、可扩展性和分离关注点。它使得对象之间的通信更加灵活，能够方便地增加新的观察者对象，同时将关注点分离开来，每个对象只关注自己的职责。

• 观察者模式适用于当一个对象的改变需要同时改变其他对象时，或者一个对象需要通知其他对象但又不希望与其紧耦合的情况下。

• 总结来说，观察者模式是一种简单而灵活的设计模式，它能够帮助构建松耦合的系统，实现对象之间的通信和协作，并且方便地扩展新的功能。