Java观察者模式

Java观察者模式

1. 观察者模式概述

观察者模式（Observer Pattern），又称“发布/订阅模式”（Publish/Subscribe Pattern），是一种行为型设计模式。在该模式中，一个对象（称为主题）维护一系列依赖于它的对象（称为观察者），当主题发生状态变化时，它会通知所有观察者自动更新。

2. 观察者模式实现

2.1 观察者模式代码实现

2.1.1 主题（Subject）

public interface Subject {
    /**
     * 注册观察者
     */
    void registerObserver(Observer observer);

    /**
     * 移除观察者
     */
    void removeObserver(Observer observer);

    /**
     * 通知观察者
     */
    void notifyObservers();
}

2.1.2 具体主题（ConcreteSubject）

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

public class ConcreteSubject implements Subject {
    private List<Observer> observers = new ArrayList<Observer>();
    private String state;
    
    @Override
    public void registerObserver(Observer observer) {
        if (!observers.contains(observer)) {
            observers.add(observer);
        }
    }

    @Override
    public void removeObserver(Observer observer) {
        if (observers.contains(observer)) {
            observers.remove(observer);
        }
    }

    @Override
    public void notifyObservers() {
        for (Observer observer : observers) {
            observer.update(state);
        }
    }
    
    public void setState(String state) {
        this.state = state;
        notifyObservers();
    }
}

2.1.3 观察者（Observer）

public interface Observer {
    /**
     * 更新方法
     * @param state 状态
     */
    void update(String state);
}

2.1.4 具体观察者（ConcreteObserver）

public class ConcreteObserver implements Observer {
    private String name;

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

    @Override
    public void update(String state) {
        System.out.println(name + " 收到更新，新状态为：" + state);
    }
}

2.1.5 测试代码

public class ObserverTest {
    public static void main(String[] args) {
        // 创建主题
        ConcreteSubject subject = new ConcreteSubject();

        // 创建观察者
        Observer observerA = new ConcreteObserver("观察者A");
        Observer observerB = new ConcreteObserver("观察者B");

        // 注册观察者
        subject.registerObserver(observerA);
        subject.registerObserver(observerB);

        // 设置状态并通知观察者
        subject.setState("Ready");
        
        // 移除观察者
        subject.removeObserver(observerB);
        
        // 再次设置状态并通知观察者
        subject.setState("Go!");
    }
}

输出结果如下：

观察者A 收到更新，新状态为：Ready
观察者B 收到更新，新状态为：Ready
观察者A 收到更新，新状态为：Go!

3. 观察者模式优缺点

3.1 优点

1. 主题与观察者之间的解耦，主题只需要知道观察者列表，而不必了解观察者的具体实现。
2. 支持广播通信，主题只需要通知观察者列表，而不必通知具体观察者。
3. 观察者可以动态注册和注销，不需要修改主题代码即可增加或减少观察者。
4. 符合开闭原则，新增和删除观察者不会影响主题和其他观察者的代码。

3.2 缺点

1. 观察者太多时，通知所有观察者会消耗大量时间和系统资源。
2. 观察者和主题之间循环依赖时，可能导致代码死循环。
3. 使用不当可能出现事件上下文混乱。

4. 观察者模式使用场景

1. 对象之间存在一对多的关系，一个对象的状态发生变化，需要通知其他多个对象。
2. 当需要增加或删除观察者时，无需修改主题和观察者的代码，只需动态地注册或注销观察者。
3. 当需要广播通知时，观察者模式能够很好地解决这个问题。

5. 总结

观察者模式是一种常用的设计模式，它通过将观察者对象加入到主题对象的观察者列表中，主题对象在状态发生改变时会自动通知观察者对象，从而实现了对象之间的解耦，使得它们之间不再需要互相依赖。使用观察者模式能够很好地提高代码的灵活性和可重用性。