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

自《编程篇》和《设计篇》发布以来,收到了一些反馈。尤其是园友双鱼座提到.NET 3.5下的System.ComponentModel.DataAnnotations命名空间具有相似的实现,并且通过“表达式”的方式实现了CompositeValidator的服务逻辑判断的功能。为此,我对这个“验证框架”进行了相应的改进,让CompositeValidator具有了解析“验证表达式”的能力。为了让大家对此改进又一个深刻的认识,我们来对比之下对于同一个验证规则,改进前后有何不同。[源代码从这里下载]

一、改进前如何使用CompositeValidator?

改进前的CompositeValidator仅仅提供对两种基本逻辑运算(“析取”和“或取”)的支持,他们分别通过两个具体的CompositeValidator实现,即AndCompositeValidator和OrCompositeValidator。那么对于一些相对复杂的验证规则,应用在属性上的ValidatorAttribute或者ValidatorElementAttribute有可能需要很多,将使我们的代码显得非常臃肿。通过采用《编程篇》中的“找对象”的例子,如果对年龄具有这样的要求:年龄要么在18到25周岁之间,要么在40岁到50周岁之间,对于这段不算太复杂的验证规则,我们需要在Age属性上添加如下7个特性。

   1: public class Mate
   2: {
   3:     private const string messageTemplate   = "通过属性{PropertyName}表示的{Tag}要么在18到25周岁之间,要么在40到50周岁之间。 当前{Tag}为{PropertyValue}周岁!";
   4:    
   5:     [OrCompositeValidator(messageTemplate,"between18And25,between40And50",Tag = "年龄")]
   6:     [AndCompositeValidatorElement("between18And25", "greaterThan18,lessThan25")]
   7:     [AndCompositeValidatorElement("between40And50", "greaterThan40,lessThan50")]
   8:     [GreaterThanValidatorElement("greaterThan18", 18)]
   9:     [GreaterThanValidatorElement("greaterThan40", 40)]
  10:     [LessThanValidatorElement("lessThan25", 25)]
  11:     [LessThanValidatorElement("lessThan50", 50)]
  12:     public int Age { get; set; }
  13:  
  14:     public Mate(int age)
  15:     {
  16:         this.Age = age;
  17:     }
  18: }

采用《编程篇》中定义的辅助方法Validate,我们通过如下的代码对具有不同Age属性值的Mate对象实施验证。对于不同的年龄——16(不符合要求)、20(符合要求)、28(不符合要求)、45(符合要求)和60(不符合要求),分别具有不同的验证结果。

   1: static void Main(string[] args)
   2: {
   3:     var mate = new Mate(16);
   4:     Validate<Mate>(mate);
   5:  
   6:     mate.Age = 20;
   7:     Validate<Mate>(mate);
   8:  
   9:     mate.Age = 28;
  10:     Validate<Mate>(mate);
  11:  
  12:     mate.Age = 45;
  13:     Validate<Mate>(mate);
  14:  
  15:     mate.Age = 60;
  16:     Validate<Mate>(mate);
  17: }

输出结果:

1: 验证失败!

2: 通过属性Age表示的年龄要么在18到25周岁之间,要么在40到50周岁之间。 当前年龄为16周岁!

3: 验证成功!

4: 验证失败!

5: 通过属性Age表示的年龄要么在18到25周岁之间,要么在40到50周岁之间。 当前年龄为28周岁!

6: 验证成功!

7: 验证失败!

8: 通过属性Age表示的年龄要么在18到25周岁之间,要么在40到50周岁之间。 当前年龄为60周岁!

二、在新的CompositeValidator中使用表达式来定义验证规则

如果你采用改进后的验证框架,上面的验证规则可以通过表达式的形式直接写在CompositeValidatorAttribute特性中,下面的代码为你展示了相应的采用改进后的CompositeValidator的Mate类型该如果定义。从中我们可以看出,上述的验证规则对应的表达式为:(V: greaterThan18 AND V: lessThan25) OR (V: greaterThan40 AND V: lessThan50),不但直观而且简洁。在这段表达式中通过“V:{ValidatorElementName}” 表示相应ValidatorElement最终的验证结果(True或者False)。“V: greaterThan18 ”表示应用在Age属性上名称为greaterThan18的GreaterThanValidatorElementAttribute对应的GreaterThanValidator对Age属性值最终的验证结果。目前为止,验证规则对应的表达式支持三种基本的逻辑操作:AND、OR和NOT,这三个操作符结合括号将会使你的验证表达式具有很强的表达能力。如果还不够,你甚至可以定义更多的逻辑操作符。

   1: public class Mate
   2: {
   3:     private const string messageTemplate = "通过属性{PropertyName}表示的{Tag}要么在18到25周岁之间, 要么在40到50周岁之间。 当前{Tag}为{PropertyValue}。";
   4:  
   5:     [CompositeValidator(messageTemplate, "(V: greaterThan18 AND V: lessThan25) OR (V: greaterThan40 AND V: lessThan50)",Tag ="年龄")]
   6:     [GreaterThanValidatorElement("greaterThan18", 18)]
   7:     [LessThanValidatorElement("lessThan25", 25)]
   8:     [GreaterThanValidatorElement("greaterThan40", 40)]
   9:     [LessThanValidatorElement("lessThan50", 50)]
  10:     public int Age { get; set; }
  11:  
  12:     public Mate(int age)
  13:     {
  14:         this.Age = age;
  15:     }
  16: }

三、最新的CompositeValidator作了哪些改变?

在之前的版本中,CompositeValidator是一个抽象类,我们需要定义继承自该类的具体的CompositeValidator来完成相应的逻辑运算,比如AndCompositeValidator和OrCompositeValidator。在新的版本中,CompositeValidator本身就是一个可以用于验证的Validator。我们为它指定一个验证表达式,它自己可以对表达式进行解析,并调用相应的ValidatorElement实施单一验证。最终将这些单一验证结果按照表达式定义的逻辑关系,得到一个最终的结果。最新的CompositeValidator定义如下:

   1: public  class CompositeValidator:Validator
   2: {
   3:     public string ValidationExpression { get; private set; }
   4:     public ExpressionParser ExpressionParser { get; private set; }
   5:     public IEnumerable<Validator> Validators { get; private set; }
   6:  
   7:     public CompositeValidator(string messageTemplate, string validationExpression,IEnumerable<Validator> validators):base(messageTemplate)
   8:     {
   9:         Guard.ArgumentNotNullOrEmpty(validationExpression, "validationExpression");
  10:         Guard.ArgumentNotNull(validators, "validators");
  11:         this.ValidationExpression = validationExpression;
  12:         this.Validators = validators;
  13:         this.ExpressionParser = new ExpressionParser(validators);
  14:     }
  15:     public override ValidationError Validate(object objectToValidate)
  16:     {
  17:         if (this.ExpressionParser.Parse(this.ValidationExpression).Evaluate(objectToValidate))
  18:         {
  19:             return null;
  20:         }
  21:         else
  22:         {
  23:             return this.CreateValidationError(objectToValidate);
  24:         }
  25:     }
  26: }

通过可以看到,CompositeValidator多了两个只读属性:ValidationExpression和ExpressionParser,分别表示验证表达式和表达式解析器(Parser)。那么在Validate方法中,直接调用ExpressionParser的Parse方法会得到一个自定义的BooleanExpression对象,直接调用该对象的Evaluate方法并传入验证对象作为参数,就可以得到最终的验证结果。

CompositeValidatorAttribute随着CompositeValidator的改进也作了相应的变化。只要是提供了一个表示验证表达式的ValidationExpression的属性,该属性在构造函数中指定。和之前的版本一样,CompositeValidatorAttribute不得不采用显式指定ValidatorElment列表的方式(调用CreateCompositeValidator方法来创建CompositeValidator对象)。

   1: public class CompositeValidatorAttribute : ValidatorAttribute
   2: {
   3:     public string ValidationExpression { get; private set; }
   4:     public CompositeValidatorAttribute(string messageTemplate, string validationExpression)
   5:         : base(messageTemplate)
   6:     {
   7:         Guard.ArgumentNotNullOrEmpty(validationExpression, "validationExpression");
   8:         this.ValidationExpression = validationExpression;
   9:         
  10:     }
  11:     public CompositeValidator CreateCompositeValidator(IEnumerable<Validator> validators)
  12:     {
  13:         return new CompositeValidator(this.MessageTemplate, this.ValidationExpression, validators);
  14:     }
  15:     public override Validator CreateValidator()
  16:     {
  17:         throw new NotImplementedException();
  18:     }
  19: }

对于ExpressionParser得实现,我是借鉴了EnterLib安全模块的Authorization表达式的解析方法。由于逻辑稍微有点复杂,有兴趣的朋友可以分析一下EnterLib的源码,也可以直接下载本验证框架的源代码分析表达式解析的逻辑。

四、最终的验证逻辑变得简单

表达式的引入使CompositeValidator和它们ValidatorElement变成是纯粹的两层关系(原来还有一个CompositeValidatorElement的概念),免去了复杂的递归逻辑操作。我将所有的代码写在下面,里面主要涉及到的逻辑就是如果得到某个属性相匹配的Validator。为了避免频繁的反射和对Validator的创建,我参数了缓存机制。不过代码行数还是不少,如果对此真的感兴趣的话还是下载源代码吧。

   1: public static class Validation
   2: {
   3:     private static Dictionary<NamedProperty, IEnumerable<Validator>> validators = new Dictionary<NamedProperty, IEnumerable<Validator>>();
   4:     private static Dictionary<NamedProperty, IEnumerable<Validator>> validatorElements = new Dictionary<NamedProperty, IEnumerable<Validator>>();
   5:  
   6:     private static IEnumerable<Validator> GetValidators(string ruleName, PropertyInfo property)
   7:     {
   8:         var key = new NamedProperty(ruleName, property);
   9:         if (validators.ContainsKey(key))
  10:         {
  11:             return validators[key];
  12:         }
  13:         lock (typeof(Validation))
  14:         {
  15:             if (validators.ContainsKey(key))
  16:             {
  17:                 return validators[key];
  18:             }
  19:             validators[key] = DoGetValidators(ruleName,property);
  20:             return validators[key];
  21:         }
  22:     }
  23:  
  24:     private static IEnumerable<Validator>  GetValidatorElements(string ruleName, PropertyInfo property)
  25:     {
  26:          var key = new NamedProperty(ruleName, property);
  27:          if (validatorElements.ContainsKey(key))
  28:         {
  29:             return validatorElements[key];
  30:         }
  31:         lock (typeof(Validation))
  32:         {
  33:             if (validatorElements.ContainsKey(key))
  34:             {
  35:                 return validatorElements[key];
  36:             }
  37:             validatorElements[key] = DoGetValidatorElements(ruleName, property);
  38:             return validatorElements[key];
  39:         }
  40:     }
  41:  
  42:     private static IEnumerable<Validator> DoGetValidatorElements(string ruleName, PropertyInfo property)
  43:     {
  44:         foreach (ValidatorElementAttribute attribute in property.GetCustomAttributes(typeof(ValidatorElementAttribute), true))
  45:         {
  46:             yield return attribute.CreateValidator();
  47:         }
  48:     }
  49:  
  50:     private static IEnumerable<Validator> DoGetValidators(string ruleName, PropertyInfo property)
  51:     {
  52:         var validatorAttributes = new List<ValidatorAttribute>();
  53:  
  54:         foreach (var attribute in property.GetCustomAttributes(typeof(ValidatorAttribute), true))
  55:         {
  56:             ValidatorAttribute validatorAttribute = (ValidatorAttribute)attribute;
  57:             if (validatorAttribute.RuleName == ruleName)
  58:             {
  59:                 validatorAttribute.FormatMessage(property);
  60:                 validatorAttributes.Add(validatorAttribute);
  61:             }
  62:         }
  63:  
  64:         foreach (var attribute in validatorAttributes)
  65:         {
  66:             if (attribute is CompositeValidatorAttribute)
  67:             {
  68:                 yield return ((CompositeValidatorAttribute)attribute).CreateCompositeValidator(GetValidatorElements(ruleName, property));
  69:             }
  70:             else
  71:             {
  72:                 yield return attribute.CreateValidator();
  73:             }
  74:         }
  75:     }
  76:  
  77:     public static bool Validate(object value, out IEnumerable<ValidationError> validationErrors)
  78:     {
  79:         return Validate(value,string.Empty, out validationErrors);
  80:     }
  81:  
  82:     public static bool Validate(object value, string ruleName, out IEnumerable<ValidationError> validationErrors)
  83:     {
  84:         validationErrors = new List<ValidationError>();
  85:         Guard.ArgumentNotNull(value, "value");
  86:         foreach (var property in value.GetType().GetProperties())
  87:         {
  88:             var validators = GetValidators(ruleName, property);
  89:             if (validators.Count() > 0)
  90:             {
  91:                 var propertyValue = property.GetValue(value, null);
  92:                 foreach (var validator in validators)
  93:                 {
  94:                     validator.FormatMessage(propertyValue);
  95:                     var error = validator.Validate(propertyValue);
  96:                     if (null != error)
  97:                     {
  98:                         ((List<ValidationError>)validationErrors).Add(error);
  99:                     }
 100:                 }
 101:             }
 102:         }
 103:         return validationErrors.Count() == 0;
 104:     }
 105: }
 106:  
 107: internal class NamedProperty
 108: {
 109:     public string RuleName { get; set; }
 110:     public PropertyInfo Property { get; set; }
 111:  
 112:     public NamedProperty(string name, PropertyInfo property)
 113:     {
 114:         this.RuleName = name ?? string.Empty;
 115:         Guard.ArgumentNotNull(property, "property");
 116:         this.Property = property;
 117:     }
 118:  
 119:     public override int GetHashCode()
 120:     {
 121:         return this.RuleName.GetHashCode() ^ this.Property.GetHashCode();
 122:     }
 123: }

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

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

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏程序员的SOD蜜

浅议“全局变量”、“多线程”和“编译器陷阱”

今天偶然看到一段代码,也看到了作者对此的说明,觉得很有意思: public event EventHandler Started; protected vir...

2518
来自专栏黑泽君的专栏

传智播客_毕姥爷_2012年毕向东Java基础教程_毕向东老师

视频百度网盘下载链接:https://pan.baidu.com/s/1bpD3P07#list/path=%2F

1091
来自专栏coolblog.xyz技术专栏

Spring IOC 容器源码分析 - 填充属性到 bean 原始对象

本篇文章,我们来一起了解一下 Spring 是如何将配置文件中的属性值填充到 bean 对象中的。我在前面几篇文章中介绍过 Spring 创建 bean 的流程...

1332
来自专栏雪胖纸的玩蛇日常

第二章 基本数据结构

2008
来自专栏nice_每一天

转载 Java设计模式

设计模式; 一个程序员对设计模式的理解: “不懂”为什么要把很简单的东西搞得那么复杂。后来随着软件开发经验的增加才开始明白我所看到的“复杂”恰恰就是设计模式的精...

1212
来自专栏刘望舒

JNI的实现原理

JNI是Java Native Interface的缩写,它为java提供了调用C和C++代码的能力。java.lang包下的很多类都用到了native方法,比...

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

基于跳跃表的 ConcurrentSkipListMap 内部实现(Java 8)

我们知道 HashMap 是一种键值对形式的数据存储容器,但是它有一个缺点是,元素内部无序。由于它内部根据键的 hash 值取模表容量来得到元素的存储位置,所以...

4465
来自专栏为数不多的Android技巧

ART深度探索开篇:从Method Hook谈起

Android上的热修复框架 AndFix 想必已经是耳熟能详,它的原理实际上很简单:方法替换——Java层的每一个方法在虚拟机实现里面都对应着一个ArtMet...

1801
来自专栏mySoul

设计模式-原型模式

关于Cloneable 接口,用途和Serializable一样为标记型接口,内部没有方法和属性,implements Cloneable 表示对象能被克隆,即...

851
来自专栏糊一笑

几个关于js数组方法reduce的经典片段

以下是个人在工作中收藏总结的一些关于javascript数组方法reduce的相关代码片段,后续遇到其他使用这个函数的场景,将会陆续添加,这里作为备忘。 jav...

4339

扫码关注云+社区

领取腾讯云代金券