【观察者】设计模式：构建灵活且响应式的软件系统

引言

在软件开发中，我们经常面临需要在多个对象之间进行通信的挑战。特别是当一个对象的状态发生变化时，我们希望所有依赖于这个状态的对象都能自动更新。这就是观察者设计模式大显身手的地方。

简介

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

核心组件

Subject（主题）：也称为Observable，它维护一组观察者，提供添加、删除和通知观察者的接口；
Observer（观察者）：为所有具体观察者定义一个接口，在得到主题的通知时更新自己；
ConcreteSubject（具体主题）：保存状态，当状态变化时通知观察者；
ConcreteObserver（具体观察者）：实现观察者更新接口，以便在主题状态变化时更新自己。

经典实现

// 主题-被观察者
public interface Subject {void registerObserver(Observer observer); //注册观察者void removeObserver(Observer observer); //移除观察者void notifyObservers(Message message); //通知观察者
}
// 观察者
public interface Observer {void update(Message message);
}public class ConcreteSubject implements Subject {private List<Observer> observers = new ArrayList<Observer>();@Overridepublic void registerObserver(Observer observer) {observers.add(observer);}@Overridepublic void removeObserver(Observer observer) {observers.remove(observer);}@Overridepublic void notifyObservers(Message message) {for (Observer observer : observers) {observer.update(message);}}
}//观察者1
public class ConcreteObserverOne implements Observer {@Overridepublic void update(Message message) {//TODO: 获取消息通知，执行自己的逻辑...System.out.println("ConcreteObserverOne is notified.");}
}
//观察者2
public class ConcreteObserverTwo implements Observer {@Overridepublic void update(Message message) {//TODO: 获取消息通知，执行自己的逻辑...System.out.println("ConcreteObserverTwo is notified.");}
}public class Demo {public static void main(String[] args) {ConcreteSubject subject = new ConcreteSubject();subject.registerObserver(new ConcreteObserverOne());subject.registerObserver(new ConcreteObserverTwo());subject.notifyObservers(new Message());}
}

投资理财系统

比如，我们现在在开发一个投资理财系统，用户注册成功后，会给用户发放投资体验金，代码实现大致如下：

public class UserController {private UserService userService; // 依赖注入private PromotionService promotionService; // 依赖注入public Long register(String telephone, String password) {// 注册long userId = userService.register(telephone, password);// 发放体验金promotionService.issueNewUserExperienceCash(userId);return userId;}
}

假如没有扩展和修改的需求，那么现在的代码是可以被接受的。如果非得用观察者模式，就会引入更多的类和更加复杂的代码结构，反而是一种过度设计。

相反，假如需求频繁改动，比如用户注册成功后，不再发放体验金，而是改为发放优惠券，且给用户发送一封“注册成功”的站内信。此时，就需要频繁修改register函数的代码，违反开闭原则。
而且，如果注册成功后需要执行的后续操作越来越多，那register函数也会越来越复杂，影响代码的可读性和可维护性。

同步阻塞实现

//观察者接口
public interface RegObserver {void handleRegSuccess(long userId);
}//观察者1
public class RegPromotionObserver implements RegObserver {private PromotionService promotionService; // 依赖注入@Overridepublic void handleRegSuccess(long userId) {promotionService.issueNewUserExperienceCash(userId);}
}
//观察者2
public class RegNotificationObserver implements RegObserver {private NotificationService notificationService;@Overridepublic void handleRegSuccess(long userId) {notificationService.sendInboxMessage(userId, "Welcome...");}
}public class UserController {private UserService userService; // 依赖注入private List<RegObserver> regObservers = new ArrayList<>();// 设置观察者public void setRegObservers(List<RegObserver> observers) {regObservers.addAll(observers);}public Long register(String telephone, String password) {long userId = userService.register(telephone, password);//通知观察者for (RegObserver observer : regObservers) {observer.handleRegSuccess(userId);}return userId;}
}