jackson的常用使用方法

package usi.dbdp.util;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.JavaType;
import com.fasterxml.jackson.databind.ObjectMapper;

import net.sf.json.JSONSerializer;
import net.sf.json.xml.XMLSerializer;

/**
 * @Description 工具类,提供jackson的常用使用方法
 */
public class JacksonUtil {
    private static final ObjectMapper OBJECTMAPPER = new ObjectMapper();
    
    private static TypeReference<Map<String, String>> tr = new TypeReference<Map<String, String>>() {};
    
    /**
     * @Description 对象转为json字符串
     * @param obj(该对象的类应提供getter和setter方法)
     * @return
     * @throws JsonProcessingException 
     */
    public static String obj2json(Object obj) throws JsonProcessingException{
        return OBJECTMAPPER.writeValueAsString(obj);
    }
    
    /**
     * @Description json字符串转为对象
     * @param jsonStr
     * @param clazz (对象的类型)
     * @return
     * @throws Exception
     */
    public static <T> T json2pojo(String jsonStr,Class<T> clazz) throws Exception {
        return OBJECTMAPPER.readValue(jsonStr, clazz);
    }
    
    /**
     * @Description json字符串转为map
     * @param jsonStr
     * @return
     * @throws Exception
     */
    @SuppressWarnings("unchecked")
	public static Map<String,Object> json2map(String jsonStr) throws Exception {
        return OBJECTMAPPER.readValue(jsonStr, Map.class);
    }
    
    /**
     * @Description json字符串转为map(Map<String,T>)
     * @param jsonStr(json字符串)
     * @param clazz(map中value的类型)
     * @return
     * @throws Exception
     */
    public static <T> Map<String,T> json2map(String jsonStr,Class<T> clazz) throws Exception {
        Map<String,Map<String,Object>> map = OBJECTMAPPER.readValue(jsonStr, new TypeReference<Map<String,T>>(){});
        Map<String,T> result = new HashMap<String, T>();
        for (Entry<String, Map<String,Object>> entry : map.entrySet()) {
            result.put(entry.getKey(), map2pojo(entry.getValue(), clazz));
        }
        return result;
    }
    
    /**
     * @Description json字符串转为map(Map<String,String>)
     * @param jsonStr
     * @return
     * @throws Exception
     */
    public static Map<String, String> json2Stringmap(String jsonStr) throws Exception{
    	return OBJECTMAPPER.readValue(jsonStr, tr);
    }
    
    /**
     * @Description map转为pojo类
     * @param map
     * @param clazz(pojo类型,该类应提供getter和setter方法以及没有参数的构造方法)
     * @return
     */
    @SuppressWarnings("rawtypes")
	public static <T> T map2pojo(Map map,Class<T> clazz){
        return OBJECTMAPPER.convertValue(map, clazz);
    }
    
    /**
     * @Description json字符串转为list
     * @param jsonArrayStr(json字符串)
     * @param clazz(list中元素的类型)
     * @return
     * @throws Exception
     */
    public static <T> List<T> json2list(String jsonArrayStr,Class<T> clazz)throws Exception{
        List<Map<String,Object>> list = OBJECTMAPPER.readValue(jsonArrayStr, new TypeReference<List<T>>() {});
        List<T> result = new ArrayList<T>();
        for (Map<String, Object> map : list) {
            result.add(map2pojo(map, clazz));
        }
        return result;
    }
    
    /**
     * @Description json字符串转为list
     * @param jsonArrayStr(json字符串)
     * @param listClass(list的实现类一般是ArrayList.class)
     * @param clazz(list中元素的类型)
     * @return
     * @throws Exception
     */
    public static <T, L> List<T> json2list(String jsonArrayStr,Class<L> listClass, Class<T> clazz) throws Exception{
        JavaType javaType = OBJECTMAPPER.getTypeFactory().constructParametricType(listClass, clazz);
        List<T> result = OBJECTMAPPER.readValue(jsonArrayStr, javaType);
        return result;
    }
    /**
	 * 
	 * <p>将返回的xml转换为json字符串
	 *
	 * @param xmlParam
	 * @return
	 */
	public static String parseXml2Json(String xmlParam){
		XMLSerializer xmlSerializer = new XMLSerializer();
		String jsonStr = xmlSerializer.read(xmlParam).toString();
		
		return jsonStr;
	}
	
	/**
	 * 
	 * <p>将json格式字符串转换为xml
	 *
	 * @param jsonParam
	 * @return
	 */
	public static String parseJson2Xml(String jsonParam){
		XMLSerializer xmlSerializer = new XMLSerializer();
		xmlSerializer.setRootName("OutputInfo");
		xmlSerializer.setArrayName("userList");
		xmlSerializer.setElementName("entity");
		xmlSerializer.setNamespaceLenient(false);
		String xmlStr = xmlSerializer.write((JSONSerializer.toJSON(jsonParam)),"UTF-8");
		return xmlStr;
	}
	/**
	 * 将json格式字符串转换成xml
	 * @param jsonParam json字符串
	 * @param rootName 设置根目录配置内容
	 * @return
	 */
	public static String parseJson2Xml(String jsonParam,String rootName){
		XMLSerializer xmlSerializer = new XMLSerializer();
		xmlSerializer.setRootName(rootName);
		xmlSerializer.setArrayName("userList");
		xmlSerializer.setElementName("entity");
		xmlSerializer.setNamespaceLenient(false);
		String xmlStr = xmlSerializer.write((JSONSerializer.toJSON(jsonParam)),"UTF-8");
		return xmlStr;
	}
}