Observer模式在Java中是如何工作的

Observer模式是一种行为设计模式，它定义了对象之间的一对多依赖关系，使得当一个对象改变状态时，所有依赖于它的对象都会得到通知并自动更新。在Java中，Observer模式主要通过以下几个组件实现：

1. Subject（主题）

• 定义：主题是观察者模式的中心对象，它维护一个观察者列表，并提供添加、删除观察者的方法。
• 职责：
  • 维护观察者列表。
  • 提供注册（attach）和注销（detach）观察者的方法。
  • 当状态改变时，通知所有注册的观察者。

2. Observer（观察者）

• 定义：观察者是一个接口，任何希望接收主题状态变化的类都可以实现这个接口。
• 职责：
  • 实现update(Observable o, Object arg)方法，当主题状态改变时，这个方法会被调用。

3. Observable（可观察对象）

• 定义：这是一个抽象类，实现了Subject接口，提供了管理观察者列表和通知观察者的基本实现。
• 职责：
  • 维护一个观察者列表。
  • 提供添加、删除观察者的方法。
  • 当状态改变时，调用setChanged()标记状态已改变，并调用notifyObservers(Object arg)通知所有观察者。

4. ConcreteSubject（具体主题）

• 定义：继承自Observable的具体类，实现了具体的业务逻辑。
• 职责：
  • 实现具体的业务逻辑。
  • 在适当的时候调用setChanged()和notifyObservers(Object arg)来通知观察者。

5. ConcreteObserver（具体观察者）

• 定义：实现了Observer接口的具体类，根据主题的状态变化执行相应的操作。
• 职责：
  • 实现update(Observable o, Object arg)方法，根据传入的参数执行相应的操作。

示例代码

Subject接口

public interface Subject {
    void registerObserver(Observer o);
    void removeObserver(Observer o);
    void notifyObservers();
}

Observer接口

public interface Observer {
    void update(Subject s, Object arg);
}

Observable抽象类

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

public abstract class Observable implements Subject {
    private List<Observer> observers;
    private boolean changed;

    public Observable() {
        observers = new ArrayList<>();
    }

    @Override
    public void registerObserver(Observer o) {
        observers.add(o);
    }

    @Override
    public void removeObserver(Observer o) {
        observers.remove(o);
    }

    @Override
    public void notifyObservers() {
        if (changed) {
            for (Observer observer : observers) {
                observer.update(this, null);
            }
            changed = false;
        }
    }

    protected void setChanged() {
        changed = true;
    }
}

ConcreteSubject类

public class ConcreteSubject extends Observable {
    private String state;

    public void setState(String state) {
        this.state = state;
        setChanged();
        notifyObservers();
    }

    public String getState() {
        return state;
    }
}

ConcreteObserver类

public class ConcreteObserver implements Observer {
    private String name;

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

    @Override
    public void update(Subject s, Object arg) {
        if (s instanceof ConcreteSubject) {
            ConcreteSubject subject = (ConcreteSubject) s;
            System.out.println(name + " received update: " + subject.getState());
        }
    }
}

测试类

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

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

        subject.registerObserver(observer1);
        subject.registerObserver(observer2);

        subject.setState("State 1");
        subject.setState("State 2");

        subject.removeObserver(observer1);

        subject.setState("State 3");
    }
}

总结

Observer模式通过定义对象之间的一对多依赖关系，使得当一个对象的状态发生改变时，所有依赖于它的对象都会得到通知并自动更新。这种模式在Java中主要通过Observable和Observer接口以及它们的具体实现来实现。