Java观察者设计模式

Java观察者设计模式

定义

观察者模式，定义了对象之间的一对多依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。在Java中，观察者模式通常由两个接口组成：Subject和Observer。Subject是被观察的对象，Observer是观察者。Subject接口定义了一系列方法，用于添加、删除和通知观察者，Observer接口定义了一个update()方法，当Subject状态发生改变时，该方法被调用。

对应角色

在观察者模式中，有两个主要的角色：Subject和Observer。Subject是被观察的对象，Observer是观察者。Subject接口定义了一系列方法，用于添加、删除和通知观察者，Observer接口定义了一个update()方法，当Subject状态发生改变时，该方法被调用。

优缺点

优点

• 观察者模式可以实现表示层和数据逻辑层的分离，并定义了稳定的消息更新传递机制，抽象了更新接口，使得可以有各种各样不同的表示层充当具体观察者角色。
• 观察者模式在观察目标和观察者之间建立一个抽象的耦合。观察目标只知道观察者列表，不知道具体的观察者。由于观察目标和观察者之间的抽象耦合，它们之间可以保持相对独立的关系。
• 观察者模式支持广播通信。观察目标会向所有已注册的观察者对象发送通知，只要它们实现了该接口。

缺点

• 如果一个被观察者对象有很多直接或间接的观察者，将所有的观察者都通知到会花费很多时间。
• 如果在被观察者对象之间有循环依赖，则可能导致系统崩溃。
• 观察者模式没有相应的机制让观察者知道所观察的对象是怎么发生变化的，而仅仅是知道发生了变化。

应用场景

• 当一个抽象模型有两个方面，其中一个方面依赖于另一个方面。将这两个方面封装在独立的对象中以使它们可以各自独立地改变和复用。
• 当对一个对象的改变需要同时改变其它对象，而不知道具体有多少对象有待改变。
• 当一个对象必须通知其它对象，而它又不能假定其它对象是谁。换句话说，你不希望这些对象是紧密耦合的。

实例

import java.util.ArrayList;
import java.util.List;

interface Observer {
    void update(String message);
}

class Subject {
    private List<Observer> observers = new ArrayList<>();

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

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

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

class ConcreteObserver implements Observer {
    private String name;

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

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

public class ObserverPatternDemo {
    public static void main(String[] args) {
        Subject subject = new Subject();

        ConcreteObserver observer1 = new ConcreteObserver("Observer 1");
        ConcreteObserver observer2 = new ConcreteObserver("Observer 2");

        subject.addObserver(observer1);
        subject.addObserver(observer2);

        subject.notifyObservers("Hello World!");
    }
}

Springboot事件（观察者模式）

import org.springframework.context.ApplicationEvent;
import org.springframework.context.ApplicationListener;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.stereotype.Component;

@Component
class MyEvent extends ApplicationEvent {
    public MyEvent(Object source) {
        super(source);
    }
}

@Component
class MyEventListener implements ApplicationListener<MyEvent> {
    @Override
    public void onApplicationEvent(MyEvent event) {
        System.out.println("Received event: " + event);
    }
}

public class ObserverPatternDemo {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
        context.register(MyEventListener.class);
        context.refresh();

        context.publishEvent(new MyEvent("Hello World!"));
    }
}