缓存

最新推荐文章于 2024-12-05 16:19:16 发布
转载最新推荐文章于 2024-12-05 16:19:16 发布 · 760 阅读
本文介绍了一种在ANDROID平台中实现JSON序列化和反序列化的轻量级方法。该方法通过反射机制处理复杂的数据类型，如数组、集合及自定义对象，并将其转换为JSON格式。此外，还提供了异常处理机制以确保序列化过程的稳定性。
AresCJ的专栏

    目录视图
摘要视图
订阅

   

       博客专家福利     
       有奖试读&征文——我们在互联网上奋斗的故事      
       10月推荐文章汇总      
       参与话题讨论，好礼等你拿（获奖名单公布）     
       公告：博客新皮肤上线啦
      

        
       ANDROID轻量级JSON序列化和反序列化
      

       分类： ANDROID JSON解析 phone
       2012-02-14 21:39 
       5856人阅读 
       评论(11) 
       收藏 
       举报
      

       json
       android
       string
       exception
       object
       null
      
[java]view plaincopy
import java.lang.reflect.Array;  
import java.lang.reflect.Field;  
import java.lang.reflect.Method;  
import java.lang.reflect.ParameterizedType;  
import java.lang.reflect.Type;  
import java.text.SimpleDateFormat;  
import java.util.ArrayList;  
import java.util.Collection;  
import java.util.Date;  
import java.util.HashMap;  
import java.util.HashSet;  
import java.util.Iterator;  
import java.util.List;  
import java.util.Locale;  
import java.util.Map;  
import java.util.Set;  
  
import org.json.JSONArray;  
import org.json.JSONException;  
import org.json.JSONObject;  
import org.json.JSONStringer;  
  
import android.util.Log;  
  
  
/** 
 * @author keane 
 *  
 */  
public class JSONHelper {  
    private static String TAG = "JSONHelper";  
  
    /** 
     * 将对象转换成Json字符串 
     * @param obj 
     * @return json类型字符串 
     */  
    public static String toJSON(Object obj) {  
        JSONStringer js = new JSONStringer();  
        serialize(js, obj);  
        return js.toString();  
    }  
  
    /** 
     * 序列化为JSON 
     * @param js json对象 
     * @param o 待需序列化的对象 
     */  
    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 if (isMap(clazz)) { // 集合  
            HashMap<?,?> collection = (HashMap<?,?>) o;  
            serializeMap(js, collection);  
        } else { // 单个值  
            try {  
                js.value(o);  
            } catch (JSONException e) {  
                e.printStackTrace();  
            }  
        }  
    }  
  
    /** 
     * 序列化数组  
     * @param js    json对象 
     * @param array 数组 
     */  
    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();  
        }  
    }  
  
    /** 
     * 序列化集合 
     * @param js    json对象 
     * @param collection    集合 
     */  
    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();  
        }  
    }  
      
    /** 
     * 序列化Map 
     * @param js    json对象 
     * @param map   map对象 
     */  
    private static void serializeMap(JSONStringer js, Map<?,?> map) {  
        try {  
            js.object();  
            @SuppressWarnings("unchecked")  
            Map<String, Object> valueMap = (Map<String, Object>) map;  
            Iterator<Map.Entry<String, Object>> it = valueMap.entrySet().iterator();  
            while (it.hasNext()) {  
                Map.Entry<String, Object> entry = (Map.Entry<String, Object>)it.next();  
                js.key(entry.getKey());  
                serialize(js,entry.getValue());  
            }  
            js.endObject();  
        } catch (Exception e) {  
            e.printStackTrace();  
        }  
    }  
  
    /** 
     * 序列化对象 
     * @param js    json对象 
     * @param obj   待序列化对象 
     */  
    private static void serializeObject(JSONStringer js, Object obj) {  
        try {  
            js.object();  
            Class<? extends Object> objClazz = obj.getClass();  
            Method[] methods = objClazz.getDeclaredMethods();     
            Field[] fields = objClazz.getDeclaredFields();       
            for (Field field : fields) {     
                try {     
                    String fieldType = field.getType().getSimpleName();     
                    String fieldGetName = parseMethodName(field.getName(),"get");     
                    if (!haveMethod(methods, fieldGetName)) {     
                        continue;     
                    }     
                    Method fieldGetMet = objClazz.getMethod(fieldGetName, new Class[] {});     
                    Object fieldVal = fieldGetMet.invoke(obj, new Object[] {});     
                    String result = null;     
                    if ("Date".equals(fieldType)) {     
                        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss",Locale.US);     
                        result = sdf.format((Date)fieldVal);    
  
                    } else {     
                        if (null != fieldVal) {     
                            result = String.valueOf(fieldVal);     
                        }     
                    }     
                    js.key(field.getName());  
                    serialize(js, result);    
                } catch (Exception e) {     
                    continue;     
                }     
            }    
            js.endObject();  
        } catch (Exception e) {  
            e.printStackTrace();  
        }  
    }  
  
    /** 
     * 判断是否存在某属性的 get方法 
     * @param methods   引用方法的数组 
     * @param fieldMethod   方法名称 
     * @return true或者false 
     */  
    public static boolean haveMethod(Method[] methods, String fieldMethod) {  
        for (Method met : methods) {  
            if (fieldMethod.equals(met.getName())) {  
                return true;  
            }  
        }  
        return false;  
    }  
  
    /** 
     * 拼接某属性的 get或者set方法 
     * @param fieldName 字段名称 
     * @param methodType    方法类型 
     * @return 方法名称 
     */  
    public static String parseMethodName(String fieldName,String methodType) {  
        if (null == fieldName || "".equals(fieldName)) {  
            return null;  
        }  
        return methodType + fieldName.substring(0, 1).toUpperCase() + fieldName.substring(1);  
    }  
      
    /**   
     * 给字段赋值   
     * @param obj  实例对象 
     * @param valMap  值集合 
     */    
    public static void setFieldValue(Object obj, Map<String, String> valMap) {     
        Class<?> cls = obj.getClass();     
        // 取出bean里的所有方法     
        Method[] methods = cls.getDeclaredMethods();     
        Field[] fields = cls.getDeclaredFields();     
    
        for (Field field : fields) {     
            try {       
                String setMetodName = parseMethodName(field.getName(),"set");     
                if (!haveMethod(methods, setMetodName)) {     
                    continue;     
                }     
                Method fieldMethod = cls.getMethod(setMetodName, field     
                        .getType());     
                String value = valMap.get(field.getName());     
                if (null != value && !"".equals(value)) {     
                    String fieldType = field.getType().getSimpleName();     
                    if ("String".equals(fieldType)) {     
                        fieldMethod.invoke(obj, value);     
                    } else if ("Date".equals(fieldType)) {     
                        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss",Locale.US);     
                        Date temp = sdf.parse(value);      
                        fieldMethod.invoke(obj, temp);     
                    } else if ("Integer".equals(fieldType)     
                            || "int".equals(fieldType)) {     
                        Integer intval = Integer.parseInt(value);     
                        fieldMethod.invoke(obj, intval);     
                    } else if ("Long".equalsIgnoreCase(fieldType)) {     
                        Long temp = Long.parseLong(value);     
                        fieldMethod.invoke(obj, temp);     
                    } else if ("Double".equalsIgnoreCase(fieldType)) {     
                        Double temp = Double.parseDouble(value);     
                        fieldMethod.invoke(obj, temp);     
                    } else if ("Boolean".equalsIgnoreCase(fieldType)) {     
                        Boolean temp = Boolean.parseBoolean(value);     
                        fieldMethod.invoke(obj, temp);     
                    } else {     
                        System.out.println("setFieldValue not supper type:" + fieldType);     
                    }     
                }     
            } catch (Exception e) {     
                continue;     
            }     
        }     
    
    }   
      
    /** 
     * bean对象转Map 
     * @param obj   实例对象 
     * @return  map集合 
     */  
    public static Map<String, String> beanToMap(Object obj) {     
        Class<?> cls = obj.getClass();     
        Map<String, String> valueMap = new HashMap<String, String>();     
        // 取出bean里的所有方法     
        Method[] methods = cls.getDeclaredMethods();     
        Field[] fields = cls.getDeclaredFields();       
        for (Field field : fields) {     
            try {     
                String fieldType = field.getType().getSimpleName();     
                String fieldGetName = parseMethodName(field.getName(),"get");     
                if (!haveMethod(methods, fieldGetName)) {     
                    continue;     
                }     
                Method fieldGetMet = cls.getMethod(fieldGetName, new Class[] {});     
                Object fieldVal = fieldGetMet.invoke(obj, new Object[] {});     
                String result = null;     
                if ("Date".equals(fieldType)) {     
                    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss",Locale.CHINA);     
                    result = sdf.format((Date)fieldVal);     
  
                } else {     
                    if (null != fieldVal) {     
                        result = String.valueOf(fieldVal);     
                    }     
                }     
                valueMap.put(field.getName(), result);     
            } catch (Exception e) {     
                continue;     
            }     
        }     
        return valueMap;     
    
    }     
  
    /** 
     * 给对象的字段赋值 
     * @param obj   类实例 
     * @param fieldSetMethod    字段方法 
     * @param fieldType 字段类型 
     * @param value 
     */  
    public static void setFiedlValue(Object obj,Method fieldSetMethod,String fieldType,Object value){  
             
        try {      
            if (null != value && !"".equals(value)) {      
                if ("String".equals(fieldType)) {     
                    fieldSetMethod.invoke(obj, value.toString());     
                } else if ("Date".equals(fieldType)) {     
                    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss",Locale.CHINA);     
                    Date temp = sdf.parse(value.toString());      
                    fieldSetMethod.invoke(obj, temp);     
                } else if ("Integer".equals(fieldType)     
                        || "int".equals(fieldType)) {     
                    Integer intval = Integer.parseInt(value.toString());     
                    fieldSetMethod.invoke(obj, intval);     
                } else if ("Long".equalsIgnoreCase(fieldType)) {     
                    Long temp = Long.parseLong(value.toString());     
                    fieldSetMethod.invoke(obj, temp);     
                } else if ("Double".equalsIgnoreCase(fieldType)) {     
                    Double temp = Double.parseDouble(value.toString());     
                    fieldSetMethod.invoke(obj, temp);     
                } else if ("Boolean".equalsIgnoreCase(fieldType)) {     
                    Boolean temp = Boolean.parseBoolean(value.toString());     
                    fieldSetMethod.invoke(obj, temp);     
                } else {     
                    fieldSetMethod.invoke(obj, value);   
                    Log.e(TAG, TAG  + ">>>>setFiedlValue -> not supper type" + fieldType);     
                }   
            }  
                  
        } catch (Exception e) {     
//            Log.e(TAG, TAG  + ">>>>>>>>>>set value error.",e);  
            e.printStackTrace();  
        }     
      
    }  
      
    /** 
     * 反序列化简单对象 
     * @param jo    json对象 
     * @param clazz 实体类类型 
     * @return  反序列化后的实例 
     * @throws JSONException  
     */  
    public static <T> T parseObject(JSONObject jo, Class<T> clazz) throws JSONException {  
        if (clazz == null || isNull(jo)) {  
            return null;  
        }  
  
        T obj = newInstance(clazz);  
        if (obj == null) {  
            return null;  
        }  
        if(isMap(clazz)){   
            setField(obj,jo);  
        }else{  
              // 取出bean里的所有方法     
            Method[] methods = clazz.getDeclaredMethods();     
            Field[] fields = clazz.getDeclaredFields();               
            for (Field f : fields) {  
                String setMetodName = parseMethodName(f.getName(),"set");     
                if (!haveMethod(methods, setMetodName)) {     
                    continue;     
                }                   
                try {  
                    Method fieldMethod = clazz.getMethod(setMetodName, f.getType());  
                    setField(obj,fieldMethod,f, jo);  
                } catch (Exception e) {  
                    e.printStackTrace();  
                }    
            }  
        }  
        return obj;  
    }  
      
    /** 
     * 反序列化简单对象 
     * @param jsonStr   json字符串 
     * @param clazz 实体类类型 
     * @return  反序列化后的实例 
     * @throws JSONException  
     */  
    public static <T> T parseObject(String jsonStr, Class<T> clazz) throws JSONException {  
        if (clazz == null || jsonStr == null || jsonStr.length() == 0) {  
            return null;  
        }  
          
        JSONObject jo = null;  
        jo = new JSONObject(jsonStr);  
        if (isNull(jo)) {  
            return null;  
        }  
  
        return parseObject(jo, clazz);  
    }  
  
    /** 
     * 反序列化数组对象 
     * @param ja    json数组 
     * @param clazz 实体类类型 
     * @return  反序列化后的数组 
     */  
    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;  
    }  
  
      
    /** 
     * 反序列化数组对象 
     * @param jsonStr   json字符串 
     * @param clazz 实体类类型 
     * @return  序列化后的数组 
     */  
    public static <T> T[] parseArray(String jsonStr, Class<T> clazz) {  
        if (clazz == null || jsonStr == null || jsonStr.length() == 0) {  
            return null;  
        }  
        JSONArray jo = null;  
        try {  
            jo = new JSONArray(jsonStr);  
        } catch (JSONException e) {  
            e.printStackTrace();  
        }  
  
        if (isNull(jo)) {  
            return null;  
        }  
  
        return parseArray(jo, clazz);  
    }  
  
    /** 
     * 反序列化泛型集合 
     * @param ja    json数组 
     * @param collectionClazz   集合类型 
     * @param genericType   实体类类型 
     * @return 
     * @throws JSONException  
     */  
    @SuppressWarnings("unchecked")  
    public static <T> Collection<T> parseCollection(JSONArray ja, Class<?> collectionClazz,  
            Class<T> genericType) throws JSONException {  
  
        if (collectionClazz == null || genericType == null || isNull(ja)) {  
            return null;  
        }  
  
        Collection<T> collection = (Collection<T>) newInstance(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;  
    }  
  
    /** 
     * 反序列化泛型集合 
     * @param jsonStr   json字符串 
     * @param collectionClazz   集合类型 
     * @param genericType   实体类类型 
     * @return  反序列化后的数组 
     * @throws JSONException  
     */  
    public static <T> Collection<T> parseCollection(String jsonStr, Class<?> collectionClazz,  
            Class<T> genericType) throws JSONException {  
        if (collectionClazz == null || genericType == null || jsonStr == null  
                || jsonStr.length() == 0) {  
            return null;  
        }  
        JSONArray jo = null;  
        try {  
            //如果为数组，则此处转化时，需要去掉前面的键，直接后面的[]中的值  
            int index = jsonStr.indexOf("[");  
            String arrayString=null;   
              
            //获取数组的字符串  
            if(-1!=index){  
                arrayString = jsonStr.substring(index);  
            }  
              
            //如果为数组，使用数组转化  
            if(null!=arrayString){  
                jo = new JSONArray(arrayString);  
            }  
            else{  
                jo = new JSONArray(jsonStr);  
            }  
              
        } catch (JSONException e) {  
            e.printStackTrace();  
        }  
  
        if (isNull(jo)) {  
            return null;  
        }  
  
        return parseCollection(jo, collectionClazz, genericType);  
    }  
  
    /** 
     * 根据类型创建对象 
     * @param clazz 待创建实例的类型 
     * @return  实例对象 
     * @throws JSONException  
     */  
    @SuppressWarnings({ "unchecked", "rawtypes" })  
    private static <T> T newInstance(Class<T> clazz) throws JSONException {  
        if (clazz == null)  
            return null;  
        T obj = null;  
        if (clazz.isInterface()) {  
            if (clazz.equals(Map.class)) {  
                obj = (T) new HashMap();  
            }else if (clazz.equals(List.class)) {  
                obj = (T) new ArrayList();  
            }else if (clazz.equals(Set.class)) {  
                obj = (T) new HashSet();  
            }else{  
                throw new JSONException("unknown interface: " + clazz);  
            }  
        }else{  
            try {  
                obj = clazz.newInstance();  
            }catch (Exception e) {  
                throw new JSONException("unknown class type: " + clazz);  
            }  
        }     
        return obj;  
    }  
      
    /** 
     * 设定Map的值 
     * @param obj   待赋值字段的对象 
     * @param jo    json实例 
     */  
    private static void setField(Object obj, JSONObject jo) {  
        try {  
            @SuppressWarnings("unchecked")  
            Iterator<String> keyIter = jo.keys();  
            String key;  
            Object value;  
            @SuppressWarnings("unchecked")  
            Map<String, Object> valueMap = (Map<String, Object>) obj;  
            while (keyIter.hasNext()) {  
                key = (String) keyIter.next();  
                value = jo.get(key);                  
                valueMap.put(key, value);  
  
            }  
        } catch (JSONException e) {  
            e.printStackTrace();  
        }  
    }     
      
    /** 
     * 设定字段的值 
     * @param obj   待赋值字段的对象 
     * @param fieldSetMethod    字段方法名 
     * @param field 字段 
     * @param jo    json实例 
     */  
    private static void setField(Object obj, Method fieldSetMethod,Field field, JSONObject jo) {  
        String name = field.getName();  
        Class<?> clazz = field.getType();       
        try {  
            if (isArray(clazz)) { // 数组  
                Class<?> c = clazz.getComponentType();  
                JSONArray ja = jo.optJSONArray(name);  
                if (!isNull(ja)) {  
                    Object array = parseArray(ja, c);  
                    setFiedlValue(obj, fieldSetMethod, clazz.getSimpleName(), array);  
                }  
            } else if (isCollection(clazz)) { // 泛型集合  
                // 获取定义的泛型类型  
                Class<?> c = null;  
                Type gType = field.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);  
                    setFiedlValue(obj, fieldSetMethod, clazz.getSimpleName(), o);  
                }  
            } else if (isSingle(clazz)) { // 值类型  
                Object o = jo.opt(name);  
                if (o != null) {  
                    setFiedlValue(obj, fieldSetMethod, clazz.getSimpleName(), o);  
                }  
            } else if (isObject(clazz)) { // 对象  
                JSONObject j = jo.optJSONObject(name);  
                if (!isNull(j)) {  
                    Object o = parseObject(j, clazz);  
                    setFiedlValue(obj, fieldSetMethod, clazz.getSimpleName(), o);  
                }  
            } else if (isList(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();  
        }  
    }  
      
    /** 
     * 设定字段的值  
     * @param obj   待赋值字段的对象 
     * @param field 字段 
     * @param jo    json实例 
     */  
    @SuppressWarnings("unused")  
    private static void setField(Object obj, Field field, JSONObject jo) {  
        String name = field.getName();  
        Class<?> clazz = field.getType();  
        try {  
            if (isArray(clazz)) { // 数组  
                Class<?> c = clazz.getComponentType();  
                JSONArray ja = jo.optJSONArray(name);  
                if (!isNull(ja)) {  
                    Object array = parseArray(ja, c);  
                    field.set(obj, array);  
                }  
            } else if (isCollection(clazz)) { // 泛型集合  
                // 获取定义的泛型类型  
                Class<?> c = null;  
                Type gType = field.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);  
                    field.set(obj, o);  
                }  
            } else if (isSingle(clazz)) { // 值类型  
                Object o = jo.opt(name);  
                if (o != null) {  
                    field.set(obj, o);  
                }  
            } else if (isObject(clazz)) { // 对象  
                JSONObject j = jo.optJSONObject(name);  
                if (!isNull(j)) {  
                    Object o = parseObject(j, clazz);  
                    field.set(obj, o);  
                }  
            } else if (isList(clazz)) { // 列表  
                JSONObject j = jo.optJSONObject(name);  
                if (!isNull(j)) {  
                    Object o = parseObject(j, clazz);  
                    field.set(obj, o);  
                }  
            }else {  
                throw new Exception("unknow type!");  
            }  
        } catch (Exception e) {  
            e.printStackTrace();  
        }  
    }  
  
    /** 
     * 判断对象是否为空 
     * @param obj   实例 
     * @return 
     */  
    private static boolean isNull(Object obj) {  
        if (obj instanceof JSONObject) {  
            return JSONObject.NULL.equals(obj);  
        }  
        return obj == null;  
    }  
  
    /** 
     * 判断是否是值类型  
     * @param clazz  
     * @return 
     */  
    private static boolean isSingle(Class<?> clazz) {  
        return isBoolean(clazz) || isNumber(clazz) || isString(clazz);  
    }  
  
    /** 
     * 是否布尔值 
     * @param clazz  
     * @return 
     */  
    public static boolean isBoolean(Class<?> clazz) {  
        return (clazz != null)  
                && ((Boolean.TYPE.isAssignableFrom(clazz)) || (Boolean.class  
                        .isAssignableFrom(clazz)));  
    }  
  
    /** 
     * 是否数值  
     * @param clazz  
     * @return 
     */  
    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)));  
    }  
  
    /** 
     * 判断是否是字符串  
     * @param clazz  
     * @return 
     */  
    public static boolean isString(Class<?> clazz) {  
        return (clazz != null)  
                && ((String.class.isAssignableFrom(clazz))  
                        || (Character.TYPE.isAssignableFrom(clazz)) || (Character.class  
                        .isAssignableFrom(clazz)));  
    }  
  
    /** 
     * 判断是否是对象 
     * @param clazz  
     * @return 
     */  
    private static boolean isObject(Class<?> clazz) {  
        return clazz != null && !isSingle(clazz) && !isArray(clazz) && !isCollection(clazz) && !isMap(clazz);  
    }  
  
    /** 
     * 判断是否是数组  
     * @param clazz 
     * @return 
     */  
    public static boolean isArray(Class<?> clazz) {  
        return clazz != null && clazz.isArray();  
    }  
  
    /** 
     * 判断是否是集合 
     * @param clazz 
     * @return 
     */  
    public static boolean isCollection(Class<?> clazz) {  
        return clazz != null && Collection.class.isAssignableFrom(clazz);  
    }  
          
    /** 
     * 判断是否是Map 
     * @param clazz 
     * @return 
     */  
    public static boolean isMap(Class<?> clazz) {  
        return clazz != null && Map.class.isAssignableFrom(clazz);  
    }  
      
    /** 
     * 判断是否是列表  
     * @param clazz 
     * @return 
     */  
    public static boolean isList(Class<?> clazz) {  
        return clazz != null && List.class.isAssignableFrom(clazz);  
    }  
      
}  

ANDROID JSON解析工具类，不需要第三方包，支持集合，直接贴代码。
       


调用测试代码：
       
[java]view plaincopy
public class User{  
    private String name;  
    private String password;  
    public String getName() {  
        return name;  
    }  
    public void setName(String name) {  
        this.name = name;  
    }  
    public String getPassword() {  
        return password;  
    }  
    public void setPassword(String password) {  
        this.password = password;  
    }  
      
}  
  
void testObj(){  
    try {  
        User user = new User();  
        user.setName("abcd");  
        user.setPassword("123456");  
          
        User user1 = new User();  
        user.setName("abcdf");  
        user.setPassword("1234567");  
          
        String jsonStrUser = JSONHelper.toJSON(user);   //序列化  
        User jsonUser = JSONHelper.parseObject(jsonStrUser, User.class);    //反序列化        
        Map mapUser = JSONHelper.parseObject(jsonStrUser, HashMap.class);   //反序列化            
          
          
        List sourceList = new ArrayList<User>();  
        sourceList.add(user);  
        sourceList.add(user1);            
        String jsonStrUserList = JSONHelper.toJSON(sourceList);         //序列化  
        List listUser = (List) JSONHelper.parseCollection(jsonStrUserList, List.class, User.class); //反序列化  
    } catch (JSONException e) {  
        e.printStackTrace();  
    }  
      
}  






       
       
       
       
       
       
      
上一篇ANDROID时间标准化
下一篇conversion to dalvik format failed with error 1

       
        
         顶
        
        
         4
        
       
       
        
         踩
        
        
         0
        
       
      

      
       主题推荐
      
      
       android
       json
       arraylist
       interface
       泛型
      
     
      
       猜你在找
      
      
       Map对象用JSON反序列化的方法
      
      
       序列化泛型 反序列化JSON
      
      
       讲解JAVA中JSON的反序列化
      
      
       json数据反序列化C#实体
      
      
       包含多集合的json反序列化
      
      
       Web前台传对象字符串到后台并让后台反序列化对象字符串的方法（ASP.NET) json对象和字符串的转换
      
      
       Silverlight 加载JSON文件 以及反序列化
      
      
       Json-lib反序列化对象忽略属性
      
      
       .NET 2.0 使用最新版的JSON.net 进行反序列化
      
     
       id="ad_frm_0" frameborder="0" scrolling="no" src="http://blog.youkuaiyun.com/common/ad.html?t=4&containerId=ad_cen&frmId=ad_frm_0" style="border-width: 0px; overflow: hidden; width: 746px; height: 90px;">
     

       查看评论
       
      

        
         8楼 
         南极圈圈 2014-11-03 16:33发表 [回复]
        
        
         
        
        
         有点难
        
       
        
         7楼 
         xiaosong2007 2014-06-24 18:21发表 [回复]
        
        
         
        
        
         经过使用，发现序列化的时候，全部值的类型都为String(字符串)，经过一步步的跟踪调试，完美了，改动部分如下：
         
private static void serializeObject(JSONStringer js, Object obj) {
         
...
         
for (Field field : fields) {
         
try {
         
String fieldType = field.getType().getSimpleName();
         
String fieldGetName = parseMethodName(field.getName(),"get");
         
if (!haveMethod(methods, fieldGetName)) {
         
continue;
         
}
         
Method fieldGetMet = objClazz.getMethod(fieldGetName, new Class[] {});
         
Object fieldVal = fieldGetMet.invoke(obj, new Object[] {});
         

         
if ("Date".equals(fieldType)) {
         
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss",Locale.US);
         
fieldVal = sdf.format((Date)fieldVal);
         
}
         

         
js.key(field.getName());
         
serialize(js, fieldVal);
         
} catch (Exception e) {
         
continue;
         
}
         
...
         
}
        
        
         
          Re: 
          AresCJ 2014-08-01 16:50发表 [回复]
         
         
          
         
         
          回复xiaosong2007：多谢完善，3KS
         
        
       
        
         6楼 
         xiaosong2007 2014-06-24 16:43发表 [回复]
        
        
         
        
        
         果然够强大，谢谢楼主！
        
       
        
         5楼 
         默凡 2013-09-25 15:16发表 [回复]
        
        
         
        
        
         好东西顶一下
        
       
        
         4楼 
         10l乐仔 2013-06-17 14:07发表 [回复]
        
        
         
        
        
         大神，int类型的数据怎么想办法转成对应int型的，你这种做法都转成String的，有没有什么办法哈？求帮助
        
        
         
          Re: 
          xiaosong2007 2014-06-24 18:23发表 [回复]
         
         
          
         
         
          回复le292583883：你的问题已经解决，见7楼。
         
        
       
        
         3楼 
         landerson 2013-06-06 16:21发表 [回复]
        
        
         
        
        
         如果字段，没有get set方法，那这个字段就跳过了？
        
       
        
         2楼 
         bruce_shaoheng 2012-09-17 12:53发表 [回复]
        
        
         
        
        
         刚好有用到，jsonlib依赖太多，这个JsonHelper类正好用来处理实体的映射。
        
       
        
         1楼 
         mahong2008 2012-04-10 01:24发表 [回复]
        
        
         
        
        
         楼主，请教个问题，如果传递参数 Class<?> ollectionClazz 
         
该如何传递？
        
        
         
          Re: 
          AresCJ 2012-04-12 11:30发表 [回复]
         
         
          
         
         
          回复mahong2008：ollectionClazz 是集合类型，如List.cass
         
        
       

       
       
       
       
          发表评论
         
用 户 名：
jks456
评论内容：

            
           
  
         
 
      

       * 以上用户言论只代表其个人观点，不代表优快云网站的观点或立场
       
       
      

       id="ad_frm_1" frameborder="0" scrolling="no" src="http://blog.youkuaiyun.com/common/ad.html?t=5&containerId=ad_bot&frmId=ad_frm_1" style="border-width: 0px; overflow: hidden; width: 746px; height: 0px;">
     
 
     
 
      
      
     
 核心技术类目
       全部主题 
       Hadoop 
       AWS 
       移动游戏 
       Java 
       Android 
       iOS 
       Swift 
       智能硬件 
       Docker 
       OpenStack
       VPN 
       Spark 
       ERP 
       IE10 
       Eclipse 
       CRM 
       JavaScript 
       数据库 
       Ubuntu 
       NFC 
       WAP 
       jQuery 
       BI
       HTML5 
       Spring 
       Apache 
       .NET 
       API 
       HTML 
       SDK 
       IIS 
       Fedora 
       XML 
       LBS 
       Unity 
       Splashtop
       UML 
       components 
       Windows Mobile 
       Rails 
       QEMU 
       KDE 
       Cassandra 
       CloudStack 
       FTC 
       coremail
       OPhone 
       CouchBase 
       云计算 
       iOS6 
       Rackspace 
       Web App 
       SpringSide 
       Maemo 
       Compuware
       大数据 
       aptech 
       Perl 
       Tornado 
       Ruby 
       Hibernate 
       ThinkPHP 
       HBase 
       Pure 
       Solr 
       Angular
       Cloud Foundry 
       Redis 
       Scala 
       Django 
       Bootstrap
      
 
      
        个人资料
      
 
       
         
        
 
        AresCJ
       

         
        
       
 
        
访问：50595次
积分：822
等级： 
排名：千里之外
 原创：30篇
 转载：10篇
 译文：0篇
 评论：29条
 
     
 
      
        文章搜索
      
 
       
        
        
        
        
      
 
     
 
      
        文章分类
      
 
      .NET(0)
C/C++(2)
JAVA(1)
JavaMe(2)
Linux(1)
phone(8)
操作系统(1)
数据库(2)
ANDROID(10)
JSON解析(1)
 
     
 
      
        文章存档
      
 
       
         2014年10月(1)
 2014年08月(1)
 2014年02月(1)
 2013年11月(1)
2013年10月(1)
           展开
         
 
     
 
      
        阅读排行
      
 
      ANDROID轻量级JSON序列化和反序列化(5847)
android 双卡双待 发送短信(4400)
ECLIPSE配置PROGUARD(2745)
Android Wifi IP 设置(2569)
ANDROID时间标准化(2414)
ORACLE11 EM启动不了(2314)
MTK编译MODIS(2125)
IM协议介绍(1905)
当CAsyncSocket遇到多线程（转）(1719)
回音消除技术概述(1701)
 
     
 
      
        评论排行
      
 
      ANDROID轻量级JSON序列化和反序列化(11)
android 双卡双待 发送短信(4)
Android Wifi IP 设置(3)
MTK编译MODIS(3)
当CAsyncSocket遇到多线程（转）(2)
IM协议介绍(2)
倒影 特效 控件 View ReflectionLayout(1)
ANDROID 自动接听 支持2.3以上版本(1)
回音消除技术概述(1)
GW620 刷机 ANDROID 1.5、2.2、2.3(1)
 
     
 
      
        推荐文章
      
 
      
        id="ad_frm_2" frameborder="0" scrolling="no" src="http://blog.youkuaiyun.com/common/ad.html?t=12&containerId=ad_commend&frmId=ad_frm_2" style="border-width: 0px; overflow: hidden; width: 182px; height: 200px;">
      
 
     
 
      
        最新评论
      
 
      ANDROID轻量级JSON序列化和反序列化南极圈圈: 有点难
android 双卡双待 发送短信jianhp: 是啊 我这边也是 为啥没有一个人能上传一个demo呢 无语
当CAsyncSocket遇到多线程（转）AresCJ: @newTTTTTT:我亲测是可以的，不知道你是什么情况，收不到数据是其他原因吧？
ANDROID轻量级JSON序列化和反序列化AresCJ: @xiaosong2007:多谢完善，3KS
ANDROID轻量级JSON序列化和反序列化xiaosong2007: @le292583883:你的问题已经解决，见7楼。
ANDROID轻量级JSON序列化和反序列化xiaosong2007: 经过使用，发现序列化的时候，全部值的类型都为String(字符串)，经过一步步的跟踪调试，完美了，改...
ANDROID轻量级JSON序列化和反序列化xiaosong2007: 果然够强大，谢谢楼主！
当CAsyncSocket遇到多线程（转）公共马甲0315: 这样改了以后是不出错了。但是数据根本收不到了.....比如我设置一个子线程来发送命令，在Socket...
IM协议介绍AresCJ: @bluky999:不好意思，转载的！
IM协议介绍子江: TODO 的部分还补充么？哈哈
 
     
 
   
     
    
    
     公司简介|
     招贤纳士|
     广告服务|
     银行汇款帐号|
     联系方式|
     版权声明|
     法律顾问|
     问题报告|
     合作伙伴|
     论坛反馈
    
    
     网站客服 
     杂志客服 
     微博客服 
     webmaster@youkuaiyun.com 
     400-600-2320
    
    
     京 ICP 证 070598 号
    
    
     北京创新乐知信息技术有限公司 版权所有
    
    
     江苏乐知网络技术有限公司 提供商务支持
    
    
     Copyright © 1999-2014, youkuaiyun.com, All Rights Reserved 
     
    
    
  