用ExpressionTree实现JSON解析器

2019/04/10 10:10
阅读数 6

  今年的春节与往年不同,对每个人来说都是刻骨铭心的。突入其来的新型冠状病毒使大家过上了“梦想”中的生活:吃了睡,睡了吃,还不用去公司上班,如今这样的生活就在我们面前,可一点都不踏实,只有不停的学习才能让人安心。于是我把年前弄了一点的JSON解析器实现了一下,序列化/反序列化对象转换这部分主要用到了ExpressionTree来实现,然后写了这篇文章来介绍这个项目(查看源码)。

先展示一下使用方法:

 1     public class Student
 2     {
 3         public int Id { get; set; }
 4         public string Name { get; set; }
 5         public Sex Sex { get; set; }
 6         public DateTime? Birthday { get; set; }
 7         public string Address { get; set; }
 8     }
 9 
10     public enum Sex
11     {
12         Unkown,Male,Female,
13     }
Student

json反序列化成Student:

var json = "{\"id\":100,\"Name\":\"张三\",\"Sex\":1,\"Birthday\":\"2000-10-10\"}";
var student = JsonParse.To<Student>(json);

Student序列化为json:

var student = new Student
            {
                Id = 111,
                Name = "testName",
                Sex = Sex.Unkown,
                Address = "北京市海淀区",
                Birthday = DateTime.Now
            };
            var json = JsonParse.ToJson(student);
            //{"Id":111,"Name":"testName","Sex":"Unkown","Birthday":"2020-02-15 17:43:31","Address":"北京市海淀区"}
            var option = new JsonOption
            {
                WriteEnumValue = true, //序列化时使用枚举值
                DateTimeFormat = "yyyy-MM-dd" //指定datetime格式
            };
            var json2 = JsonParse.ToJson(student, option);
            //{"Id":111,"Name":"testName","Sex":0,"Birthday":"2020-02-15","Address":"北京市海淀区"}

json反序列化List,Ienumerable,Array:

var json = "[{\"id\":100,\"Name\":\"张三\",\"Sex\":1,\"Birthday\":\"2000-10-10\"},{\"id\":101,\"Name\":\"李四\",\"Sex\":\"female\",\"Birthday\":null,\"Address\":\"\"}]";
  var list = JsonParse.To<List<Student>>(json);
  var list2 = JsonParse.To<IEnumerable<Student>>(json);
  var arr = JsonParse.To<Student[]>(json);

List<Stuednt> 转换为json

var list = new List<Student>
            {
                new Student {Id=123,Name="username1",Sex=Sex.Male,Birthday = new DateTime(1980,1,1) },
                new Student {Id=125,Name="username2",Sex=Sex.Female},
            };
            var json1 = JsonParse.ToJson(list, true); //使用缩进格式,默认是压缩的json
            /*
            [
                {
                    "Id":123,
                    "Name":"username1",
                    "Sex":"Male",
                    "Birthday":"1980-01-01 00:00:00",
                    "Address":null
                },
                {
                    "Id":125,
                    "Name":"username2",
                    "Sex":"Female",
                    "Birthday":null,
                    "Address":null
                }
            ] 
            */
            var option = new JsonOption
            {
                Indented = true,    //缩进格式
                DateTimeFormat = "yyyy-MM-dd",
                IgnoreNullValue = true //忽略null输出
            };
            var json2 = JsonParse.ToJson(list, option);
            /*
               [
                    {
                        "Id":123,
                        "Name":"username1",
                        "Sex":"Male",
                        "Birthday":"1980-01-01"
                    },
                    {
                        "Id":125,
                        "Name":"username2",
                        "Sex":"Female"
                    }
                ]
             */

json转为Dictironary:

//Json to Dictionary
var json = "{\"确诊病例\":66580,\"疑似病例\":8969,\"治愈病例\":8286,\"死亡病例\":1524}";
var dic = JsonParse.To<Dictionary<string, int>>(json);
var dic2 = JsonParse.To<IDictionary<string, int>>(json);

 JsonParse提供了一些可以重载的对象序列化/反序列化的静态方法,内部实际是调用JsonSerializer去完成的,更复杂的功能也是需要利用JsonSerializer来实现的,这个不是重点就不去介绍了。

  对于JSON的解析主要包含两个功能:序列化和反序列化,序列化是将对象转换为JSON字符串,反序列化是将JSON字符串转换为指定的对象。本项目涉及到的几个核心对象有JsonReader、JsonWriter、 ITypeConverter、IConverterCreator等,下面一一介绍。

1、JsonReader json读取器

  JsonReader可以简单的理解为一个json字符串的扫描仪,按照json语法规则进行扫描,每次扫描取出一个JsonTokenType及其对应的值,JsonTokenType枚举定义:

 1   public enum JsonTokenType : byte
 2     {
 3         None,    
 4         StartObject,  //{
 5         EndObject,    //}   
 6         StartArray,   //[
 7         EndArray,     //]
 8         PropertyName, //{标识后双引号包围的字符串或{内逗号后双引号包围的字符串 解析为PropertyName
 9         String,    //除PropertyName外双引号包围的字符串
10         Number,    //没有引号包围的数字  
11         True,      //true
12         False,     //false
13         Null,      //null
14         Comment    //注释
15     }
View Code

字符串扫描方法 Read() :

 1         public bool Read()
 2         {
 3             switch (_state)
 4             {
 5                 case ReadState.Start: _line = _position = 1; return ReadToken();
 6                 case ReadState.StartObject: return ReadProperty();
 7                 case ReadState.Property:
 8                 case ReadState.StartArray: return ReadToken();
 9                 case ReadState.EndObject:
10                 case ReadState.EndArray:
11                 case ReadState.Comma:
12                 case ReadState.Value: return ReadNextToken();
13                 case ReadState.End: return ValidateEndToken();
14                 default: throw new JsonException($"非法字符{_currentChar}", _line, _position);
15             }
16         }
View Code

  从Read方法可以看出JsonReader内部维持了一个ReadState状态机,每次调用根据上一个ReadState来进行下一个token的解析,这样既驱动了内部方法分支跳转,同时又比较容易的对json格式进行校验,例如:遇到 {(StartObject) 下一个有效字符(空白字符除外)只能是(PropertyName)}(EndObject)之一,所以当ReadState=StartObject时应该去执行ReadProperty()方法,而在ReadProperty()方法里只需要对  } 两个字符做正确的响应,出现其他字符都说明这个json文档格式不正确,抛异常就行了,所以ReadProperty()方法的核心代码如下所示:

 1 private bool ReadProperty()
 2 {
 3        var value =  MoveNext(true);
 4        switch (value)
 5        {
 6             case '"':
 7                 //读取propertyName值
 8                 return true;
 9             case '}':
10                 //readState状态值切换
11                 return true;
12             default: throw new JsonException($"非法字符{value }", _line, _position);
13         }
14 }
15
View Code

....等等其他方法的跳转和格式的校验都是采用类似方法处理的。

  token的校验有一个比较麻烦的地方就是容器(JsonObject和JsonArray)嵌套后符号的闭合是否正确,即{}[]必须成对出现,比如: [ { } } ]这个错误的json字符串,如果仅仅利用上一个token来验证下一个token是否合法,是无法判断出这个json是不合法的, 这时Stack后进先出的特性就非常适合这个场景了,借助Stack我们可以这样验证这个json:遇到第一个[,进行压栈操作;第二个{,继续压栈;第三个},出栈操作,对出栈的值进行判断与当前值是否能闭合,出栈值是{,刚好与}是成对的,那么第三个字符是合法的,此时栈顶值是[;第四个字符},出栈操作,出栈的值是[,与}无法成对,值非法,验证结束。

  JsonReader的核心功能是对json文本的拆解与校验,核心方法就是Read(),调用Read()方法会有3中情况存在:1.返回true,正确读取到一个JsonTokenType且文档未读完  2.返回false,正确读取到一个JsonTokenType且文档已全部读取完毕 3.出现异常,json格式不正确或不满足配置要求。上层的反序列化功能都是依赖JsonReader来完成的,使用JsonReader读完一个json后得到的是一组的JsonTokenType以及对应的值,至于这些tokentype之间所包含的层级关系会由后面的ITypeConverter或JsonToken等对象进行处理。

2、JosnWriter json写入器

  JosnWriter和JsonReader的功能则相反,是将数据按照json规范输出为json字符串,序列化功能类最终都是交给JosnWriter来完成的。调用JsonWriter的写入方法每次会写入一个JsonTokenType值,当然写的时候也需要校验值是否合法,校验逻辑与JsonReader的校验差不多,功能相对简单就不去介绍了,有兴趣的同学可以直接看代码,代码地址在文档末尾。

3、(反)序列化接口ITypeConverter

 主要类之间的引用关系图:

  

  ITypeConverter接口是整个对象序列化/反序列化过程的核心,ITypeConverter的职责是依托于JsonReader,JsonWriter来实现特定对象类型的(反)序列化,但是光有ITypeConverter还不够,因为是特定对象的(反)序列化器,一个ITypeConverter实现类只能解析一个或一类对象,解析一个对象会用到很多个ITypeConverter,对于外部调用者来说根本不知道什么的时候使用哪个ITypeConverter,这个工作就交给了IConverterCreator工厂来完成,看下IConverterCreator的定义:

1 public interface IConverterCreator
2     {
3         bool CanConvert(Type type);
4 
5         ITypeConverter Create(Type type);
6     }
View Code

使用这个工厂创建ITypeConverter前需要调用CanConvert方法来判断给定的Type是否支持,当返回true时就可以去创建对应的TypeConverter,不然创建出来了也不能正常工作,这样就需要有一堆IConverterCreator的候选项来供调用者查找,然后去遍历这些候选项调用CanConvert方法,当遍历到某个候选项返回true时,就可以创建ITypeConverter开始干活了,基于此抽象了一个TypeConverterProvider类:

 1  public abstract class TypeConverterProvider
 2     {
 3         public abstract IReadOnlyCollection<IConverterCreator> AllConverterFactories();
 4 
 5         public abstract void AddConverterFactory(IConverterCreator converter);
 6 
 7         public virtual ITypeConverter Build(Type type)
 8         {
 9             ITypeConverter convert = null;
10             foreach (var creator in AllConverterFactories())
11             {
12                 if (creator.CanConvert(type))
13                 {
14                     convert = creator.Create(type);
15                     break;
16                 }
17             }
18             if (convert == null) throw new JsonException($"创建{type}的{nameof(ITypeConverter)}失败,不支持的类型");
19             return convert;
20         }
21     }
View Code

为了能够扩展使用自定义实现的IConverterCreator,提供了一个AddConverterFactory方法,可以从外部添加自定义的IConverterCreator。Build方法的默认实现就是遍历AllConverterFactories,然后判断是否能创建ITypeConverter,只要符合条件就调用IConverterCreator的Create方法来创建ITypeConverter返回,整个工厂生成器实现闭合,理论上只要AllConverterFactories里面的IConverterCreator足够多或者足够强大,能够转换所有类型的Type,那么这个工厂生成器就可以利用IConverterCreator创建ITypeConverter来实现任意类型的(反)序列化工作了。

4、用ExpressionTree对ITypeConverter的几个实现  

 4.1 TypeConverterBase

  利用表达式树生成委托的功能,然后将委托缓存下来,执行性能可以和静态编写的代码相当。TypeConverterBase提取了一个公共属性Func<object> CreateInstance,目的是为反序列化创建Type的对象是调用,委托的是使用表达式树编译生成:

 1  protected virtual Func<object> BuildCreateInstanceMethod(Type type)
 2         {
 3             NewExpression newExp;
 4             //优先获取无参构造函数
 5             var constructor = type.GetConstructor(Array.Empty<Type>());
 6             if (constructor != null)
 7                 newExp = Expression.New(type);
 8             else
 9             {
10                 //查找参数最少的一个构造函数
11                 constructor = type.GetConstructors().OrderBy(t => t.GetParameters().Length).FirstOrDefault();
12                 var parameters = constructor.GetParameters();
13                 List<Expression> parametExps = new List<Expression>();
14                 foreach (var para in parameters)
15                 {
16                     //有参构造函数使用默认值填充
17                     var defaultValue = GetDefaultValue(para.ParameterType);
18                     ConstantExpression constant = Expression.Constant(defaultValue);
19                     var paraValueExp = Expression.Convert(constant, para.ParameterType);
20                     parametExps.Add(paraValueExp);
21                 }
22                 newExp = Expression.New(constructor, parametExps);
23             }
24             Expression<Func<object>> expression = Expression.Lambda<Func<object>>(newExp);
25             return expression.Compile();
26         }
View Code

这个方法首先判断该类型是否有无参的构造函数,如果有就直接通过Expression.New(type)去构造,没有的话去查找参数最少的一个构造函数来构造,构造带参数构造函数的时候是需要传递这些参数的,默认实现是直接传递当前参数类型的默认值,当然也是可以通过配置等方式来指定参数数据值的。获取一个type默认值的表达式Expression.Default(type),如果类型是int,就相当于default(int),如果类型是string,就相当于default(string)等等。然后使用常量表达式Expression.Constant(defaultValue)转换成Expression,将转换的结果添加到List<Expression>中,再使用构造函数表达式的重载方法newExp= Expression.New(constructor, parametExps),转换成lambad表达式Expression.Lambda<Func<object>>(newExp),就可以调用Compile方法生成委托了。

  有了Func<object> CreateInstance这个委托方法,实例化对象就只需要执行委托就行了,也不用反射创建去对象了。

  TypeConverterBase的具体实现类大体归为3类,处理JsonObject类型的解析器:ObjectConverter、DictionaryConverter,处理JsonArray类型的解析器:EnumberableConverter(具体实现有ListConverter,ArrayConverter...); 处理Json值类型(JsonString,JsonNumber,JsonBoolean,JsonNull)的解析器:ValueConverter。每个解析器都是针对各自类型特点来完成json(反)序列化的。

 4.2 对象解析器 ObjectConverter

  为了能使对象中的属性/字段能与JsonObject中的Property进行相互转化,我们定义了2个委托属性:Func<object, object> GetValue,设置属性/字段值Action<object, object> SetValue。参数的定义都是使用object类型的,目的是为了保证方法的通用性。GetValue是获取属性/字段值的委托方法,第一个入参object是当前类的实例对象,返回的object是对应属性/字段的值。看下GetValue委托生成的代码:

1         protected virtual Func<object, object> BuildGetValueMethod()
2         {
3             var instanceExp = Expression.Parameter(typeof(object), "instance");
4             var instanceTypeExp = Expression.Convert(instanceExp, MemberInfo.DeclaringType);
5             var memberExp = Expression.PropertyOrField(instanceTypeExp, MemberInfo.Name);
6             var body = Expression.TypeAs(memberExp, typeof(object));
7             Expression<Func<object, object>> exp = Expression.Lambda<Func<object, object>>(body, instanceExp);
8             return exp.Compile();
9         }
View Code

首先定义好方法的参数var instanceExp = Expression.Parameter(typeof(object), "instance"),入参是object类型的,使用的时候是需要转换成其真实类型的,使用Expression.Convert(instanceExp, MemberInfo.DeclaringType),Expression.Convert是做类型转换的(Expression.TypeAs也可以类型转换,但转换类型如果是值类型会报错,只能用于转换为引用类型),然后再用Expression.PropertyOrField(instanceTypeExp, MemberInfo.Name),传入实例与成员名称就可以获取到成员值了,这个GetValue方法的逻辑就相当于下面的伪代码:

protected object GetValue(object obj)
        {
            var instance = (目标类型)obj;
            var value = instance.目标属性/字段;
            return (object)value;
        }

再看看SetValue委托的生成逻辑:

 1       protected virtual Action<object, object> BuildSetValueMethod()
 2         {
 3             var instanceExp = Expression.Parameter(typeof(object), "instance");
 4             var valueExp = Expression.Parameter(typeof(object), "memberValue");
 5 
 6             var instanceTypeExp = Expression.Convert(instanceExp, MemberInfo.DeclaringType);
 7             var memberExp = Expression.PropertyOrField(instanceTypeExp, MemberInfo.Name);
 8             //成员赋值
 9             var body = Expression.Assign(memberExp, Expression.Convert(valueExp, MemberType));
10             Expression<Action<object, object>> exp = Expression.Lambda<Action<object, object>>(body, instanceExp, valueExp);
11             return exp.Compile();
12         }
View Code

赋值操作不需要有返回值,第一个参数是实例对象,第二个参数是成员对象,都通过Expression.Parameter方法声明,Expression.PropertyOrField是获取属性/字段的表达式相当于静态代码的instance.属性/字段名 这样的写法,成员赋值表达式:Expression.Assign(memberExp, Expression.Convert(valueExp, MemberType)),成员入参声明的是object,同样需要调用Expression.Convert(valueExp, MemberType) 来转换成真实类型。然后使用Expression.Lambda的Compile方法就可以生成目标委托了。

  一个类里会有多个属性/字段,每个属性/字段都需要对应各自的GetValue/SetValue, 我们将GetValue/SetValue委托的生成统一放在了MemberDefinition类中,一个MemberDefinition只负责管理一个成员信息(PropertyInfo或FieldInfo)的读写委托的生成,然后在ObjectConverter里面维护了一个MemberDefinition列表public IEnumerable<MemberDefinition> MemberDefinitions 来映射当前类的多个属性/字段,每次对成员赋值或写值时,只需要找到对应的MemberDefinition,然后调用其GetValue/SetValue委托就可以了。

 4.3 字典类型解析器 DictionaryConverter

DictionaryConverter为了处理Dictionary<,>与JsonObject之间互转换的,因为是泛型接口,键与值的类型需要用两个属性来保存

public Type KeyType { get; protected set; }

public Type ValueType { get; protected set; }

 这两个Type类型的属性是为了赋值/写值时类型转换用的。 与对象成员赋值的方法不一样,字典键值的读写可以通过索引器来完成,字典赋值委托:Action<object, object, object>,第一个参数是字典实例,第二个参数是key的值,第三个参数是value的值,执行这个委托就等于调用这句代码:dic[key]=value; 来看一下表达式生成这个委托的代码:

protected virtual Action<object, object, object> BuildSetKeyValueMethod(Type type)
        {
            var objExp = Expression.Parameter(typeof(object), "dic");
            var keyParaExp = Expression.Parameter(typeof(object), "key");
            var valueParaExp = Expression.Parameter(typeof(object), "value");
            var dicExp = Expression.TypeAs(objExp, Type);
            var keyExp = Expression.Convert(keyParaExp, KeyType);
            var valueExp = Expression.Convert(valueParaExp, ValueType);
            //调用索引器赋值
            var property = type.GetProperty("Item", new Type[] { KeyType });
            var indexExp = Expression.MakeIndex(dicExp, property, new Expression[] { keyExp });
            var body = Expression.Assign(indexExp, valueExp);
            var expression = Expression.Lambda<Action<object, object, object>>(body, objExp, keyParaExp, valueParaExp);
            return expression.Compile();
        }
View Code

这个无返回值的委托有3个object类型的入参,都通过Expression.Parameter定义,再分别转换成各自真实的数据类型,然后反射找到索引器对应的PropertyInfo:type.GetProperty("Item", new Type[] { KeyType })(索引器默认属性名为Item),得到索引器Expression.MakeIndex(dicExp, property, new Expression[] { keyExp }),这句话相当于读key的值,对索引器赋值的话还需要用 Expression.Assign(indexExp, valueExp)来完成,这样通过索引器赋值的委托就搞定了。字典根据key获取value值的委托:Func<object, object, object>逻辑与赋值操作基本相同,只需要将索引器拿到的结果返回就完事,代码就不贴了。

4.4 可迭代类型(实现IEnumerable接口的类型)解析器EnumerableConverter

   实现了IEnumerable接口的类型与JsonArray之间的互转主要用到了2个功能的委托:Func<object, IEnumerator> GetEnumerator和Action<object, object> AddItem,分别相当于读和写,读是拿到IEnumerable的迭代器GetEnumerator(),然后遍历迭代器;写是对集合添加元素,最终是集合调用自己的”Add“方法,由于不是所有集合添加数据的方法名字都叫Add,所以EnumerableConverter是一个抽象类,只实现了公共逻辑部分,具体实现由具体实现类来完成(比如:ListConverter,ArrayConverter...)。贴上获取迭代器委托的生成代码与集合添加数据委托的生成代码:

 1         protected virtual Func<object, IEnumerator> BuildGetEnumberatorMethod(Type type)
 2         {
 3             var paramExp = Expression.Parameter(typeof(object), "list");
 4             var listExp = Expression.TypeAs(paramExp, type);
 5             var method = type.GetMethod(nameof(IEnumerable.GetEnumerator));//实现了IEnumerable的类一定有GetEnumerator方法
 6             var callExp = Expression.Call(listExp, method); //调用GetEnumerator()方法
 7             var body = Expression.TypeAs(callExp, typeof(IEnumerator)); //结果转换为IEnumerator类型
 8             var expression = Expression.Lambda<Func<object, IEnumerator>>(body, paramExp);  
 9             return expression.Compile();
10         }
BuildGetEnumberatorMethod
 1         protected virtual Action<object, object> BuildAddItemMethod(Type type)
 2         {
 3             var listExp = Expression.Parameter(typeof(object), "list");
 4             var itemExp = Expression.Parameter(typeof(object), "item");
 5             var instanceExp = Expression.Convert(listExp, type);
 6             var argumentExp = Expression.Convert(itemExp, ItemType);
 7             var addMethod = type.GetMethod(AddMethodName);//添加数据方法AddMethodName有实现的子类去指定,默认为Add
 8             var callExp = Expression.Call(instanceExp, addMethod, argumentExp); //调用添加数据方法
 9             Expression<Action<object, object>> addItemExp = Expression.Lambda<Action<object, object>>(callExp, listExp, itemExp);
10             return addItemExp.Compile();
11         }
BuildAddItemMethod

   使用EnumerableConverter序列化对象时只需要调用GetEnumerator委托,拿到迭代器IEnumerator,遍历迭代器将每个item输出到json就可以了。反序列化对象时执行AddItem委托就等于集合调用自己添加数据的方法,从而完成对集合数据的填充。但是数组是不可变的,没有添加元素的方法如何处理呢?这里的处理方法是数组的构造先由List来完成,添加数据就可以用List.Add方法了,到最后统一调用List的ToArray()方法转换成目标数组。所以ArrayConverter是继承自ListConverter的,重写一下父类ListConverter的反序列化方法,在父类处理完后调用list的ToArray方法就完成了。

  还有一大堆具体的实现这里也不去介绍了,主要是把表达式树实现这块的东西写出来当作学习笔记,顺便分享一下。

  写这个项目主要是为了学习表达式树的运用与json的解析,其中一部分设计思路参考了Newtonsoft.Json源码,受限于本人的水平,加上项目也没有全面的测试,里面一定有不少问题,欢迎大佬们提出指正,希望能与大家共同学习进步。最后希望疫情早日结束,能早点回去搬砖。

  贴上源码地址:https://github.com/zhangmingjian/RapidityJson

原文出处:https://www.cnblogs.com/zhangmingjian/p/12295997.html

展开阅读全文
打赏
0
0 收藏
分享
加载中
更多评论
打赏
0 评论
0 收藏
0
分享
返回顶部
顶部