DDD架构下订单跨聚合引用问题及优化方案咨询

安全阿岳

2026-8-25

DDD领域设计订单分配问题咨询

场景描述

客户提交订单列表（例如：customer1的订单包含Onion、Apple、Orange、Wireless Mouse、PC、Fish、Egg），每个订单可分配至不同商店（例如：Grocery Store负责Onion、Apple、Orange、Fish、Egg这类商品）。

当前设计问题

现有设计将Customer作为聚合根持有Order实体列表，Order为实体；同时Store也作为聚合根，需要持有订单列表。这违反了DDD中聚合根不应引用其他聚合根内实体的规则，且部分订单可分配给多个商店，导致数据关联逻辑混乱。

纠结的三个方案

方案1：保留Customer中的Order实体，为每个Order分配Store列表；
方案2：将Order设为聚合根，包含订单列表及customerId，但不知道如何对订单列表做整体验证；
方案3：将Customer中的Order改为值对象，复制给其他聚合根，但维护难度极高。

现有代码实现

Customer与Order类

public class Customer : AggregateRoot<long>
{
    public long Id { get;private set; }
    public string CustomerName { get;private set; }

    private List<Order> _orders = new List<Order>();
    public IReadOnlyCollection<Order> Orders => _orders.AsReadOnly();

    public Customer(long id, string customerName)
    {
        Id = id;
        CustomerName = customerName;
    }

    public void AssignOrders(List<Order> orders)
    {
        //check some validation on orders before assignments
        this._orders=orders;
    }
}

public class Order : Entity<long>
{
    public long Id { get;private set; }
    public string Name { get;private set; }

    public Order(long id,string name)
    {
        //check some validation for single order before creation
        this.Id=id;
        this.Name=name; 
    }
}

Store类

public class Store:AggregateRoot<long>
{
    public long Id { get;private set; }
    public string StoreName { get;private set; }
    private List<Order> _orders = new List<Order>();
    public IReadOnlyCollection<Order> Orders => _orders.AsReadOnly();

    public Store(string storeName, long id)
    {
        StoreName = storeName;
        Id = id;
    }

    public void AssignOrders(List<Order> orders)
    {
        //check some validation on orders before assignments
        this._orders = orders;
    }
}

方案分析与建议

方案1分析

该方案保留Customer聚合对Order的持有，但需注意：Order不能直接引用Store实体，只能存储StoreId集合（避免跨聚合引用实体）。不过这种设计下，订单的分配操作需要通过Customer聚合根触发，虽然能保证Customer聚合的完整性，但Store侧无法直接持有订单关联，只能通过StoreId查询订单，适配性一般。且如果订单分配是独立于客户的高频操作，这种设计会增加Customer聚合的复杂度。

方案2分析（推荐）

将Order设为独立聚合根是更符合DDD原则的选择：订单本身具备独立的业务生命周期，且涉及跨聚合（客户、商店）的关联，适合作为聚合根。

解决订单列表整体验证的问题

可以通过领域服务来处理订单列表的整体验证逻辑，步骤如下：

验证客户的合法性（比如是否具备下单资格）；
对每个订单，验证关联的商店是否支持该商品；
批量创建并保存Order聚合根。

优化后的代码示例

Order聚合根

public class Order : AggregateRoot<long>
{
    public long Id { get; private set; }
    public long CustomerId { get; private set; }
    public string ProductName { get; private set; }
    private List<long> _storeIds = new List<long>();
    public IReadOnlyCollection<long> StoreIds => _storeIds.AsReadOnly();

    private Order() { } // 供ORM框架使用的无参构造

    public Order(long id, long customerId, string productName)
    {
        if (customerId <= 0)
            throw new ArgumentException("客户ID无效");
        if (string.IsNullOrWhiteSpace(productName))
            throw new ArgumentException("商品名称不能为空");

        Id = id;
        CustomerId = customerId;
        ProductName = productName;
    }

    public void AssignStore(long storeId)
    {
        if (storeId <= 0)
            throw new ArgumentException("商店ID无效");
        if (!_storeIds.Contains(storeId))
            _storeIds.Add(storeId);
    }

    public void RemoveStore(long storeId)
    {
        _storeIds.Remove(storeId);
    }
}

Customer聚合根（简化，不再持有Order）

public class Customer : AggregateRoot<long>
{
    public long Id { get; private set; }
    public string CustomerName { get; private set; }

    public Customer(long id, string customerName)
    {
        if (id <= 0)
            throw new ArgumentException("客户ID无效");
        if (string.IsNullOrWhiteSpace(customerName))
            throw new ArgumentException("客户名称不能为空");

        Id = id;
        CustomerName = customerName;
    }

    // 验证客户是否具备下单资格的业务方法
    public bool CanPlaceOrders()
    {
        // 示例规则：客户状态正常则允许下单
        return true;
    }
}

Store聚合根（简化，不再持有Order）

public class Store : AggregateRoot<long>
{
    public long Id { get; private set; }
    public string StoreName { get; private set; }

    public Store(long id, string storeName)
    {
        if (id <= 0)
            throw new ArgumentException("商店ID无效");
        if (string.IsNullOrWhiteSpace(storeName))
            throw new ArgumentException("商店名称不能为空");

        Id = id;
        StoreName = storeName;
    }

    // 验证商店是否支持指定商品的业务方法
    public bool IsProductSupported(string productName)
    {
        // 根据商店类型定义支持的商品列表，示例为生鲜店
        var supportedProducts = new List<string> { "Onion", "Apple", "Orange", "Fish", "Egg" };
        return supportedProducts.Contains(productName, StringComparer.OrdinalIgnoreCase);
    }
}

订单批量处理领域服务

public class OrderBatchService
{
    private readonly ICustomerRepository _customerRepository;
    private readonly IStoreRepository _storeRepository;
    private readonly IOrderRepository _orderRepository;

    public OrderBatchService(ICustomerRepository customerRepository, IStoreRepository storeRepository, IOrderRepository orderRepository)
    {
        _customerRepository = customerRepository;
        _storeRepository = storeRepository;
        _orderRepository = orderRepository;
    }

    public void CreateAndAssignOrders(long customerId, List<(string ProductName, List<long> StoreIds)> orderItems)
    {
        // 验证客户合法性
        var customer = _customerRepository.GetById(customerId);
        if (customer == null || !customer.CanPlaceOrders())
            throw new InvalidOperationException("当前客户无法下单");

        foreach (var item in orderItems)
        {
            var orderId = GenerateOrderId();
            var order = new Order(orderId, customerId, item.ProductName);

            // 验证每个商店是否支持该商品并分配订单
            foreach (var storeId in item.StoreIds)
            {
                var store = _storeRepository.GetById(storeId);
                if (store == null || !store.IsProductSupported(item.ProductName))
                    throw new InvalidOperationException($"商店{storeId}不支持商品{item.ProductName}");
                order.AssignStore(storeId);
            }

            _orderRepository.Add(order);
        }

        _orderRepository.SaveChanges();
    }

    // 实际项目中建议使用分布式ID生成器
    private long GenerateOrderId()
    {
        return new Random().NextInt64(1, 10000);
    }
}

方案3分析

将Order改为值对象并复制到多个聚合根，会导致严重的数据冗余。当订单信息（比如商品名称）发生变更时，需要同步所有聚合根中的副本，维护成本极高，完全不符合DDD的设计初衷，不推荐使用。

内容的提问来源于stack exchange，提问作者Afsaneh Daneshi

DDD架构下订单跨聚合引用问题及优化方案咨询

场景描述 #

当前设计问题 #

纠结的三个方案 #

现有代码实现 #

Customer与Order类 #

Store类 #

方案分析与建议 #

方案1分析 #

方案2分析（推荐） #