Osheep

时光不回头,当下最重要。

Java使用jackson操作Json格式数据

JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式,她是 JavaScript原生态的数据格式。
她独立于任何编程语言、可读性高、易于生成和解析、体积轻量,这些优雅的特性,让JSON成为非常理想的数据交换的语言。

在使用Java操作JSON时,我们用到了Jackson框架。

Jackson可以轻松的将Java对象转换成json对象和xml文档,同样也可以将json、xml转换成Java对象。

Jackson相关

下载依赖库jar包

Jackson的jar all下载地址:http://jackson.codehaus.org/1.7.6/jackson-all-1.7.6.jar

然后在工程中导入这个jar包即可开始工作

官方示例:http://wiki.fasterxml.com/JacksonInFiveMinutes

下面为基于Jackson的JsonUtils操作工具类:

Code   ViewCopyPrint

  1. /**  
  2.  * 操作Json数据工具类  
  3.  * @author daybreak  
  4.  * @since 2014-12-29  
  5.  */  
  6. public class JSONUtils {   
  7.   
  8.     private static Logger logger = Logger.getLogger(JSONUtils.class);   
  9.        
  10.     /**  
  11.      * 将Json对象字符串转化为Map对象  
  12.      * @param jsonStr JSON字符串  
  13.      * @return 转换成功返回Map对象,失败则返回null  
  14.      */  
  15.     public static Map<String, String> JsonToMap(String jsonStr) {   
  16.         try {   
  17.             ObjectMapper objectMapper = new ObjectMapper();   
  18.             Map<String, String> params = objectMapper.readValue(jsonStr,Map.class);   
  19.             return params;   
  20.         } catch (Exception e) {   
  21.             logger.error(“JsonToMap Error “ + jsonStr, e);   
  22.             return null;   
  23.         }   
  24.     }   
  25.        
  26.     /**  
  27.      * 将Json对象字符串转化为Map<String, Object>对象  
  28.      * @param jsonStr JSON字符串  
  29.      * @return 转换成功返回Map对象,失败则返回null  
  30.      */  
  31.     public static Map<String, Object> readJson2Map(String jsonStr) {   
  32.         try {   
  33.             ObjectMapper objectMapper = new ObjectMapper();   
  34.             Map<String, Object> params = objectMapper.readValue(jsonStr,Map.class);   
  35.             return params;   
  36.         } catch (Exception e) {   
  37.             logger.error(“JsonToMap Error “ + jsonStr, e);   
  38.             return null;   
  39.         }   
  40.     }   
  41.        
  42.     /**  
  43.      * 将Json对象字符串转化为JavaBean类对象  
  44.      * @param jsonStr JSON字符串  
  45.      * @param clazz 类类型  
  46.      * @return 转换成功返回JavaBean类对象,失败则返回null  
  47.      */  
  48.     public static <T> T readJson2Bean(String jsonStr,Class<T> clazz) {   
  49.         try {   
  50.             ObjectMapper objectMapper = new ObjectMapper();   
  51.             T t = objectMapper.readValue(jsonStr,clazz);   
  52.             return t;   
  53.         } catch (Exception e) {   
  54.             logger.error(“readJson2Bean Error “ + jsonStr, e);   
  55.             return null;   
  56.         }   
  57.     }   
  58.        
  59.     /**  
  60.      * 将Json对象字符串转化为List<Map>对象  
  61.      * @param jsonStr JSON字符串  
  62.      * @return 转换成功返回Map对象,失败则返回null  
  63.      */  
  64.     public static List<HashMap<String, Object>> JsonToMapList(String jsonStr) {   
  65.         try {   
  66.             ObjectMapper objectMapper = new ObjectMapper();   
  67.             List<HashMap<String, Object>> params = objectMapper.readValue(jsonStr,List.class);   
  68.             for (int i = 0; i < params.size(); i++) {   
  69.                 Map<String, Object> map = params.get(i);   
  70.                 Set<String> set = map.keySet();   
  71.                 for (Iterator<String> it = set.iterator();it.hasNext();) {   
  72.                     String key = it.next();   
  73.                 }   
  74.             }   
  75.             return params;   
  76.         } catch (Exception e) {   
  77.             logger.error(“JsonToMap Error “ + jsonStr, e);   
  78.             return null;   
  79.         }   
  80.     }   
  81.        
  82.     /**  
  83.      * 将传入能够整除2的数量的参数序列化为Json对象  
  84.      * @param result  
  85.      * @return  
  86.      */  
  87.     public static String WriteToJson(Object… paramObjs){   
  88.         try {   
  89.             if(paramObjs==null||paramObjs.length==0){   
  90.                 logger.error(“参数实例为空”);   
  91.             }   
  92.             Map<String,Object> paramMap = new HashMap<String, Object>();   
  93.             for(int i=0;i<paramObjs.length;i+=2){   
  94.                 paramMap.put((String) paramObjs[i], paramObjs[i+1]);   
  95.             }   
  96.             ObjectMapper objectMapper = new ObjectMapper();   
  97.             return objectMapper.writeValueAsString(paramMap);   
  98.         } catch (Exception e) {   
  99.             return “”;   
  100.         }   
  101.     }   
  102.        
  103.     /**  
  104.      * 将传入能够整除2的数量的参数序列化为Json对象,并进行UrlDecode操作  
  105.      * @param result  
  106.      * @return  
  107.      */  
  108.     public static Map<String, String> JsonToMapAndDecode(String result) {   
  109.         Map<String, String> params = JsonToMap(result);   
  110.         for (String key : params.keySet()) {   
  111.             params.put(key, HttpUtils.urlDecode(params.get(key), “UTF-8”));   
  112.         }   
  113.         return params;   
  114.     }   
  115.        
  116.     public static String toJson(Object target){   
  117.         String result = null;   
  118.         try {   
  119.             ObjectMapper objectMapper = new ObjectMapper();   
  120.             result = objectMapper.writeValueAsString(target);   
  121.         } catch (Exception e) {   
  122.             logger.error(“convert to Json Str Fail !”);   
  123.             e.printStackTrace();   
  124.         }   
  125.         return result;   
  126.     }   
  127. }  

最后,Jackson对XML的支持

Code   ViewCopyPrint

  1. public void writeObject2Xml() {   
  2.     //stax2-api-3.0.2.jar   
  3.     System.out.println(“XmlMapper”);   
  4.     XmlMapper xml = new XmlMapper();   
  5.        
  6.     try {   
  7.         //javaBean转换成xml   
  8.         //xml.writeValue(System.out, bean);   
  9.         StringWriter sw = new StringWriter();   
  10.         xml.writeValue(sw, bean);   
  11.         System.out.println(sw.toString());   
  12.         //List转换成xml   
  13.         List<AccountBean> list = new ArrayList<AccountBean>();   
  14.         list.add(bean);   
  15.         list.add(bean);   
  16.         System.out.println(xml.writeValueAsString(list));   
  17.            
  18.         //Map转换xml文档   
  19.         Map<String, AccountBean> map = new HashMap<String, AccountBean>();   
  20.         map.put(“A”, bean);   
  21.         map.put(“B”, bean);   
  22.         System.out.println(xml.writeValueAsString(map));   
  23.     } catch (JsonGenerationException e) {   
  24.         e.printStackTrace();   
  25.     } catch (JsonMappingException e) {   
  26.         e.printStackTrace();   
  27.     } catch (IOException e) {   
  28.         e.printStackTrace();   
  29.     }   
  30. }  


版权所有,转载请注明出处 本文出自:破晓博客


点赞