一些json与对象转换的工具集合类

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/QL753123/article/details/86085087

package com.myhexin.ifs.utils;

import org.codehaus.jackson.JsonFactory;
import org.codehaus.jackson.JsonGenerationException;
import org.codehaus.jackson.JsonGenerator;
import org.codehaus.jackson.JsonNode;
import org.codehaus.jackson.JsonParseException;
import org.codehaus.jackson.JsonParser;
import org.codehaus.jackson.annotate.JsonAutoDetect;
import org.codehaus.jackson.annotate.JsonMethod;
import org.codehaus.jackson.map.DeserializationConfig;
import org.codehaus.jackson.map.JsonMappingException;
import org.codehaus.jackson.map.ObjectMapper;
import org.codehaus.jackson.type.TypeReference;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.StringWriter;
import java.util.List;
import java.util.Map;

/**
 * 
 * @ClassName: JsonUtils
 * @Description: 一些json与对象转换的工具集合类
 * @author qiaolei
 * @date 
 */
public class JsonUtils {

   private static Logger logger = LoggerFactory.getLogger(JsonUtils.class);

   private static final ObjectMapper objectMapper = new ObjectMapper();

   private JsonUtils() {
   }

   public static ObjectMapper getInstance() {
      return objectMapper;
   }
    private static JsonFactory jsonFactory = new JsonFactory();  
  
  
    /** 
     * 泛型返回，json字符串转对象 
     * 
     * auther:shijing 
     * @param jsonAsString 
     * @param pojoClass 
     * @return 
     * @throws JsonMappingException 
     * @throws JsonParseException 
     * @throws IOException 
     */  
    public static <T> T fromJson(String jsonAsString, Class<T> pojoClass) throws JsonMappingException,  
            JsonParseException, IOException {  
        return objectMapper.readValue(jsonAsString, pojoClass);  
    }  
  
    public static <T> T fromJson(FileReader fr, Class<T> pojoClass) throws JsonParseException, IOException {  
        return objectMapper.readValue(fr, pojoClass);  
    }  
  
    /** 
     * Object对象转json 
     * 
     * auther:shijing 
     * @param pojo 
     * @return 
     * @throws JsonMappingException 
     * @throws JsonGenerationException 
     * @throws IOException 
     */  
    public static String toJson(Object pojo) throws JsonMappingException, JsonGenerationException, IOException {  
        return toJson(pojo, false);  
    }  
  
    public static String toJson(Object pojo, boolean prettyPrint) throws JsonMappingException, JsonGenerationException,  
            IOException {  
        StringWriter sw = new StringWriter();  
        JsonGenerator jg = jsonFactory.createJsonGenerator(sw);  
        if (prettyPrint) {  
            jg.useDefaultPrettyPrinter();  
        }  
        objectMapper.writeValue(jg, pojo);  
        return sw.toString();  
    }  
  
    public static void toJson(Object pojo, FileWriter fw, boolean prettyPrint) throws JsonMappingException,  
            JsonGenerationException, IOException {  
        JsonGenerator jg = jsonFactory.createJsonGenerator(fw);  
        if (prettyPrint) {  
            jg.useDefaultPrettyPrinter();  
        }  
        objectMapper.writeValue(jg, pojo);  
    }  
  
    /** 
     * json字符串转Map 
     *
     * auther:shijing 
     * @param jsonStr 
     * @return 
     * @throws IOException 
     */  
    public static Map<String, Object> parseMap(String jsonStr) throws IOException {  
        Map<String, Object> map = objectMapper.readValue(jsonStr, Map.class);  
        return map;  
    }  
  
    public static JsonNode parse(String jsonStr) throws IOException {  
        JsonNode node = null;  
        node = objectMapper.readTree(jsonStr);  
        return node;  
    }  
  
    public static ObjectMapper getObjectMapper() {  
        return objectMapper;  
    }  
      
   /* *//** 
     * json字符串转 List对象 
     * 
     * auther:shijing 
     * @param str   json字符串 
     * @param clazz 转换的类型 
     * @return 
     *//*  
    public static <T> List<T> fromListJson(String str,Class<T> clazz){  
        return JSONArray.parseArray(str, clazz);  
    }  */
   /**
    * 使用Jackson 数据绑定 将对象转换为 json字符串
    * 
    * 还可以 直接使用 JsonUtils.getInstance().writeValueAsString(Object obj)方式
    * 
    * @param obj
    * @return
    */
   public static String toJsonString(Object obj,JsonParser.Feature... features) {
      try {
         if (features.length>0)
         for (int i=0;i<features.length;i++)
            objectMapper.configure(features[i],true);
         return objectMapper.writeValueAsString(obj);
      } catch (JsonGenerationException e) {
         logger.error("转换为json字符串失败" + e.toString());
      } catch (JsonMappingException e) {
         logger.error("转换为json字符串失败" + e.toString());
      } catch (IOException e) {
         logger.error("转换为json字符串失败" + e.toString());
      }
      return null;
   }






   /**
    * json字符串转化为 JavaBean
    * 
    * 还可以直接JsonUtils.getInstance().readValue(String content,Class
    * valueType)用这种方式
    * 
    * @param <T>
    * @param content
    * @param valueType
    * @return
    */
   public static <T> T toJavaBean(String content, Class<T> valueType,JsonParser.Feature... features) {
      try {
         if (features.length>0)
            for (int i=0;i<features.length;i++)
               objectMapper.configure(features[i],true);

         objectMapper.setVisibility(JsonMethod.GETTER, JsonAutoDetect.Visibility.NONE) // but only public getters
               .setVisibility(JsonMethod.FIELD, JsonAutoDetect.Visibility.ANY) // auto-detect all member fields
               .setVisibility(JsonMethod.IS_GETTER, JsonAutoDetect.Visibility.NONE);
         return objectMapper.readValue(content, valueType);
      } catch (JsonParseException e) {
         logger.error("json字符串转化为 javabean失败" + e.toString());
      } catch (JsonMappingException e) {
         logger.error("json字符串转化为 javabean失败" + e.toString());
      } catch (IOException e) {
         logger.error("json字符串转化为 javabean失败" + e.toString());
      }
      return null;
   }

   /**
    * json字符串转化为list
    * 
    * 还可以 直接使用 JsonUtils.getInstance().readValue(String content, new
    * TypeReference<List<T>>(){})方式
    * 
    * @param <T>
    * @param content
    * @param
    * @return
    * @throws IOException
    */
   public static <T> List<T> toJavaBeanList(String content,
         TypeReference<List<T>> typeReference) throws IOException {
      try {
         return objectMapper.readValue(content, typeReference);
      } catch (JsonParseException e) {
         logger.error("json字符串转化为 list失败,原因:" + e.toString());
         throw new RuntimeException("json字符串转化为 list失败");
      } catch (JsonMappingException e) {
         logger.error("json字符串转化为 list失败,原因" + e.toString());
         throw new JsonMappingException("json字符串转化为 list失败");
      } catch (IOException e) {
         logger.error("json字符串转化为 list失败,原因" + e.toString());
         throw new IOException("json字符串转化为 list失败");
      }
   }
   
}