domain-driven-design - 如何为在一个上下文中是聚合根但在另一上下文中不是聚合根的实体编写命令？

Question

我正在为一家公司开展一个项目，该项目寻找供应商为员工搬迁提供服务。这些服务是搬运工不具备专业知识可以做的事情，例如准备钢琴或运输或为贵重元素 build crate 。

在此域中，一个订单具有 1:多个位置。

在搬家行业中，订单经常不断变化，直到供应商执行其要求的服务为止。因此，在我们的模型中，我们有一些适用于订单和地点的状态(例如已提交、已取消、暂停)。

这里适用一些非常简单的业务规则。这是一个示例:

1. 当订单被搁置时，所有地点都将被搁置。
2. 如果其父订单处于保留状态，则无法取消保留位置。

等等。从这些规则来看，对我来说很明显，这形成了聚合根边界。因此，我有一个 MyClient.Statuses.Order 聚合，其中 Statuses 是上下文/服务/您想要调用的任何内容的名称:

public class Order {
    private Guid _id;
    private OrderStatus _status;

    public void PlaceOnHold() {
        if (_status == OrderStatus.Cancelled)
            // throw exception

        _status = OrderStatus.OnHold;
        Locations.ForEach(loc => loc.PlaceOnHold());
    } 

    public void PlaceLocationOnHold(Guid id) {
        if (_status == OrderStatus.Cancelled)
            // throw exception
        Locations.Single(loc => loc.Id == id).PlaceOnHold();
    }

    // etc...

        private Location[] Locations;
}

internal class Location { 
    public Guid Id;
    public LocationStatus Status;

    public void PlaceOnHold() {
        // It's ok for a cancelled location on a non-cancelled order,
        // but a Location cannot be placed On Hold if it's Cancelled so 
        // just ignore it
        if (Status == LocationStatus.Cancelled)
            return; 

        Status = LocationStatus.OnHold;
    }
}

这两个对象(订单、位置)在其他上下文中都具有 GUID ID(例如，对于没有状态转换的基于 CRUD 的属性)。现在我们终于回答我的问题了:

如何编写命令和处理程序来保留某个位置？

我想让这个东西保持DRY和面向服务，以最大限度地减少耦合，但是在一个地方保持两个实体之间的父子关系确实很困难。

选项 1 - 单个位置 ID:

public class PlaceLocationOnHold_V1 {
    public readonly Guid Id;
}

public class PlaceLocationOnHold_V1Handler {
    public void Handle(PlaceLocationOnHold_V1 command) {
        // This is typically a no-no.  Should only fetch by OrderId:
        var aggregate = _repository.GetByLocationId(command.Id);  

        aggregate.PlaceLocationOnHold(command.Id);
        _repository.Save();
    }
}

选项 2 - 订单 ID 和位置 ID:

public class PlaceLocationOnHold_V2 {
    public readonly Guid OrderId; // This feels redundant
    public readonly Guid LocationId;
}

public class PlaceLocationOnHold_V2Handler {
    public void Handle(PlaceLocationOnHold_V2 command) {
        var aggregate = _repository.GetById(command.OrderId);
        aggregate.PlaceLocationOnHold(command.LocationId);
        _repository.Save();
    }
}

选项 3 - 具有封装“属于订单的位置”的类的单个参数

public class LocationIdentity {
    public Guid Id;
    public Guid OrderId;
}

public class PlaceLocationOnHold_V3 {
    public readonly LocationIdentity Location;
}

public class PlaceLocationOnHold_V3Handler {
    public void Handle(PlaceLocationOnHold_V3 command) {
        var aggregate = _repository.GetById(command.Location.OrderId);  
        aggregate.PlaceLocationOnHold(command.Location.Id);
        _repository.Save();
    }
}

Answer 1

查看 Vaughn Vernon 关于 Effective Aggregate Design 的文章。具体来说，Part 2 - 有一些关于建模相互通信的聚合的好信息。

您的设计中缺少的要点是，正如您已经提到的，这些都是 AR - 它们是全局可识别的。所以他们应该通过 ID 互相引用。订单不应包含位置的子集合。

因此，您的 Order 类将具有 LocationId 的集合，并且您的 Location 将具有 OrderId。

public class Order
{
    private Guid _id;
    private OrderStatus _status;
    private Guid[] _locationIds;
    //...
}

public class Location
{
    private Guid _id;
    private Guid _orderId;
    //...
}

一旦你正确地解决了这个问题，选项 #1 就有意义了。由于 Location 本身就是一个 AR，因此您可以实例化它并直接在其上调用 PlaceOnHold，而无需通过 Order AR。

对于一个 AR 中的更改渗透到其他 AR 的情况(即，搁置订单也会使所有位置也搁置)，您可以使用域事件或最终一致性。

public class Order
{
    //... private instance variables

    public void PlaceOnHold()
    {
        if (_status == OrderStatus.Cancelled)
          // throw exception

        _status == Orderstatus.OnHold;

        DomainEvents.Handle(new OrderPlacedOnHold(_id)); // handle this, look up the related locations and call PlaceOnHold on each of them)
    }
}

对于您可能尝试取消对某个位置的保留，但订单被保留而导致该操作非法的情况，您可以在命令处理程序中实例化 Order 对象并将其传递到地点。 Vernon 提到了这一点，并重申了这一点:每笔交易只能更改一个 AR，并不意味着您不能在交易中实例化多个 AR。

public class RemoveHoldFromLocation : IHandler<RemoveHoldFromLocationCommand>
{
    public void Execute(RemoveHoldFromLocationCommand cmd)
    {
        var location = locationRepo.Get(cmd.LocationId);
        var order = orderRepo.Get(location.GetOrderId());

        location.RemoveHold(order.GetStatus());
    }
}

public class Location
{
    //... private instance variables, etc.

    public void RemoveHold(OrderStatus orderStatus)
    {
        if (orderStatus == OrderStatus.OnHold)
            // throw Exception

        _status == LocationStatus.OnHold;
    }
}

这只是伪代码，因此请原谅拼写错误等。类似的代码示例位于 Vernon PDF 中。