[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。