DDD：如何保证聚合的一致性

聚合一致性

从时间维度考虑，一致性分为“实时一致性”和“最终一致性”。在企业应用中，多数情况都是使用实时一致性。在WEB应用中，为了最大限度的提高系统的吞吐量，经常使用最终一致性，如：博客园的积分和排名计算。

从聚合的维度考虑，一致性分为“内部一致性”和“外部一致性”。内部一致性是指一个聚合实例本身状态的一致性。外部一致性是指多个聚合实例之间状态的一致性。

代码示例

需求

1. 1. 订单要记录订单原始总额。（内部一致性）
   2. 订单有两种状态，未提交和提交，不能修改已提交的订单。（内部一致性）
   3. 订单要记录订单的总额，总额 = 原始总额 * 折扣，如果客户是VIP就打8折。（外部一致性）
   4. 客户信用评级。（最终一致性）

类图

核心代码

Order

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 状态一致性.Code
{
    public sealed class Order
    {
        private readonly List<OrderItem> _orderItems = new List<OrderItem>();
        private OrderStatus _status = OrderStatus.UnSubmited;
        private Decimal _rawTotal = 0M;
        private Decimal _total = 0M;

        internal Order() { }

        internal void AddOrderItem(OrderItem orderItem)
        {
            this.DoValidation();

            _orderItems.Add(orderItem);

            this.CalculateAndSetRawTotal();
        }

        internal void MarkAsSubmited()
        {
            this.DoValidation();

            _status = OrderStatus.Submited;
        }

        public Guid CustomerId { get; internal set; }

        public Decimal Total
        {
            get
            {
                return _total;
            }
            internal set
            {
                this.DoValidation();

                _total = value;
            }
        }

        public Decimal RawTotal
        {
            get
            {
                return _rawTotal;
            }
        }

        private void CalculateAndSetRawTotal()
        {
            _rawTotal = _orderItems.Sum(x => x.Price);
        }

        private void DoValidation()
        {
            if (_status == OrderStatus.Submited)
            {
                throw new InvalidOperationException("处于提交状态的订单不能执行修改操作");
            }
        }
    }
}

OrderItem

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 状态一致性.Code
{
    public sealed class OrderItem
    {
        public OrderItem(Decimal price)
        {
            this.Price = price;
        }

        internal Decimal Price { get; private set; }
    }
}

OrderStatus

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 状态一致性.Code
{
    public enum OrderStatus
    {
        UnSubmited = 0,
        Submited = 1
    }
}

Customer

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 状态一致性.Code
{
    public sealed class Customer
    {
        public Guid CustomerId { get; set; }
        public bool IsVip { get; set; }

        internal void ApplyDiscount(Order order)
        {
            var discount = 1M;
            if (IsVip)
            {
                discount = 0.8M;
            }

            order.Total = order.RawTotal * discount;
        }
    }
}

UnSubmitedService

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 状态一致性.Code
{
    public sealed class UnSubmitedService
    {
        public void CreateOrder(Customer customer, IEnumerable<OrderItem> orderItems, bool autoSubmit)
        {
            var order = new Order();
            order.CustomerId = customer.CustomerId;

            foreach (var orderItem in orderItems)
            {
                order.AddOrderItem(orderItem);
            }

            customer.ApplyDiscount(order);

            if (autoSubmit)
            {
                order.MarkAsSubmited();
            }
        }
    }
}

代码说明

1. OrderItem的成员都实现成了只读，否则会导致封装失败，进而导致内部一致性的失败。
2. Order实现了内部一致性，而且将API尽可能的声明为internal或private，这样就保证UI层不会跨越领域服务（外部一致性）直接调用Order。
3. UnSubmitedService实现了外部一致性。

如果要完整的实现内部一致性，会尽可能多的采用值类型语义的实体和封装集合模式。

备注

关于最终一致性的理解我还很肤浅，这里就不丢人现眼了。实时一致性可以参考这篇文章：.NET：处理数据库事务中的并发。