重新整理 .net core 实践篇—————领域事件[二十九]
前文
前面整理了仓储层，工作单元模式，同时简单介绍了一下mediator。
那么就mediator在看下领域事件启到了什么作用吧。
正文
这里先注册一下MediatR服务:
// 注册中间者：MediatR
services.AddMediatRServices();
具体注册:
/// <summary>
/// 注册 ？？？
/// </summary>
/// <param name="services"></param>
/// <returns></returns>
public static IServiceCollection AddMediatRServices(this IServiceCollection services)
{
// 注册事务流程管理类
services.AddTransient(typeof(IPipelineBehavior<,>), typeof(DomainContextTransactionBehavior<,>));
// package: MediatR.Extensions.Microsoft.Dependency
return services.AddMediatR(typeof(Order).Assembly, typeof(Program).Assembly);
}
前文提及在共享层的领域抽象类库中，有下面几个类:
用来标志领域事件的接口:
/// <summary>
/// 领域事件接口
/// 用来标记我们某一个对象是否是领域事件
/// </summary>
public interface IDomainEvent : INotification
{
}
用来标志领域处理的接口:
/// <summary>
/// 领域事件处理器接口
/// </summary>
public interface IDomainEventHandler<TDomainEvent> : INotificationHandler<TDomainEvent> where TDomainEvent : IDomainEvent
{
//这里我们使用了INotificationHandler的Handle方法来作为处理方法的定义，所以无需重新定义
//Task Handle(TDomainEvent domainEvent, CancellationToken cancellationToken);
}
实际上就是在mediator的INotification和INotificationHandler 封装一层。
那么是否有必要封装呢？其实我们大多数使用别人的库，如果不是静态调用最好封装一层，这样可以让上层看来依赖于下层的IDomainEvent和IDomainEventHandler，而不是和某个框架耦合在一起。
比如说有一个框架是Mediator的升级版，兼容了Mediator的功能，但是暴露出来的接口是INotificationPlusHandler，如果上层去耦合的话，改动的地方就有点多，风险也就越高，这不符合稳定性。
下面是实体抽象类：
/// <summary>
/// 实体抽象类（包含多个主键的实体接口）
/// </summary>
public abstract class Entity : IEntity
{
public abstract object[] GetKeys();
public override string ToString()
{
return $"[Entity:{GetType().Name}] Keys = {string.Join(",", GetKeys())}";
}
#region 领域事件定义处理 DomainEvents
/// <summary>
/// 领域事件集合
/// </summary>
private List<IDomainEvent> _domainEvents;
/// <summary>
/// 获取当前实体对象领域事件集合（只读）
/// </summary>
public IReadOnlyCollection<IDomainEvent> DomainEvents => _domainEvents?.AsReadOnly();
/// <summary>
/// 添加领域事件至当前实体对象领域事件结合中
/// </summary>
/// <param name="eventItem"></param>
public void AddDomainEvent(IDomainEvent eventItem)
{
_domainEvents = _domainEvents ?? new List<IDomainEvent>();
_domainEvents.Add(eventItem);
}
/// <summary>
/// 移除指定领域事件
/// </summary>
/// <param name="eventItem"></param>
public void RemoveDomainEvent(IDomainEvent eventItem)
{
_domainEvents?.Remove(eventItem);
}
/// <summary>
/// 清空所有领域事件
/// </summary>
public void ClearDomainEvents()
{
_domainEvents?.Clear();
}
#endregion
}
/// <summary>
/// 实体抽象类（包含唯一主键Id的实体接口）
/// </summary>
/// <typeparam name="TKey">主键ID类型</typeparam>
public abstract class Entity<TKey> : Entity, IEntity<TKey>
{
int? _requestedHasCode;
public virtual TKey Id { get; protected set; }
public override object[] GetKeys()
{
return new object[] { Id };
}
/// <summary>
/// 对象是否想等
/// </summary>
/// <param name="obj"></param>
/// <returns></returns>
public override bool Equals(object obj)
{
if (obj == null || !(obj is Entity<TKey>))
{
return false;
}
if (Object.ReferenceEquals(this, obj))
{
return true;
}
Entity<TKey> item = (Entity<TKey>)obj;
if (item.IsTransient() || this.IsTransient())
{
return false;
}
else
{
return item.Id.Equals(this.Id);
}
}
public override int GetHashCode()
{
if (!IsTransient())
{
if (!_requestedHasCode.HasValue)
{
_requestedHasCode = this.Id.GetHashCode() ^ 31; // TODO
}
return _requestedHasCode.Value;
}
else
{
return base.GetHashCode();
}
}
/// <summary>
/// 对象是否为全新创建的，未持久化的
/// </summary>
/// <returns></returns>
public bool IsTransient()
{
return EqualityComparer<TKey>.Default.Equals(Id, default);
}
public override string ToString()
{
return $"[Entity:{GetType().Name}] Id = {Id}";
}
/// <summary>
/// == 操作符重载
/// </summary>
/// <param name="left"></param>
/// <param name="right"></param>
/// <returns></returns>
public static bool operator ==(Entity<TKey> left,Entity<TKey> right)
{
if (Object.Equals(left,null))
{
return (Object.Equals(right, null)) ? true : false;
}
else
{
return left.Equals(right);
}
}
/// <summary>
/// != 操作符重载
/// </summary>
/// <param name="left"></param>
/// <param name="right"></param>
/// <returns></returns>
public static bool operator !=(Entity<TKey> left, Entity<TKey> right)
{
return !(left == right);
}
}
那么我们在领域层中，我们的实体可以这样定义:
/// <summary>
/// 订单实体
/// </summary>
public class Order : Entity<long>, IAggregateRoot
{
// 实体内字段的 set 方法都是 private 的
// 实体类型相关的数据操作，都应该是由我们实体来负责，而不是被外部的对象去操作
// 这样的好处是让我们的领域模型符合封闭开放的原则
public string UserId { get; private set; }
public string UserName { get; private set; }
public Address Address { get; private set; }
public int ItemCount { get; set; }
protected Order()
{
}
public Order(string userId, string userName, int itemCount, Address address)
{
this.UserId = userId;
this.UserName = userName;
this.ItemCount = itemCount;
this.Address = address;
// 构造新的Order对象的时候，添加一个创建Order领域事件
this.AddDomainEvent(new OrderCreatedDomainEvent(this));
}
/// <summary>
/// 修改收货地址
/// </summary>
/// <param name="address"></param>
public void ChangeAddress(Address address)
{
this.Address = address;
// 同样的，在修改地址操作时，也该定义一个类似的修改地址领域事件
//this.AddDomainEvent(new OrderAddressChangedDomainEvent(this));
}
}
在实例化的时候将创建一个OrderCreatedDomainEvent事件,这个后面是用来处理订单创建完成之后的事件。
那么现在看下这个OrderCreatedDomainEvent是什么:
/// <summary>
/// 创建Order领域事件
/// </summary>
public class OrderCreatedDomainEvent : IDomainEvent
{
/// <summary>
/// 写入私有，读取公开
/// </summary>
public Order Order { get; private set; }
public OrderCreatedDomainEvent(Order order)
{
this.Order = order;
}
}
那么在我们的应用层可以定义一个订单创建完成的事件处理类，比如说OrderCreatedDomainEventHandler:
/// <summary>
/// 创建Order领域事件处理
/// </summary>
public class OrderCreatedDomainEventHandler : IDomainEventHandler<OrderCreatedDomainEvent>
{
ICapPublisher _capPublisher;
public OrderCreatedDomainEventHandler(ICapPublisher capPublisher)
{
_capPublisher = capPublisher;
}
/// <summary>
/// 领域事件处理
/// </summary>
/// <param name="notification"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
public async Task Handle(OrderCreatedDomainEvent notification, CancellationToken cancellationToken)
{
// 当创建新订单时，向 EventBus 发布一个事件
await _capPublisher.PublishAsync("OrderCreated", new OrderCreatedIntegrationEvent(notification.Order.Id));
//_capPublisher.Publish("OrderCreated", new OrderCreatedIntegrationEvent(notification.Order.Id));
//return Task.CompletedTask;
}
}
上面表示，当我们创建一个订单后完成后的类，如果订单创建完毕，会向 EventBus 发布一个事件。
上面是订单处理完成后的事件，那么我们创建订单是不是也应该写一个请求呢?
为什么我们写请求，而不是写事件呢？一个是因为请求与请求处理是1对1，事件与事件处理是一对多。第二个是跟符合意境，一切的源头写出请求更好，还有就是创建订单的确在生活中像一个请求。
CreateOrderCommand 如下:
/// <summary>
/// 创建订单 Command
/// </summary>
public class CreateOrderCommand : IRequest<long>
{
public long ItemCount { get; private set; }
// public CreateOrderCommand() { }
public CreateOrderCommand(int itemCount)
{
ItemCount = itemCount;
}
}
具体的订单创建事件CreateOrderCommandHandler:
/// <summary>
/// 领域事件:订单创建命令处理程序
/// 注：在创建完我们的领域模型并将其保存之后才会触发该处理程序
/// </summary>
public class CreateOrderCommandHandler : IRequestHandler<CreateOrderCommand, long>
{
IOrderRepository _orderRepository;
ICapPublisher _capPublisher;
public CreateOrderCommandHandler(IOrderRepository orderRepository, ICapPublisher capPublisher)
{
_orderRepository = orderRepository;
_capPublisher = capPublisher;
}
/// <summary>
/// 处理订单创建命令
/// </summary>
/// <param name="request"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
public async Task<long> Handle(CreateOrderCommand request, CancellationToken cancellationToken)
{
var address = new Address("wen san lu", "hangzhou", "310000");
var order = new Order("xiaohong1999", "小红", (int)request.ItemCount, address);
_orderRepository.Add(order);
await _orderRepository.UnitOfWork.SaveEntitiesAsync(cancellationToken);
return order.Id;
}
}
那么这个就会去处理相应的创建订单。
那么测试一下:
/// <summary>
/// 创建订单
/// </summary>
/// <param name="cmd"></param>
/// <returns></returns>
[HttpPost]
public async Task<long> CreateOrder([FromBody] CreateOrderCommand cmd)
{
// 中间者，发送订单创建命令
return await _mediator.Send(cmd, HttpContext.RequestAborted);
}
第一步调用这里:
第二步调用CreateOrderCommandHandler，去调用相应的订单调用事件：
第三步，调用订单创建完的中间处理,也就是订单创建完的事件分发:
代码如下:
/// <summary>
/// 中间者，领域事件发布扩展类
/// </summary>
public static class MediatorExtension
{
/// <summary>
/// 领域事件发布，执行事件发送
/// </summary>
/// <param name="mediator"></param>
/// <param name="ctx"></param>
/// <returns></returns>
public static async Task DispatchDomainEventsAsync(this IMediator mediator, DbContext ctx)
{
// 1. 从当前要保存的 EntityContext 里面去跟踪实体
// 从跟踪到的实体对象中，获取到我们当前的 Event
var domainEntities = ctx.ChangeTracker
.Entries<Entity>()
.Where(x => x.Entity.DomainEvents != null && x.Entity.DomainEvents.Any());
// Events 类型转换
var domainEvents = domainEntities.SelectMany(x => x.Entity.DomainEvents).ToList();
// 2. 将实体内的 Events 清除
domainEntities.ToList().ForEach(entity => entity.Entity.ClearDomainEvents());
// 3. 将所有的 Event 通过中间者发送出去
// 发出后，并找到对应的 handle 进行处理
foreach (var domainEvent in domainEvents)
{
await mediator.Publish(domainEvent);
}
}
}
第四步 调用创建订单之后的回调事件，也就是第三步中的分发：
这里可能疑问DispatchDomainEventsAsync是怎么触发的?
这里是在EFContext中的save中：
/// <summary>
/// 保存实体变更
/// </summary>
/// <param name="cancellationToken"></param>
/// <returns></returns>
public async Task<bool> SaveEntitiesAsync(CancellationToken cancellationToken = default)
{
var result = await base.SaveChangesAsync(cancellationToken);
// 执行发送领域事件
await _mediator.DispatchDomainEventsAsync(this);
return true;
}
然后调用这个就会去找到相应事件，然后调用publish，找到事件处理类进行handle方法调用:
/// <summary>
/// 领域事件发布，执行事件发送
/// </summary>
/// <param name="mediator"></param>
/// <param name="ctx"></param>
/// <returns></returns>
public static async Task DispatchDomainEventsAsync(this IMediator mediator, DbContext ctx)
{
// 1. 从当前要保存的 EntityContext 里面去跟踪实体
// 从跟踪到的实体对象中，获取到我们当前的 Event
var domainEntities = ctx.ChangeTracker.Entries<Entity>().Where(x => x.Entity.DomainEvents != null && x.Entity.DomainEvents.Any());
// Events 类型转换
var domainEvents = domainEntities.SelectMany(x => x.Entity.DomainEvents).ToList();
// 2. 将实体内的 Events 清除
domainEntities.ToList().ForEach(entity => entity.Entity.ClearDomainEvents());
// 3. 将所有的 Event 通过中间者发送出去
// 发出后，并找到对应的 handle 进行处理
foreach (var domainEvent in domainEvents)
{
await mediator.Publish(domainEvent);
}
}
结
下一节Mediator的介绍。
