DDD：订单管理 之 如何组织代码

背景

系统开发最难的是职责的合理分配，或者叫：“如何合理的组织代码”，今天说一个关于这方面问题的示例，希望大家多批评。

示例背景

参考数据字典

需求

1. OrderCode必须唯一。
2. Total = Sum（Subtotal）。
3. 订单有三种状态：【未提交】、【待审核】和【已审核】，合理的状态迁移有：【未提交】----》【待审核】和【待审核】----》【已审核】，只有处于【未提交】状态的订单能修改。
4. 订单和订单项中的状态必须合法，规则自己定义。

示例实现

项目结构

• Application：应用层，负责领域逻辑的封装。主要角色：ApplicationService、CommandHandler。
• Boostrap：启动管理层，负责启动过程管理，如：注册Ioc、初始化配置。主要角色：BootstrapListener。
• Commands：命令层，是一个契约层。主要角色：Comamnd、DTO。
• Controllers：控制器层，边界层。主要角色：Controller。
• Domain：领域层，负责领域逻辑的组织。主要角色：Aggregate、Entity、ValueObject、Factory、DomainService、IRepository、IUnitOfWork。
• Events：事件层，是一个契约层，跨聚合流程可以采用。主要角色：Event。
• EventSubscribers：事件监听层。主要角色：EventSubscriber。
• Infrastructure：基础设施层。主要角色：Repository、QueryService、UnitOfWork。
• Query：查询层，为UI的查询提供服务，主要角色：QueryService。

项目整体采用简单的CQRS架构，Command端采用DDD组织，Query直接从数据库返回dynamic类型。Event可以用来处理跨聚合通信，也可以用来处理长事务或离线事务。

重点介绍的领域层

采用状态模式处理状态迁移。

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

 namespace Happy.Example.Domain.TestOrders
 {
     public interface ITestOrderState
     {
         void AddTestOrderDetail(TestOrderDetail testOrderDetail);

         void UpdateTestOrderDetail(Guid testOrderDetailId, decimal subtotal);

         void RemoveTestOrderDetail(Guid testOrderDetailId);

         void Commit();

         void Verify();

         string Status { get; }

         TestOrder TestOrder { set; }
     }
 }

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

 namespace Happy.Example.Domain.TestOrders
 {
     public partial class TestOrder
     {
         private abstract class TestOrderState : ITestOrderState
         {
             public virtual void AddTestOrderDetail(TestOrderDetail testOrderDetail)
             {
                 this.ThrowInvalidOperationException();
             }

             public virtual void UpdateTestOrderDetail(Guid testOrderDetailId, decimal subtotal)
             {
                 this.ThrowInvalidOperationException();
             }

             public virtual void RemoveTestOrderDetail(Guid testOrderDetailId)
             {
                 this.ThrowInvalidOperationException();
             }

             public virtual void Commit()
             {
                 this.ThrowInvalidOperationException();
             }

             public virtual void Verify()
             {
                 this.ThrowInvalidOperationException();
             }

             public abstract string Status { get; }

             public TestOrder TestOrder { protected get; set; }

             private void ThrowInvalidOperationException()
             {
                 throw new InvalidOperationException(string.Format("处于【{0}】的订单不能执行此操作！", this.Status));
             }
         }
     }
 }

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

 namespace Happy.Example.Domain.TestOrders
 {
     public partial class TestOrder
     {
         private sealed class UnCommitted : TestOrderState
         {
             internal static readonly string UnCommittedStatus = "未提交";

             public override void AddTestOrderDetail(TestOrderDetail testOrderDetail)
             {
                 this.TestOrder.DoAddTestOrderDetail(testOrderDetail);
             }

             public override void UpdateTestOrderDetail(Guid testOrderDetailId, decimal subtotal)
             {
                 this.TestOrder.DoUpdateTestOrderDetail(testOrderDetailId, subtotal);
             }

             public override void RemoveTestOrderDetail(Guid testOrderDetailId)
             {
                 this.TestOrder.DoRemoveTestOrderDetail(testOrderDetailId);
             }

             public override void Commit()
             {
                 this.TestOrder.DoCommit();
             }

             public override string Status
             {
                 get { return UnCommittedStatus; }
             }
         }
     }
 }

采用封装集合手法处理Total的同步问题。

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

 using Happy.Domain;
 using Happy.Domain.Tree;
 using Happy.Infrastructure.ExtentionMethods;
 using Happy.Example.Events.TestOrders;

 namespace Happy.Example.Domain.TestOrders
 {
     public partial class TestOrder : AggregateRoot<Guid>
     {
         private ITestOrderState _orderState;

         protected TestOrder() { }

         public TestOrder(string orderCode, string customer)
         {
             orderCode.MustNotNullAndNotWhiteSpace("orderCode");
             customer.MustNotNullAndNotWhiteSpace("customer");

             this.Id = Guid.NewGuid();
             this.OrderCode = orderCode;
             this.Customer = customer;
             this.OrderState = TestOrderStateFactory.CreateUnCommittedTestOrderState(this);
             this.TestOrderDetails = new List<TestOrderDetail>();
         }

         public virtual System.String OrderCode { get; protected set; }
         public virtual System.String Customer { get; protected set; }
         public virtual System.Decimal Total { get; protected set; }
         public virtual System.String Status { get; protected set; }
         public virtual ICollection<TestOrderDetail> TestOrderDetails { get; protected set; }

         private ITestOrderState OrderState
         {
             get
             {
                 if (_orderState == null)
                 {
                     _orderState = TestOrderStateFactory.Create(this, this.Status);
                 }

                 return _orderState;
             }
             set
             {
                 _orderState = value;
                 this.Status = value.Status;
             }
         }

         public void AddTestOrderDetail(TestOrderDetail testOrderDetail)
         {
             this.OrderState.AddTestOrderDetail(testOrderDetail);
         }

         public void UpdateTestOrderDetail(Guid testOrderDetailId, decimal subtotal)
         {
             this.OrderState.UpdateTestOrderDetail(testOrderDetailId, subtotal);
         }

         public void RemoveTestOrderDetail(Guid testOrderDetailId)
         {
             this.OrderState.RemoveTestOrderDetail(testOrderDetailId);
         }

         public void Commit()
         {
             this.OrderState.Commit();
         }

         public void Verify()
         {
             this.OrderState.Verify();
         }

         private void DoAddTestOrderDetail(TestOrderDetail testOrderDetail)
         {
             this.TestOrderDetails.Add(testOrderDetail);

             this.Total += testOrderDetail.Subtotal;
         }

         private void DoUpdateTestOrderDetail(Guid testOrderDetailId, decimal subtotal)
         {
             var testOrderDetail = this.TestOrderDetails.First(x => x.Id == testOrderDetailId);

             this.Total -= testOrderDetail.Subtotal;
             testOrderDetail.Subtotal = subtotal;
             this.Total += testOrderDetail.Subtotal;
         }

         private void DoRemoveTestOrderDetail(Guid testOrderDetailId)
         {
             var testOrderDetail = this.TestOrderDetails.First(x => x.Id == testOrderDetailId);

             this.TestOrderDetails.Remove(testOrderDetail);
             this.Total -= testOrderDetail.Subtotal;
         }

         private void DoCommit()
         {
             this.OrderState = TestOrderStateFactory.CreatePendingVerificationTestOrderState(this);
         }

         private void DoVerify()
         {
             this.OrderState = TestOrderStateFactory.CreateVerifiedTestOrderState(this);

             this.PublishEvent(new TestOrderVerified());
         }
     }
 }

效果图

背景

写这个简单的Demo过程，遇到了很多小的决策，这篇文章就看做一个开头吧，后边重点介绍每个决策点，在一篇文章中真的很难说完，喜欢看代码的朋友，先去https://happy.codeplex.com/下载。