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<String,Object> map;
	List<Object> list;
}

test a=new test();
a.id=10001;
a.msg="JAVABean转化为JSON~";
a.error=true;
a.map=new HashMap<String,Object>();
a.list=new ArrayList<Object>();

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

a.map.put("name", "yiqinlin");
a.map.put("mail", "yiqinlin@foxmail.com");

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

输出结果

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

 

 

 

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

首先我们来看供外部调用的方法

    public static <T> T fromJson(String JsonStr,Class<T> 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<Object> JsonArrayToList(JSONArray jsonArray) throws JSONException {
        List<Object> list = new ArrayList<Object>();
        if(jsonArray!=null){
            for (int i = 0; i < jsonArray.length(); i++) {
                Object val = jsonArray.get(i);
                if(val!=null){
                    if (val instanceof JSONObject) {
                        Map<String, Object> 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<String, Object> JsonObjectToMap(JSONObject jsonResult) throws JSONException {
    Map<String, Object> result = new HashMap<String, Object>();
    if(jsonResult!=null) {
        Iterator<String> keyIt = jsonResult.keys();
        while (keyIt.hasNext()) {
            String key = keyIt.next();
            Object val = jsonResult.get(key);
            if(val!=null){
                if (val instanceof JSONObject) {
                    Map<String, Object> 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\":\"yiqinlin@foxmail.com\",\"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

喜欢的朋友可以点颗星~