自动提出字符串 java_自动根据json字符串生成javabean类 - 全文

你还在为文档里铺天盖地滴变量， 结构复杂的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类型