电子发烧友App
// 根据类型名和控件对象名生成变量申明语句
// private TextView tv_name;
sb.append（“\t\tprivate ”）
.append（getTypeName（j2j））
.append（“ ”）
.append（j2j.getName（））
.append（“;\n”）;
// 已经使用的数据会移除，减少下一次外层循环的遍历次数
customIterator.remove（）;
}
}
sb.append（“\t}\n”）;
}
}
sb.append（“}”）;
return sb.toString（）;
}
/**
* 递归遍历整个json数据结构，保存至jsonBeans集合中
*
* @param rootJo 根json对象
* @return 解析好的数据集合
*/
private static ListgetJsonBeanTree（JsonObject rootJo） {
jsonBeans = new ArrayList（）;
recursionJson（rootJo， null）;
return jsonBeans;
}
/**
* 保存递归获取到数据的集合
*/
private static ListjsonBeans = new ArrayList（）;
/**
* 递归获取json数据
*
* @param jo 当前递归解析的json对象
* @param parent 已经解析好的上一级数据，无上一级时传入null
*/
private static void recursionJson（JsonObject jo， Json2JavaElement parent） {
// 循环整个json对象的键值对
for （Entry entry ： jo.entrySet（）） {
// json对象的键值对建构为 {“key”：value}
// 其中，值可能是基础类型，也可能是集合或者对象，先解析为json元素
String name = entry.getKey（）;
JsonElement je = entry.getValue（）;
Json2JavaElement j2j = new Json2JavaElement（）;
j2j.setName（name）;
if（parent ！= null） {
j2j.setParentJb（parent）;
}
// 获取json元素的类型，可能为多种情况，如下
Classtype = getJsonType（je）;
if（type == null） {
// 自定义类型
// json键值的首字母转为大写，作为自定义类名
j2j.setCustomClassName（StringUtils.firstToUpperCase（name））;
// ？
j2j.setSouceJo（je.getAsJsonObject（））;
jsonBeans.add（j2j）;
// 自定义类需要继续递归，解析自定义类中的json结构
recursionJson（je.getAsJsonObject（）， j2j）;
} else if（type.equals（JsonArray.class）） {
// 集合类型
// 重置集合数据，并获取当前json元素的集合类型信息
deepLevel = 0;
arrayType = new ArrayType（）;
getJsonArrayType（je.getAsJsonArray（））;
j2j.setArray（true）;
j2j.setArrayDeep（deepLevel）;
if（arrayType.getJo（） ！= null） {
j2j.setCustomClassName（StringUtils.firstToUpperCase（name））;
// 集合内的末点元素类型为自定义类， 递归
recursionJson（arrayType.getJo（）， j2j）;
} else {
j2j.setType（arrayType.getType（））;
}
jsonBeans.add（j2j）;
} else {
// 其他情况，一般都是String，int等基础数据类型
j2j.setType（type）;
jsonBeans.add（j2j）;
}
}
}
/**
* 集合深度，如果是3则为ArrayList》》
*/
private static int deepLevel = 0;
/**
* 集合类型数据，用于保存递归获取到的集合信息
*/
private static ArrayType arrayType = new ArrayType（）;
/**
* 递归获取集合的深度和类型等信息
*
* @param jsonArray json集合数据
*/
private static void getJsonArrayType（JsonArray jsonArray） {
// 每次递归，集合深度+1
deepLevel ++;
if （jsonArray.size（） == 0） {
// 如果集合为空，则集合内元素类型无法判断，直接设为Object
arrayType.setArrayDeep（deepLevel）;
arrayType.setType（Object.class）;
} else {
// 如果集合非空则取出第一个元素进行判断
JsonElement childJe = jsonArray.get（0）;
// 获取json元素的类型
Classtype = getJsonType（childJe）;
if（type == null） {
// 自定义类型
// 设置整个json对象，用于后续进行进一步解析处理
arrayType.setJo（childJe.getAsJsonObject（））;
arrayType.setArrayDeep（deepLevel）;
} else if （type.equals（JsonArray.class）） {
// 集合类型
// 如果集合里面还是集合，则递归本方法
getJsonArrayType（childJe.getAsJsonArray（））;
} else {
// 其他情况，一般都是String，int等基础数据类型
arrayType.setArrayDeep（deepLevel）;
arrayType.setType（type）;
}
}
}
/**
* 获取json元素的类型
*
* @param je json元素
* @return 类型
*/
private static ClassgetJsonType（JsonElement je） {
Classclazz = null;
if（je.isJsonNull（）） {
// 数据为null时，无法获取类型，则视为object类型
clazz = Object.class;
} else if（je.isJsonPrimitive（）） {
// primitive类型为基础数据类型，如String，int等
clazz = getJsonPrimitiveType（je）;
} else if（je.isJsonObject（）） {
// 自定义类型参数则返回null，让json的解析递归进行进一步处理
clazz = null;
} else if（je.isJsonArray（）） {
// json集合类型
clazz = JsonArray.class;
}
return clazz;
}
/**
* 将json元素中的json基础类型，转换为String.class，int.class等具体的类型
*
* @param je json元素
* @return 具体数据类型，无法预估的类型统一视为Object.class类型
*/
private static ClassgetJsonPrimitiveType（JsonElement je） {
Classclazz = Object.class;
JsonPrimitive jp = je.getAsJsonPrimitive（）;
// json中的类型会将数字集合成一个总的number类型，需要分别判断
if（jp.isNumber（）） {
String num = jp.getAsString（）;
if（num.contains（“。”）） {
// 如果包含“。”则为小数，先尝试解析成float，如果失败则视为double
try {
Float.parseFloat（num）;
clazz = float.class;
} catch（NumberFormatException e） {
clazz = double.class;
}
} else {
// 如果不包含“。”则为整数，先尝试解析成int，如果失败则视为long
try {
Integer.parseInt（num）;
clazz = int.class;
} catch（NumberFormatException e） {
clazz = long.class;
}
}
} else if（jp.isBoolean（）） {
clazz = boolean.class;
} else if（jp.isString（）） {
clazz = String.class;
}
// json中没有其他具体类型如byte等
return clazz;
}
/**
* 获取类型名称字符串
*
* @param j2j 转换数据元素
* @return 类型名称，无法获取时，默认Object
*/
private static String getTypeName（Json2JavaElement j2j） {
String name = “Object”;
Classtype = j2j.getType（）;
if（j2j.getCustomClassName（） ！= null && j2j.getCustomClassName（）.length（） 》 0） {
// 自定义类，直接用自定义的名称customClassName
name = j2j.getCustomClassName（）;
} else {
// 非自定义类即可以获取类型，解析类型class的名称，如String.class就对应String
name = type.getName（）;
int lastIndexOf = name.lastIndexOf（“。”）;
if（lastIndexOf ！= -1） {
name = name.substring（lastIndexOf + 1）;
}
}
// 如果集合深度大于0，则为集合数据，根据深度进行ArrayList嵌套
// 深度为3就是ArrayList
StringBuilder sb = new StringBuilder（）;
for（int i=0; i
sb.append（“ArrayList《”）;
}
sb.append（name）;
for（int i=0; i
sb.append（“》”）;
}
return sb.toString（）;
}
工商网监
评论