标签 标签 标签

  • 一句话的事儿：

一、前言

　　在前一专题中介绍了规约模式的实现，然后在仓储实现中，经常会涉及工作单元模式的实现。然而，在我的网上书店案例中也将引入工作单元模式，所以本专题将详细介绍下该模式，为后面案例的实现做一个铺垫。

二、什么是工作单元模式（Unit Of Work）

　　工作单元模式：用来维护一个已经被业务事务修改（包括添加、修改或更新）的业务对象列表。工作单元模式复制协调这些修改的持久化工作以及所有标记的并发问题。采用工作单元模式带来的好处是能够保证数据的完整性。如果在持久化一系列业务对象的过程中出现问题，则将所有的修改回滚，以保证数据始终处于有效状态。
　　简单来说，工作单元模式就是把业务对象的持久化由工作单元实现类进行统一管理。而不想之前那样，分布在每个具体的仓储类中，这样就可以达到一系列业务对象的统一管理，不至于在每个业务对象中出现统一的提交和回滚业务逻辑，实现代码最大化重用。

三、工作单元模式的实现

　　从工作单元模式的定义可以看出，工作单元需要保存被业务事务修改的业务对象列表，则必须定义3个集合，分别是添加、修改和更新集合，然而如果使用EF的话，则不需要了，因为DbContext.DbSet就可以代替这三个集合。这里为了演示，我们并没有引入EF，所以我们实现中定义了3个集合来保存被修改的业务对象。既然要在工作单元类中进行统一管理，则我们就需要在工作单元类中定义一个Commit方法，该方法的实现就是去遍历这三个集合的对象，对它们进行统一提交，如果其中一个失败，则进行数据回滚。根据面向接口编程原则，我们需要定义一个工作单元接口，即IUnitOfWork接口。经过上面的分析，再结合下面具体的实现来理解，工作单元模式的实现也就更加清晰了，下面让我们一起去实现下工作单元模式。
　　第一步：我们需要定义我们的领域层。
　　这里以银行账号之间转账业务作为背景，自然涉及到银行账号业务对象。并且领域层同时包括仓储接口的定义和领域服务。
　　领域服务指的是：如果有些方法涉及多个实体或聚合的交互，此时就应该把这段逻辑放到领域服务中，领域服务只有方法没有属性，也就是没有状态的。在银行转账业务中，账户之间的转账操作就适合作为领域服务来提供，因为转账操作涉及多个聚合间的交互，需要从一个账户扣钱和另一个账户加钱。所以在领域层还需要定义账户转账服务。经过这样的分析，则领域层的实现如下所示：

  1. // 账号仓储接口
  2. public interface IAccountRepository
  3. {
  4.     void Save(Account account);
  5.     void Add(Account account);
  6.     void Remove(Account account);  
  7. }
  8. // 账号实体类
  9. public class Account : IAggregateRoot
  10. {
  11.     public decimal Balance { get; set; }
  12.     public System.Guid Id { get; set; }
  13.     public Account()
  14.     {
  15.         Id = Guid.NewGuid();
  16.     }
  17. }
  18. // 账号转账领域服务类
  19. public class AccountService
  20. {
  21.     private readonly IAccountRepository _productRepository;
  22.     private readonly IUnitOfWork _unitOfWork;
  23.     public AccountService(IAccountRepository productRepository, IUnitOfWork unitOfWork)
  24.     {
  25.         _productRepository = productRepository;
  26.         _unitOfWork = unitOfWork;            
  27.     }
  29.     public void Transfer(Account from, Account to, decimal amount)
  30.     {
  31.         if (from.Balance >= amount)
  32.         {
  33.             from.Balance -= amount;
  34.             to.Balance += amount;
  35.             _productRepository.Save(from);
  36.             _productRepository.Save(to);
  37.             _unitOfWork.Commit();
  38.         }
  39.     } 
  40. }

　　第二步：构建基础设施层
　　我们一般把工作单元模式的实现放在基础设施层，因为工作单元模式属于一种技术支持。根据上面工作单元模式的分析，我们首先定义IUnitOfWork接口，接着定义它的实现。因为这里没有引入EF，所以具体的实体的持久化还是调用具体的仓储来实现持久化的，所以还需要定义一个IUnitOfWorkRepository接口。则基础设施层的实现如下所示：

  1. //工作单元接口
  2. public interface IUnitOfWork
  3. {
  4.     void RegisterAmended(IAggregateRoot entity, IUnitOfWorkRepository unitofWorkRepository);
  5.     void RegisterNew(IAggregateRoot entity, IUnitOfWorkRepository unitofWorkRepository);
  6.     void RegisterRemoved(IAggregateRoot entity, IUnitOfWorkRepository unitofWorkRepository);
  7.     void Commit();
  8. }
  9. // 工作单元实现
  10. public class UnitOfWork : IUnitOfWork
  11. {
  12.     // 引入了EF就不需要额外定义三个列表了，因为EF框架中包含的DbContext.DbSet<T>可以记录这3个列表
  13.     // 然而在ByteartRetail案例中，也定义这3个列表，但其没有被真真使用到
  14.     private readonly Dictionary<IAggregateRoot, IUnitOfWorkRepository> _addedEntities;
  15.     private readonly Dictionary<IAggregateRoot, IUnitOfWorkRepository> _changedEntities;
  16.     private readonly Dictionary<IAggregateRoot, IUnitOfWorkRepository> _deletedEntities;
  17.     public UnitOfWork()
  18.     {
  19.         _addedEntities = new Dictionary<IAggregateRoot, IUnitOfWorkRepository>();
  20.         _changedEntities = new Dictionary<IAggregateRoot, IUnitOfWorkRepository>();
  21.         _deletedEntities = new Dictionary<IAggregateRoot, IUnitOfWorkRepository>();
  22.     }
  23.     // 将业务对象实体添加到内部列表中，真正完成实体持久化操作的还是由具体的仓储类去完成
  24.     public void RegisterAmended(IAggregateRoot entity, IUnitOfWorkRepository unitofWorkRepository)
  25.     {
  26.         if (!_changedEntities.ContainsKey(entity))
  27.         {
  28.             _changedEntities.Add(entity, unitofWorkRepository);
  29.         }
  30.     }
  31.     public void RegisterNew(IAggregateRoot entity, IUnitOfWorkRepository unitofWorkRepository)
  32.     {
  33.         if (!_addedEntities.ContainsKey(entity))
  34.         {
  35.             _addedEntities.Add(entity, unitofWorkRepository);
  36.         };
  37.     }
  38.     public void RegisterRemoved(IAggregateRoot entity, IUnitOfWorkRepository unitofWorkRepository)
  39.     {
  40.         if (!_deletedEntities.ContainsKey(entity))
  41.         {
  42.             _deletedEntities.Add(entity, unitofWorkRepository);
  43.         }
  44.     }
  46.     protected void ClearRegisterations()
  47.     {
  48.         _addedEntities.Clear();
  49.         _changedEntities.Clear();
  50.         _deletedEntities.Clear();
  51.     }
  52.     // 对内部列表进行统一提交
  53.     // 引入EF后，提交的实现有点不同，它具体的持久化只需要调用DbContext.SaveChanges方法来完成
  54.     // 则具体的仓储接口不需要实现IUnitOfWorkRepository接口，则自然不存在IUnitOfWorkRepository接口的定义
  55.     public void Commit()
  56.     {
  57.         // 事务范围
  58.         using (var scope = new TransactionScope())
  59.         {
  60.             // 分别调用具体的仓储对象的持久化逻辑来对业务对象进行持久化
  61.             foreach (var entity in this._addedEntities.Keys)
  62.             {
  63.                 this._addedEntities[entity].PersistCreationOf(entity);
  64.             }
  65.             foreach (var entity in this._changedEntities.Keys)
  66.             {
  67.                 this._changedEntities[entity].PersistUpdateOf(entity);
  68.             }
  69.             foreach (var entity in this._deletedEntities.Keys)
  70.             {
  71.                 this._deletedEntities[entity].PersistDeletionOf(entity);
  72.             }
  73.             scope.Complete();
  74.         }
  75.          // 清楚内存中对象
  76.         ClearRegisterations();
  77.     }
  78. }
  79. public interface IUnitOfWorkRepository
  80. {
  81.     Hashtable AccountList { get; }
  82.     void PersistCreationOf(IAggregateRoot entity);
  83.     void PersistUpdateOf(IAggregateRoot entity);
  84.     void PersistDeletionOf(IAggregateRoot entity); 
  85. }
  86. public interface IAggregateRoot
  87. {
  88.     Guid Id { get; }
  89. }


　　第三步：实现仓储层。
　　仓储的实现在之前也说过，它其实可以放在基础设施层里，但一般总将其放在一个单独层进行实现。所以这里也就放在一个单独层进行实现。这里仓储实现只有一个类，即对IAccountRepository接口的实现。具体的实现代码如下所示：

  1. public class AccountRepository : IAccountRepository, IUnitOfWorkRepository
  2. {
  3.     private readonly IUnitOfWork _unitOfWork;
  4.     public AccountRepository(IUnitOfWork unitOfWork)
  5.     {
  6.         _unitOfWork = unitOfWork;
  7.         AccountList = new Hashtable();
  8.     }
  9.     public Hashtable AccountList { get; set; }
  10.     #region IAccountRepository Members
  11.     public void Save(Account account)
  12.     {
  13.         _unitOfWork.RegisterAmended(account, this);
  14.     }
  15.     public void Add(Account account)
  16.     {
  17.         _unitOfWork.RegisterNew(account, this);
  18.     }
  19.     public void Remove(Account account)
  20.     {
  21.         _unitOfWork.RegisterRemoved(account, this);
  22.     }
  23.     #endregion
  24.     #region IUnitOfWorkRepository Members
  25.     public void PersistUpdateOf(IAggregateRoot entity)
  26.     {
  27.         // ADO.net code to update the entity...
  28.         // 这里为了演示，只它持久化到内存中
  29.         if (AccountList.ContainsKey(entity.Id))
  30.         {
  31.             AccountList[entity.Id] = entity;
  32.         }
  33.     }
  34.     public void PersistCreationOf(IAggregateRoot entity)
  35.     {
  36.         // ADO.net code to Add the entity...
  37.         // 这里为了演示，只它持久化到内存中
  38.         AccountList.Add(entity.Id, entity);
  39.     }
  40.     public void PersistDeletionOf(IAggregateRoot entity)
  41.     {
  42.         // ADO.net code to delete the entity...
  43.         // 这里为了演示，只它持久化到内存中
  44.         if (AccountList.ContainsKey(entity.Id))
  45.         {
  46.             AccountList.Remove(entity.Id);
  47.         }
  48.     }
  49.     #endregion
  50. }

　　这样，就完成了工作单元模式模式的实现和应用了，工作单元模式的实现存在于基础设施层，其他层的构建主要为了演示，下面通过一个测试项目来进行测试下工作单元的使用。具体项目的引入将会在下一个专题中介绍，下一个专题将引入工作单元模式和规约模式的实现。具体的测试项目的代码如下所示：

  1. [TestClass]
  2. public class AccountRepositoryTests
  3. {
  4.     [TestMethod]
  5.     public void AccountRepository_Delegates_Changes_To_The_Unit_Of_Work_Instance()
  6.     {
  7.         var accountToBeAmended = new Account();
  8.         var accountToBeRemoved = new Account();
  9.         var accountToBeAdded = new Account();
  10.         // 需要引入Moq Mock框架
  11.         var unitOfWorkMockery = new Mock<IUnitOfWork>();
  12.         var accountRepository = new AccountRepository(unitOfWorkMockery.Object);
  13.         unitOfWorkMockery.Setup(uow => uow.RegisterAmended(accountToBeAmended, accountRepository));
  14.         unitOfWorkMockery.Setup(uow => uow.RegisterNew(accountToBeAdded, accountRepository));
  15.         unitOfWorkMockery.Setup(uow => uow.RegisterRemoved(accountToBeRemoved, accountRepository));
  16.         accountRepository.Add(accountToBeAdded);
  17.         accountRepository.Save(accountToBeAmended);
  18.         accountRepository.Remove(accountToBeRemoved);
  19.         unitOfWorkMockery.VerifyAll();
  20.     }        
  21. }

四、总结

　　到这里，本专题的内容就介绍完了，上一专题和这一专题都是一个前期准备的专题，主要是为网上书店案例引入这2个模式的实现做一个铺垫，为了让大家对知识点分开吸收，然后再通过后面一专题的应用来加深理解这2个模式的应用。
　　本专题的所有源码下载：UnitOfWorkDemo.zip

  • 本文作者：GeekPower - Felix Sun
  • 版权声明： 本博客所有文章除特别声明外，均采用 MIT 许可协议。转载请注明出处！