JSON数据与对象之间的快速转化----原生org.json实现

java对象和json数据之间的转换方式一般有两种,一种是引用第三方的jar包,如Gson(谷歌)、Fastjson(阿里)、Jackson等,这种方式优点是语法精练,可以实现一句话转化,但缺点是会引入庞大的第三方库,第二种是直接使用Java自带的org.json解析,但这个库功能比较基础,解析会写很多重复的代码,这篇文章在原生json的基础上做了一些包装,也实现了一句话转化。


序列化(toJson)的实现思路是:通过反射找到对象中所有的属性和对应的属性值,然后根据属性的类型调用org.json相应的方法将值装入进去,再使用原生的方法将对象转变为json数据。


下面先来看如何获取属性的类型

public static int getType(Class type)
    {
        if(type!=null&&(String.class.isAssignableFrom(type)||Character.class.isAssignableFrom(type)||Character.TYPE.isAssignableFrom(type)||char.class.isAssignableFrom(type)))
            return 0;
        if(type!=null&&(Byte.TYPE.isAssignableFrom(type)||Short.TYPE.isAssignableFrom(type)||Integer.TYPE.isAssignableFrom(type)||Integer.class.isAssignableFrom(type)||Number.class.isAssignableFrom(type)||int.class.isAssignableFrom(type)||byte.class.isAssignableFrom(type)||short.class.isAssignableFrom(type)))
            return 1;
        if(type!=null&&(Long.TYPE.isAssignableFrom(type)||long.class.isAssignableFrom(type)))
            return 2;
        if(type!=null&&(Float.TYPE.isAssignableFrom(type)||float.class.isAssignableFrom(type)))
            return 3;
        if(type!=null&&(Double.TYPE.isAssignableFrom(type)||double.class.isAssignableFrom(type)))
            return 4;
        if(type!=null&&(Boolean.TYPE.isAssignableFrom(type)||Boolean.class.isAssignableFrom(type)||boolean.class.isAssignableFrom(type)))
            return 5;
        if(type!=null&&type.isArray())
            return 6;
        if(type!=null&&Connection.class.isAssignableFrom(type))
            return 7;
        if(type!=null&&JSONArray.class.isAssignableFrom(type))
            return 8;
        if(type!=null&&List.class.isAssignableFrom(type))
            return 9;
        if(type!=null&&Map.class.isAssignableFrom(type))
            return 10;
        return 11;
    }

该方法用来判断属性的类型是哪一种,方便程序做后面的工作,Class可以代表泛型所对应的类。


下面是根据不同的类型将对象转化成json

public static String toJson(Object obj)throws IllegalAccessException,JSONException
    {
        JSONObject json=new JSONObject();
        Field[] fields = obj.getClass().getDeclaredFields();
        for (Field field : fields) {
                switch(getType(field.getType()))
                {
                    case 0:
                        json.put(field.getName(),(field.get(obj)==null?"":field.get(obj)));
                        break;
                    case 1:
                        json.put(field.getName(),(int)(field.get(obj)==null?0:field.get(obj)));
                        break;
                    case 2:
                        json.put(field.getName(),(long)(field.get(obj)==null?0:field.get(obj)));
                        break;
                    case 3:
                        json.put(field.getName(),(float)(field.get(obj)==null?0:field.get(obj)));
                        break;
                    case 4:
                         json.put(field.getName(),(double)(field.get(obj)==null?0:field.get(obj)));
                        break;
                    case 5:
                        json.put(field.getName(),(boolean)(field.get(obj)==null?false:field.get(obj)));
                        break;
                    case 6:
                    case 7:
                    case 8://JsonArray型
                        json.put(field.getName(),(field.get(obj)==null?null:field.get(obj)));
                        break;
                    case 9:
                        json.put(field.getName(),  new JSONArray((List)field.get(obj)));
                        break;
                    case 10:
                        json.put(field.getName(),new  JSONObject((HashMap)field.get(obj)));
                        break;
                }
        }
        return json.toString();
    }

obj.getClass().getDeclaredFields()是通过反射获取到对象的所有属性

field.getType()获取属性的类型

field.getName()获取属性的属性名

field.get(obj)获取属性的值,返回值为字符串,对应类型需要强转


调用的时候只需要像下面这样

class test{
    int id;
    String msg;
    boolean error;
}
test a=new test();
a.id=10001;
a.msg="JAVABean转化为JSON~";
a.error=true;

try {
    System.out.println(Json.toJson(a));
} catch (Exception e) {
    e.printStackTrace();
}

输出结果

{"msg":"JAVABean转化为JSON~","id":10001,"error":true}


当然我们也可以解析JSON数组和对象

JSONArray用java的List来解析

JSONObject用Java的Map来解析

class test{
	int id;
	String msg;
	boolean error;
	HashMap map;
	List list;
} 
  
test a=new test();
a.id=10001;
a.msg="JAVABean转化为JSON~";
a.error=true;
a.map=new HashMap();
a.list=new ArrayList();

a.list.add("array1");
a.list.add("array2");

a.map.put("name", "yiqinlin");
a.map.put("mail", "[email protected]");

try {
    System.out.println(Json.toJson(a));
} catch (Exception e) {
    e.printStackTrace();
} 
  

输出结果

{
    "msg":"JAVABean转化为JSON~",
    "id":10001,
    "error":true,
    "list":["array1","array2"],
    "map":{
    "mail":"[email protected]",
    "name":"yiqinlin"
    }
}


反序列化(fromJson)的实现思路是:利用JAVA的反射来找出对象中包含的属性,然后通过属性名使用org.json提取json字符串中对应的属性值,再把值通过反射赋值给对象中的属性。

首先我们来看供外部调用的方法
    public static  T fromJson(String JsonStr,Class type)throws JSONException,NullPointerException,IllegalAccessException, InstantiationException{
        if(JsonStr ==null||JsonStr.equals("")) {
            throw new NullPointerException("JsonString can't be null");
        }
        T data = type.newInstance();;
        Field[] fields= type.getDeclaredFields();
        JSONObject jsonObject=(JSONObject)new JSONTokener(JsonStr).nextValue();
        for (Field field : fields) {
            field.setAccessible(true);
            field.set(data,JsonObjectToObject(jsonObject, field));
        }
        return data;
    }

传入的参数有两个,一个Json字符串,一个是类的类型,先通过newInstance();将类型转化出一个对象,然后继续使用我们的反射获取到对象中有哪些属性,接着使用set方法,设置对应的属性值。

JsonObjectToObject是根据属性类型来转化的方法

public static Object JsonObjectToObject(JSONObject obj,Field field) throws JSONException{
        switch (getType(field.getType()))//field.getType:获取属性声明时类型对象(返回class对象)
        {
            case 0:
                return obj.opt(field.getName());
            case 1:
                return obj.optInt(field.getName());
            case 2:
                return obj.optLong(field.getName());
            case 3:
            case 4:
                return obj.optDouble(field.getName());
            case 5:
                return obj.optBoolean(field.getName());
            case 6:
            case 7:
            case 8://JsonArray型
                return obj.optJSONArray(field.getName());
            case 9:
                return JsonArrayToList(obj.optJSONArray(field.getName()));
            case 10:
                return JsonObjectToMap(obj.optJSONObject(field.getName()));
            default:
                return null;
        }
    }

遇到List和Map的情况需要特殊处理

public static List JsonArrayToList(JSONArray jsonArray) throws JSONException {
        List list = new ArrayList();
        if(jsonArray!=null){
            for (int i = 0; i < jsonArray.length(); i++) {
                Object val = jsonArray.get(i);
                if(val!=null){
                    if (val instanceof JSONObject) {
                        Map map = JsonObjectToMap((JSONObject) val);
                        list.add(map);
                    }else if(val instanceof JSONArray){
                        list.add(JsonArrayToList((JSONArray) val));
                    }else {
                        list.add(val);
                    }
                }
            }
        }
        return list;
    } 
  

遍历JSON数组中的值,如果是JSON对象,将它解析成Map,如果是数组,那继续递归,如果是其他情况,就直接加入List当中

public static Map JsonObjectToMap(JSONObject jsonResult) throws JSONException {
    Map result = new HashMap();
    if(jsonResult!=null) {
        Iterator keyIt = jsonResult.keys();
        while (keyIt.hasNext()) {
            String key = keyIt.next();
            Object val = jsonResult.get(key);
            if(val!=null){
                if (val instanceof JSONObject) {
                    Map valMap = JsonObjectToMap((JSONObject) val);
                    result.put(key, valMap);
                }else if (val instanceof JSONArray) {
                    JSONArray ja = (JSONArray) val;
                    result.put(key, JsonArrayToList(ja));
                }else {
                    result.put(key, val);
                }
            }else {
                result.put(key, null);
            }
        }
    }
    return result;
}

同样是循环遍历Map中的值,如果是JSON对象,解析成Map,如果是数组,递归遍历,如果是其他,直接加入Map当中

到这,我们就实现了将JSON数据转化成对象的过程了


下面是调用的过程

String jsonStr="{\"msg\":\"JSON转化为JAVABean~\",\"id\":10001,\"error\":true}";
try {
    test a=Json.fromJson(jsonStr,test.class);
    System.out.println(a.id+"--"+a.msg+"--"+a.error);
} catch (Exception e) {
    e.printStackTrace();
}

输出结果

10001--JSON转化为JAVABean~--true

解析数组和对象

String jsonStr="{"
	+ "\"msg\":\"JSON转化为JAVABean~\","
	+ "\"id\":10001,"
	+ "\"error\":true,"
	+ "\"list\":[\"array1\",\"array2\"],"
	+ "\"map\":{\"mail\":\"[email protected]\",\"name\":\"yiqinlin\"}}";
try {
    test a=Json.fromJson(jsonStr,test.class);
    System.out.println(a.id+"--"+a.msg+"--"+a.error+"--"+a.list.get(0)+"--"+a.map.get("name"));
} catch (Exception e) {
    e.printStackTrace();
}

输出结果

10001--JSON转化为JAVABean~--true--array1--yiqinlin

完整的源码在我的github上 github-Json

喜欢的朋友可以点颗星~


你可能感兴趣的:(JSON数据与对象之间的快速转化----原生org.json实现)