设计模式学习笔记：观察者模式及应用场景

关注

原创最新推荐文章于 2026-06-03 14:54:13 发布 262 阅读 AI 写同款· GEO 优化 ›

surfer10与Arcgis10.3 完美生成等值线和等值面方法 surfer10 与Arcgis10.3生成等值线和等值面的步骤如下： 1.准备surfer用的Book1.dat文件，格式如下： "x" "y" "z" 116.471992 40.809975 232 116.335556 40.700542 1235 116.541626 40.713333 214 116.73349 40.798607 566 2.在surfer中，选择Gr 阅读详情

观察者模式（Observer Design Pattern）,也叫做发布订阅模式（Publish-Subscribe Design Pattern）、模型-视图（Model-View）模式、源-监听器（Source-Listener）模式、从属者（Dependents）模式。指在对象之间定义一个一对多的依赖，当一个对象状态改变的时候，所有依赖的对象都会自动收到通知。

比如说Redis 中的基于频道的发布订阅就是观察者模式的应用：

一、观察者模式的介绍

观察者模式是一种对象行为型模式，下面就来看看观察者模式的结构及其实现：

1.1 观察者模式的结构

观察者模式结构中主要包括观察目标（Object）和观察者（Observer）主要结构：

Subject
ConcreteSubject
Observer
ConcreteObserver1、ConcreteObserver2
Client

1.2 观察者模式的实现

根据上面的类图，我们可以实现对应的代码。

首先定义一个抽象目标类 Subject ，其中包括增加、注销和通知观察者方法

public abstract class Subject {

    protected List<Observer> observerList = new ArrayList<Observer>();

    /**
     * 增加观察者
     * @param observer 观察者
     */
    public void add(Observer observer) {
        observerList.add(observer);
    }

    /**
     * 注销观察者，从观察者集合中删除一个观察者
     * @param observer 观察者
     */
    public void remove(Observer observer) {
        observerList.remove(observer);
    }

    /**通知观察者*/
    public abstract void notifyObserver();
}

对应具体的目标类 ConcreteSubject

public class ConcreteSubject extends Subject{

    @Override
    public void notifyObserver() {
        System.out.println("遍历观察者：");
        for (Observer observer : observerList) {
            observer.response();
        }
    }
}

此外需要定义抽象观察者 Observer ，它一般定义为一个接口，声明一个 response() 方法，为不同观察者的相应行为定义相同的接口：

public interface Observer {
    /**声明响应方法*/
    void response();
}

具体的观察者实现：

public class ConcreteObserver1 implements Observer{

    @Override
    public void response() {
        System.out.println("我是具体观察者ConcreteObserver1");
    }
}

public class ConcreteObserver2 implements Observer{

    @Override
    public void response() {
        System.out.println("我是具体观察者ConcreteObserver2");
    }
}

最后是客户端测试：

public class Client {
    public static void main(String[] args) {
        Subject concreteSubject = new ConcreteSubject();
        //具体观察者
        Observer concreteObserver1 = new ConcreteObserver1();
        Observer concreteObserver2 = new ConcreteObserver2();
        concreteSubject.add(concreteObserver1);
        concreteSubject.add(concreteObserver2);
        
        concreteSubject.notifyObserver();
    }
}

测试结果：

遍历观察者：
我是具体观察者ConcreteObserver1
我是具体观察者ConcreteObserver2

二、观察者模式的应用场景

在以下情况就可以考虑使用观察者模式：

一个对象的改变会导致一个或多个对象发生改变，而并不知道具体有多少对象将会发生改变，也不知道这些对象是谁
当一个抽象模型有两个方面，其中的一个方面依赖于另一个方面时，可将这两者封装在独立的对象中以使他们可以各自独立地改变和复用
需要在系统中创建一个触发链，使得事件拥有跨域通知（跨越两种观察者的类型）

2.1 观察者模式在java.util包中的应用

观察者模式在JDK中就有典型应用，比如 java.util.Observable 和 java.util.Observer 类。结构如下图所示：

我们可以通过实现具体的 ConcreteObserver 和具体的 ConcreteObservable 完成观察者模式流程

2.2 观察者模式在MVC中的应用

MVC(Modew-View-Controller)架构中也应用了观察者模式，其中模型（Model）可以对应观察者模式中的观察目标，而视图（View）对应于观察者，控制器（Controller）就是中介者模式的应用：

三、观察者模式实战

在本案例中模拟北京小客车指标摇号事件的通知场景（来源于《重学Java设计模式》）

对于通知事件，可以将其分成三个部分： 事件监听 、 事件处理 和 具体的业务流程 ，如下图所示：

对于和核心流程和非核心流程的结构，非核心流程可以是异步的，在MQ以及定时任务的处理下，能够最终保证一致性。

具体代码实现

事件监听接口及具体实现

这个部分就相当于观察者（Observer）的角色

在接口中定义基本事件类方法 doEvent()

public interface EventListener {

    void doEvent(LotteryResult result);

}

监听事件的具体实现 MessageEventListener （短消息事件）和 MQEventListener （MQ发送事件）

public class MessageEventListener implements EventListener{

    private Logger logger = LoggerFactory.getLogger(MessageEventListener.class);

    @Override
    public void doEvent(LotteryResult result) {
        logger.info("给用户 {} 发送短信通知(短信)：{}", result.getuId(), result.getMsg());
    }
}

public class MQEventListener implements EventListener{

    private Logger logger = LoggerFactory.getLogger(MQEventListener.class);

    @Override
    public void doEvent(LotteryResult result) {
        logger.info("记录用户 {} 摇号结果(MQ)：{}", result.getuId(), result.getMsg());
    }
}

事件处理类

该部分就相当于主题（Object）部分

对于不同的事件类型（MQ和Message）进行枚举处理，并提供三个方法： subscribe() 、 unsubscribe() 和 notify() 用于对监听事件的注册和使用：

public class EventManager {

    Map<Enum<EventType>, List<EventListener>> listeners = new HashMap<>();

    public EventManager(Enum<EventType>... operations) {
        for (Enum<EventType> operation : operations) {
            listeners.put(operation, new ArrayList<>());
        }
    }

    public enum EventType {
        MQ,
        Message
    }

    /**
     * 订阅
     * @param eventType 事件类型
     * @param listener  监听
     */
    public void subscribe(Enum<EventType> eventType, EventListener listener) {
        List<EventListener> eventListeners = listeners.get(eventType);
        eventListeners.add(listener);
    }

    /**
     * 取消订阅
     * @param eventType 事件类型
     * @param listener 监听
     */
    public void unsubscribe(Enum<EventType> eventType, EventListener listener) {
        List<EventListener> eventListeners = listeners.get(eventType);
        eventListeners.remove(listener);
    }

    /**
     * 通知
     * @param eventType 事件类型
     * @param result    结果
     */
    public void notify(Enum<EventType> eventType, LotteryResult result) {
        List<EventListener> eventListeners = listeners.get(eventType);
        for (EventListener eventListener : eventListeners) {
            eventListener.doEvent(result);
        }
    }
}

业务抽象类接口及其实现

使用抽象类的方式实现方法，好处是可以在方法中扩展额外的调用，并提供抽象方法 doDraw ，让继承者去实现具体的逻辑

public abstract class LotteryService {

    private EventManager eventManager;

    public LotteryService() {
        eventManager = new EventManager(EventManager.EventType.MQ, EventManager.EventType.Message);
        eventManager.subscribe(EventManager.EventType.MQ, new MQEventListener());
        eventManager.subscribe(EventManager.EventType.Message, new MessageEventListener());
    }

    public LotteryResult draw(String uId) {
        LotteryResult lotteryResult = doDraw(uId);
        eventManager.notify(EventManager.EventType.MQ, lotteryResult);
        eventManager.notify(EventManager.EventType.Message, lotteryResult);
        return lotteryResult;
    }

    protected abstract LotteryResult doDraw(String uId);
}

public class LotteryServiceImpl extends LotteryService{

    private MinibusTargetService minibusTargetService = new MinibusTargetService();

    @Override
    protected LotteryResult doDraw(String uId) {
        //摇号测试
        String lottery = minibusTargetService.lottery(uId);
        return new LotteryResult(uId, lottery, new Date());
    }
}

其他的类

摇号服务接口：

/**
 * 小客车指标调控服务
 */
public class MinibusTargetService {

    /**
     * 模拟摇号，但不是摇号算法
     *
     * @param uId 用户编号
     * @return 结果
     */
    public String lottery(String uId) {
        return Math.abs(uId.hashCode()) % 2 == 0 ? "恭喜你，编码".concat(uId).concat("在本次摇号中签") : "很遗憾，编码".concat(uId).concat("在本次摇号未中签或摇号资格已过期");
    }

}

事件信息返回类：

public class LotteryResult {

    private String uId;
    private String msg;
    private Date dateTime;

    //get set constructor... 
}

测试类

public class ApiTest {

    private Logger logger = LoggerFactory.getLogger(ApiTest.class);

    @Test
    public void test() {
        LotteryServiceImpl lotteryService = new LotteryServiceImpl();
        LotteryResult result = lotteryService.draw("1234567");
        logger.info("摇号结果：{}", JSON.toJSONString(result));
    }
}

测试结果：

11:43:09.284 [main] INFO  c.e.d.event.listener.MQEventListener - 记录用户 1234567 摇号结果(MQ)：恭喜你，编码1234567在本次摇号中签
11:43:09.288 [main] INFO  c.e.d.e.l.MessageEventListener - 给用户 1234567 发送短信通知(短信)：恭喜你，编码1234567在本次摇号中签
11:43:09.431 [main] INFO  ApiTest - 摇号结果：{"dateTime":1649475789279,"msg":"恭喜你，编码123