groovy/java自实现json解析器（2）JsonObject

底层数据结构实现

本对象的底层数据结构是一个Map(映射)，我们用

def private jsonMap

将其定义为对象变量。我们在构造函数中对其进行初始化，它以键值对的形式存储数据，其中键必须为字符串，值可以为字符串、Boolean、Integer、JsonArray、JsonObject，从最后两个可存储对象，我们或多或少地已能看出JsonObject是如何达成普通json对象里的无限嵌套了。

下面是本对象的构造函数。

def JsonObject( jsonMap = null) {
this.jsonMap = jsonMap == null ? [:] : jsonMa//初始化jsonMap
}

在调用构造函数时，如果我们不传入jsonMap，则会使用默认参数null,这时，我们就以[:]对map进行初始化。

公共调用API

下面定义了一些对外提供的API接口工具函数：

/**
* 根据键获取内容
* @param key
* @return
*/
def get(key){
return jsonMap.get(key)
}
/**
* 以key为键，将value存入map中
* @param key
* @param value
* @return
*/
def put(key,value){
jsonMap.put(key, value)
}
/**
* 根据健删除内容，返回被删除的内容(如果不存在则返回null)
* @param key
* @return
*/
def romove(key){
return jsonMap.remove(key)
}
/**
* 返回键集
* @return
*/
def keySet(){
return jsonMap.keySet()
}
/**
* 返回键值对集
* @return
*/
def entrySet(){
return jsonMap.entrySet()
}
/**
* 判断是否为空
*/
def isEmpty(){
return jsonMap.isEmpty()
}
/**
* 返回对象的大小
*/
def size(){
return jsonMap.size()
}

如果使用过类似于net.json等库函数操作json字符串的，就会对上述的方法非常熟悉了。

核心算法实现

在核心实现中，首先定义了toJsonObject(object)方法，它能将普通json字符串、集合或数组和普通数据类型转化为我们的jsonObject对象，它的定义形如：

/**
* 将object内容转换成JsonObject ,
* object 必须是普通json字符串、集合或数组和普通数据类型
* @param object
* @return
*/
final static JsonObject toJsonObject(object) {
JsonObject jsonObject = null
println object
if (object.getClass() == String.class) {// 如果是普通字符串，则格式化字符串格式输入
some codes...
}else{//条件判断是对象类型还是非字符串普通数据类型还是数组或集合类型，遍历对象属性添加
the other codes...
}// end of 对象类型外循环
jsonObject  //返回值
}

首先我们把object是否为字符串拿出来单独判断，如果

object.getClass() == String.class

，object必须以”{“开头，且以”}“结尾。这种情况我们单独解析，而关于如何把json格式字符串解析成我们的JsonObject,这里使用了两种方法：

第一种方法的思路是参考了逆波兰算法的模式括号匹配。

/**
* 方法一：非递归实现json字符串格式转化
*/
//先检查是否满足json格式要求
if(!ValidateJson.validate(object)){//不满足要求
return null//返回空
}
String jsonStr = ValidateJson.jsonStr//object
println jsonStr
// 先判断字符串是否以“{}“开头结尾
//          if (!jsonStr.startsWith("{") || !jsonStr.endsWith("}")) {
//              throw new IllegalArgumentException("字符串必须以“{}“开头结尾")
//          }
def  lrMArray = JsonTool.posBrackerOfString(jsonStr,"[","]")//获取json字符串中所有中括号的位置
def  lrBArray = JsonTool.posBrackerOfString(jsonStr,"{","}")//获取json字符串中所有大括号的位置
println "中括号:${lrMArray}"
println "大括号:${ lrBArray}"

//开始根据括号来构建jsonObject
//主要实现原理，根据lrBArray的特定，先存放的括号必定是最里面的，但后面存放的括号不一定包括前一个括号里面的内容
//故这里再次模拟一个栈来一次保存每个括号转换成的jsonObject对象，然后再后续进行序号比较
//若后面括号的起始端序号大于前面括号的起始端信号，说明是包含关系，则在转换后面括号为对象时，通过序号相等将前面括号对象作为后面括号对象的一员，
//注意此时应删除已应用的对象，具体见fromJsonObjectPart函数
jsonObject  = JsonTool.getJsonByMergeArray(jsonStr,lrMArray, lrBArray)//这里当前区域函数结束的最后一行，会将函数结果作为返回值返回。即返回我们最终的jsonObject对象

（关于JsonArray的相关解析请看后面系列：”groovy/java自实现json解析器（3）JsonArray”部分，但鉴于json字符串对象和数组的循环嵌套特性，两者的结合分析将贯穿整个类各个函数。）

我们知道，json字符串对象的键必须为字符串，而值可为布尔值、数字、字符串、对象、数组等，像布尔值、数字、字符这些不会存在嵌套，我们无需过多考虑，可以直接根据json字符串格式，直接解析，但如果值为对象或数组，则值对应的字符串又会以”{“开头，“}”结尾或以”[“开头,”]”结尾，这个时候，我们就不能简单地直接解析，我们需要先用两个栈（分别存储中括号和大括号的索引位置）来存储字符串出现的左括号，然后不断扫描json字符串，当检测到右括号时，就将之前的左括号弹出栈，将匹配的括号对在字符串中的索引位置存储在一个整型数组中，这是posBrackerOfString()函数的实现思路，它返回了所搜寻括号的所有对应索引位置，根据数组索引从小到大，对应括号位置从里到外。当我们分别获得中括号，大括号对应索引的两个数组时，我们需要对它们进行合并（合并算法有点像数据结构中的归并排序），即调用getJsonByMergeArray()，合并的结果就是我们最终需要的jsonObject对象了。关于这是posBrackerOfString和即getJsonByMergeArray定义请查看后面系列内容。

除了使用模式括号匹配来把字符串解析成我们需要的jsonObject，我们还可以通过相对”朴素“的递归实现。

/**
*  方法二：通过递归实现对json格式字符串的转化，同时进行了校验，算法效率较高
*/
jsonObject = StringToJson.jsonStringToObjectOrArray(object)

因为无论多复杂的json字符串，最后还是归结为值为字符串、数字、布尔值的形式。所以从递归的思想来分析，凡是遇到字符串、数字、布尔值，就直接解析，遇到对象/数组，就新建一个jsonObject/jsonArray，不断地逐层深入递进解析，总会有穷尽的时候，而一旦穷尽地进入最内层（没有了对象和数组），就是归的开始了，最终，一定能把我们的json字符串解析成一个jsonObject和jsonArray复杂嵌套的jsonObject(考虑字符串充分复杂的话）,具体实现在讲解StringToJson类中分析。

现在让我们看看object是：对象类型还是非字符串普通数据类型还是数组或集合类型，这个时候我们调用来递归获取

jsonObject =  recusiveToJsonObject(object)

下面是recusiveToJsonObject函数的定义，它的实现思想体现在注释中。

/**
* 非字符串Object递归处理部分，涵盖对象类型、基本数据类型、Map类型的处理
* @param object
* @return
*/
private final static recusiveToJsonObject(object){
if(object instanceof Map){//将fieldData的Map中的属性转移到新的Map中
def jsonMap = [:]
for(entry in object){
jsonMap[entry.key] = entry.value
}
return new JsonObject(jsonMap)
}else if(object instanceof Collection || object.getClass().isArray()){//如果是数组类型，默认用”jsonArray"作键保存一个jsonArray
return JsonArray.recusiveToJsonArray(object)
}
if(JsonTool.checkIsBasicClass(object.getClass())){//如果是非字符串的基本数据类型，则直接返回
return object
}
//object 为对象类型，则通过反射遍历对象构建jsonObject
def jsonMap = [:]
Field[] fields = object.getClass().getDeclaredFields()
for(i in 0..fields.length - 1){
if(fields[i].name.contains("\$") || fields[i].name == "metaClass"){//过滤groovy默认添加的元属性和其他特定属性
continue
}
Method method = null
//先获取相应的get方法
try {
method = object.getClass().getMethod(JsonTool.getGetMethodName(fields[i].getName()))
} catch (NoSuchMethodException e) {
continue //不是需要格式化为json的方法，故跳过
}
//从对象中获取对应的属性
def firldData = method.invoke(object)
//判断该属性是基本类型还是复杂类型
if(JsonTool.checkIsBasicClass(fields[i].getType())){//是基本的数据类型
jsonMap.put(fields[i].getName(),firldData);
}else  if(fields[i].getType() == Date.class){//如果是日期类型
//先默认转换特定格式，后期补充自定义
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss")
jsonMap.put(fields[i].getName(),sdf.format(firldData))
}else if(fields[i] instanceof Map){//Map类型,转换成jsonObject
jsonMap[fields[i].getName()] = recusiveToJsonObject(firldData);//递归调用创建新的对象并放入jsonMap中
}else if(fields[i].getType().isArray() || fields[i] instanceof Collection){//数组类型
jsonMap[fields[i].getName()] =  JsonArray.toJsonArray(firldData)
}else{//复杂对象类型,直接放入
jsonMap[fields[i].getName()] =  recusiveToJsonObject(firldData)
}
}//end of 属性添加到jsonMap的循环
new JsonObject(jsonMap)
}

以上我们完成了object类型到JsonObject的转化，但实际比较常用的一个应用，就是把JsonObject，自动组装成我们需要的类对象，这个时候，我们就需要用到java的反射技术了。可惜的是，groovy是一门动态语言，它的动态特性会为我们在用反射构造对象时带来许多麻烦，以下是一个粗糙的实现：

/**
* 递归将jsonObject根据类参数转化为特定的类对象
* @param clazz //要转换为对象的类
* @param jsonObject
* @return
*/
final static toBean(Class<?> clazz,JsonObject jsonObject){
Object instance = clazz.newInstance()//初始化一个要转化的类对象
for(Map.Entry<String,Object> entry : jsonObject.entrySet()){
//根据entry对应的key名获取类相应的属性（用来获取属性的类型)set方法
Field field = null
Method method = null
try{
field = clazz.getDeclaredField(entry.getKey());//获取属性
}catch(NoSuchFieldException e){
System.out.println("没有在类"+clazz+"中找到"+jsonObject+"中的json健名："+entry.getKey() + "请检查该类是否明确定义")
throw e
}
try {
method = clazz.getMethod(JsonTool.getSetMethodName(entry.getKey()),field.getType());//获取方法
} catch (NoSuchMethodException e) {
System.out.println("没有与"+entry.getKey()+"对应的公用set方法")
throw e
}

//判断该属性是jsonObject或是jsonArray或是普通数据类型
if(entry.getValue().getClass() == JsonObject.class){
method.invoke(instance, toBean(field.getType(), (JsonObject) entry.getValue()));//递归调用，将jsonObject转换为bean再注入
}else if(entry.getValue().getClass() == JsonArray.class){
method.invoke(instance, JsonArray.toArray(field.getType(),entry.getValue()))
}else{//普通数据类型,则entry.getValue类型统一为String
method.invoke(instance, JsonTool.getValueByType(field.getType(),String.valueOf(entry.getValue())));//调用方法为属性注入值
}
}
instance//返回值
}

这个方法在groovy中用得并不完美，在实际使用中还会有或多或少的bug,同样的json功能函数，在Java中就显得严谨健壮多了。

/**
* 递归将jsonObject根据类参数转化为特定的类对象
* @param clazz //要转换为对象的类
* @param jsonObject
* @return
* @throws IllegalAccessException
* @throws InstantiationException
* @throws NoSuchFieldException
* @throws NoSuchMethodException
* @throws ParseException
* @throws InvocationTargetException
* @throws IllegalArgumentException
*/
public Object toBean(Class<?> clazz, JsonObject jsonObject) throws InstantiationException, IllegalAccessException, NoSuchFieldException, NoSuchMethodException, IllegalArgumentException, InvocationTargetException, ParseException{
Object instance = clazz.newInstance();//初始化一个要转化的类对象
Map<String,Object> jsonMap =jsonObject.getJsonMap();//获取map，并遍历中的所有属性
for(Map.Entry<String,Object> entry : jsonMap.entrySet()){
//根据entry对应的key名获取类相应的属性（用来获取属性的类型)set方法
Field field = null;
Method method = null;
try{
field = clazz.getDeclaredField(entry.getKey());//获取属性
}catch(NoSuchFieldException e){
System.out.println("没有在类中找到json健名："+entry.getKey());
throw e;
}
try {
method = clazz.getMethod(getSetMethodName(entry.getKey()),field.getType());//获取方法
} catch (NoSuchMethodException e) {
System.out.println("没有与"+entry.getKey()+"对应的公用set方法");
throw e;
}

//判断该属性是jsonObject或是jsonArray或是普通数据类型
if(entry.getValue().getClass() == JsonObject.class){
method.invoke(instance, toBean(field.getType(), (JsonObject) entry.getValue()));//递归调用，将jsonObject转换为bean再注入
}else if(entry.getValue().getClass() == JsonArray.class){
method.invoke(instance, JsonArray.toArray(field.getType(),(JsonArray)entry.getValue()));
}else{//普通数据类型,则entry.getValue类型统一为String
method.invoke(instance, JsonTool.getValueByType(field.getType(),String.valueOf(entry.getValue())));//调用方法为属性注入值
}
}

return instance;
}

toString方法重写

最后，也是每个对象常常具备且需重写的”toString”方法，但在我们这个对象中，我们不能单纯地把它的对象属性：jsonMap println出来，那不是我们想要的，我们应该把它解析成一个合格的json字符串来返回：

/**
* 重写toString函数，将jsonObject转换成json字符串格式输出
*/
@Override
def String toString() {
StringBuffer str = JsonTool.objectToString(this,new StringBuffer());
String jsonStr = str.substring(0,str.length() - 1);
return jsonStr;
}

它的具体实现将会在jsonTool类讲解中看到。