轻量级的json操作类

 

import java.lang.reflect.Array;

import java.lang.reflect.Field;

import java.lang.reflect.ParameterizedType;

import java.lang.reflect.Type;

import java.util.Collection;

import org.json.JSONArray;

import org.json.JSONException;

import org.json.JSONObject;

import org.json.JSONStringer;

 

/**  JSON序列化辅助类 * */

public  class JSONHelper {

 

     /**  将对象转换成Json字符串 * */

     public  static String toJSON(Object obj) {

        JSONStringer js =  new JSONStringer();

        serialize(js, obj);

         return js.toString();

    }

 

     /**  序列化为JSON * */

     private  static  void serialize(JSONStringer js, Object o) {

         if (isNull(o)) {

             try {

                js.value( null);

            }  catch (JSONException e) {

                e.printStackTrace();

            }

             return;

        }

 

        Class<?> clazz = o.getClass();

         if (isObject(clazz)) {  //  对象

            serializeObject(js, o);

        }  else  if (isArray(clazz)) {  //  数组

            serializeArray(js, o);

        }  else  if (isCollection(clazz)) {  //  集合

            Collection<?> collection = (Collection<?>) o;

            serializeCollect(js, collection);

        }  else {  //  单个值

             try {

                js.value(o);

            }  catch (JSONException e) {

                e.printStackTrace();

            }

        }

    }

 

     /**  序列化数组 * */

     private  static  void serializeArray(JSONStringer js, Object array) {

         try {

            js.array();

             for ( int i = 0; i < Array.getLength(array); ++i) {

                Object o = Array.get(array, i);

                serialize(js, o);

            }

            js.endArray();

        }  catch (Exception e) {

            e.printStackTrace();

        }

    }

 

     /**  序列化集合 * */

     private  static  void serializeCollect(JSONStringer js, Collection<?> collection) {

         try {

            js.array();

             for (Object o : collection) {

                serialize(js, o);

            }

            js.endArray();

        }  catch (Exception e) {

            e.printStackTrace();

        }

    }

 

     /**

     * 序列化对象

     * 

     * * */

     private  static  void serializeObject(JSONStringer js, Object obj) {

         try {

            js.object();

             for (Field f : obj.getClass().getFields()) {

                Object o = f.get(obj);

                js.key(f.getName());

                serialize(js, o);

            }

            js.endObject();

        }  catch (Exception e) {

            e.printStackTrace();

        }

    }

 

     /**

     * 反序列化简单对象

     * 

     *  @throws

     * */

     public  static <T> T parseObject(JSONObject jo, Class<T> clazz) {

         if (clazz ==  null || isNull(jo)) {

             return  null;

        }

 

        T obj = createInstance(clazz);

         if (obj ==  null) {

             return  null;

        }

 

         for (Field f : clazz.getFields()) {

            setField(obj, f, jo);

        }

 

         return obj;

    }

 

     /**

     * 反序列化简单对象

     * 

     *  @throws

     * */

     public  static <T> T parseObject(String jsonString, Class<T> clazz) {

         if (clazz ==  null || jsonString ==  null || jsonString.length() == 0) {

             return  null;

        }

        JSONObject jo =  null;

         try {

            jo =  new JSONObject(jsonString);

        }  catch (JSONException e) {

            e.printStackTrace();

        }

 

         if (isNull(jo)) {

             return  null;

        }

 

         return parseObject(jo, clazz);

    }

 

     /**

     * 反序列化数组对象

     * 

     *  @throws

     * */

     public  static <T> T[] parseArray(JSONArray ja, Class<T> clazz) {

         if (clazz ==  null || isNull(ja)) {

             return  null;

        }

 

         int len = ja.length();

 

        @SuppressWarnings("unchecked")

        T[] array = (T[]) Array.newInstance(clazz, len);

 

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

             try {

                JSONObject jo = ja.getJSONObject(i);

                T o = parseObject(jo, clazz);

                array[i] = o;

            }  catch (JSONException e) {

                e.printStackTrace();

            }

        }

 

         return array;

    }

 

     /**

     * 反序列化数组对象

     * 

     *  @throws

     * */

     public  static <T> T[] parseArray(String jsonString, Class<T> clazz) {

         if (clazz ==  null || jsonString ==  null || jsonString.length() == 0) {

             return  null;

        }

        JSONArray jo =  null;

         try {

            jo =  new JSONArray(jsonString);

        }  catch (JSONException e) {

            e.printStackTrace();

        }

 

         if (isNull(jo)) {

             return  null;

        }

 

         return parseArray(jo, clazz);

    }

 

     /**

     * 反序列化泛型集合

     * 

     *  @throws

     * */

    @SuppressWarnings("unchecked")

     public  static <T> Collection<T> parseCollection(JSONArray ja, Class<?> collectionClazz,

            Class<T> genericType) {

 

         if (collectionClazz ==  null || genericType ==  null || isNull(ja)) {

             return  null;

        }

 

        Collection<T> collection = (Collection<T>) createInstance(collectionClazz);

 

         for ( int i = 0; i < ja.length(); ++i) {

             try {

                JSONObject jo = ja.getJSONObject(i);

                T o = parseObject(jo, genericType);

                collection.add(o);

            }  catch (JSONException e) {

                e.printStackTrace();

            }

        }

 

         return collection;

    }

 

     /**

     * 反序列化泛型集合

     * 

     *  @throws

     * */

     public  static <T> Collection<T> parseCollection(String jsonString, Class<?> collectionClazz,

            Class<T> genericType) {

         if (collectionClazz ==  null || genericType ==  null || jsonString ==  null

                || jsonString.length() == 0) {

             return  null;

        }

        JSONArray jo =  null;

         try {

            jo =  new JSONArray(jsonString);

        }  catch (JSONException e) {

            e.printStackTrace();

        }

 

         if (isNull(jo)) {

             return  null;

        }

 

         return parseCollection(jo, collectionClazz, genericType);

    }

 

     /**  根据类型创建对象 * */

     private  static <T> T createInstance(Class<T> clazz) {

         if (clazz ==  null)

             return  null;

        T obj =  null;

         try {

            obj = clazz.newInstance();

        }  catch (Exception e) {

            e.printStackTrace();

        }

         return obj;

    }

 

     /**  设定字段的值 * */

     private  static  void setField(Object obj, Field f, JSONObject jo) {

        String name = f.getName();

        Class<?> clazz = f.getType();

         try {

             if (isArray(clazz)) {  //  数组

                Class<?> c = clazz.getComponentType();

                JSONArray ja = jo.optJSONArray(name);

                 if (!isNull(ja)) {

                    Object array = parseArray(ja, c);

                    f.set(obj, array);

                }

            }  else  if (isCollection(clazz)) {  //  泛型集合

                 //  获取定义的泛型类型

                Class<?> c =  null;

                Type gType = f.getGenericType();

                 if (gType  instanceof ParameterizedType) {

                    ParameterizedType ptype = (ParameterizedType) gType;

                    Type[] targs = ptype.getActualTypeArguments();

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

                        Type t = targs[0];

                        c = (Class<?>) t;

                    }

                }

 

                JSONArray ja = jo.optJSONArray(name);

                 if (!isNull(ja)) {

                    Object o = parseCollection(ja, clazz, c);

                    f.set(obj, o);

                }

            }  else  if (isSingle(clazz)) {  //  值类型

                Object o = jo.opt(name);

                 if (o !=  null) {

                    f.set(obj, o);

                }

            }  else  if (isObject(clazz)) {  //  对象

                JSONObject j = jo.optJSONObject(name);

                 if (!isNull(j)) {

                    Object o = parseObject(j, clazz);

                    f.set(obj, o);

                }

            }  else {

                 throw  new Exception("unknow type!");

            }

        }  catch (Exception e) {

            e.printStackTrace();

        }

    }

 

     /**  判断对象是否为空 * */

     private  static  boolean isNull(Object obj) {

         if (obj  instanceof JSONObject) {

             return JSONObject.NULL.equals(obj);

        }

         return obj ==  null;

    }

 

     /**  判断是否是值类型 * */

     private  static  boolean isSingle(Class<?> clazz) {

         return isBoolean(clazz) || isNumber(clazz) || isString(clazz);

    }

 

     /**  是否布尔值 * */

     public  static  boolean isBoolean(Class<?> clazz) {

         return (clazz !=  null)

                && ((Boolean.TYPE.isAssignableFrom(clazz)) || (Boolean. class

                        .isAssignableFrom(clazz)));

    }

 

     /**  是否数值 * */

     public  static  boolean isNumber(Class<?> clazz) {

         return (clazz !=  null)

                && ((Byte.TYPE.isAssignableFrom(clazz)) || (Short.TYPE.isAssignableFrom(clazz))

                        || (Integer.TYPE.isAssignableFrom(clazz))

                        || (Long.TYPE.isAssignableFrom(clazz))

                        || (Float.TYPE.isAssignableFrom(clazz))

                        || (Double.TYPE.isAssignableFrom(clazz)) || (Number. class

                        .isAssignableFrom(clazz)));

    }

 

     /**  判断是否是字符串 * */

     public  static  boolean isString(Class<?> clazz) {

         return (clazz !=  null)

                && ((String. class.isAssignableFrom(clazz))

                        || (Character.TYPE.isAssignableFrom(clazz)) || (Character. class

                        .isAssignableFrom(clazz)));

    }

 

     /**  判断是否是对象 * */

     private  static  boolean isObject(Class<?> clazz) {

         return clazz !=  null && !isSingle(clazz) && !isArray(clazz) && !isCollection(clazz);

    }

 

     /**  判断是否是数组 * */

     public  static  boolean isArray(Class<?> clazz) {

         return clazz !=  null && clazz.isArray();

    }

 

     /**  判断是否是集合 * */

     public  static  boolean isCollection(Class<?> clazz) {

         return clazz !=  null && Collection. class.isAssignableFrom(clazz);

    }

}

 

转载于:https://www.cnblogs.com/brokge/archive/2013/04/08/3008872.html