采用一个自创的"验证框架"实现对数据实体的验证[设计篇]

没有想到自己头脑发热写了一个简陋版本的所谓“验证框架”能够得到众多网友的推荐。个人觉得这个验证框架有两个主要的特点是:提供CompositeValidator使复杂逻辑判断成为可能;提供多验证规则的支持。《编程篇》中,我主要介绍了如何通过自定义特性的方式进行验证规则的定义,在本篇中我主要来介绍该验证框架的设计原理和实现。

一、核心三人组:Validator、ValidatorAttribute和ValidationError

应该说整个验证框架的核心体系只包含如下三中类型:Validator、ValidatorAttribute和ValidationError

  • Validator:所有的验证逻辑均实现在相应的“验证器”中,具体的验证器均直接或者间接继承自Validator这个抽象基类;
  • ValidatorAttribute:上述的验证器通过对应的自定义特性(Attribute)的方式应用到相应的数据实体类的属性上,ValidatorAttribute是这些特性的基类;
  • ValidationError:在Validator进行数据验证的时候,如果数据实体对象顺利通过验证,则返回Null,否则验证的错误信息封装成一个ValidationError对象返回。

上面的类图反映了上述三个核心类型的属性和操作,以及它们之间的关系。Validator通过Validate方法对传入的数据实体进行验证,验证失败的错误结果以ValidationError对象的形式返回;通过将相应的Validator应用到数据类型的目标属性上的ValidatorAttribute最终需要完成对Validator的创建。

实际上,上述三个类型的定义都比较简单,我们先来看看Validator这个抽象类的定义。如下面的代码所示,Validator具有一个MessageTemplate的属性,表示验证错误信息的模板,该模板具有一些预定义的占位符。这些占位符可以包括与具体Validator无关的一般意义的对象,比如{PropertyName}、{PropertyValue}表示目标属性名和属性值,也包括一些具体Validator专有的占位符,比如《编程篇》提到的GreaterThanValidator的{LowerBound}和LessThanValidator的{UpperBound}。虚FormatMessage方法用于对MessageTemplate进行格式化,即通过相应的值来替换对应的占位符。在这里将被验证的值替换掉{PropertyValue}占位符。最终的验证通过抽象方法Validate体现。

   1: public abstract class Validator
   2: {
   3:     public string MessageTemplate { get; protected set; }
   4:     public abstract ValidationError Validate(object objectToValidate);
   5:     public Validator(string messageTemplate)
   6:     {
   7:         this.MessageTemplate = messageTemplate ?? string.Empty;
   8:     }
   9:     public virtual void FormatMessage(object objectToValidate)
  10:     {
  11:         this.MessageTemplate = this.MessageTemplate.Replace("{PropertyValue}", objectToValidate.ToString());
  12:     }
  13:     protected  ValidationError CreateValidationError(object objectToValidate)
  14:     {
  15:         Guard.ArgumentNotNull(objectToValidate, "objectToValidate");
  16:         return new ValidationError(this.MessageTemplate, objectToValidate, this);
  17:     }
  18: }

我们接着分析ValidatorAttribute的定义。如下面提供的代码片断所示,这是一个继承自Attribute的抽象类。MessageTemplate属性无需多说,RuleName属性表示验证规则的名称。而Tag是为了灵活实现对消息模板格式化的需要,你可以在MessageTemplate中定义{Tag}占位符,然后通过该属性指定替换它的值。ValidatorAttribute同样定义需方法FormatMessage,在这里我们用属性名称替换{PropertyName}占位符。我们的框架最终需要通过ValidatorAttribute创建相应的Validator,这个操作以抽象方法CreateValidator方法提供。

   1: [AttributeUsage(AttributeTargets.Property, AllowMultiple = true)]
   2: public abstract class ValidatorAttribute: Attribute
   3: {
   4:     public string RuleName { get; set; }
   5:     public string Tag { get; set; }
   6:     public string MessageTemplate { get; private set; }
   7:     public abstract Validator CreateValidator();
   8:  
   9:     public ValidatorAttribute(string messageTemplate)
  10:     {
  11:         Guard.ArgumentNotNullOrEmpty(messageTemplate, "messageTemplate");
  12:         this.MessageTemplate = messageTemplate;
  13:         this.RuleName = string.Empty;
  14:     }
  15:     public virtual void FormatMessage(PropertyInfo property)
  16:     {
  17:         this.MessageTemplate = this.MessageTemplate.Replace("{PropertyName}", property.Name)
  18:             .Replace("{Tag}", this.Tag);
  19:     }
  20: }

表示验证失败信息的ValidationError,我尽量将其定义的简单一点。它包含Message、Target和Validtor三个属性,分别表示错误消息、验证的目标对象和采用的Validator。

   1: public class ValidationError
   2: {
   3:     public string       Message { get; internal set; }
   4:     public object       Target { get; internal set; }
   5:     public Validator    Validator { get; internal set; }
   6:  
   7:     public ValidationError(string message, object target, Validator validator)
   8:     {
   9:         Guard.ArgumentNotNull(message, "message");
  10:         Guard.ArgumentNotNull(target, "target");
  11:         Guard.ArgumentNotNull(validator, "validator");
  12:  
  13:         this.Message = message;
  14:         this.Target = target;
  15:         this.Validator = validator;
  16:     }
  17: }

二、一个特殊但却意义重大的Validator:CompositeValidator

正如开篇所说,这个框架一个重要的可取之处在于能够提供对复杂逻辑运算的支持,而这是通过CompositeValidator这种特殊的Validator来实现的。我们提要提供两种具体的CompositeValidator:AndCompositeValidator和OrCompositeValidator,分别用于进行“逻辑与”和“逻辑或”的逻辑判断。它们具有一个相同的抽象基类——CompositeValidator。下面提供的代码片断表明,CompositeValidator仅仅在原来的基础上增加了一个IEnumerable<Validator>类型只读属性:Validators。我将Validators集合中的每一个Validator成为构成CompositeValidator的验证器元素(ValidatorElement)。

   1: public abstract class CompositeValidator:Validator
   2: {
   3:     public CompositeValidator(string messageTemplate, IEnumerable<Validator> validators):base(messageTemplate)
   4:     {
   5:         Guard.ArgumentNotNull(validators, "validators");
   6:         this.Validators = validators;
   7:     }
   8:     public IEnumerable<Validator> Validators { get; private set; }
   9: }

而AndCompositeValidator和OrCompositeValidator定义也很简单,不用多说你也能够看明白具体采用的验证逻辑。

   1: public class AndCompositeValidator: CompositeValidator
   2: {
   3:     public AndCompositeValidator(string messageTemplate,IEnumerable<Validator> validators)
   4:         : base(messageTemplate,validators)
   5:     { }
   6:  
   7:     public override ValidationError Validate(object objectToValidate)
   8:     {
   9:         foreach (var validator in this.Validators)
  10:         {
  11:             if (null != validator.Validate(objectToValidate))
  12:             {
  13:                 return this.CreateValidationError(objectToValidate);
  14:             }
  15:         }
  16:         return null;
  17:     }
  18: }
   1: public class OrCompositeValidator : CompositeValidator
   2: {
   3:     public OrCompositeValidator(string messageTemplate, IEnumerable<Validator> validators)
   4:         : base(messageTemplate,validators){ }
   5:  
   6:     public override ValidationError Validate(object objectToValidate)
   7:     {
   8:         foreach (var validator in this.Validators)
   9:         {
  10:             var validationError = validator.Validate(objectToValidate);
  11:             if (null == validationError)
  12:             {
  13:                 return null;
  14:             }
  15:         }
  16:         return this.CreateValidationError(objectToValidate);
  17:     }
  18: }

基于重用的目的,我们会CompositeValidator定义了ValidatorAttribute基类:CompositeValidatorAttribute。我们将所有ValidatorElement的名称用逗号作为分隔符连接成一个字符串参数传入到构造函数中。

   1: public abstract class CompositeValidatorAttribute : ValidatorAttribute
   2: {        
   3:     public IEnumerable<string> ValidatorElements { get; private set; }
   4:     public CompositeValidatorAttribute(string messageTemplate, string validatorElements):base(messageTemplate)
   5:     {
   6:         Guard.ArgumentNotNullOrEmpty(validatorElements, "validatorElements");
   7:         this.ValidatorElements = validatorElements.Split(',');
   8:     }
   9:     public abstract CompositeValidator CreateCompositeValidator(IEnumerable<Validator> validator);
  10:     public override Validator CreateValidator()
  11:     {
  12:         throw new NotImplementedException();
  13:     }
  14: }

三、验证器元素(ValidatorElement)如何定义?

我们所有的验证规则均通过自定义特性(Attribute)的方式进行定义,说白了就是通过特性的方式将相应的Validator应用到数据类型的目标属性中去。Validator通过ValidatorAttribute可以方便地进行应用,但是构成上述CompositeValidator的验证器元素有如何应用呢?在这里我创建了另一种类型的特性——ValidatorElementAttribute。和ValidatorAttribute不同,ValidatorElementAttribute没有定义MessageTemplate属性,应为最终的验证消息通过CompositeValidator来提供。ValidatorElementAttribute提供了一个Name属性,表示该验证器元素的唯一标识。ValidatorElementAttribute和ValidatorAttribute一样,最终通过CreateValidator创建相应的Validator。

   1: [AttributeUsage(AttributeTargets.Property, AllowMultiple =true)]
   2: public abstract class ValidatorElementAttribute:Attribute
   3: {
   4:     public string Name { get; private set; }
   5:     public ValidatorElementAttribute(string name )
   6:     {
   7:         Guard.ArgumentNotNullOrEmpty(name, "name");
   8:         this.Name = name;
   9:     }
  10:     public abstract Validator CreateValidator();
  11: }

四、CompositeValidator需要有特殊的ValidatorElementAttribute

对于任何一个具体的Validator,由于它既可以作为独立的验证器进行数据验证工作,也可以作为CompositeValidator的验证器元素协同其他的Validator一起完成复杂逻辑判断。所以一个Validator同时具有一个ValidatorAttribute和ValidatorElementAttribute,即使CompositeValidator本身也不能例外。原因很简单,CompositeValidator本身通过自己的ValidatorElement按照相应的逻辑判断规则进行验证,其自身也可以作为另一个CompositeValidator的ValidatorElement。

但是基于CompositeValidator的ValidatorElementAttribute有点特别,以至于我们不得不为之定义一个单独的基类:CompositeValidatorElementAttribute。由于CompositeValidator具有一个以IEnumerable<Validator>对象体现的验证器元素的列表,在ValidatorElementAttribute的CreateValidator方法中无法获取,所以不得不创建一个额外的CreateCompositeValidator抽象方法,以输入参数的方式提供验证器元素列表。

   1: public abstract class CompositeValidatorElementAttribute : ValidatorElementAttribute
   2: {
   3:     public IEnumerable<string> ValidatorElements { get; private set; }
   4:     public CompositeValidatorElementAttribute(string name, string validatorElements)
   5:         : base(name)
   6:     {
   7:         Guard.ArgumentNotNullOrEmpty(validatorElements, "validatorElements");
   8:         this.ValidatorElements = validatorElements.Split(',');
   9:     }
  10:     public abstract CompositeValidator CreateCompositeValidator(IEnumerable<Validator> validators);
  11:     public override Validator CreateValidator()
  12:     {
  13:         throw new NotImplementedException();
  14:     }
  15: }

以上我们着重在介绍CompositeValidator的设计,CompositeValidator以及相关的ValidatorElementAttribute和CompositeValidatorElementAttribute之间的关系可以通过下面的类图表示。

五、最终的验证如何进行?

到目前为止,构成验证框架的所有核心的元素都已经介绍完成,现在我们来看看最终的验证是如何进行的。在《编程篇》我们可以看到没,我们最终是调用静态外观类Validation的Validate方法对数据实体对象进行验证的。具体来说我们定义了如下两个Validate重载,其正一个可以指定验证规则名称。

   1: public static class Validation
   2: {    
   3:     public static bool Validate(object value, out IEnumerable<ValidationError> validationErrors)
   4:     {
   5:         return Validate(value,string.Empty, out validationErrors);
   6:     }
   7:  
   8:     public static bool Validate(object value, string ruleName, out IEnumerable<ValidationError> validationErrors)
   9:     {
  10:         //省略
  11:     }
  12: }

最终的验证逻辑都实现在带ruleName参数的Validate方法中,下面是该方法的定义。只要的逻辑就是:通过反射获取验证对象类型的共有PropertyInfo,并通过它和验证规则名称得到匹配的Validator的列表,然后用它们对属性的值进行验证。

   1: public static bool Validate(object value, string ruleName, out IEnumerable<ValidationError> validationErrors)
   2: {
   3:     validationErrors = new List<ValidationError>();
   4:     Guard.ArgumentNotNull(value, "value");
   5:     foreach (var property in value.GetType().GetProperties())
   6:     {
   7:         var validators = GetValidators(ruleName, property);
   8:         if (validators.Count() > 0)
   9:         {
  10:             var propertyValue = property.GetValue(value, null);
  11:             foreach (var validator in validators)
  12:             {
  13:                 validator.FormatMessage(propertyValue);
  14:                 var error = validator.Validate(propertyValue);
  15:                 if (null != error)
  16:                 {
  17:                     ((List<ValidationError>)validationErrors).Add(error);
  18:                 }
  19:             }
  20:         }
  21:     }
  22:     return validationErrors.Count() == 0;
  23: }

实际上Validate方法中最复杂的逻辑在于如何通过PropertyInfo和验证规则的名称获取匹配的Validator的列表。主要的思路还是通过PropertyInfo进行反射获取应用在上面的ValidatorAttribute,并通过得到ValidatorAttribute创建相应的Validator。不过这其中涉及到对Validator的缓存,以及的CompositeValidator创建时采用的递归,代码相对较多,在这里不作具体介绍了。有兴趣的朋友可以从这里下载源代码进行分析。

六、更多的考虑

和我很多文章一样,这篇文章仅仅是为某个应用场景提供一种大体上的思路,或者提供一种最为简单的解决方案。如果你需要将这些半理论的东西用于实践,你应该根据具体的需求做更多的考虑。本文提供的所谓的“验证框架”我之所以打上引号,是因为其粗陋不堪,实际上就是我花了不到3个小时写成的一个小程序。不过,对于这个小程序背后的解决问题的思路,我觉得还是可取的。有心的朋友不妨从下面的方面对这个“框架”进行扩充:

  • 通过配置+特性的方式是验证规则的变得更加灵活;
  • Validator不仅仅能够应用于属性,可以考虑字段;
  • Validator不仅仅能够应用公有成员,或许可以考虑非公有成员;
  • Validator不仅仅可以应用于属性、字段,也可以应用于整个类型,这就可以对整个对象级别定义验证规则,比如验证StartDate〈EndDate(StartDate和EndDate对应两个属性);
  • Validator还可以应用于方法的参数;
  • 考虑和相应AOP框架集成,让验证(主要是参数验证)自动完成;
  • 如果你希望将Validator应用于WCF服务或者契约方法的参数,可以考虑通过WCF扩展让验证工作自动执行;
  • 通过Resource的方式定义验证消息模板,可以获得多语言文化的支持
  • 其他

采用一个自创的"验证框架"实现对数据实体的验证[编程篇] 采用一个自创的"验证框架"实现对数据实体的验证[设计篇] 采用一个自创的"验证框架"实现对数据实体的验证[改进篇] 采用一个自创的"验证框架"实现对数据实体的验证[扩展篇]

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏程序员的知识天地

Python实现堆栈

堆栈是一个后进先出的数据结构,其工作方式就像一堆汽车排队进去一个死胡同里面,最先进去的一定是最后出来。

1282
来自专栏专注 Java 基础分享

CAS 无锁式同步机制

计算机系统中,CPU 和内存之间是通过总线进行通信的,当某个线程占有 CPU 执行指令的时候,会尽可能的将一些需要从内存中访问的变量缓存在自己的高速缓存区中,而...

1172
来自专栏漫漫深度学习路

C/C++ 预处理器

预处理是在 程序编译之前进行的一步操作。 翻译程序 这个操作是 预处理之前 的操作,在 预处理 之前,编译器会对源代码会进行一些翻译操作: 将源代码中出现的字符...

2469
来自专栏菩提树下的杨过

利用sharding-jdbc分库分表

sharding-jdbc是当当开源的一款分库分表的数据访问层框架,能对mysql很方便的分库、分表,基本不用修改原有代码,只要配置一下即可,完整的配置参考以下...

5417
来自专栏架构技术

AOP缓存实现

1764
来自专栏小樱的经验随笔

Gym 100952B&&2015 HIAST Collegiate Programming Contest B. New Job【模拟】

B. New Job time limit per test:1 second memory limit per test:64 megabytes input...

2066
来自专栏Golang语言社区

Golang视角下的设计模式

这篇文章想聊聊Golang语言下的设计模式问题,我觉得这个话题还是比较有意思的。Golang没有像java那样对设计模式疯狂的迷恋,而是摆出了一份“看庭前花开花...

3829
来自专栏SDNLAB

OFTest(一):如何忽略一些字段在端口poll报文

1 前言 ✔ 关于OFTest的介绍,请戳这里(https://github.com/floodlight/oftest) ✔ 总的来说,就是用python写的...

3639
来自专栏尾尾部落

[剑指offer] 用两个栈实现队列

用两个栈来实现一个队列,完成队列的Push和Pop操作。 队列中的元素为int类型。

901
来自专栏haifeiWu与他朋友们的专栏

聊聊 JDK 非阻塞队列源码(CAS实现)

正如上篇文章聊聊 JDK 阻塞队列源码(ReentrantLock实现)所说,队列在我们现实生活中队列随处可见,最经典的就是去银行办理业务,超市买东西排队等。今...

1832

扫码关注云+社区

领取腾讯云代金券