返回专栏
· 17 分钟阅读

响应式与事件驱动编程


一、响应式编程(Reactive Programming)

1. 什么是响应式编程

响应式编程是一种面向数据变化和传播过程的编程范式。

其核心思想是:将数据变化视为可观察的信号,当数据发生变化时,依赖该数据的计算和处理逻辑能够自动响应。

传统命令式编程通常由开发者显式控制更新过程:

let price = 100;
let quantity = 2;

let total = price * quantity;

price = 120;

// 必须手动重新计算
total = price * quantity;

console.log(total); // 240

响应式编程则强调建立数据之间的依赖关系,使派生数据能够随着源数据变化而更新。

概念上:

price ─────┐
           ├──> total
quantity ──┘

这里的关系表示 total 依赖 price 和 quantity。当任一依赖发生变化时,系统可以触发重新计算。

2. 响应式系统的核心组成

一个典型的响应式系统通常包含以下组成部分:

组成 作用
数据源(Source) 提供初始值或持续变化的数据
可观察对象(Observable) 表示可以被订阅的数据流
订阅者(Subscriber) 接收数据变化并执行处理
操作符(Operator) 转换、过滤、组合数据流
调度器(Scheduler) 控制任务执行时机和调度策略
依赖追踪(Dependency Tracking) 记录数据与计算逻辑之间的依赖关系

并非所有响应式框架都采用完全相同的实现结构。例如,基于信号(Signal)的系统通常直接追踪状态依赖,而 RxJS 一类的流式系统则以 Observable 和订阅机制为核心。

3. 响应式数据传播机制

响应式系统通常需要完成依赖建立、变化检测、依赖通知和派生计算。

flowchart TD
    A["创建数据源"] --> B["建立依赖关系"]
    B --> C["订阅或追踪依赖"]
    C --> D["源数据发生变化"]
    D --> E["检测变化"]
    E --> F["通知依赖节点"]
    F --> G["重新计算或执行回调"]
    G --> H["更新下游状态或视图"]

    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style C fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style D fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style E fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style F fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style G fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style H fill:#E8EDF2,stroke:#B8C3CE,color:#334155
    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

需要注意,响应式不意味着每次数据变化都会立即同步执行所有依赖逻辑。具体执行时机取决于框架的调度策略,可能涉及批处理、微任务、宏任务或延迟计算。

4. 响应式数据与依赖追踪

响应式系统的重要能力是自动建立数据依赖。

例如:

const state = {
    price: 100,
    quantity: 2
};

function getTotal() {
    return state.price * state.quantity;
}

如果使用响应式系统,执行 getTotal() 时可以记录它读取了哪些响应式属性。

当 price 或 quantity 更新时,系统便知道需要重新执行相关计算。

依赖关系可以抽象为:

flowchart TD
    A["price"] --> C["getTotal"]
    B["quantity"] --> C
    C --> D["total"]
    D --> E["视图更新"]

    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style C fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style D fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style E fill:#FFF5DE,stroke:#E8D29A,color:#334155
    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

在 JavaScript 中,可以通过 Proxy 实现简单的属性访问追踪:

const dependencies = new Map();

let activeEffect = null;

function reactive(target) {
    return new Proxy(target, {
        get(obj, key) {
            if (activeEffect) {
                let effects = dependencies.get(key);

                if (!effects) {
                    effects = new Set();
                    dependencies.set(key, effects);
                }

                effects.add(activeEffect);
            }

            return obj[key];
        },

        set(obj, key, value) {
            obj[key] = value;

            const effects = dependencies.get(key);

            if (effects) {
                effects.forEach(effect => effect());
            }

            return true;
        }
    });
}

function effect(fn) {
    activeEffect = fn;
    fn();
    activeEffect = null;
}

const state = reactive({
    price: 100,
    quantity: 2
});

effect(() => {
    console.log(state.price * state.quantity);
});

state.price = 120;

这个简化示例演示了依赖收集和触发更新的基本思想。

生产级响应式系统还需要处理:

  • 多个对象具有相同属性名时的依赖隔离。
  • 嵌套对象和数组的依赖追踪。
  • 条件分支导致的动态依赖变化。
  • 删除属性和新增属性。
  • 嵌套 effect 的上下文恢复。
  • 循环更新与重复触发。
  • 批量调度和更新顺序。

例如,上面的示例仅使用属性名作为依赖键,不同对象中相同名称的属性会产生错误的依赖关联,因此不能直接用于生产环境。

5. 响应式数据流

响应式编程不仅可以处理单个变量的变化,还可以将连续发生的数据变化组织成数据流(Data Stream)。

数据流可以表示:

  • 用户输入。
  • 鼠标移动。
  • 网络请求结果。
  • 定时器信号。
  • 消息队列数据。
  • 传感器数据。
  • 实时业务事件。

例如,使用 RxJS:

import { fromEvent } from "rxjs";
import { map, filter } from "rxjs/operators";

const clicks = fromEvent(
    document,
    "click"
);

const positions = clicks.pipe(
    map(event => ({
        x: event.clientX,
        y: event.clientY
    })),
    filter(position => position.x > 100)
);

const subscription = positions.subscribe(position => {
    console.log(position);
});

这里:

  • fromEvent 将 DOM 事件转换为 Observable。
  • map 将原始事件转换为坐标数据。
  • filter 过滤不满足条件的数据。
  • subscribe 注册数据流消费者。

数据流处理的优势是可以通过操作符逐步构建复杂的异步处理逻辑。

6. 响应式编程的主要特点

声明式数据关系

开发者描述数据依赖和转换规则,而不必在每个数据修改位置手动更新所有关联状态。

自动依赖传播

数据发生变化时,系统根据依赖关系通知相关计算或订阅者。

异步数据处理

可以统一处理定时器、网络请求、用户输入和消息事件等异步数据源。

数据流组合

通过映射、过滤、合并、节流等操作符构建复杂的数据处理流程。

执行调度

系统可以控制更新时机,支持批处理、延迟执行和并发调度。


二、事件驱动编程(Event-Driven Programming)

1. 什么是事件驱动编程

事件驱动编程是一种以事件发生作为程序执行触发条件的编程模型。

事件(Event)表示系统中发生的某种事实或状态变化,例如:

  • 用户点击按钮。
  • HTTP 请求到达。
  • 定时器触发。
  • 文件读取完成。
  • 数据库连接断开。
  • 消息队列收到消息。
  • 订单状态发生变化。

程序不必按照固定顺序主动轮询所有可能发生的情况,而是注册事件处理逻辑,在事件到达时执行对应操作。

例如:

const button = document.querySelector("#submit");

button.addEventListener("click", () => {
    console.log("按钮被点击");
});

这里:

  • click 是事件类型。
  • addEventListener 注册事件监听器。
  • 回调函数是事件处理器。
  • 用户点击按钮时,浏览器触发事件处理流程。

2. 事件驱动系统的核心组成

组成 作用
事件源(Event Source) 产生事件的实体
事件(Event) 描述发生的事实
事件监听器(Listener) 监听指定类型的事件
事件处理器(Handler) 接收事件并执行业务逻辑
事件分发器(Dispatcher) 将事件分发给相应处理器
事件队列(Event Queue) 暂存等待处理的事件
事件循环(Event Loop) 协调事件与任务的执行

不同系统不一定包含所有组件。

例如,浏览器 DOM 事件具有事件传播机制,而消息队列驱动的后端系统可能由 Broker、Consumer 和消息确认机制组成。

3. 事件驱动的基本执行流程

flowchart TD
    A["事件源产生事件"] --> B["事件进入分发机制"]
    B --> C["匹配监听器"]
    C --> D["调用事件处理器"]
    D --> E{"处理成功?"}
    E -->|"是"| F["完成事件处理"]
    E -->|"否"| G["执行异常处理"]
    G --> H["记录错误或重试"]
    H --> I["结束或重新投递"]

    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style C fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style D fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style E fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style F fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style G fill:#FBE9E9,stroke:#D9AAAA,color:#334155
    style H fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style I fill:#E8EDF2,stroke:#B8C3CE,color:#334155
    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

事件驱动模型的关键是事件与处理逻辑之间的关联关系,而不是必须存在一个独立的事件队列。

4. 事件监听与处理

在 JavaScript 中,可以使用 EventTarget 实现事件监听。

const eventTarget = new EventTarget();

function handleOrderCreated(event) {
    console.log("订单创建成功:", event.detail);
}

eventTarget.addEventListener(
    "orderCreated",
    handleOrderCreated
);

const event = new CustomEvent("orderCreated", {
    detail: {
        orderId: 1001,
        amount: 299
    }
});

eventTarget.dispatchEvent(event);

这里通过自定义事件将事件产生者与处理逻辑分离。

事件生产者只负责发布事件,不需要直接知道具体由谁处理。

5. 发布订阅模式(Publish-Subscribe)

发布订阅模式是事件驱动编程中常见的设计模式。

它通过事件主题或消息通道建立发布者和订阅者之间的间接关系。

  • 发布者(Publisher):发布事件。
  • 订阅者(Subscriber):订阅感兴趣的事件。
  • 事件中心(Event Bus):负责接收和分发事件。

例如:

class EventBus {
    constructor() {
        this.events = new Map();
    }

    on(type, handler) {
        if (!this.events.has(type)) {
            this.events.set(type, new Set());
        }

        this.events.get(type).add(handler);
    }

    emit(type, data) {
        const handlers = this.events.get(type);

        if (!handlers) {
            return;
        }

        handlers.forEach(handler => handler(data));
    }

    off(type, handler) {
        this.events.get(type)?.delete(handler);
    }
}

const bus = new EventBus();

bus.on("orderCreated", data => {
    console.log("通知库存服务", data);
});

bus.on("orderCreated", data => {
    console.log("通知消息服务", data);
});

bus.emit("orderCreated", {
    orderId: 1001
});

一个事件可以被多个订阅者接收,实现一对多的消息分发。

需要注意,以上实现是同步的内存事件总线,不具备持久化、跨进程传输、消息确认和失败重试等能力。

6. 事件驱动与事件循环

在 JavaScript 浏览器环境和 Node.js 中,事件循环(Event Loop)是异步任务调度的重要机制。

以浏览器环境为例,主要涉及:

  • 调用栈(Call Stack)。
  • 浏览器提供的 Web APIs。
  • 任务队列(Task Queue)。
  • 微任务队列(Microtask Queue)。
  • 事件循环调度。

典型执行关系:

flowchart TD
    A["执行同步代码"] --> B["调用栈执行完成"]
    B --> C["执行微任务队列"]
    C --> D{"是否还有微任务?"}
    D -->|"是"| C
    D -->|"否"| E["浏览器执行渲染机会"]
    E --> F["执行下一个宏任务"]
    F --> G["检查微任务队列"]
    G --> C

    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style C fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style D fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style E fill:#E8EDF2,stroke:#B8C3CE,color:#334155
    style F fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style G fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

这里需要特别注意:

  1. 同步代码在当前调用栈中执行。
  2. 当前任务结束后,浏览器会执行微任务检查点。
  3. 微任务通常包括 Promise 回调和 queueMicrotask 注册的任务。
  4. 浏览器在适当时机执行渲染。
  5. 随后继续处理后续任务。

这个流程是浏览器事件循环的简化模型。Node.js 的事件循环阶段、调度规则和渲染机制与浏览器不同,不能直接套用浏览器的完整执行顺序。


三、响应式编程与事件驱动编程的区别

两者经常结合使用,但关注点并不相同。

1. 核心区别

对比维度 响应式编程 事件驱动编程
核心关注 数据变化与传播 事件发生与处理
基本抽象 数据流、状态、依赖 事件、监听器、处理器
触发依据 数据源变化 事件被触发
处理方式 转换、过滤、组合、传播 分发、监听、执行处理器
典型场景 状态管理、实时数据流 用户交互、消息处理
常见技术 RxJS、Reactor、Signals DOM Events、EventEmitter、消息队列
设计目标 管理数据变化关系 解耦事件产生与事件处理

2. 两者的关系

响应式编程可以使用事件作为数据源,事件驱动系统也可以使用响应式数据流处理事件。

例如:

flowchart TD
    A["用户点击按钮"] --> B["产生 Click 事件"]
    B --> C["转换为响应式数据流"]
    C --> D["过滤无效事件"]
    D --> E["执行数据转换"]
    E --> F["更新应用状态"]
    F --> G["触发视图更新"]

    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style C fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style D fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style E fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style F fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style G fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

两者的结合可以同时获得:

  • 事件生产与业务处理之间的解耦。
  • 数据变化的自动传播。
  • 数据流的转换与组合能力。
  • 对异步处理过程的统一管理。

四、响应式编程的典型实现机制

不同响应式框架采用的实现方式并不完全相同,但常见机制包括依赖追踪、订阅通知、数据流操作和调度执行。

1. 观察者模式(Observer Pattern)

观察者模式通过维护观察者列表,使一个对象的状态变化能够通知多个观察者。

基本结构:

  • Subject:被观察对象。
  • Observer:观察者。
  • Notify:通知机制。
  • Update:观察者的更新行为。
class Subject {
    constructor() {
        this.observers = new Set();
    }

    subscribe(observer) {
        this.observers.add(observer);
    }

    unsubscribe(observer) {
        this.observers.delete(observer);
    }

    notify(data) {
        this.observers.forEach(observer => {
            observer.update(data);
        });
    }
}

class Observer {
    update(data) {
        console.log("收到更新:", data);
    }
}

const subject = new Subject();

const observer1 = new Observer();
const observer2 = new Observer();

subject.subscribe(observer1);
subject.subscribe(observer2);

subject.notify({
    value: 100
});

观察者模式适合实现一对多的通知关系。