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]
}