中介者模式

用途：
如果多个服务经常一起使用，可以创建一个中介者服务来封装这些服务的协作。请举个例子，说明一下如何引入中介者，中介者如何帮助程序找到该使用的服务

中介者模式的例子

引入中介者模式的目的是为了降低系统中多个组件或类之间的直接交互，从而减少它们之间的耦合度。中介者充当协调者的角色，使得各个组件不需要直接相互引用，而是通过中介者来进行通信。

下面是一个简单的例子，说明如何在一个电商应用中引入中介者服务来封装订单处理的协作逻辑：

假设我们有以下几个服务：

• InventoryService：库存服务，负责管理商品库存。
• PaymentService：支付服务，负责处理支付事务。
• ShippingService：物流服务，负责处理商品配送。

在没有中介者的情况下

一个订单处理的服务可能直接依赖上述所有服务

@Service
public class OrderService {
    @Autowired
    private InventoryService inventoryService;
    @Autowired
    private PaymentService paymentService;
    @Autowired
    private ShippingService shippingService;

    public void processOrder(Order order) {
        // 检查库存
        boolean inStock = inventoryService.checkInventory(order);
        if (!inStock) {
            throw new OutOfStockException();
        }
        // 处理支付
        paymentService.processPayment(order.getPaymentDetails());
        // 安排发货
        shippingService.scheduleDelivery(order);
    }
}

引入中介者后

我们可以创建一个名为 OrderProcessingService 的中介者服务来封装订单处理的逻辑：

@Service
public class OrderProcessingService {
    private final InventoryService inventoryService;
    private final PaymentService paymentService;
    private final ShippingService shippingService;

    @Autowired
    public OrderProcessingService(InventoryService inventoryService,
                                  PaymentService paymentService,
                                  ShippingService shippingService) {
        this.inventoryService = inventoryService;
        this.paymentService = paymentService;
        this.shippingService = shippingService;
    }

    public void processOrder(Order order) {
        // 检查库存
        boolean inStock = inventoryService.checkInventory(order);
        if (!inStock) {
            throw new OutOfStockException();
        }
        // 处理支付
        paymentService.processPayment(order.getPaymentDetails());
        // 安排发货
        shippingService.scheduleDelivery(order);
    }
}

现在，其他服务或控制器可以只依赖这个 OrderProcessingService，而不是直接依赖三个不同的服务：

@RestController
public class OrderController {
    private final OrderProcessingService orderProcessingService;

    @Autowired
    public OrderController(OrderProcessingService orderProcessingService) {
        this.orderProcessingService = orderProcessingService;
    }

    @PostMapping("/order")
    public ResponseEntity<String> createOrder(@RequestBody Order order) {
        orderProcessingService.processOrder(order);
        return ResponseEntity.ok("Order processed successfully");
    }
}

结论

通过这种方式，OrderController 只需要与 OrderProcessingService 交互，而不必关心订单处理涉及到的底层服务细节。这样，如果将来订单处理的逻辑发生变化，只需要修改 OrderProcessingService，而不会影响到 OrderController。

中介者服务 OrderProcessingService 使得程序更容易找到并使用正确的服务，因为它为订单处理提供了一个清晰的、单一的入口点。这样的封装还降低了组件之间的耦合，提高了代码的可维护性和可扩展性。