Java中Json对象序列化与反序列化工具类

package com.gj5u.publics.util;

import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.List;
import java.util.Locale;
import java.util.Map;

import net.sf.json.JSONArray;
import net.sf.json.JSONObject;
import net.sf.json.JSONSerializer;
import net.sf.json.JsonConfig;
import net.sf.json.processors.JsonValueProcessor;

import org.codehaus.jackson.map.ObjectMapper;

/**
 * Json操作工具
 * 
 * @author Rex
 *
 */
public class JsonUtil
{
    /**
     * 由字符串反序列化成实体类 
     * 针对的是一个实体，此实体中的属性不包括自定义的类型，如Teacher类型，或者List>Teacher<类型
     * 
     * @param source
     *            传入json中的字符串      
     * @param beanClass
     *            实体类的类型      
     * @return 实体类      
     */
    @SuppressWarnings("rawtypes")
    public static Object getObjFormJsonArrStr(String source, Class beanClass)
    {
        JSONObject jsonObject = (JSONObject) JSONSerializer.toJSON(source);
        return JSONObject.toBean(jsonObject, beanClass);
    }
    
    /**
     * 由字符串反序列化成实体类  针对的是一个实体，此实体中的属性包括自定义的类型，如Teacher类型，或者List>Teacher<类型
     *       classMap如下写法 Map>String, Class< classMap = new
     * HashMap>String, Class<(); classMap.put("col", DataColumn.class);
     * classMap.put("row", DataRow.class);
     * 
     * @param jsonArrStr
     *                 
     * @param clazz
     *                 
     * @param classMap
     *                 
     * @return      
     */
    @SuppressWarnings("rawtypes")
    public static Object getObjFormJsonArrStr(String jsonArrStr, Class clazz, Map classMap)
    {
        JSONObject jsonObj = JSONObject.fromObject(jsonArrStr);
        return JSONObject.toBean(jsonObj, clazz, classMap);
    }
    
    /**
     * 将string转换成listBean     
     * 
     * @param jsonArrStr
     *            需要反序列化的字符串     
     * @param clazz
     *            被反序列化之后的类      
     * @return 实体list      
     */
    @SuppressWarnings({ "unchecked", "rawtypes" })
    public static List getListFromJsonArrStr(String jsonArrStr, Class clazz)
    {
        JSONArray jsonArr = JSONArray.fromObject(jsonArrStr);
        List list = new ArrayList();
        for (int i = 0; i < jsonArr.size(); i++)
        {
            list.add(JSONObject.toBean(jsonArr.getJSONObject(i), clazz));
        }
        return list;
    }
    
    /**
     *      * 将string转换成listBean 属性中包含实体类等 如List>Student<
     * 而Student中含有属性List>Teacher<    
     * 
     * @param jsonArrStr
     *            需要反序列化的字符串      
     * @param clazz
     *            反序列化后的类      
     * @param classMap
     *            将属性中包含的如Teacher加入到一个Map中，格式如map.put("teacher",Teacher.class)
     * @return 反序列化后的字符串       使用示例： Map classMap = new HashMap();
     *                 //必须要对Parent进行初始化 否则不识别          Teacher p = new
     *         Teacher();          classMap.put("teacher", p.getClass()); List
     *         mlist =JSONTransfer.getListFromJsonArrStr(resultStr,
     *         Student.class, classMap);      
     */
    @SuppressWarnings({ "unchecked", "rawtypes" })
    public static List getListFromJsonArrStr(String jsonArrStr, Class clazz, Map classMap)
    {
        JSONArray jsonArr = JSONArray.fromObject(jsonArrStr);
        List list = new ArrayList();
        for (int i = 0; i < jsonArr.size(); i++)
        {
            list.add(JSONObject.toBean(jsonArr.getJSONObject(i), clazz, classMap));
        }
        return list;
    }
    
    /**
     * 序列化操作，无论是单个的对象，还是list，抑或是list中的属性仍包含list，都可以直接序列化成String类型
     * 
     * @param obj
     *            需要被序列化的对象
     * @return 序列化之后的字符串
     */
    public static String getJsonArrStrFromList(Object obj)
    {
        // 返回結果
        String jsonStr = null;
        // 判空
        if (obj == null)
        {
            return "{}";
        }
        // Json配置     
        JsonConfig jsonCfg = new JsonConfig();
        // 注册日期处理器 ;
        jsonCfg.registerJsonValueProcessor(java.util.Date.class, JsonDateValueProcessor.getInstance());
        // 判断是否是list
        if (obj instanceof Collection || obj instanceof Object[])
        {
            jsonStr = JSONArray.fromObject(obj, jsonCfg).toString();
        }
        else
        {
            jsonStr = JSONObject.fromObject(obj, jsonCfg).toString();
        }
        return jsonStr;
    }
    
    /**
     * 序列化操作，对象类型大小写可以按照@ JsonProperty自定义来执行
     * 
     * @param obj
     *            对象类型
     * @param IsJsonProperty
     *            是否按照JsonProperty中定义的类进行序列化
     * @return 返回Json字符串
     */
    public static String getJsonArrStrFromList(Object obj, Boolean IsJsonProperty)
    {
        if (IsJsonProperty)
        {
            try
            {
                ObjectMapper mapper = new ObjectMapper();
                String json = mapper.writeValueAsString(obj);
                return json;
            }
            catch (Exception e)
            {
                FileWriteAndReadUtil.writeFile("执行Json序列化失败:（方法名：getJsonArrStrFromList），（错误提示：" + e.getMessage() + "）", true);
                return "{}";
            }
        }
        else
        {
            return getJsonArrStrFromList(obj);
        }
    }
    
    /**
     * 由字符串反序列化成实体类 
     * 针对的是一个实体，此实体中的属性不包括自定义的类型，如Teacher类型，或者List>Teacher<类型
     * 
     * @param source
     *            传入json中的字符串      
     * @param beanClass
     *            实体类的类型      
     * @param IsJsonProperty
     *            是否按照JsonProperty中定义的类进行序列化
     * @return 实体类      
     */
    @SuppressWarnings({ "rawtypes", "unchecked" })
    public static Object getObjFormJsonArrStr(String source, Class beanClass, Boolean IsJsonProperty)
    {
        if (IsJsonProperty)
        {
            try
            {
                ObjectMapper mapper = new ObjectMapper();
                Object result = mapper.readValue(source, beanClass);
                return result;
            }
            catch (Exception e)
            {
                FileWriteAndReadUtil.writeFile("执行Json序列化失败:（方法名：getObjFormJsonArrStr），（错误提示：" + e.getMessage() + "）", true);
                return null;
            }
        }
        else
        {
            return getObjFormJsonArrStr(source, beanClass);
        }
    }
    
    /**
     * 将string转换成listBean     
     * 
     * @param jsonArrStr
     *            需要反序列化的字符串     
     * @param clazz
     *            被反序列化之后的类    
     * @param IsJsonProperty
     *            是否按照JsonProperty中定义的类进行序列化  
     * @return 实体list      
     */
    @SuppressWarnings({ "unchecked", "rawtypes" })
    public static List getListFromJsonArrStr(String jsonArrStr, Class clazz, Boolean IsJsonProperty)
    {
        if (IsJsonProperty)
        {
            try
            {
                JSONArray jsonArr = JSONArray.fromObject(jsonArrStr);
                List list = new ArrayList();
                for (int i = 0; i < jsonArr.size(); i++)
                {
                    ObjectMapper mapper = new ObjectMapper();
                    Object result = mapper.readValue(jsonArr.getJSONObject(i).toString(), clazz);
                    list.add(result);
                }
                return list;
            }
            catch (Exception e)
            {
                FileWriteAndReadUtil.writeFile("执行Json序列化失败:（方法名：getListFromJsonArrStr），（错误提示：" + e.getMessage() + "）", true);
                return null;
            }
        }
        else
        {
            return getListFromJsonArrStr(jsonArrStr, clazz);
        }
    }
    
    // [start] 日期处理
    /** * JSON 日期格式处理（java转化为JSON） */
    public static class JsonDateValueProcessor implements JsonValueProcessor
    {
        private static JsonDateValueProcessor dateValueProcessor;
        /**
         * datePattern
         */
        private String datePattern = "yyyy-MM-dd HH:mm:ss";
        
        private JsonDateValueProcessor()
        {
        }
        
        public static JsonDateValueProcessor getInstance()
        {
            if (dateValueProcessor == null)
            {
                dateValueProcessor = new JsonDateValueProcessor();
            }
            return dateValueProcessor;
        }
        
        public Object processArrayValue(Object value, JsonConfig jsonConfig)
        {
            return process(value);
        }
        
        public Object processObjectValue(String key, Object value, JsonConfig jsonConfig)
        {
            return process(value);
        }
        
        // 用于格式化date类型的值
        private Object process(Object value)
        {
            try
            {
                if (value instanceof Date)
                {
                    SimpleDateFormat sdf = new SimpleDateFormat(datePattern, Locale.CHINESE);
                    return sdf.format((Date) value);
                }
                return value == null ? "" : value.toString();
            }
            catch (Exception e)
            {
                return "";
            }
        }
        
        public static JsonConfig getJsonConfig()
        {
            JsonConfig jcfg = new JsonConfig();
            jcfg.registerJsonValueProcessor(Date.class, JsonDateValueProcessor.getInstance());
            return jcfg;
        }
    }
    // [end]
}

需要的Jar包可以自己百度下载。。。

json-lib-2.4-jdk15