使用DDD模式实现简单API(8/1)

使用纯SQL语句和DDD模式实现简单的读写分离(转)

转载自（http://www.kamilgrzybek.com/design/simple-cqrs-implementation-with-raw-sql-and-ddd/）

介绍
这篇文章将展示如何使用.NET CORE和CQRS,完成一个简单的REST API应用。这是最简单的实现版本-通过Write Model(写模型)更新数据，Read Model(读模型)的数据也立即更新。在大多数的情况下，将逻辑拆分为读和写并使用各自的模型是非常有效的，在这篇文章里的示例程序中就是如此。具体代码在github(https://github.com/kgrzybek/sample-dotnet-core-cqrs-api.git)。

目标
通过这个解决方案，希望完成下面几个目标：
1、清晰的拆分读模型和写模型。
2、使用读模型获取数据应该尽可能快。
3、写模型应该使用DDD模式实现；DDD实现的层级视领域的复杂度而定。
4、应用的逻辑应该与UI层解耦。
5、选择的第三方库应该是成熟的、知名的且有团队支持的。
设计
组件间高层级的流程如下：

如上图，读取数据的流程是相当简单直接的，因为需要尽可能快的获取数据。在这里不需要多级抽象和复杂的实现方式。从查询对象获取参数，执行SQL语句获取数据即可完成流程。
在写入数据的时候情况就不一样了，写操作通常需要更加进阶的技术，因为需要执行逻辑、计算数据或者进行验证。使用拥有跟踪改变功能的ORM工具和仓储模式，可以实现上述需求，并保持领域模型的完整。

解决方案
读模型
下面的图展示了完成读取操作时，组件之间的数据流转：

UI层负责创建查询对象：

/// <summary>
/// Get customer order details.
/// </summary>
/// <param name="orderId">Order ID.</param>
[Route("{customerId}/orders/{orderId}")]
[HttpGet]
[ProducesResponseType(typeof(OrderDetailsDto), (int)HttpStatusCode.OK)]
public async Task<IActionResult> GetCustomerOrderDetails(
    [FromRoute]Guid orderId)
{
    var orderDetails = await _mediator.Send(new GetCustomerOrderDetailsQuery(orderId));

    return Ok(orderDetails);
}

internal class GetCustomerOrderDetailsQuery : IRequest<OrderDetailsDto>
{
    public Guid OrderId { get; }

    public GetCustomerOrderDetailsQuery(Guid orderId)
    {
        this.OrderId = orderId;
    }
}

然后，查询处理器执行查询操作：

internal class GetCustomerOrderDetialsQueryHandler : IRequestHandler<GetCustomerOrderDetailsQuery, OrderDetailsDto>
{
    private readonly ISqlConnectionFactory _sqlConnectionFactory;

    public GetCustomerOrderDetialsQueryHandler(ISqlConnectionFactory sqlConnectionFactory)
    {
        this._sqlConnectionFactory = sqlConnectionFactory;
    }

    public async Task<OrderDetailsDto> Handle(GetCustomerOrderDetailsQuery request, CancellationToken cancellationToken)
    {
        using (var connection = this._sqlConnectionFactory.GetOpenConnection())
        {
            const string sql = "SELECT " +
                               "[Order].[Id], " +
                               "[Order].[IsRemoved], " +
                               "[Order].[Value] " +
                               "FROM orders.v_Orders AS [Order] " +
                               "WHERE [Order].Id = @OrderId";
            var order = await connection.QuerySingleOrDefaultAsync<OrderDetailsDto>(sql, new {request.OrderId});

            const string sqlProducts = "SELECT " +
                               "[Order].[ProductId] AS [Id], " +
                               "[Order].[Quantity], " +
                               "[Order].[Name] " +
                               "FROM orders.v_OrderProducts AS [Order] " +
                               "WHERE [Order].OrderId = @OrderId";
            var products = await connection.QueryAsync<ProductDto>(sqlProducts, new { request.OrderId });

            order.Products = products.AsList();

            return order;
        }
    }
}

public class SqlConnectionFactory : ISqlConnectionFactory, IDisposable
{
    private readonly string _connectionString;
    private IDbConnection _connection;

    public SqlConnectionFactory(string connectionString)
    {
        this._connectionString = connectionString;
    }

    public IDbConnection GetOpenConnection()
    {
        if (this._connection == null || this._connection.State != ConnectionState.Open)
        {
            this._connection = new SqlConnection(_connectionString);
            this._connection.Open();
        }

        return this._connection;
    }

    public void Dispose()
    {
        if (this._connection != null && this._connection.State == ConnectionState.Open)
        {
            this._connection.Dispose();
        }
    }
}

首先，获取打开的数据库连接，这通过SqlConnectionFactory类实现，这个类从IOC容器的Http Request生命周期中获取，所以可以保证，在一次请求过程中使用相同的数据库连接。

第二步是准备和执行SQL，这里尝试不和数据库表关联而是与数据库视图关联。这使应用与数据库的表解耦，尽可能的隐藏数据库的内部结构。

对于SQL的执行，使用了微型ORM框架-Dapper，因为它差不多和本地的ADO.NET一样快。简而言之，它做了它该做的事情，而且做的很好。

写模型

下图展示了写操作时，组件之间的数据流转：

写操作的起点和读操作差不多，但是创建了Command对象代替了Query对象。

/// <summary>
/// Add customer order.
/// </summary>
/// <param name="customerId">Customer ID.</param>
/// <param name="request">Products list.</param>
[Route("{customerId}/orders")]
[HttpPost]
[ProducesResponseType((int)HttpStatusCode.Created)]
public async Task<IActionResult> AddCustomerOrder(
    [FromRoute]Guid customerId, 
    [FromBody]CustomerOrderRequest request)
{
   await _mediator.Send(new AddCustomerOrderCommand(customerId, request.Products));

   return Created(string.Empty, null);
}

接下来，命令处理器被调用。

public class AddCustomerOrderCommandHandler : IRequestHandler<AddCustomerOrderCommand>
{
    private readonly ICustomerRepository _customerRepository;
    private readonly IProductRepository _productRepository;

    public AddCustomerOrderCommandHandler(
        ICustomerRepository customerRepository, 
        IProductRepository productRepository)
    {
        this._customerRepository = customerRepository;
        this._productRepository = productRepository;
    }

    public async Task<Unit> Handle(AddCustomerOrderCommand request, CancellationToken cancellationToken)
    {
        var customer = await this._customerRepository.GetByIdAsync(request.CustomerId);

        var selectedProducts = request.Products.Select(x => new OrderProduct(x.Id, x.Quantity)).ToList();
        var allProducts = await this._productRepository.GetAllAsync();

        var order = new Order(selectedProducts, allProducts);
        
        customer.AddOrder(order);

        await this._customerRepository.UnitOfWork.CommitAsync(cancellationToken);

        return Unit.Value;
    }
}

命令处理器不同于查询处理器，因为在写操作中通常会比读操作复杂，在这里使用了DDD方法的高度抽象，Aggregates和Entities。命令处理器创建Aggregates并调用其方法，最终保存数据到数据库。

客户Aggregate定义如下：

public class Customer : Entity
{
    public Guid Id { get; private set; }

    private readonly List<Order> _orders;

    private Customer()
    {
        this._orders = new List<Order>();
    }

    public void AddOrder(Order order)
    {
        this._orders.Add(order);

        this.AddDomainEvent(new OrderAddedEvent(order));
    }

    public void ChangeOrder(Guid orderId, List<OrderProduct> products, IReadOnlyCollection<Product> allProducts)
    {
        var order = this._orders.Single(x => x.Id == orderId);
        order.Change(products, allProducts);

        this.AddDomainEvent(new OrderChangedEvent(order));
    }

    public void RemoveOrder(Guid orderId)
    {
        var order = this._orders.Single(x => x.Id == orderId);
        order.Remove();

        this.AddDomainEvent(new OrderRemovedEvent(order));
    }
}

public class Order : Entity
{
    public Guid Id { get; private set; }
    private bool _isRemoved;
    private decimal _value;
    private List<OrderProduct> _orderProducts;

    private Order()
    {
        this._orderProducts = new List<OrderProduct>();
        this._isRemoved = false;
    }

    public Order(List<OrderProduct> orderProducts, IReadOnlyCollection<Product> allProducts)
    {
        this.Id = Guid.NewGuid();
        this._orderProducts = orderProducts;

        this.CalculateOrderValue(allProducts);
    }

    internal void Change(List<OrderProduct> products, IReadOnlyCollection<Product> allProducts)
    {
        foreach (var product in products)
        {
            var orderProduct = this._orderProducts.SingleOrDefault(x => x.ProductId == product.ProductId);
            if (orderProduct != null)
            {
                orderProduct.ChangeQuantity(product.Quantity);
            }
            else
            {
                this._orderProducts.Add(product);
            }
        }

        var existingProducts = this._orderProducts.ToList();
        foreach (var existingProduct in existingProducts)
        {
            var product = products.SingleOrDefault(x => x.ProductId == existingProduct.ProductId);
            if (product == null)
            {
                this._orderProducts.Remove(existingProduct);
            }
        }

        this.CalculateOrderValue(allProducts);
    }

    internal void Remove()
    {
        this._isRemoved = true;
    }

    private void CalculateOrderValue(IReadOnlyCollection<Product> allProducts)
    {
        this._value = this._orderProducts.Sum(x => x.Quantity * allProducts.Single(y => y.Id == x.ProductId).Price);
    }
}

架构

解决方案的架构基于知名的Onion Architecture定义，如下图：

如上图，定义了三个项目：

• API项目包含程序端点和应用逻辑（命令和查询处理器）。
• 领域项目和领域模型
• 基础架构项目包含与数据库的集成

总结

在这篇文章中，尝试用最简单的方法来实现CQRS模式，使用原始sql脚本作为读模型端处理，使用DDD方法作为写模型端实现。这样就能够在不失去开发速度的情况下实现更多的关注点分离。引入这种解决方案的成本非常低，而且回报很快。