你还在为文档里铺天盖地滴变量， 结构复杂的json而烦恼吗~

　　写错了一个类型，然后各种崩溃

　　写错了一个变量名无法解析

　　代码工具来啦~

　　自动生成javabean类，只要一键~

　　此系列的代码工具就致力于此，替你完成这些无聊的工作，让你有更多的精力时间研究新姿势

　　使用方法

　　先将代码工具导入Eclipse， 该项目为Java Project，注意不是Android Project

　　1.将json字符串数据复制到项目中的jsonString.txt文件中

　　（json数据可以从文档中的json数据示例里，或先运行一遍接口调用代码打印出来json字符串获取到）

　　2.运行代码工具中的JsonUtils类，其中的main函数中会运行json解析主方法

　　3.打开JsonBean.java文件，刷新，复制其中自动生成好的javabean类直接使用

　　补充

　　如果需要public修饰变量，可以ctrl+F进行全部替换

　　如果需要生成getter and setter方法，可以右键Source-》Generate Getter and Setter进行设置

　　工具代码已开源，也可以根据需求自行修改

　　好了，工具使用到此结束，后面介绍下代码原理等

　　原理

　　项目为一个Java Project

　　利用Gson工具将字符串树结构解析出来，然后利用File IO流将bean结构根据需求生成代码再写入到文件中

　　可见项目中源码，良心注释，几乎2行代码1行注释

　　这里也贴出下核心类JsonUtils的代码

　　package utils;

　　import java.io.File;

　　import java.util.ArrayList;

　　import java.util.Iterator;

　　import java.util.List;

　　import java.util.Map.Entry;

　　import com.google.gson.JsonArray;

　　import com.google.gson.JsonElement;

　　import com.google.gson.JsonObject;

　　import com.google.gson.JsonParser;

　　import com.google.gson.JsonPrimitive;

　　import entity.ArrayType;

　　import entity.Json2JavaElement;

　　public class JsonUtils {

　　public static void main（String［］ args） {

　　parseJson2Java（）;

　　}

　　/**

　　* 将json字符串转换为对应的javabean

　　* 用法：

　　* 将json字符串拷贝至本项目中/Json/JsonString.txt 文件中去，然后调用该方法，

　　* 就会在本项目中/Json/JsonBean.java中生成一个对应的JavaBean类

　　* 注意：

　　* 如果json字符串中有null或者空集合［］这种无法判断类型的，会统一使用Object类型

　　*/

　　public static void parseJson2Java（） {

　　/// 读取json字符串

　　String string = FileUtils.readToString（new File（“Json\\JsonString.txt”）， “UTF-8”）;

　　// 解析获取整个json结构集合

　　JsonParser parser = new JsonParser（）;

　　JsonElement element = parser.parse（string）;

　　JsonObject jo = element.getAsJsonObject（）;

　　ListjsonBeanTree = getJsonBeanTree（jo）;

　　// 利用获取到的json结构集合，创建对应的javabean文件内容

　　String javaBeanStr = createJavaBean（jsonBeanTree）;

　　// 将生成的内容写入到文件中去

　　FileUtils.writeString2File（javaBeanStr， new File（“Json\\JsonBean.java”））;

　　}

　　/**

　　* 根据解析好的数据创建生成对应的javabean类字符串

　　*

　　* @param jsonBeanTree 解析好的数据集合

　　* @return 生成的javabean类字符串

　　*/

　　private static String createJavaBean（ListjsonBeanTree） {

　　StringBuilder sb = new StringBuilder（）;

　　// 是否包含自定义子类

　　boolean hasCustomeClass = false;

　　ListcustomClassNames = new ArrayList（）;

　　sb.append（“public class JsonBeans {\n”）;

　　// 由于在循环的时候有移除操作，所以使用迭代器遍历

　　Iteratoriterator = jsonBeanTree.iterator（）;

　　while（iterator.hasNext（）） {

　　Json2JavaElement j2j = iterator.next（）;

　　// 保存自定义类名称至集合中，注意已经包含的不再添加

　　if（j2j.getCustomClassName（） ！= null && ！customClassNames.contains（j2j.getCustomClassName（））） {

　　customClassNames.add（j2j.getCustomClassName（））;

　　}

　　if（j2j.getParentJb（） ！= null） {

　　// 如果有parent，则为自定义子类，设置标识符不做其他操作

　　hasCustomeClass = true;

　　} else {

　　// 如果不是自定义子类，则根据类型名和控件对象名生成变量申明语句

　　// private TextView tv_name;

　　sb.append（“\tprivate ”）

　　.append（getTypeName（j2j））

　　.append（“ ”）

　　.append（j2j.getName（））

　　.append（“;\n”）;

　　// 已经使用的数据会移除，则集合中只会剩下自定义子类相关的元素数据，将在后续的循环中处理

　　iterator.remove（）;

　　}

　　}

　　// 设置所有自定义类

　　if（hasCustomeClass） {

　　for（String customClassName ： customClassNames） {

　　// 根据名称申明子类

　　// /*sub class*/

　　// public class CustomClass {

　　sb.append（“\n\t/*sub class*/\n”）;

　　sb.append（“\tpublic class ”）

　　.append（customClassName）

　　.append（“ {\n”）;

　　// 循环余下的集合

　　IteratorcustomIterator = jsonBeanTree.iterator（）;

　　while（customIterator.hasNext（）） {

　　Json2JavaElement j2j = customIterator.next（）;

　　// 根据当前数据的parent名称，首字母转为大写生成parent的类名

　　String parentClassName = StringUtils.firstToUpperCase（j2j.getParentJb（）.getName（））;

　　// 如果当前数据属于本次外层循环需要处理的子类

　　if（parentClassName.equals（customClassName）） {

　　// 根据类型名和控件对象名生成变量申明语句

　　// 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（）;

　　}

　　}

　　问题

　　对于数组数据，其中元素的类型只会取第一个数据进行解析，

　　如果json字符串中数据内第一个数据不全或者数据为空，即无法获取

　　对于此类无法获取数据值造成无法判断类型的情况，都默认设为了Object类型

『本文转载自网络,版权归原作者所有,如有侵权请联系删除』