应用程序框架实战十五:DDD分层架构之领域实体（验证篇）

　　在应用程序框架实战十四:DDD分层架构之领域实体（基础篇）一文中，我介绍了领域实体的基础，包括标识、相等性比较、输出实体状态等。本文将介绍领域实体的一个核心内容——验证，它是应用程序健壮性的基石。为了完成领域实体的验证，我们在前面已经准备好了验证公共操作类和异常公共操作类。

　　.Net提供的DataAnnotations验证方法非常强大，Mvc会自动将DataAnnotations特性转换为客户端Js验证，从而提升了用户体验。但是客户端验证是靠不住的，因为很容易绕开界面向服务端提交数据，所以服务端必须重新验证。换句话说，服务端验证才是必须的，客户端验证只是为了提升用户体验而已。

　　为了在服务端能够进行验证，Mvc提供了ModelState.IsValid。

[HttpPost]
public ActionResult 方法名( 实体名 model ) {
    if ( ModelState.IsValid == false ) {
    //验证失败就返回，可能会添加错误消息，也可能要转换为客户端能识别的消息格式
    }
//验证成功就执行后面的代码
}

　　在控制器里写if ( ModelState.IsValid == false )判断有几个问题，下面进行一些讨论。

　　第一，可能误导初学者，导致分层不清。

　　从分层架构的角度来讲，验证属于业务层，在DDD分层架构就是领域层。观察ModelState.IsValid可以发现，这句代码并不是在定义验证规则，而是调用验证。在控制器上直接调用验证可能并不是什么问题，但初学者可能会认为，既然可以在控制器上调用ModelState.IsValid进行验证，那么其它验证代码也可以放到控制器上。

        [HttpPost]
        public ActionResult 方法名( 实体名 model ) {
            if ( ModelState.IsValid == false ) {
                //验证失败就返回
            }
            if ( model.A >  ) {
                //验证失败就返回
            }
            if ( model.B >  ) {
                //验证失败就返回
            }
            //验证成功就执行后面的代码
        }

　　观察上面代码，model.A > 1 已经将本属于领域层的验证定义规则泄露到表现层来了，因为这句代码访问了实体的属性，所谓验证规则，就是对实体属性值进行某些约束。

　　既然可以在控制器上写验证，那么就会有人在这里写业务逻辑，所以到了后面，DDD分层架构如同虚设。

　　第二，错误的验证时机可能导致验证失败。

　　考虑这样的场景，如果实体中某些属性需要调用特定方法来产生结果，当提交到控制器操作时，这些属性还是空值，由于还没有调用特定方法，所以调用ModelState.IsValid可能导致验证失败。

　　可以看出，这其实是因为验证的时机不对，验证几乎一定要在某些操作之后来进行，比如初始化操作，当然你可以在调用ModelState.IsValid之前调用特定方法，但这会导致分层不清的问题。

　　打个比方，实体中有一个订单号，它是一个字符串类型，并且添加了[Required]特性，需要调用某个方法来创建订单号，当订单实体被提交到控制器操作时，调用ModelState.IsValid就会失败，因为订单号现在是空值。当然你可以把生成订单号的操作提前到创建订单界面之前，这样再提交过来就没问题了，在这个例子上一般是可行的，但有些操作你可能无法提前。

　　第三，无法保证验证完整性，可能需要多次验证。

　　很多时候，DataAnnotations无法满足我们的需求，所以我们还需要为特定业务需求写一些定制的验证代码。而ModelState.IsValid只能验证DataAnnotations特性，所以这时候验证通过意义不大，因为你需要在后面再验证一次。当然你可以通过一些手段进行扩展，让ModelState.IsValid能够验证你的特定规则，但没有多大必要，因为表现层在分层上的要点就是尽量不要写代码。

　　第四，导致冗余代码。

　　现在来观察每个ModelState.IsValid判断都干了些什么工作，一般都会转换成客户端的特定消息，比如某种格式的Json，然后返回给客户端显示出来。为了这样一个简单的功能，需要在大量的方法上添加这个判断吗？更好的方法是把这个判断抽象到控制器基类，由基类来进行处理，其它地方有错误抛出异常就可以了。这样可以得到一个统一的异常处理模型，并且消除了大量冗余代码。从这里也可以看出，打造你的应用程序框架，总是从这些不起眼的地方着手，反复考虑每个判断，每行代码是不是可以消灭，把尽量多的东西抽象到框架中，这样在开发过程中更多工作就会自动完成，不断提炼可以让你的工作越来越轻松。

　　综上所述，在表现层进行验证并不是一个好方法，执行验证可以在应用层，而定义验证就一定要在领域层。下面开始介绍如何对领域实体进行验证支持。

　　现在有一个员工实体，叫Employee，如下所示。

    /// <summary>
    /// 员工
    /// </summary>
    public class Employee : EntityBase {
        /// <summary>
        /// 姓名
        /// </summary>
        [Required( ErrorMessage = "姓名不能为空" )]
        public string Name { get; set; }

        /// <summary>
        /// 性别
        /// </summary>
        [Required( ErrorMessage = "性别不能为空" )]
        public string Gender { get; set; }

        /// <summary>
        /// 年龄
        /// </summary>
        [Range(,,ErrorMessage = "年龄范围为18岁到50岁")]
        public int Age { get; set; }

        /// <summary>
        /// 职业
        /// </summary>
        [Required(ErrorMessage = "职业不能为空")]
        public string Job { get; set; }

        /// <summary>
        /// 工资
        /// </summary>
        public double Salary { get; set; }
  }

　　为了简单起见，我把一些东西简化了，比如性别用枚举更好，但用了字符串类型，而年龄根据出生年月推断会更好等等。这个例子只是想说明验证的方法，所以不用考虑它的真实性。

　　可以看见，在员工实体的属性上添加了一些DataAnnotations特性，这些特性保证了基本的验证。现在定义了验证规则，那么怎么执行验证呢？前面已经说了，用ModelState.IsValid虽然可以实现这个功能，但不是最优方法，所以我们要另谋出路。

　　执行验证的最简单方法可能长成这样：employee.Validate(),employee是Employee的实例，Validate是Employee中的一个实例方法。

　　注意，现在我们在领域实体中定义了一个方法，这可能会打破你平时的习惯和认识。多年的习惯可能让你对实体的认识就是，只有一堆属性的对象。现在要把思维转变过来，这个转变至关重要，它是你进入面向对象开发的第一步。

　　想想看，你现在要进行验证，应该上哪才能找到这个能执行验证的方法呢？如果它不在实体中，那么它可能在表现层，也可能在应用层，还可能在领域服务中，当然还有可能不存在，都还没人实现呢。

　　所以我们需要给业务逻辑安家，这样才能帮你统一的管理业务逻辑，并提供唯一的访问点。这个家最好的地方就是实体本身，因为属性全都在这里面，属性上执行的逻辑也全部放进来，就能实现对象级别的高内聚。当属性和逻辑发生变化时，对外的方法接口可能不变，这时候所有变化引起的影响就被限制在实体内部，这样就达到了更低的耦合。

　　下面，我们来实现Validate方法。

　　首先考虑，这个方法应该被定义在哪呢？是不是每个实体上都定义一个，由于验证对于绝大部分实体都是必须的功能，所以需要定义到层超类型上，即EntityBase。

　　再来考虑一下Validate的方法签名。需要一个返回值吗，比如bool值，我在之前的文章已经讨论了返回bool值来指示是否验证通过不是一个好方法，所以我们现在返回void。那么方法参数呢？由于现在是直接在实体上调用，所以参数也不是必须的。

        /// <summary>
        /// 验证
        /// </summary>
        public void Validate() {
        }

　　为了实现这个方法，我们必须要能够验证实体上的DataAnnotations特性，这在前面的验证公共操作类已经准备好了。我们在Util.Validations命名空间中定义了IValidation接口，并使用企业库实现了这个接口。

　　考虑在EntityBase的Validate方法中该如何获得IValidation的实例呢？依赖程度最低的方法是使用构造方法注入。

    /// <summary>
    /// 领域实体
    /// </summary>
    /// <typeparam name="TKey">标识类型</typeparam>
    public abstract class EntityBase<TKey> {
        /// <summary>
        /// 验证器
        /// </summary>
        private IValidation _validation; 

        /// <summary>
        /// 标识
        /// </summary>
        [Required]
        public TKey Id { get; private set; } 

        /// <summary>
        /// 初始化领域实体
        /// </summary>
        /// <param name="id">标识</param>
        /// <param name="validation">验证器</param>
        protected EntityBase( TKey id, IValidation validation ) {
            Id = id;
            _validation = validation;
        }
}

　　在外部通过构造方法把需要的验证器实例传进来，这样甚至不需要在Util.Domains中引用任何程序集。这看起来很诱人，但不要盲目的追求低耦合。考虑验证器的稳定性，这应该非常高，你基本不会随便换掉它，更不会动态更换它。再看构造方法，多了一个参数，这会导致实体使用起来非常困难。所以为了不必要的扩展性牺牲易用性，并不划算。

　　另一种方法是通过Validate方法的参数注入，这样可能要好些，但还是会让方法在调用时变得难用。

　　应用程序框架只是给你或你的团队在小范围使用的，它不像.Net Framework或第三方框架在全球范围使用，所以你没有必要追求非常高的扩展性，如果发生变化导致你需要修改应用程序框架，你打开来改一下也不是啥大问题，因为框架和项目源码都在你的控制范围内，不见得非要达到OCP原则。当然，如果发生变化的可能性高，你还是需要考虑降低依赖。在依赖性和易用性间取舍，一定要根据实际情况，不要盲目追求低耦合。

　　另外再考虑每个实体可能需要更换不同的验证器吗？如果需要，那就得引入工厂方法模式。由于这个验证器只是用来验证DataAnnotations特性的，所以没这必要。

　　那么直接在EntityBase中new一个Validation实例好不好呢？嘿嘿，这我也只能说要求太低了。一个折中的方案是使用简单静态工厂，如果需要更换验证器实现，你就把这个工厂打开来改改，其它地方不动，一般来讲这已经够用。

　　为Util.Domains引用Util.Validations.EntLib程序集，并在Util.Domains中添加ValidationFactory类。

using Util.Validations;
using Util.Validations.EntLib; 

namespace Util.Domains {
    /// <summary>
    /// 验证工厂
    /// </summary>
    public class ValidationFactory {
        /// <summary>
        /// 创建验证操作
        /// </summary>
        public static IValidation Create() {
            return new Validation();
        }
    }
}

　　在EntityBase类中添加Validate方法。

        /// <summary>
        /// 验证
        /// </summary>
        public void Validate() {
            var result = ValidationFactory.Create().Validate( this );
            if ( result.IsValid )
                return;
            throw new Warning( result.First().ErrorMessage );
        }

　　我们在Validate方法中将领域实体本身传入Validation实例中进行验证，获得验证结果以后，判断如果验证失败就抛出异常，这里的异常是我们在上一篇定义的异常公共操作类Warning，这样我们就知道是业务上发生了错误，可以把这个抛出的消息显示给客户。

　　完成了上面的步骤以后，就可以进行基本的验证了。但是只能用DataAnnotations进行基本验证，很明显无法满足我们的实际需求。

　　现在来假想一个验证需求，你的老板是个好人，你们的人力资源系统也是自己开发的，他要求程序员老男人的工资不能小于一万。换句话说，如果是一个程序员老男人，他的信息被保存到数据库的时候，工资不能小于一万，否则就是非法数据。程序员老男人这个词汇很明显不存在，为了加深你的印象，用它来给你演示业务概念如何被映射到系统中。

　　程序员老男人包含三个条件：

1. 职业 == 程序员
2. 年龄 > 40
3. 性别 == 男

　　你为了验证这个需求，能使用DataAnnotations特性吗，也许你真的可以，但是大部分人都做不到，哪怕做到也异常复杂。

　　为了实现这个功能，你可能在调用了Validate()方法之后，紧接着进行判断。

 employee.Validate();
 if ( employee.Job == "程序员" && employee.Age >  && employee.Gender == "男" && employee.Salary <  )
    throw new Warning( "程序员老男人的工资不能低于1万" );

　　如果你调用Validate是在应用层，这下好了，把验证逻辑泄露到应用层去了，很快，你的分层架构就会乱成一团。

　　时刻记住，只要是业务逻辑，你就一定要放到领域层。验证是业务逻辑的一个重要组成部分，这就是说，没有验证，业务逻辑可能是错的，因为进来的数据不在合法范围。

　　现在把这句判断移到Employee实体，最合适的地方就是Validate方法中，但这个方法是在基类EntityBase上定义的，为了能够给基类方法添加行为，可以把EntityBase中的Validate方法设为虚方法，这样子类就可以重写了。

　　基类EntityBase中的Validate方法修改如下。

        /// <summary>
        /// 验证
        /// </summary>
        public virtual void Validate() {
            var result = ValidationFactory.Create().Validate( this );
            if ( result.IsValid )
                return;
            throw new Warning( result.First().ErrorMessage );
        }

　　在Employee实体中重写Validate方法，注意必须调用base.Validate()，否则对DataAnnotations的验证将丢失。

        public override void Validate() {
            base.Validate();
            if ( Job == "程序员" && Age >  && Gender == "男" && Salary <  )
                throw new Warning( "程序员老男人的工资不能低于1万" );
        }

　　对于应用层来讲，它并不关心具体怎么验证，它只知道调用employee.Validate()就行了。这样就把验证给封装了起来，为应用层提供了一个清晰而简单的API。

　　一般说来，DataAnnotations和重写Validate方法添加自定义验证可以满足大部分领域实体的验证需求。但是，如果验证规则很多，而且很复杂，会发现重写的Validate方法很快变成一团乱麻。

　　除了代码杂乱无章之外，还有一个问题是，业务概念被淹没在大量的条件判断中，比如Job == "程序员" && Age > 40 && Gender == "男" && Salary < 10000这个条件实际上代表的业务概念是程序员老男人的工资规则。

　　另一个问题是，有些验证规则只在某些特定条件下进行，直接固化到实体中并不合适。

　　当验证变得逐渐复杂时，就需要考虑将验证从实体中拆分出来。将一条验证规则封装到一个验证规则对象中，这就是规约模式在验证上的应用。规约的概念很简单，它是一个谓词，用来测试一个对象是否满足某些条件。规约的强大之处在于，将一堆相关的条件表达式封装起来，清晰的表达了业务概念。

　　把程序员老男人的工资规则提取到一个OldProgrammerSalaryRule类中，如下所示。

    /// <summary>
    /// 程序员老男人的工资验证规则
    /// </summary>
    public class OldProgrammerSalaryRule {
        /// <summary>
        /// 初始化程序员老男人的工资验证规则
        /// </summary>
        /// <param name="employee">员工</param>
        public OldProgrammerSalaryRule( Employee employee ) {
            _employee = employee;
        } 

        /// <summary>
        /// 员工
        /// </summary>
        private readonly Employee _employee; 

        /// <summary>
        /// 验证
        /// </summary>
        public bool Validate() {
            if ( _employee.Job == "程序员" && _employee.Age >  && _employee.Gender == "男" && _employee.Salary <  )
                return false;
            return true;
        }
    }

　　上面的验证规则对象，通过构造方法接收业务实体，然后通过Validate方法进行验证，如果验证失败就返回false。

　　返回bool值的一个问题是，错误描述就拿不到了。为了获得错误描述，我把返回类型从bool改成ValidationResult。

using System.ComponentModel.DataAnnotations; 

namespace Util.Domains.Tests.Samples {
    /// <summary>
    /// 程序员老男人的工资验证规则
    /// </summary>
    public class OldProgrammerSalaryRule {
        /// <summary>
        /// 初始化程序员老男人的工资验证规则
        /// </summary>
        /// <param name="employee">员工</param>
        public OldProgrammerSalaryRule( Employee employee ) {
            _employee = employee;
        } 

        /// <summary>
        /// 员工
        /// </summary>
        private readonly Employee _employee; 

        /// <summary>
        /// 验证
        /// </summary>
        public ValidationResult Validate() {
            if ( _employee.Job == "程序员" && _employee.Age >  && _employee.Gender == "男" && _employee.Salary <  )
                return new ValidationResult( "程序员老男人的工资不能低于1万" );
            return ValidationResult.Success;
        }
    }
}

　　验证规则对象虽然抽出来了，但是在哪调用它呢？最好的地方就是领域实体的Validate方法，因为这样应用层将非常简单。

　　为了能够在领域实体的Validate方法中调用验证规则对象，需要将验证规则添加到该实体中，这可以在Employee中增加一个AddValidationRule方法。

    /// <summary>
    /// 员工
    /// </summary>
    public class Employee : EntityBase {
        //构造方法和属性

        /// <summary>
        /// 验证规则集合
        /// </summary>
        private List<OldProgrammerSalaryRule> _rules; 

        /// <summary>
        /// 添加验证规则
        /// </summary>
        /// <param name="rule">验证规则</param>
        public void AddValidationRule( OldProgrammerSalaryRule rule ) {
            if ( rule == null )
                return;
            _rules.Add( rule );
        } 

        /// <summary>
        /// 验证
        /// </summary>
        public override void Validate() {
            base.Validate();
            foreach ( var rule in _rules ) {
                var result = rule.Validate();
                if ( result == ValidationResult.Success )
                    continue;
                throw new Warning( result.ErrorMessage );
            }
        }
    }

　　如果另一个领域实体需要使用验证规则，就要复制代码过去改一下，这显然是不行的，所以需要把添加验证规则抽到基类EntityBase中。为了支持这个功能，首先要为验证规则抽象出一个接口，代码如下。

using System.ComponentModel.DataAnnotations; 

namespace Util.Validations {
    /// <summary>
    /// 验证规则
    /// </summary>
    public interface IValidationRule {
        /// <summary>
        /// 验证
        /// </summary>
        ValidationResult Validate();
    }
}

　　在EntityBase中添加AddValidationRule方法，并修改Validate方法，代码如下。

        /// <summary>
        /// 验证规则集合
        /// </summary>
        private readonly List<IValidationRule> _rules; 

        /// <summary>
        /// 添加验证规则
        /// </summary>
        /// <param name="rule">验证规则</param>
        public void AddValidationRule( IValidationRule rule ) {
            if ( rule == null )
                return;
            _rules.Add( rule );
        } 

        /// <summary>
        /// 验证
        /// </summary>
        public virtual void Validate() {
            var result = ValidationFactory.Create().Validate( this );
            foreach ( var rule in _rules )
                result.Add( rule.Validate() );
            if ( result.IsValid )
                return;
            throw new Warning( result.First().ErrorMessage );
        }

　　现在让OldProgrammerSalaryRule实现IValidationRule接口，应用层可以像下面这样调用。

employee.AddValidationRule( new OldProgrammerSalaryRule( employee ) );
employee.Validate();

　　可以在几个地方为领域实体设置验证规则对象。

1. 领域实体的构造方法中。
2. 具体的领域实体重写Validate方法中。
3. 当工厂创建领域实体（聚合）时。
4. 领域服务或应用服务调用领域实体进行验证时。

　　设置验证规则的要点是，稳定的验证规则尽量放到实体中，以方便使用。

　　现在还有一个问题是，验证处理是抛出一个异常，这个异常的消息设置为验证结果集合的第一个消息。这在大部分时候都够用了，但是某些时候对错误的处理会有所不同，比如你现在要显示全部验证失败的消息，这时候将要修改框架。所以把验证的处理提取出来是个不错的方法。

　　定义一个验证处理的接口IValidationHandler，这个验证处理接口有一个Handle的处理方法，接收一个验证结果集合的参数，代码如下。

    /// <summary>
    /// 验证处理器
    /// </summary>
    public interface IValidationHandler {
        /// <summary>
        /// 处理验证错误
        /// </summary>
        /// <param name="results">验证结果集合</param>
        void Handle( ValidationResultCollection results );
    }

　　由于只需要在特殊情况下更换验证处理实现，所以定义一个默认的实现，代码如下。

    /// <summary>
    /// 默认验证处理器，直接抛出异常
    /// </summary>
    public class ValidationHandler : IValidationHandler{
        /// <summary>
        /// 处理验证错误
        /// </summary>
        /// <param name="results">验证结果集合</param>
        public void Handle( ValidationResultCollection results ) {
            if ( results.IsValid )
                return;
            throw new Warning( results.First().ErrorMessage );
        }
    }

　　为了能够更换验证处理器，需要在EntityBase中提供一个方法SetValidationHandler，代码如下。

        /// <summary>
        /// 验证处理器
        /// </summary>
        private IValidationHandler _handler; 

        /// <summary>
        /// 设置验证处理器
        /// </summary>
        /// <param name="handler">验证处理器</param>
        public void SetValidationHandler( IValidationHandler handler ) {
            if ( handler == null )
                return;
            _handler = handler;
        }

　　在EntityBase构造方法中初始化_handler = new ValidationHandler()，并修改Validate方法。

        /// <summary>
        /// 验证
        /// </summary>
        public virtual void Validate() {
            var result = ValidationFactory.Create().Validate( this );
            foreach ( var rule in _rules )
                result.Add( rule.Validate() );
            if ( result.IsValid )
                return;
            _handler.Handle( result );
        }

　　最后，用提取方法重构来改善一下Validate代码。

        /// <summary>
        /// 验证
        /// </summary>
        public virtual void Validate() {
            var result = GetValidationResult();
            HandleValidationResult( result );
        }

        /// <summary>
        /// 获取验证结果
        /// </summary>
        private ValidationResultCollection GetValidationResult() {
            var result = ValidationFactory.Create().Validate( this );
            Validate( result );
            foreach ( var rule in _rules )
                result.Add( rule.Validate() );
            return result;
        }

        /// <summary>
        /// 验证并添加到验证结果集合
        /// </summary>
        /// <param name="results">验证结果集合</param>
        protected virtual void Validate( ValidationResultCollection results ) {
        }

        /// <summary>
        /// 处理验证结果
        /// </summary>
        private void HandleValidationResult( ValidationResultCollection results ) {
            if ( results.IsValid )
                return;
            _handler.Handle( results );
        }

　　注意，这里添加了一个Validate( ValidationResultCollection results )虚方法，这是一个钩子方法，提供它的目的是允许子类向ValidationResultCollection中添加自定义验证的结果。它和重写Validate()方法的区别是，如果重写Validate()方法，那么你将需要自己处理验证，而Validate( ValidationResultCollection results )方法将以统一的方式被handler处理。

　　这样，我们就实现了验证规则定义与验证处理的分离。

　　最后，再对这个小例子完善一下，可以将“程序员老男人”这个概念封装到Employee的一个方法中。

        /// <summary>
        /// 是否程序员老男人
        /// </summary>
        public bool IsOldProgrammer() {
            return Job == "程序员" && Age >  && Gender == "男";
        }

　　OldProgrammerSalaryRule验证规则的实现修改为如下代码。

        /// <summary>
        /// 验证
        /// </summary>
        public ValidationResult Validate() {
            if ( _employee.IsOldProgrammer() && _employee.Salary <  )
                return new ValidationResult( "程序员老男人的工资不能低于1万" );
            return ValidationResult.Success;
        }

　　这样不仅概念上更清晰，而且当多个地方需要对“程序员老男人”进行验证时，还能体现出更强的封装性。

　　由于代码较多，完整代码就不粘贴了，如有需要请自行下载。

　　如果你有更好的验证方法，请一定要告诉我，等我理解以后分享给大家。

　　.Net应用程序框架交流QQ群: 386092459，欢迎有兴趣的朋友加入讨论。

　　谢谢大家的持续关注，我的博客地址：http://www.cnblogs.com/xiadao521/

　　下载地址：http://files.cnblogs.com/xiadao521/Util.2014.11.20.1.rar