DDD 实战记录——实现「借鉴学习计划」

「借鉴学习计划」的核心是：复制一份别人的学习计划到自己的计划中，并同步推送学习任务给自己，并且每个操作都要发送通知给对方。

它们的类图如下：

它们的关系是一对多：

// Schedule
entity.HasOne(x => x.Parent).WithMany(x => x.Children).HasForeignKey(x => x.ParentId).OnDelete(DeleteBehavior.Restrict);
entity.HasIndex(nameof(Schedule.UserId), nameof(Schedule.ParentId)).IsUnique().HasFilter($"[{nameof(Schedule.Deleted)}]=0 and [{nameof(Schedule.ParentId)}] is not null");

// ScheduleItem
entity.HasOne(i => i.Schedule).WithMany(s => s.Items).HasForeignKey(i => i.ScheduleId);
entity.HasOne(i => i.Html).WithOne(h => h.Item).HasForeignKey<ScheduleItemHtml>(h => h.ScheduleItemId);
entity.HasOne(x => x.Parent).WithMany(x => x.Children).HasForeignKey(x => x.ParentId).OnDelete(DeleteBehavior.Restrict);
entity.HasIndex(nameof(ScheduleItem.UserId), nameof(ScheduleItem.ParentId)).IsUnique().HasFilter($"[{nameof(ScheduleItem.Deleted)}]=0 and [{nameof(ScheduleItem.ParentId)}] is not null");

按照 DDD 的思路，业务应该发生在领域层中，事件也是从领域中触发的，整个流程的可读性比较强，下面以借鉴功能为例：

    // Domain.Schedule.cs
    /* 借鉴 */
    public class Schedule : Entity, IAggregateRoot
    {
        private Schedule()
        {
            Items = new List<ScheduleItem>();
            Children = new List<Schedule>();
        }

        public Schedule(string title, string description, Guid userId, bool isPrivate = false, long? parentId = null) : this()
        {
            Title = title;
            Description = description;
            UserId = userId;
            IsPrivate = isPrivate;
            if (parentId.HasValue)
            {
                ParentId = parentId;
            }
            AddDomainEvent(new ScheduleCreatedEvent(UUID));
        }
        public Schedule Subscribe(Guid userId)
        {
            if (userId == UserId)
            {
                throw new ValidationException("不能借鉴自己的计划");
            }

            if (ParentId > 0)
            {
                throw new ValidationException("很抱歉，暂时不支持借鉴来的学习计划");
            }
            var child = Deliver(userId);
            Children.Add(child);
            FollowingCount += 1;

            AddDomainEvent(new NewSubscriberEvent(this.UUID, child.UUID));

            return child;
        }
        public Schedule Deliver(Guid userId)
        {
            var schedule = new Schedule(Title, Description, userId, isPrivate: false, Id);
            return schedule;
        }
    }

阅读Subscribe()：首先不能借鉴自己的计划，其次不能借鉴借鉴来的计划，Deliver()生产或者说克隆一个Schedule出来，作为当前计划的孩子，然后把借鉴数+1，触发有新的借鉴者事件NewSubscriberEvent。

Application作为领域的消费者，就可以直接消费这个领域了。

        // Application.ScheduleAppService.cs
        public async Task<long> SubscribeAsync(long id, Guid userId)
        {
            var schedule = await _repository.Schedules.FirstOrDefaultAsync(s => s.Id == id);
            if (schedule != null)
            {
                try
                {
                    schedule.Subscribe(userId);
                    await _repository.UnitOfWork.SaveEntitiesAsync();
                }
                catch (Exception ex) when (ex.InnerException is SqlException sqlerror)
                {
                    if (sqlerror.Number == 2601)
                    {
                        throw new ValidationException("已经借鉴过了");
                    }
                }
            }
            return 0;
        }

最后使用 UnitOfWork 工作单元持久化到数据库，并分发领域中产生的事件。

// Infrastructure.DbContext.cs
        public async Task<bool> SaveEntitiesAsync(CancellationToken cancellationToken = default(CancellationToken))
        {
            //https://stackoverflow.com/questions/45804470/the-dbcontext-of-type-cannot-be-pooled-because-it-does-not-have-a-single-public
            var bus = this.GetService<ICapPublisher>();
            using (var trans = Database.BeginTransaction())
            {
                if (await SaveChangesAsync(cancellationToken) > 0)
                {
                    await bus.DispatchDomianEventsAsync(this);
                    trans.Commit();
                }
                else
                {
                    trans.Rollback();
                    return false;
                }
            }
            return true;
        }

通过 EF Core 的上下文实现了 IUnitOfWork 接口，通过事务保证一致性。这里使用 DotNetCore.CAP 这个优秀的开源产品帮助我们分发事件消息，处理最终一致性。

    public static class CapPublisherExtensions
    {
        public static async Task<int> DispatchDomianEventsAsync(this ICapPublisher bus, AcademyContext ctx)
        {
            var domainEntities = ctx.ChangeTracker
                           .Entries<BaseEntity>()
                           .Where(x => x.Entity.DomainEvents != null && x.Entity.DomainEvents.Any());

            if (domainEntities == null || domainEntities.Count() < 1)
            {
                return 0;
            }

            var domainEvents = domainEntities
                .SelectMany(x => x.Entity.DomainEvents)
                .ToList();

            domainEntities.ToList()
                .ForEach(entity => entity.Entity.ClearDomainEvents());

            var tasks = domainEvents
                .Select(domainEvent => bus.PublishAsync(domainEvent.GetEventName(), domainEvent));

            await Task.WhenAll(tasks);
            return domainEvents.Count;
        }
    }

这里参考了eShopContainer的实现。在触发事件的时候一直都有一个疑问，我们的实体的主键是自增长类型的，只有持久化到数据库之后才知道 Id 的值是多少，但是我们在领域事件中却经常需要这个 Id作为消息的一部分。我解决这个问题的方案，给实体增加一个 GUID 类型的字段UUID，作为唯一身份标识，这样我们就不需要关心最终的Id是多少了，用UUID就可以定位到这个实体了。

事件消息分发出去后，关心这个事件消息的领域就能通过订阅去消费这个事件消息了。

当有新的借鉴者的时候，“消息中心”这个领域关心这个事件，它的MsgService通过DotNetCore.CAP订阅事件消息:

// Msg.AppService.cs
[CapSubscribe(EventConst.NewSubscriber, Group = MsgAppConst.MessageGroup)]
public async Task HandleNewSubscriberEvent(NewSubscriberEvent e)
{
    // Notify schedule author
    var child = await _repository.FindByUUID<Schedule>(e.ChildScheduleUuid).Include(x => x.Parent).FirstOrDefaultAsync();
    if (child == null) return;
    var auth = await _uCenter.GetUser(x => x.UserId, child.Parent.UserId);
    if (auth == null) return;
    var subscriber = await _uCenter.GetUser(x => x.UserId, child.UserId);
    if (subscriber == null) return;
    var msg = new Notification
    {
        RecipientId = auth.SpaceUserId,
        Title = $"有用户借鉴了您的「{child.Parent.Title}」",
        Content = $@"<p>亲爱的 {auth.DisplayName} 同学：</p>
                <p>
                    <b>
                    <a href='{AppConst.DomainAddress}/schedules/u/{subscriber.Alias}/{child.Id}'>
                        {subscriber.DisplayName}</a>
                    </b>
                    借鉴了您的学习计划
                    <a href='{AppConst.DomainAddress}/schedules/u/{auth.Alias}/{child.ParentId}'>
                    「{child.Parent.Title}」
                    </a>
                </p>"
    };
    await _msgSvc.NotifyAsync(msg);
}

“消息中心”的业务是要给作者发送通知，它负责生产出通知Notification，因为我们团队已经有了基础服务——MsgService，已经实现发送通知的功能，所以只需要调用即可，如果没有的话我们就要自己来实现通过邮件或者短信进行通知。

源代码已托管在 github 上了