[Android开发] Json解析工具类,一个类搞定Json的解析

[Android开发] Json解析工具类，一个

类搞定Json的解析

一、简介

利用递归的方式反射解析到bean里面

二、详细代码

1、Json格式

例如服务器指定规定json格式为:

{

"code": "……" , // 返回代号，预留字段，默认返回null

"type":"ERROR", // 返回类型，表示操作是成功或失败

"desc":"……", // 返回描述，描述性文字，主要保存用于弹窗显示的文字

"action":"SHOW", //返回操作，该操作值提供给终端使用，用于决定当前收到返回后的操作

"data": "……" // 返回数据，根据请求上传的参数，返回对应的数据，或返回null

}

对应的数据在data里面，data里面的key对应一个bean，例如一个列表数据:

{

"desc":"查询成功",

"data":{

"diseaseList":[

{

"xmlName":"精神病评估",

"xmlId":"1066",

"category":"symptom"

},

{

"xmlName":"对学习困难和认知延迟的评估",

"xmlId":"884",

"category":"symptom"

},

{

"xmlName":"疲乏的评估",

"xmlId":"571",

"category":"symptom"

},

{

"xmlName":"痴呆的评估",

"xmlId":"242",

"category":"symptom"

},

{

"xmlName":"非故意性体重减轻评估",

"xmlId":"548",

"category":"symptom"

}

]

},

"action":null,

"code":"",

"type":"SUCCESS"

}

2、定义数据Bean类

上面的list的bean定义为DiseaseList.Java

public class DiseaseList {

/**

* xmlName : 分裂情感性障碍

* xmlId : 1199

* category : disease

*/

private String xmlName; //症状名字

private String xmlId; //症状名字

private String category; //分类的英文名

private String letter = ""; //字母，转为拼音后在这里添加

public String getXmlName() {

return xmlName;

}

public void setXmlName(String xmlName) {

this.xmlName = xmlName;

}

public String getXmlId() {

return xmlId;

}

public void setXmlId(String xmlId) {

this.xmlId = xmlId;

}

public String getCategory() {

return category;

}

public void setCategory(String category) { this.category = category;

}

public String getLetter() {

return letter;

}

public void setLetter(String letter) {

this.letter = letter;

}

}

3、定义根key的bean类

Response.java:

/**

* json返回的首key的内容类

*

*/

public class Response {

//下面四个是固定写在第一层的

private String code;

private String type;

private String desc;

private String action;

//Object 可以存放list

private HashMap datas = new HashMap(); //存放对象(一般是list)，根据String这个id来取

//存放data里面的基本类型

private HashMap dataValue = new HashMap<>();

public Response() {

code = type = desc = action /*= version = token = applyAuthenticateId*/ = "";

}

public final static String TOKEN = "token";

public final static String VERSION = "version";

public final static String PORTRAIT = "portrait";

public final static String USERID = "userId";

public final static String APPL YAUTHENTICA TEID = "applyAuthenticateId";

public final static String ISDOCTOR = "isDoctor";

public final static String ISEXPERT = "isExpert";

public final static String WAY = "way";

public final static String DOWNLOAD = "download";

/**

* 存值到hashmap里面

* @param key

* @param value

*/

public void put(String key, Object value) {

datas.put(key, value);

}

/**

* 获取key对应的对象

* @param key key

* @param 返回的对象

* @return hashMap的key对应的值

*/

public T get(String key){

if(datas.containsKey(key)){

return (T)datas.get(key);

}

return null;

}

/**

* 反射执行，添加到hashMap,data里面的基本类型数据* @param key

* @param value

*/

public void addDataValue(String key, Object value){

dataValue.put(key,value);

}

/**

* 获取data里面的基本类型数据

* @param key

* @param

* @return

*/

public T getDataV alue(String key){

if(dataValue.containsKey(key)){

return (T)dataValue.get(key);

}

return null;

}

public String getCode() {

return code;

}

public void setCode(String code) {

if(null != code && !"".equals(code.trim()))

this.code = code;

}

public String getDesc() {

return desc;

}

public void setDesc(String desc) {

if(!TextUtils.isEmpty(desc))

this.desc = desc;

}

}

4、定义反射类枚举

json解析时候根据key在这里获取到对应的类实例DA TA.java:

/**

* json解析的时候的类

*/

public enum DATA {

//疾病列表

DISEASELIST("diseaseList",DiseaseList.class)

;

private final String mId;

private final Class cls;

public Class getClzss() {

return cls;

}

DA TA(String id, Class clzss) {

mId = id;

cls = clzss;

}

/**

* 根据json的key获取类

* @param id

* @return

*/

public static DA TA fromId(String id) {

DATA[] values = values();

int cc = values.length;

for (int i = 0; i < cc; i++) {

if (values[i].mId.equals(id)) {

return values[i];

}

}

return null;

}

@Override

public String toString() {

return mId;

}

}

5、Json解析工具类

对应的注释已经写到代码里面了

JsonResolveUtils.java

/**

* json解析工具类

*/

public class JsonResolveUtils {

private static final String SET = "set";

private static final String PUT = "put";

/**

* 开始解析json 字符串，解析为Response类bean形式

*

* @param response json字符串

* @param cls Response类class

* @param 泛型，这里传递了Response

* @return

*/

public static T parseJsonToResponse(String response, Class cls) {

if (null != response) {

try {

// 构建JSONObject 实例

JSONObject json = new JSONObject(response);

// JSONObject 解析成具体Bean实例

T entity = toResponse(json, cls);

return entity;

} catch (JSONException e) {

e.printStackTrace();

} catch (InstantiationException e) {

e.printStackTrace();

} catch (IllegalAccessException e) {

e.printStackTrace();

} catch (Exception e) {

e.printStackTrace();

}

}

return null;

}

/**

* JSONObject解析成Response Bean实例

*

* @param json json对象

* @param cls 转换的对象，这里是Response

* @param 转换的对象，这里是Response

* @return 返回Response对象

* @throws IllegalAccessException

* @throws InstantiationException

*/

public static T toResponse(JSONObject json, Class cls) throws IllegalAccessException, InstantiationException {

//声明一个Response实例

T instance = null;

if (null != json) {

// 获取根key

Iterator iterator = json.keys();

//构建个实例Response Bean

instance = cls.newInstance();

//开始遍历根key

while (iterator.hasNext()) {

try {

String key = iterator.next(); //获取key

Object value = json.get(key); //获取key对应的值

//值不为空

if (null != value) {

if (!key.equals("data")) {

//不是data数据，直接为Response的Bean属性赋值

setter(instance, key, value);

} else { // 解析data数据

if (value instanceof JSONObject) {

//data 数据是JSONObject 开始解析json对象数据

parseJsonBean((JSONObject) value, instance);

} else if (value instanceof JSONArray) {

//data 数据是JSONArray 开始解析json数组数据

toBeanArray((JSONArray) value, instance);

} else {

//若都不是，直接为ResponseBean属性赋值

setter(instance, key, value);

}

}

}

} catch (Exception e) {

e.printStackTrace();

}

} // while(~)

}

return instance;

}

/**

* 解析单个JSON数据

*

* @param json json

* @param instance Bean实例

* @param

*/

public static void parseJsonBean(JSONObject json, T instance) {

//json不为空

if (null != json) {

//获取json的key iterator

Iterator iterator = json.keys();

while (iterator.hasNext()) {

//获取键值对

String key = iterator.next();

Object value = null;

try {

//获取值

value = json.get(key);

//value不为空

if (null != value) {

// value 为json对象则把json解析成具体的实例Bean

if (value instanceof JSONObject) {

// 获取对应的实例Bean Class

DATA clzss = DA TA.fromId(key);

//不为空

if (null != clzss) {

//把json解析成该实例Bean

Object entity = toBean((JSONObject) value, clzss.getClzss());

//把当前Bean类缓存在上级Bean属性里

putter(instance, entity.getClass(), key, entity);

}

} else if (value instanceof JSONArray) { //value 为json 数据对象，则把jsonarray解析成ArrayList

// 获取对应的实例Bean Class

DATA clzss = DA TA.fromId(key);

if (null != clzss) {

//把json解析成ArrayList

Object entity = parseBeanArray((JSONArray) value, clzss.getClzss());

//把当前ArrayList缓存在上级Bean属性里

putter(instance, entity.getClass(), key, entity);

}

} else {

//都是不是，直接为上级Bean属性赋值

if (instance instanceof Response) {

//dada下面的标准类型的值设置进Respone的dataString

setDataString(instance,key, value.toString());

} else {

putter(instance, value.getClass(), key, value);

}

}

}

} catch (Exception e) {

e.printStackTrace();

}

}

}

}

/**

* 设置Response的dataString

*

* @param obj

* @param key

* @param value

* @param

*/

private static void setDataString(Object obj, String key, String value) {

//值不为空

if (null == value)

return;

try {

//获取addDataString方法,参数1 为方法名，2为类型

Method method = obj.getClass().getMethod("addDataValue", String.class, Object.class);

//调用set方法赋值

method.invoke(obj, key, value);

} catch (Exception e) {

e.printStackTrace();

}

}

/**

* 解析JSON成具体实例Bean

*

* @param json json数据

* @param cls 要解析成为的实例

* @param 返回实例

* @return

* @throws IllegalAccessException

* @throws InstantiationException

*/

public static T toBean(JSONObject json, Class cls) throws IllegalAccessException, InstantiationException {

//声明实例引用

T instance = null;

//json不为空

if (null != json) {

//获取json key 的迭代器；

Iterator iterator = json.keys();

//构建实例Bean

instance = cls.newInstance();

//遍历json key

while (iterator.hasNext()) {

//获取键值对

String key = iterator.next();

Object value = null;

try {

value = json.get(key);

//value不为空

if (null != value) {

// value 为json对象则把json解析成具体的实例Bean

if (value instanceof JSONObject) {

// 获取对应的实例Bean Class

DATA clzss = DA TA.fromId(key);

if (null != clzss) {

//把json解析成该实例Bean

Object entity = toBean((JSONObject) value, clzss.getClzss());

//把当前Bean类缓存在上级Bean属性里

putter(instance, entity.getClass(), key, entity);

}

} else if (value instanceof JSONArray) { //value 为json数组对象，则把jsonarray解析成ArrayList

// 获取对应的实例Bean Class

DATA clzss = DA TA.fromId(key);

if (https://www.wendangku.net/doc/1614336243.html,ull != clzss) {

//把json解析成ArrayList

Object entity = parseBeanArray((JSONArray) value, clzss.getClzss());

//把当前ArrayList缓存在上级Bean属性里

putter(instance, entity.getClass(), key, entity);

}

} else {

//都是不是，直接为上级Bean属性赋值

setter(instance, key, value);

}

}

} catch (Exception e) {

e.printStackTrace();

}

}

}

return instance;

}

/**

* 解析json里面的json数组,例如专家列表

*

* @param jsonarr

* @param cls

* @param

* @return

*/

public static ArrayList