EDA常见的拓扑结构

在事件驱动架构中，Mediator 和 Broker 是两种常见的拓扑结构，它们分别是用来管理和传递事件或消息的组件。尽管它们都涉及事件的传递，但其运作方式和使用场景有所不同。

1. Mediator（中介者模式）

定义：Mediator 是一种中介模式，负责协调不同组件之间的交互 ，通过控制和转发消息来减少组件间的直接依赖和耦合。Mediator 作为一个中心化的组件，管理所有的交互流程，所有组件的消息都经过它来进行转发。
原理：
- 在 Mediator 模式中，各个组件不会直接相互通信，而是通过 Mediator 进行消息传递。
- Mediator 负责接收来自一个组件的消息，并根据需要将其转发给其他相关组件。
- Mediator 模式具有明确的流程和控制机制，可以集中管理复杂的组件交互。
工作流程：
1. 组件（比如UI中的按钮或输入框）发出某种操作或事件。
2. 这些事件通过 Mediator 传递，Mediator 根据业务逻辑或规则将消息转发给其他组件。
3. 通过 Mediator，组件之间的相互依赖减少，解耦变得更加清晰。
例子：想象一个在线购物系统，购物车、商品列表、用户信息都作为独立组件工作。当用户点击"购买"按钮时，商品列表、用户信息和购物车等组件的状态都可能受到影响。Mediator 将充当中心，协调这些组件的交互，确保它们的状态一致。

2. Broker（代理模式）

定义：Broker 是一种事件驱动模式，无中心、无固定流程 ，负责在发布者和订阅者之间传递消息。Broker 模式不控制流程 ，它只是充当"中介"，负责消息的转发。消息的发布者和消费者之间并不直接通信，而是通过 Broker 进行通信。Broker 作为一个解耦的组件，不干涉消息的处理流程。
原理：
- 组件（如发布者或消费者）只需通过 Broker 注册和订阅消息，而无需知道彼此的存在。
- Broker 模式没有中心控制，消息的分发由 Broker 负责，但没有明确的消息传递流程或业务规则。
- 消息可以是异步的，允许多个系统之间解耦。
工作流程：
1. 发布者向 Broker 发布消息。
2. 消费者（多个）可以订阅感兴趣的事件或消息。
3. Broker 将消息发送给所有已订阅的消费者。
4. 发布者和消费者之间没有直接的连接，所有交互都通过 Broker 进行。
例子：在电子商务系统中，订单创建时需要通知库存、支付、发货等多个系统。通过 Broker 模式，订单创建事件可以发布到 Broker，Broker 会将这个事件推送给所有相关的系统，确保各个系统能够处理相关业务。

区别总结：

特性	Mediator	Broker
角色	中介者，管理消息和事件的转发	代理，负责传递消息，但不控制流程
控制	由 Mediator 控制事件的流转和处理	无中心控制，消息由发布者和消费者直接交互
组件交互	组件之间的交互通过 Mediator 进行，遵循明确的交互流程	发布者和消费者通过 Broker 注册和订阅消息，没有固定的处理流程
适用场景	适合较小范围的组件协调，UI 系统、复杂的内部交互等	适合大规模的异步系统，事件驱动的分布式系统

Mediator模式的流程（举例）

假设我们有一个购物车系统，包括商品列表、购物车和支付信息。Mediator 负责协调这些组件。

组件结构：

ProductList（商品列表）：用户选择商品时添加到购物车。
ShoppingCart（购物车）：负责保存选中的商品。
User（用户）：从购物车中移除商品。

Mediator 充当中心角色，协调这些组件的交互。

java 复制代码

// Mediator 接口
public interface ShoppingCartMediator {
    void addProduct(String product);
    void removeProduct(String product);
}

// 购物车类
public class ShoppingCart implements ShoppingCartMediator {
    private List<String> products = new ArrayList<>();

    @Override
    public void addProduct(String product) {
        products.add(product);
        System.out.println("Product added to cart: " + product);
    }

    @Override
    public void removeProduct(String product) {
        products.remove(product);
        System.out.println("Product removed from cart: " + product);
    }
}

// 商品列表类
public class ProductList {
    private ShoppingCartMediator mediator;

    public ProductList(ShoppingCartMediator mediator) {
        this.mediator = mediator;
    }

    public void selectProduct(String product) {
        mediator.addProduct(product);
    }
}

// 用户类
public class User {
    private ShoppingCartMediator mediator;

    public User(ShoppingCartMediator mediator) {
        this.mediator = mediator;
    }

    public void removeFromCart(String product) {
        mediator.removeProduct(product);
    }
}

// 代码示例
public class Main {
    public static void main(String[] args) {
        ShoppingCart cart = new ShoppingCart();
        ProductList productList = new ProductList(cart);
        User user = new User(cart);

        // 用户选择商品
        productList.selectProduct("Laptop");
        productList.selectProduct("Phone");

        // 用户从购物车中删除商品
        user.removeFromCart("Laptop");
    }
}

Broker模式的流程（举例）

假设在一个电商系统中，订单创建时需要通知多个系统（如支付系统、库存系统等）。这时，Broker 模式适用于解耦和异步处理。

组件结构：

OrderCreatedEvent（订单创建事件）：发布订单创建事件。
PaymentSystem（支付系统）：处理订单支付。
InventorySystem（库存系统）：更新库存。

Broker 作为中介者，发布消息并将事件通知给所有订阅者。

java 复制代码

// Broker 接口
public interface EventBroker {
    void registerListener(String eventType, EventListener listener);
    void dispatchEvent(String eventType, String message);
}

// 事件监听器接口
public interface EventListener {
    void onEvent(String message);
}

// 实现一个消息经纪人
public class OrderEventBroker implements EventBroker {
    private Map<String, List<EventListener>> listeners = new HashMap<>();

    @Override
    public void registerListener(String eventType, EventListener listener) {
        listeners.computeIfAbsent(eventType, k -> new ArrayList<>()).add(listener);
    }

    @Override
    public void dispatchEvent(String eventType, String message) {
        if (listeners.containsKey(eventType)) {
            for (EventListener listener : listeners.get(eventType)) {
                listener.onEvent(message);
            }
        }
    }
}

// 各种系统作为事件监听器
public class PaymentSystem implements EventListener {
    @Override
    public void onEvent(String message) {
        System.out.println("Payment System received: " + message);
    }
}

public class InventorySystem implements EventListener {
    @Override
    public void onEvent(String message) {
        System.out.println("Inventory System received: " + message);
    }
}

// 使用示例
public class Main {
    public static void main(String[] args) {
        EventBroker broker = new OrderEventBroker();

        // 注册监听器
        broker.registerListener("orderCreated", new PaymentSystem());
        broker.registerListener("orderCreated", new InventorySystem());

        // 当订单创建时，通知所有注册的系统
        broker.dispatchEvent("orderCreated", "New order created with ID: 12345");
    }
}

通过以上例子可以看到，在 Mediator 模式下，组件之间通过 Mediator 进行交互，而在 Broker 模式下，消息的发布者和订阅者之间通过 Broker 来解耦。