技术侦探

# 事件，触发异步消息

在领域驱动设计（Domain-Driven Design, DDD）中，领域事件（Domain Events）是一种模型，用于表示领域中发生的有意义的事件。这些事件对业务来说是重要的，并且通常表示领域状态的变化。适配器（Adapter）在这个上下文中扮演着将领域事件与系统其他部分或外部系统连接起来的角色。

# 概念

领域事件是DDD中的一个关键概念，它代表了领域中发生的一个具有业务意义的事件。这些事件通常是由领域实体或聚合根的状态变化触发的。领域事件不仅仅是数据的变化，它们还承载了业务上下文和业务意图。

# 特性

  1. 意义明确：领域事件通常具有明确的业务含义，例如“用户已下单”、“商品已支付”等。
  2. 不可变性：一旦领域事件被创建，它的状态就不应该被改变。这有助于确保事件的一致性和可靠性。
  3. 时间相关性：领域事件通常包含事件发生的时间戳，这有助于追踪事件的顺序和时间线。
  4. 关联性：领域事件可能与特定的领域实体或聚合根相关联，这有助于完成事件的上下文。
  5. 可观察性：领域事件可以被其他部分的系统监听和响应，有助于实现系统间的解耦。

# 用途

  1. 解耦：领域事件可以帮助系统内部或系统间的不同部分解耦，因为它们提供了一种基于事件的通信机制。
  2. 业务逻辑触发：领域事件可以触发其他业务逻辑的执行，例如推送消息（优惠券到账）、更新其他聚合或生成数据流式报告等。
  3. 事件溯源：领域事件可以用于实现事件溯源（Event Sourcing），这是一种存储系统状态变化的方法，通过重放事件来恢复系统状态。
  4. 集成：领域事件可以用于系统与外部系统的集成，通过发布事件来通知外部系统领域中发生的变化。

# 实现

# 5.1 领域层

  1. 定义事件接口：创建一个或多个接口来定义领域事件的结构和行为。
  2. 创建领域事件类：基于定义的接口，实现具体的领域事件类，包含必要的属性和方法。
  3. 触发领域事件：在领域逻辑中的适当位置，实例化并发布领域事件。

# 5.2 基础层

  1. 实现领域接口：使用消息队列（如RocketMQ或RabbitMQ）来实现领域事件的发布和订阅机制。

# 5.3 触发器层/接口层

  1. 监听领域事件消息：在系统的其他部分或外部系统中，监听领域事件并根据事件来执行相应的业务逻辑或集成逻辑。

# 案例

以下是一个简单的Java事件消息场景案例代码，展示了如何在DDD架构中定义领域事件、发布事件以及如何通过适配器模式将事件传递给外部系统或服务。

首先，我们定义一个领域事件接口和一个具体的领域事件类：

public interface DomainEvent {

​    Date occurredOn();

}

public class OrderCreatedEvent implements DomainEvent {

​    private final String orderId;

​    private final Date occurredOn;

​    public OrderCreatedEvent(String orderId) {

​        this.orderId = orderId;

​        this.occurredOn = new Date();

​    }

​    @Override

​    public Date occurredOn() {

​        return this.occurredOn;

​    }

​    public String getOrderId() {

​        return orderId;

​    }

}

  
        代码已经复制到剪贴板
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

接下来，我们创建一个事件发布器接口和一个基于消息队列的实现：

public interface DomainEventPublisher {

​    void publish(DomainEvent event);

}

public class MessageQueueEventPublisher implements DomainEventPublisher {

​    // 模拟消息队列客户端

​    private final MessageQueueClient messageQueueClient;

​    public MessageQueueEventPublisher(MessageQueueClient messageQueueClient) {

​        this.messageQueueClient = messageQueueClient;

​    }

​    @Override

​    public void publish(DomainEvent event) {

​        // 将领域事件转换为消息并发送到消息队列

​        messageQueueClient.send(serialize(event));

​    }

​    private String serialize(DomainEvent event) {

​        // 序列化事件对象为JSON或其他格式

​        // 这里简化为直接使用toString()

​        return event.toString();

​    }

}

public class MessageQueueClient {

​    public void send(String message) {

​        // 实际的消息发送逻辑

​        System.out.println("Message sent to queue: " + message);

​    }

}

  
        代码已经复制到剪贴板
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

现在，我们可以在领域逻辑中触发领域事件：

public class OrderService {

​    private final DomainEventPublisher eventPublisher;

​    public OrderService(DomainEventPublisher eventPublisher) {

​        this.eventPublisher = eventPublisher;

​    }

​    public void createOrder(String orderId) {

​        // 创建订单的业务逻辑...

​        // 创建并发布订单创建事件

​        OrderCreatedEvent event = new OrderCreatedEvent(orderId);

​        eventPublisher.publish(event);

​    }

}

  
        代码已经复制到剪贴板
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

最后，我们模拟一个外部系统的适配器，它监听消息队列中的事件消息：

public class ExternalSystemAdapter {

​    private final MessageQueueClient messageQueueClient;

​    public ExternalSystemAdapter(MessageQueueClient messageQueueClient) {

​        this.messageQueueClient = messageQueueClient;

​        // 假设这里有一个方法来监听消息队列

​        messageQueueClient.onMessage(this::onEventReceived);

​    }

​    private void onEventReceived(String message) {

​        // 处理接收到的事件消息

​        System.out.println("External system received event: " + message);

​        // 根据事件类型执行相应的逻辑

​    }

}

  
        代码已经复制到剪贴板
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

最终，我们可以在应用程序中初始化这些组件并执行业务逻辑：

public class Application {

​    

​    public static void main(String[] args) {

​        MessageQueueClient messageQueueClient = new MessageQueueClient();

​        DomainEventPublisher eventPublisher = new MessageQueueEventPublisher(messageQueueClient);

​        OrderService orderService = new OrderService(eventPublisher);

​        // 初始化外部系统适配器

​        ExternalSystemAdapter externalSystemAdapter = new ExternalSystemAdapter(messageQueueClient);

​        // 执行业务逻辑，创建订单

​        orderService.createOrder("XFG1000900111199");

​    }

​    

}

  
        代码已经复制到剪贴板
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

在这个例子中，当OrderService创建一个新订单时，它会发布一个OrderCreatedEvent。MessageQueueEventPublisher接收到这个事件，并将其发送到消息队列。ExternalSystemAdapter监听消息队列，并在接收到事件消息时执行相应的逻辑。

请注意，这个例子是为了演示目的而简化的。在实际应用中，你需要处理消息队列的连接、错误处理、事件的序列化和反序列化等复杂问题。

上次更新: 2024/7/9

← 领域服务，实现约定 →