JSON与java对象之间的相互转换

针对于一定的业务场景，比如页面显示比较复杂的，交互或是联动比较多的场合，

假如对每一个属性都在对应表设定为一个字段，那么可想而知表的字段得有多少了，上百，好几百~~~~

看看就吓人了(虽然确实在对日项目中有见过，一张表一两百字段还是挺常见的，哈哈)，

虽然可以采取根据业务小模块分表的设计方式，但是好些张表针对一个页面也是够怪的(并且还有可能是业务类型互斥的场合)，

所以大多时候就有了采用oracle的CLOB类型字段！

此处顺便科普一下clob和blob的区别：

BLOB和CLOB都是大字段类型，BLOB是按二进制来存储的，而CLOB是可以直接存储文字的。两者都能最大存储4G.

既然采用clob字段来存储的话，就不可避免的需要用到JSON和java  Object的相互转换！

相互转换需要用到6个jar包：

核心包：json-lib-2.2.2.jar

依赖包：

commons-lang-2.4.jar

commons-logging-1.1.1.jar

commons-collections-3.2.jar

commons-beanutils-1.7.0.jar

ezmorph-1.0.4.jar

下面是各种封装好的转换方法，以方便使用：

/**
* 将Object对象转换成Json对象
*
* <pre>
*  举例：也可以传入Map
*  JsonUtil.Object2Json(User user,null)     =    {"id":"100","userName":"zhangsan",...}
* </pre>
*
* @param object
*          传入Object对象 （为空返回null）
* @param filterProperty
*          过滤属性，过滤掉可能产生的递归属性。（为空不检测）
* @return
*          Json形式的字符串，如果转换异常，返回null。
*/
public static String object2Json(Object object, final List<String> filterProperty) {

// 传如对象为空返回null;
if (object == null) {
return null;
}
try {
JsonConfig config = new JsonConfig();
if (!CollectionUtils.isEmpty(filterProperty)) {
// Json配置
config.setJsonPropertyFilter(new PropertyFilter() {
/**
* @see net.sf.json.util.PropertyFilter#apply(java.lang.Object, java.lang.String, java.lang.Object)
*/
public boolean apply(Object source, String name, Object value) {
// 配置可能出现递归的属性
return filterProperty.contains(name);
}
});
}
// 将pojo对象转换成Json对象
JSONObject jsonObject = JSONObject.fromObject(object, config);
return jsonObject.toString();
} catch (Exception e) {
logger.warn("Object对象转换成Json对象异常：", e);
return null;
}
}

/**
* 将Json串转换成Object对象,如果对象中含有其他对象，需要实现的map中注册对象,支持对象的嵌套
*
* <pre>
*  举例：ObjectA a 里面有3个参数，分别是String a, List<ObjectB> b, ObjectC c   ObjectC c中带有参数 ObjectD d
*       需要事先定义MAP对象，key值为：参数名  value值为：Class
*       Map<String, Class> map = new HashMap<String, Class>();
*       map.put("b", ObjectB.class);
*       map.put("c", ObjectC.class);
*       map.put("d", ObjectD.class);
*       ObjectA a = (ObjectA)json2Objce(jsonString, ObjectA.class, map);
* </pre>
*
* @param jsonString
*          Json字符串
* @param beanClass
*          Bean的class
* @param map
*          需要到json注册的class集合
* @return
*          返回Object对象，如果解析异常，或字符串为空返回null。
*/
public static Object json2Object(String jsonString, Class beanClass, Map<String, Class> map) {

if (StringUtil.isBlank(jsonString)) {
// 如果字符串参数为空返回空对象。
return null;
}
// 将json对象转换成对象。
JSONObject jsonObjcet = null;
try {
jsonObjcet = JSONObject.fromObject(jsonString);
if (jsonObjcet != null) {
// 返回Object对象。
return JSONObject.toBean(jsonObjcet, beanClass, map);
}

} catch (Exception e) {
logger.warn("Json串转换成Object对象异常：Json串：" + jsonString, e);
}
return null;
}

/**
* 将array对象转换成Json对象
*
* @param object [List,Map均可]
*          传入Object对象 （为空返回null）
* @param filterProperty
*          过滤属性，过滤掉可能产生的递归属性。（为空不检测）
* @return
*          Json形式的字符串，如果转换异常，返回null。
*/
public static String arrayObject2Json(Object object, final List<String> filterProperty) {

// 传如对象为空返回null;
if (object == null) {
return null;
}
try {
if (!CollectionUtils.isEmpty(filterProperty)) {
// Json配置
JsonConfig config = new JsonConfig();
config.setJsonPropertyFilter(new PropertyFilter() {
/**
* @see net.sf.json.util.PropertyFilter#apply(java.lang.Object, java.lang.String, java.lang.Object)
*/
public boolean apply(Object source, String name, Object value) {
// 配置可能出现递归的属性
if (filterProperty.contains(name)) {
return true;
} else {
return false;
}
}
});

// 将pojo对象转换成Json对象
JSONArray jsonArray = JSONArray.fromObject(object, config);
// 输出String字符串
return jsonArray.toString();
} else {
// 将pojo对象转换成Json对象
JSONArray jsonArray = JSONArray.fromObject(object);
// 输出String字符串
return jsonArray.toString();
}
} catch (Exception e) {
logger.warn("array对象转换成Json对象异常：", e);
// Json转换异常返回null。
return null;
}
}

/**
* 将Json串转换成Array对象,如果对象中含有其他对象，需要实现的map中注册对象,支持对象的嵌套
*
* @param jsonString
*          Json字符串
* @param beanClass
*          Bean的class
* @param map
*          需要到json注册的class集合
* @return
*          返回Object数组对象，如果解析异常，或字符串为空返回null。
*/
public static Object json2ArrayObject(String jsonString, Class beanClass, Map<String, Class> map) {

if (StringUtil.isBlank(jsonString)) {
// 如果字符串参数为空返回空对象。
return null;
}
// 将json对象转换成对象。
JSONArray jsonArray = null;
try {
jsonArray = JSONArray.fromObject(jsonString);
if (jsonArray != null) {
// 返回ArrayObject对象。
return JSONArray.toArray(jsonArray, beanClass, map);
}

} catch (Exception e) {
logger.warn("Json串转换成Array对象异常：Json串：" + jsonString, e);
// 解析Json字符串异常返回null对象。
return null;
}
return null;
}

/**
* 将Json串转换成Map对象，如果Map的value中含有其他对象，需要实现的map中注册对象,支持对象的嵌套
*
* @param jsonString Json字符串
* @param beanClass  转换的class,Map  LinkedHashMap(支持有序)
* @return Map<String, Object>对象
*/
private static Map<String, Object> json2Map(String jsonString, Class beanClass) {
Map<String, Object> result = null;
if (StringUtil.isBlank(jsonString)) {
// 如果字符串参数为空返回空对象。
return null;
}
// 将json对象转换成对象。
try {
result = (Map<String, Object>) JSONObject.toBean(JSONObject.fromObject(jsonString),
beanClass);

} catch (Exception e) {
logger.warn("Json串转换成Map对象异常：Json串：" + jsonString, e);
// 解析Json字符串异常返回null对象。
return null;
}
return result;
}

以上--------------