编程设计模式之观察者模式
为什么有观察者模式?
在软件开发中,经常会有一种场景,一个对象的状态发生变化时,需要通知其他相关的对象。如果直接在对象之间进行硬编码的依赖,会导致代码的耦合度增加,不利于后期的维护和扩展。观察者模式就是为了解决这一问题而诞生的。
观察者模式的设计思路
观察者模式也被称为发布-订阅模式,它定义了一种一对多的依赖关系,让多个观察者对象同时监听一个主题对象。当主题对象状态发生变化时,会通知所有的观察者对象,使它们能够自动更新。
观察者模式包含四个主要角色:
- Subject(主题):被观察的对象,它负责管理所有的观察者对象,并提供了增加、删除和通知观察者的方法。
- Observer(观察者):观察主题对象的变化,并在主题状态发生改变时更新自己。
- ConcreteSubject(具体主题):实现了主题接口,维护了一个观察者列表,并在状态发生改变时通知观察者。
- ConcreteObserver(具体观察者):实现了观察者接口,在接收到主题的通知时进行相应的更新操作。
Java示例代码
下面是一个简单的Java示例代码,演示了观察者模式的应用:
java
import java.util.ArrayList;
import java.util.List;
// 主题接口
interface Subject {
void registerObserver(Observer observer);
void removeObserver(Observer observer);
void notifyObservers();
}
// 观察者接口
interface Observer {
void update(String message);
}
// 具体主题
class ConcreteSubject implements Subject {
private List<Observer> observers = new ArrayList<>();
private String message;
@Override
public void registerObserver(Observer observer) {
observers.add(observer);
}
@Override
public void removeObserver(Observer observer) {
observers.remove(observer);
}
@Override
public void notifyObservers() {
for (Observer observer : observers) {
observer.update(message);
}
}
public void setMessage(String message) {
this.message = message;
notifyObservers();
}
}
// 具体观察者
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 Main {
public static void main(String[] args) {
// 创建具体主题
ConcreteSubject subject = new ConcreteSubject();
// 创建具体观察者,并注册到主题
Observer observer1 = new ConcreteObserver("Observer1");
Observer observer2 = new ConcreteObserver("Observer2");
subject.registerObserver(observer1);
subject.registerObserver(observer2);
// 主题状态发生改变,通知观察者
subject.setMessage("Hello, World!");
}
}
SpringBoot工程中如何应用观察者模式
在SpringBoot工程中,观察者模式常被用于事件驱动的编程,例如Spring框架中的事件机制就是一种典型的观察者模式的应用。
首先,定义一个事件对象:
java
public class MyEvent {
private String message;
public MyEvent(String message) {
this.message = message;
}
public String getMessage() {
return message;
}
}
然后,定义观察者:
java
@Component
public class MyObserver implements ApplicationListener<MyEvent> {
@Override
public void onApplicationEvent(MyEvent event) {
System.out.println("Received event: " + event.getMessage());
}
}
最后,在需要发布事件的地方,注入ApplicationEventPublisher并发布事件:
java
@Service
public class MyService {
private final ApplicationEventPublisher eventPublisher;
@Autowired
public MyService(ApplicationEventPublisher eventPublisher) {
this.eventPublisher = eventPublisher;
}
public void doSomething() {
// 发布事件
eventPublisher.publishEvent(new MyEvent("Hello, World!"));
}
}
通过这种方式,在SpringBoot工程中,我们可以方便地实现观察者模式,实现对象之间的解耦。