[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<String,Object> datas = new HashMap<String,Object>();   //存放对象(一般是list)，根据String这个id来取

//存放data里面的基本类型
private HashMap<String,Object> 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 APPLYAUTHENTICATEID = "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 <T> 返回的对象
* @return  hashMap的key对应的值
*/
public <T> 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 <T>
* @return
*/
public <T> T getDataValue(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在这里获取到对应的类实例

DATA.java:

/**
* json解析的时候的类
*/
public enum DATA {

//疾病列表
DISEASELIST("diseaseList",DiseaseList.class)

;

private final String mId;

private final Class cls;

public Class getClzss() {
return cls;
}

DATA(String id, Class clzss) {
mId = id;
cls = clzss;
}

/**
* 根据json的key获取类
* @param id
* @return
*/
public static DATA 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 <T>      泛型，这里传递了Response
* @return
*/
public static <T> T parseJsonToResponse(String response, Class<T> 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 <T>  转换的对象，这里是Response
* @return 返回Response对象
* @throws IllegalAccessException
* @throws InstantiationException
*/
public static <T> T toResponse(JSONObject json, Class<T> cls) throws IllegalAccessException, InstantiationException {

//声明一个Response实例
T instance = null;

if (null != json) {
// 获取根key
Iterator<String> 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 <T>
*/
public static <T> void parseJsonBean(JSONObject json, T instance) {
//json不为空
if (null != json) {
//获取json的key iterator
Iterator<String> 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 = DATA.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>
// 获取对应的实例Bean Class
DATA clzss = DATA.fromId(key);
if (null != clzss) {
//把json解析成ArrayList<Bean>
Object entity = parseBeanArray((JSONArray) value, clzss.getClzss());
//把当前ArrayList<Bean>缓存在上级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 <T>
*/
private static  <T> 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 <T>  返回实例
* @return
* @throws IllegalAccessException
* @throws InstantiationException
*/
public static <T> T toBean(JSONObject json, Class<T> cls) throws IllegalAccessException, InstantiationException {
//声明实例引用
T instance = null;
//json不为空
if (null != json) {
//获取json key 的迭代器；
Iterator<String> 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 = DATA.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>
// 获取对应的实例Bean Class
DATA clzss = DATA.fromId(key);
if (null != clzss) {
//把json解析成ArrayList<Bean>
Object entity = parseBeanArray((JSONArray) value, clzss.getClzss());
//把当前ArrayList<Bean>缓存在上级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 <T>
* @return
*/
public static <T> ArrayList<Object> parseBeanArray(JSONArray jsonarr, Class<T> cls) {

//声明集合List引用
ArrayList<Object> beanArray = null;
//声明实例引用
T instance = null;  // if area

if (null != jsonarr && jsonarr.length() > 0) {

beanArray = new ArrayList<Object>();
int count = jsonarr.length();
Object value = null;
for (int index = 0; index < count; index++) {

try {
value = jsonarr.get(index);
if (value instanceof String) {
beanArray.add(value);
continue;
} else {
//构造实例Bean
instance = cls.newInstance();
// value 为json对象 则把json解析成具体的实例Bean
if (value instanceof JSONObject) {
parseJsonBean((JSONObject) value, instance);
} else if (value instanceof JSONArray) {
//value 为json 数组对象，则解析jsonarray
toBeanArray((JSONArray) value, instance);
}
//解析完成后将Bean添加到List
beanArray.add(instance);
}

} catch (Exception e) {
e.printStackTrace();
}
}
}
return beanArray;
}

/**
* 解析data的key 的json数组
*
* @param jsonarr  json数据
* @param instance Response实例
* @param <T>
* @return
*/
public static <T> T toBeanArray(JSONArray jsonarr, T instance) {

if (null != jsonarr && jsonarr.length() > 0) {
int count = jsonarr.length();
Object value = null;
for (int index = 0; index < count; index++) {

try {
value = jsonarr.get(index);
if (value instanceof JSONObject) {

parseJsonBean((JSONObject) value, instance);

} else if (value instanceof JSONArray) {

toBeanArray((JSONArray) value, instance);

}
} catch (JSONException e) {
e.printStackTrace();
}

}
}
return instance;
}

/**
* 调用obj类的get参数menber方法
*
* @param obj
* @param member
* @param <T>
* @return
*/
public static <T> T getter(Object obj, String member) {

try {

Method method = obj.getClass().getMethod("get" + updateFirst(member));
return (T) method.invoke(obj);

} catch (Exception e) {
return null;
}

}

/**
* 反射的方法获取
*
* @param obj
* @param member
* @param <T>
* @return
*/
public static <T> T getterIgnoreCase(Object obj, String member) {

try {

Method method = obj.getClass().getMethod("get" + member);
return (T) method.invoke(obj);

} catch (Exception e) {
return null;
}
}

/**
* 为obj实例的属性赋值
*
* @param obj   目标实例
* @param clzss set方法形参类型
* @param value 属性值
*/
public static void putter(Object obj, Class<?> clzss, Object... value) {

//值不为空
if (null == value)
return;

try {
//获取key对应的set方法,参数1 为方法名，2为类型
Method method = obj.getClass().getMethod(SET + updateFirst((String) value[0]), clzss);
//调用set方法赋值
method.invoke(obj, value[1]);

} catch (Exception e) {
//若obj没有对应的set方法
try {
//获取obj的put方法
Method method = obj.getClass().getMethod(PUT, value[0].getClass(), Object.class);
//把属性值put入map里缓存
method.invoke(obj, value);
//System.out.println(obj.getClass()+ "调用"+value[0].toString()+" "+((ArrayList)value[1]).size());
} catch (Exception ex) {
ex.printStackTrace();
}
}

}

/**
* 反射执行
*
* @param obj
* @param member
* @param value
*/
public static void setter(Object obj, String member, Object value) {

if (null == value)
return;
try {
Method method = obj.getClass().getMethod(SET + updateFirst(member), value.getClass());
method.invoke(obj, value);
} catch (Exception e) {
e.printStackTrace();
}
}

/**
* 首字符大写
*
* @param member
* @return
*/
public static String updateFirst(String member) {

String first = member.substring(0, 1).toUpperCase();
String suffex = member.substring(1, member.length());
return new StringBuilder().append(first).append(suffex).toString();

}

}

三、使用

例如第一个数据获取到list数据

//解析为response
Response response = JsonResolveUtils.parseJsonToResponse(json,Response.class);

从response里面获取list数据
List<DiseaseList> list = new ArrayList<>();

//获取完成开始解析为list bean
Response response = JsonResolveUtils.parseJsonToResponse(json,Response.class);

ArrayList cache = null;
cache = response.get(DATA.DISEASELIST.toString());
if(cache != null && !cache.isEmpty()){
//添加到list
list.addAll(cache);
Log.e("tpnet",list.size()+"个数据");
}else{
//获取数据失败操作
}

四、使用注意

解析的时候是根据返回的格式进行解析的，如果有数字类型的数据。在bean里面应该写完整几种类型的数字，例如金额:

public class FinanceRecords {

private String sum;       //金额

public String getSum() {
return sum;
}

//添加下面四种类型供json反射回调

public void setSum(String sum) {
this.sum = sum;
}

public void setSum(Integer sum) {
this.sum = sum+"";
}

public void setSum(Float sum) {
this.sum = sum+"";
}

public void setSum(Double sum) {
this.sum = sum+"";
}

}

下一篇文章有一个完整的demo。