业务层

业务层的实现方式

 

在我的上一篇博客：对企业级应用开发的思考--分层 中，从个人的经验分享了关于程序分层方面的内容，得到了众多园友的支持。里面包含对业务逻辑层三种实现方式（事务脚本、活动记录集和领域模型）的简单描述。并没有深入去实现。本文来深入探讨一下。

本文以下面这个实体结构与数据库结构为例：

 

两个分别表示用户与学科信息（学科名称与分数）

假设有两个业务：

  1. 取得某用户的平均分；
  2. 修改某用户某学科的分数；

数据访问部分统一使用EF，因为数据访问部分不是重点，所以未给出代码，方便大家阅读。来看看几种方式的实现：

事务脚本

先贴代码：

  1. public class TransactionScript  
  2.     {  
  3.         private TestContext dbContext = new TestContext();  
  4.   
  5.         //得到平均分  
  6.         public int GetAverageScore(string username)  
  7.         {  
  8.             int total = 0;  
  9.             int count = 0;  
  10.             var subjects = dbContext.Subjects.Where(s => s.UserInfo.UserName == username);  
  11.             foreach (var s in subjects)  
  12.             {  
  13.                 total += s.Score;  
  14.                 count++;  
  15.             }  
  16.   
  17.             if (count == 0) return 0;  
  18.             return total/count;  
  19.               
  20.         }  
  21.   
  22.         //修改指定账号的学科分数  
  23.         public void ChangeScore(string username, string subjectName, int score)  
  24.         {  
  25.             var subject =  
  26.                 dbContext.Subjects.FirstOrDefault(u => u.Name == subjectName && u.UserInfo.UserName == username);  
  27.             if(subject == null)  
  28.                 throw new Exception("not found");  
  29.             subject.Score = score;  
  30.             dbContext.SaveChanges();  
  31.         }  
  32.     }  

这里，因为测试需要我的类名起的是TransactionScript，如果把它换成XXService或XXBll的话，我想100%的人都会觉得太眼熟了。就像我在上面那篇文章说的：事务脚本遵循面向过程的开发方式，而不是面向对象的方法。核心思想是为每个业务创建一个过程，每个过程都包含完成业务事务所需要的所有业务逻辑，包括从工作流、业务规则和验证检查到数据库持久化保存的所有内容。

这里操作数据库的方式不管你用普通的Ado.net，还是像文章中高大上的EF或者你用诸如Dapper之类的Orm，如果你的代码风格是这种，很不幸，别和我谈什么领域模型，你就写了个事务脚本，仅此而已！因为在以此为基础的前提下进行开发，在可以想像的未来，你的代码都逃不过这种风格。因为这时候选择的构架模式在后期基本没有重构的可能。

活动记录集

先贴代码：

  1. public partial class UserInfo  
  2.     {  
  3.         private static TestContext _db = new TestContext();  
  4.   
  5.         public static UserInfo Find(string name)  
  6.         {  
  7.             return _db.UserInfoes.FirstOrDefault(u => u.UserName == name);  
  8.         }  
  9.         //得到平均分  
  10.         public int GetAverageScore()  
  11.         {  
  12.             int total = 0;  
  13.             int count = 0;  
  14.             foreach (var s in Subjects)  
  15.             {  
  16.                 total += s.Score;  
  17.                 count++;  
  18.             }  
  19.   
  20.             if (count == 0) return 0;  
  21.             return total / count;  
  22.         }  
  23.   
  24.         //修改指定账号的学科分数  
  25.         public void ChangeScore(string subjectName, int score)  
  26.         {  
  27.             var subject =  
  28.                 Subjects.FirstOrDefault(u => u.Name == subjectName);  
  29.             if (subject == null)  
  30.                 throw new Exception("not found");  
  31.             subject.Score = score;  
  32.             _db.SaveChanges();  
  33.         }  
  34.     }  

注意，这段代码使用了partial关键字，是对EF中的UserInfo类进行扩展，代码风格和上面的事务脚本已经有很大的改变。回忆一下活动记录集的定义：存在一个业务对象代表数据库中的一行或者一张表（至于是行还是表，完全取决于自己选择表数据入口还是行数据入口，和业务层关系不大），在业务对象中包含数据和行为，同时包含用于持久化对象的方式及添加新实例和查找数据集合的方法。

这种风格已经初具面向对象的意识，避免了程序开发中的贫血模型，对象中既包含了数据，又有行为。在业务逻辑没有复杂到把领域模型单独提出来的时候，这是最为理想的开发模式。

领域模型

先贴代码：

  1. //实体  
  2. public partial class UserInfo  
  3. {  
  4.     //得到平均分  
  5.     public int GetAverageScore()  
  6.     {  
  7.         int total = 0;  
  8.         int count = 0;  
  9.         foreach (var s in Subjects)  
  10.         {  
  11.             total += s.Score;  
  12.             count++;  
  13.         }  
  14.   
  15.         if (count == 0) return 0;  
  16.         return total / count;  
  17.     }  
  18.   
  19.     //修改指定账号的学科分数  
  20.     public void ChangeScore(string subjectName, int score)  
  21.     {  
  22.         var subject =  
  23.             Subjects.FirstOrDefault(u => u.Name == subjectName);  
  24.         if (subject == null)  
  25.             throw new Exception("not found");  
  26.         subject.Score = score;  
  27.     }  
  28. }  
  29.   
  30. //仓储接口   
  31. public interface IRepository  
  32. {  
  33.     UserInfo Find(string name);  
  34.     void Update(UserInfo user);  
  35. }  
  36.   
  37. //仓储实现  
  38. public class Repository :IRepository  
  39. {  
  40.     private TestContext _db = new TestContext();  
  41.     public UserInfo Find(string name)  
  42.     {  
  43.         return _db.UserInfoes.FirstOrDefault(u => u.UserName == name);  
  44.     }  
  45.   
  46.     public void Update(UserInfo user)  
  47.     {  
  48.         var old = _db.UserInfoes.FirstOrDefault(u => u.id == user.id);  
  49.         //automapper user to old  
  50.         _db.SaveChanges();  
  51.     }  
  52. }  
  53.   
  54. // 应用服务  
  55. public class UserService  
  56. {  
  57.     private IRepository _repository;  
  58.   
  59.     public UserService(IRepository repository)  
  60.     {  
  61.         _repository = repository;  
  62.     }  
  63.   
  64.     public int GetAverage(string username)  
  65.     {  
  66.         var user = _repository.Find(username);  
  67.         return user.GetAverageScore();  
  68.     }  
  69.   
  70.     public void ModifyScore(string username, string subjectname, int score)  
  71.     {  
  72.         var user = _repository.Find(username);  
  73.         user.ChangeScore(subjectname, score);  
  74.         _repository.Update(user);  
  75.     }  
  76. }  

这是一个基于传统DDD架构风格的代码实现，应用层UserService只负责协调仓储与实现，实体本身不具备持久化能力。但代码量几乎是成倍的增长，如果没有复杂的业务流程及复杂的数据映射结构进行实践，你完全不能体会领域模型的优点。

通过这三段简单的代码可以看出，只有适合自己的，没有哪种业务模式可以成为银弹。

最后总结一下三种业务实现方式（表模块与活动记录集可以合并为一个，只是表数据入口与行数据入口的区别）的优点及适用范围：

本博客其他精彩内容：http://www.cnblogs.com/yubaolee/p/Catalogue.html

【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/Leo_wl/p/4899637.html