Json使用

import java.io.IOException;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

import org.codehaus.jackson.JsonEncoding;
import org.codehaus.jackson.JsonGenerationException;
import org.codehaus.jackson.JsonGenerator;
import org.codehaus.jackson.JsonParseException;
import org.codehaus.jackson.map.DeserializationConfig;
import org.codehaus.jackson.map.JsonMappingException;
import org.codehaus.jackson.map.ObjectMapper;
import org.codehaus.jackson.type.JavaType;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class JsonUtil {
    private static ObjectMapper objectMapper = new ObjectMapper();
    private static JsonGenerator jsonGenerator = JsonUtil.getJsonGenerator();

    private static Logger log = LoggerFactory.getLogger(JsonUtil.class);

    private static JsonGenerator getJsonGenerator() {
        try {
            jsonGenerator = objectMapper.getJsonFactory().createJsonGenerator(System.out, JsonEncoding.UTF8);
            return jsonGenerator;
        } catch (IOException e) {
            log.error("get JsonGenerator error!" + e.toString());
            return null;
        }
    }

    /**
     * 把Java对象转换成json串
     *
     * @throws IOException
     */
    public static String writeEntity2Json(Object object) throws IOException {
        if (null == object) {
            log.error("class:JsonUtil,method:writeEntity2Json,param:object == null");
            return null;
        }
        log.debug("class:JsonUtil,method:writeEntity2Json,param:object=" + object);
        return objectMapper.writeValueAsString(object);
    }

    /**
     * 把List转换成json串
     *
     * @param list
     * @return
     * @throws IOException
     */
    @SuppressWarnings("rawtypes")
    public static String writeList2Json(List list) throws IOException {
        return objectMapper.writeValueAsString(list);
    }

    /**
     * 把List<Object>转换成List<json串>
     *
     * @param list
     * @return
     * @throws IOException
     */
    @SuppressWarnings({ "rawtypes", "unchecked" })
    public static List<String> writeListObject2Json(List list) throws IOException {
        List<String> objectList = new ArrayList();
        Iterator iter = list.iterator();
        while (iter.hasNext()) {
            Object o = iter.next();
            String json = objectMapper.writeValueAsString(o);
            objectList.add(json);
        }
        return objectList;
    }

    /**
     * 把List<Object>转换成String[json串]
     *
     * @param list
     * @return
     * @throws IOException
     */
    @SuppressWarnings("rawtypes")
    public static String[] writeListObject2ArrayJson(List list) throws IOException {
        if (null == list || list.size() == 0) {
            log.error("class:JsonUtil,method:writeListObject2ArrayJson,param==null");
            return null;
        }
        String[] arrayJson = new String[list.size()];
        for (int i = 0; i < list.size(); i++) {
            Object o = list.get(i);
            String json = objectMapper.writeValueAsString(o);
            arrayJson[i] = json;
        }
        return arrayJson;
    }

    /**
     * 把map转换成json串
     *
     * @param map
     * @return
     */
    @SuppressWarnings("rawtypes")
    public static String writeMap2Json(Map map) {
        try {
            return objectMapper.writeValueAsString(map);
        } catch (JsonGenerationException e) {
            e.printStackTrace();
            return null;
        } catch (JsonMappingException e) {
            e.printStackTrace();
            return null;
        } catch (IOException e) {
            e.printStackTrace();
            return null;
        }

    }

    /**
     * JSON字符串转换为对象
     */
    @SuppressWarnings({ "rawtypes", "unchecked" })
    public static Object readJson2Entity(String json, Class c) {
        log.debug("class:JsonUtil,method:readJson2Entity,param:json=" + json);
        try {
            return objectMapper.readValue(json, c);
        } catch (JsonParseException e) {
            log.error("class:JsonUtil,method:readJson2Entity", e);
            return null;
        } catch (JsonMappingException e) {
            log.error("class:JsonUtil,method:readJson2Entity", e);
            return null;
        } catch (IOException e) {
            log.error("class:JsonUtil,method:readJson2Entity", e);
            return null;
        }
    }

    /**
     * JSON转换为List对象
     */
    @SuppressWarnings("unchecked")
    public static List<LinkedHashMap<String, Object>> readJson2List(String json) {
        try {
            return objectMapper.readValue(json, List.class);
        } catch (JsonParseException e) {
            e.printStackTrace();
            return null;
        } catch (JsonMappingException e) {
            e.printStackTrace();
            return null;
        } catch (IOException e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * JSON转换为数组对象
     */
    public static Object[] readJson2Array(String json) {
        try {
            return objectMapper.readValue(json, Object[].class);
        } catch (JsonParseException e) {
            e.printStackTrace();
            return null;
        } catch (JsonMappingException e) {
            e.printStackTrace();
            return null;
        } catch (IOException e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * JSON转换为Map对象
     */
    @SuppressWarnings("unchecked")
    public static Map<String, Map<String, Object>> readJson2Map(String json) {
        try {
            return objectMapper.readValue(json, Map.class);
        } catch (JsonParseException e) {
            e.printStackTrace();
            return null;
        } catch (JsonMappingException e) {
            e.printStackTrace();
            return null;
        } catch (IOException e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 对象转换字符串
     *
     * @param obj
     * @return
     */
    public static String Object2String(Object obj) {
        String result = null;
        try {
            result = objectMapper.writeValueAsString(obj);
        } catch (Exception e) {
            log.error("json转换异常", e);
        }
        return result;
    }

    /**
     * 字符串转换对象
     *
     * @param json
     * @param classObj
     * @return
     */
    public static Object String2Object(String json, Class<?> classObj) {
        Object result = null;
        try {
            result = objectMapper.readValue(json, classObj);
        } catch (Exception e) {
            log.error("json转换异常", e);
        }
        return result;
    }

    /**
     * 字符串转换Pagination对象,此类有firstIndex":1,"lastIndex":1属性会导致转换异常，过滤这2个属性
     *
     * @param json
     * @param classObj
     * @return
     */
    public static Object String2Pagination(String json, Class<?> classObj) {
        Object result = null;
        try {
            ObjectMapper objectMapper = new ObjectMapper();
            // 设置输入时忽略在JSON字符串中存在但Java对象实际没有的属性
            objectMapper.disable(DeserializationConfig.Feature.FAIL_ON_UNKNOWN_PROPERTIES);
            result = objectMapper.readValue(json, classObj);
        } catch (Exception e) {
            log.error("json转换异常", e);
        }
        return result;
    }

    /**
     * 字符串转换为List<?>
     *
     * @param json
     * @param classObj
     * @return
     */
    public static Object String2List(String json, Class<?> classObj) {
        Object result = null;
        try {
            result = objectMapper.readValue(json, getCollectionType(ArrayList.class, classObj));
        } catch (Exception e) {
            log.error("json转换异常", e);
        }
        return result;
    }

    private static JavaType getCollectionType(Class<?> collectionClass, Class<?>... elementClasses) {
        return objectMapper.getTypeFactory().constructParametricType(collectionClass, elementClasses);
    }

  }

 

 

 

//json工具类泛型接口

import java.util.ArrayList;
import java.util.List;

import org.codehaus.jackson.map.ObjectMapper;
import org.codehaus.jackson.type.JavaType;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * 
  *
 */
public class JsonUtil {

    private static final Logger logger = LoggerFactory.getLogger(JsonUtil.class);
    private static ObjectMapper mapper = new ObjectMapper();

    /**
     * 对象转换字符串
     *
     * @param obj
     * @return
     */
    public static String Object2String(Object obj) {
        String result = null;
        try {
            result = mapper.writeValueAsString(obj);
        } catch (Exception e) {
            logger.error("json转换异常", e);
        }
        return result;
    }

    /**
     * 字符串转换对象
     *
     * @param json
     * @param classObj
     * @return
     * @return
     */
    public static <T> T String2Object(String json, Class<T> classObj) {
        T result = null;
        try {
            result = mapper.readValue(json, classObj);
        } catch (Exception e) {
            logger.error("json转换异常", e);
        }
        return result;
    }

    /**
     * 字符串转换成较复杂的对象，如泛型对象
     *
     * @param json
     * @param classObj
     * @param valueType
     * @return
     */
    public static <T> T String2Object(String json, Class<?> classObj, Class<?>... valueType) {
        T result = null;
        try {
            result = mapper.readValue(json, getCollectionType(classObj, valueType));
        } catch (Exception e) {
            logger.error("json转换异常", e);
        }
        return result;
    }

    /**
     * 字符串转换为List<T>
     *
     * @param json
     * @param classObj
     * @return
     */
    public static <T> List<T> String2List(String json, Class<T> classObj) {
        List<T> result = null;
        try {
            result = mapper.readValue(json, getCollectionType(ArrayList.class, classObj));
        } catch (Exception e) {
            logger.error("json转换异常", e);
        }
        return result;
    }

    private static JavaType getCollectionType(Class<?> collectionClass, Class<?>... elementClasses) {
        return mapper.getTypeFactory().constructParametricType(collectionClass, elementClasses);
    }
}