<dependency>

       <groupId>net.sf.json-lib</groupId>

       <artifactId>json-lib</artifactId>

       <version>2.4</version>

       <classifier>jdk15</classifier>

    </dependency>

    <dependency>

        <groupId>org.json</groupId>

        <artifactId>json</artifactId>

        <version></version>

    </dependency>

import java.io.File;

import java.io.IOException;

import java.nio.charset.Charset;

import java.util.Collections;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import java.util.Map.Entry;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import com.fasterxml.jackson.core.type.TypeReference;

import com.fasterxml.jackson.databind.JavaType;

import com.fasterxml.jackson.databind.ObjectMapper;

import com.fasterxml.jackson.databind.type.TypeFactory;

import net.sf.json.JSONArray;

import net.sf.json.JSONObject;

public class JacksonUtil {

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

    public static final ObjectMapper mapper = new ObjectMapper();

    private JacksonUtil() {

        throw new IllegalStateException("Utility class");

    }

    /**

     * 将对象序列化成JSON字符串

     *

     * @param obj

     * @return

     */

    public static String serializeObjectToJson(Object obj) {

        try {

            return mapper.writeValueAsString(obj);

        } catch (Exception e) {

            log.error("serialize object to json", e);

            return null;

        }

    }

    /**

     * 将对象序列化到文件

     *

     * @param obj

     *            要序列化的对象

     * @param file

     *            要写入的文件

     */

    public static void serializeObjectToFile(Object obj, File file) {

        try {

            ObjectMapper mapper = new ObjectMapper();

            mapper.writeValue(file, obj);

        } catch (Exception e) {

            log.error("Serialize Object To Json", e);

        }

    }

    /**

     * 从文件读取JSON

     *

     * @param file

     *            来源文件

     * @param clazz

     *            反序列化成的类

     * @return

     */

    public static <T> T deserializeFormFile(File file, Class<T> clazz) {

        try {

            ObjectMapper mapper = new ObjectMapper();

            return mapper.readValue(file, clazz);

        } catch (Exception e) {

            log.error("Deserialize Json Form File", e);

        }

        return null;

    }

    /**

     * 将JSON字符串反序列化成对象

     *

     * @param json

     *            要反序列化JSON字符串

     * @param typeReference

     *            类型帮助类(带泛型类T为List,Map等泛型类)

     * @return

     */

    @SuppressWarnings("unchecked")

    public static <T> T deserializeJsonToObject(String json, TypeReference<T> typeReference) {

        try {

            return (T) mapper.readValue(json, typeReference);

        } catch (Exception e) {

            log.error("Deserialize Json to Object", e);

            return null;

        }

    }

    /**

     * 将JSON字符串反序列化成对象

     *

     * @param json

     *            要反序列化JSON字符串

     * @param clazz

     *            普通对象类型

     * @return

     */

    public static <T> T deserializeJsonToObject(String json, Class<T> clazz) {

        try {

            return mapper.readValue(json, clazz);

        } catch (Exception e) {

            log.error("Deserialize Json to Object", e);

            return null;

        }

    }

    /**

     * 将JSON字符串反序列化成对象

     *

     * @param json

     *            要反序列化JSON字符串

     * @param javaType

     *            JavaType表示的对象

     * @return

     */

    public static Object deserializeJsonToObject(String json, JavaType javaType) {

        try {

            return mapper.readValue(json, javaType);

        } catch (Exception e) {

            log.error("Deserialize Json to Object", e);

            return null;

        }

    }

    /**

     * 获取List类型的JavaType对象

     *

     * @param clazz

     *            List内部对象类型

     * @return

     */

    public static <T> JavaType getListJavaType(Class<T> clazz) {

        TypeFactory typeFactory = mapper.getTypeFactory();

        return typeFactory.constructCollectionType(List.class, typeFactory.constructType(clazz));

    }

    /**

     * 将JSON字符串反序列化成List

     *

     * @param json

     *            JSON字符串

     * @param clazz

     *            List内部类型

     * @return

     */

    public static <T> List<T> deserializeJsonToList(String json, Class<T> clazz) {

        JavaType javaType = getListJavaType(clazz);

        try {

            return mapper.readValue(json, javaType);

        } catch (Exception e) {

            log.error("Deserialize Json to List", e);

            return Collections.emptyList();

        }

    }

    /**

     * 获取Map类型的JavaType对象

     *

     * @param clazzKey

     *            Map key Type

     * @param clazzValue

     *            Map value Type

     * @return Map类型的JavaType对象

     */

    public static <K, V> JavaType getMapJavaType(Class<K> clazzKey, Class<V> clazzValue) {

        TypeFactory typeFactory = mapper.getTypeFactory();

        return typeFactory.constructMapType(Map.class, typeFactory.constructType(clazzKey),

                typeFactory.constructType(clazzValue));

    }

    /**

     * 将JSON字符串反序列化成Map

     *

     * @param <K>

     * @param <V>

     * @param json

     *            JSON字符串

     * @param clazzKey

     *            Map key Type

     * @param clazzValue

     *            Map value Type

     * @return Map<K,V>对象

     */

    public static <K, V> Map<K, V> deserializeJsonToMap(String json, Class<K> clazzKey, Class<V> clazzValue) {

        JavaType javaType = getMapJavaType(clazzKey, clazzValue);

        try {

            return mapper.readValue(json, javaType);

        } catch (Exception e) {

            log.error("Deserialize Json to Map", e);

            return null;

        }

    }

    /**

     * 将JSON字符串反序列化成List<Map>

     *

     * @param json

     *            JSON字符串

     * @param clazzKey

     *            key Type

     * @param clazzValue

     *            value Type

     * @return

     */

    public static <K, V> List<Map<K, V>> deserializeJsonToListMap(String json, Class<K> clazzKey, Class<V> clazzValue) {

        JavaType mapType = getMapJavaType(clazzKey, clazzValue);

        TypeFactory typeFactory = mapper.getTypeFactory();

        JavaType javaType = typeFactory.constructCollectionType(List.class, mapType);

        try {

            return mapper.readValue(json, javaType);

        } catch (Exception e) {

            log.error("Deserialize Json to List<Map>", e);

            return Collections.emptyList();

        }

    }

    /**

     * 将 LinkedHashMap 转换为正常 JSON 字符串

     *

     * @param map

     * @param charset

     * @return

     */

    public static String hashMapToJson(Map<?, ?> map, Charset charset) {

        StringBuilder jsonBuilder = new StringBuilder();

        jsonBuilder.append("{");

        StringBuilder sBuilder = new StringBuilder();

        for (Iterator<?> it = map.entrySet().iterator(); it.hasNext();) {

            Entry<?, ?> e = (Entry<?, ?>) it.next();

            sBuilder.append("\"" + e.getKey() + "\"" + ":");

            sBuilder.append("\"" + e.getValue() + "\"" + ",");

        }

        String jsonString = sBuilder.substring(, sBuilder.lastIndexOf(","));

        jsonBuilder.append(jsonString);

        jsonBuilder.append("}");

        byte[] body = jsonBuilder.toString().getBytes(charset);

        return new String(body, charset);

    }

    /**

     *

     * @param jsonString

     * @param classz

     *            Object[] obj = getJosnToArray(message, Obj.class);

     * @return

     */

    public static <T> Object[] getJosnToArray(String jsonString, Class<T> classz) {

        // net.sf.jso

        JSONArray array = JSONArray.fromObject(jsonString);

        Object[] obj = new Object[array.size()];

        for (int i = ; i < array.size(); i++) {

            JSONObject jsonObject = array.getJSONObject(i);

            obj[i] = JSONObject.toBean(jsonObject, classz);

        }

        return obj;

    }

    /**

     *

     * @param jsonString

     * @return

     */

    public static <T> List<T> getJosnToArray(String jsonString) {

        ObjectMapper mapper = new ObjectMapper();

        List<T> list = null;

        try {

            list = mapper.readValue(jsonString, new TypeReference<List<T>>() {});

        } catch (IOException e) {

            log.error("Deserialize Json to List", e);

        }

        return list;

    }

}