json、javaBean、xml互转的几种工具介绍 （转载）

2021-12-16 10:46:34

工作中经常要用到Json、JavaBean、Xml之间的相互转换，用到了很多种方式，这里做下总结，以供参考。

现在主流的转换工具有json-lib、jackson、fastjson等，我为大家一一做简单介绍，主要还是以代码形式贴出如何简单应用这些工具的，更多高级功能还需大家深入研究。

首先是json-lib，算是很早的转换工具了，用的人很多，说实在现在完全不适合了，缺点比较多，依赖的第三方实在是比较多，效率低下，API也比较繁琐，说他纯粹是因为以前的老项目很多人都用到它。不废话，开始上代码。

需要的maven依赖：

 

[plain] view plaincopy
 
  1. <!-- for json-lib -->  
  2. <dependency>    
  3.     <groupId>net.sf.json-lib</groupId>    
  4.     <artifactId>json-lib</artifactId>    
  5.     <version>2.4</version>    
  6.     <classifier>jdk15</classifier>    
  7. </dependency>  
  8. <dependency>  
  9.     <groupId>xom</groupId>  
  10.     <artifactId>xom</artifactId>  
  11.     <version>1.1</version>  
  12. </dependency>   
  13. <dependency>  
  14.     <groupId>xalan</groupId>  
  15.     <artifactId>xalan</artifactId>  
  16.     <version>2.7.1</version>  
  17. </dependency>  


使用json-lib实现多种转换

 

 

[java] view plaincopy
 
  1. import java.text.SimpleDateFormat;  
  2. import java.util.Date;  
  3. import java.util.HashMap;  
  4. import java.util.List;  
  5. import java.util.Map;  
  6. import java.util.Map.Entry;  
  7. import javax.swing.text.Document;  
  8. import net.sf.ezmorph.Morpher;  
  9. import net.sf.ezmorph.MorpherRegistry;  
  10. import net.sf.ezmorph.bean.BeanMorpher;  
  11. import net.sf.ezmorph.object.DateMorpher;  
  12. import net.sf.json.JSON;  
  13. import net.sf.json.JSONArray;  
  14. import net.sf.json.JSONObject;  
  15. import net.sf.json.JSONSerializer;  
  16. import net.sf.json.JsonConfig;  
  17. import net.sf.json.processors.JsonValueProcessor;  
  18. import net.sf.json.util.CycleDetectionStrategy;  
  19. import net.sf.json.util.JSONUtils;  
  20. import net.sf.json.xml.XMLSerializer;  
  21.   
  22. /** 
  23.  * json-lib utils 
  24.  * @author magic_yy 
  25.  * @see json-lib.sourceforge.net/ 
  26.  * @see https://github.com/aalmiray/Json-lib 
  27.  * 
  28.  */  
  29. public class JsonLibUtils {  
  30.       
  31.     public static JsonConfig config = new JsonConfig();  
  32.       
  33.     static{  
  34.         config.setCycleDetectionStrategy(CycleDetectionStrategy.LENIENT);//忽略循环，避免死循环  
  35.         config.registerJsonValueProcessor(Date.class, new JsonValueProcessor() {//处理Date日期转换  
  36.             @Override  
  37.             public Object processObjectValue(String arg0, Object arg1, JsonConfig arg2) {  
  38.                  SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");  
  39.                     Date d=(Date) arg1;  
  40.                     return sdf.format(d);  
  41.             }  
  42.             @Override  
  43.             public Object processArrayValue(Object arg0, JsonConfig arg1) {  
  44.                 return null;  
  45.             }  
  46.         });  
  47.     }  
  48.       
  49.     /**  
  50.      * java object convert to json string 
  51.      */    
  52.     public static String pojo2json(Object obj){  
  53.         return JSONObject.fromObject(obj,config).toString();//可以用toString(1)来实现格式化，便于阅读    
  54.     }    
  55.         
  56.     /**  
  57.      * array、map、Javabean convert to json string 
  58.      */    
  59.     public static String object2json(Object obj){    
  60.         return JSONSerializer.toJSON(obj).toString();    
  61.     }    
  62.         
  63.     /**  
  64.      * xml string convert to json string 
  65.      */    
  66.     public static String xml2json(String xmlString){    
  67.         XMLSerializer xmlSerializer = new XMLSerializer();    
  68.         JSON json = xmlSerializer.read(xmlString);    
  69.         return json.toString();    
  70.     }    
  71.         
  72.     /**  
  73.      * xml document convert to json string 
  74.      */    
  75.     public static String xml2json(Document xmlDocument){    
  76.         return xml2json(xmlDocument.toString());    
  77.     }    
  78.         
  79.     /**  
  80.      * json string convert to javaBean 
  81.      * @param <T> 
  82.      */    
  83.     @SuppressWarnings("unchecked")  
  84.     public static <T> T json2pojo(String jsonStr,Class<T> clazz){    
  85.         JSONObject jsonObj = JSONObject.fromObject(jsonStr);    
  86.         T obj = (T) JSONObject.toBean(jsonObj, clazz);    
  87.         return obj;    
  88.     }  
  89.       
  90.     /** 
  91.      * json string convert to map 
  92.      */  
  93.     public static Map<String,Object> json2map(String jsonStr){  
  94.         JSONObject jsonObj = JSONObject.fromObject(jsonStr);  
  95.         Map<String,Object> result = (Map<String, Object>) JSONObject.toBean(jsonObj, Map.class);  
  96.         return result;  
  97.     }  
  98.       
  99.     /** 
  100.      * json string convert to map with javaBean 
  101.      */  
  102.     public static <T> Map<String,T> json2map(String jsonStr,Class<T> clazz){  
  103.         JSONObject jsonObj = JSONObject.fromObject(jsonStr);  
  104.         Map<String,T> map = new HashMap<String, T>();  
  105.         Map<String,T> result = (Map<String, T>) JSONObject.toBean(jsonObj, Map.class, map);  
  106.         MorpherRegistry morpherRegistry = JSONUtils.getMorpherRegistry();  
  107.         Morpher dynaMorpher = new BeanMorpher(clazz,morpherRegistry);  
  108.         morpherRegistry.registerMorpher(dynaMorpher);  
  109.         morpherRegistry.registerMorpher(new DateMorpher(new String[]{ "yyyy-MM-dd HH:mm:ss" }));  
  110.         for (Entry<String,T> entry : result.entrySet()) {  
  111.             map.put(entry.getKey(), (T)morpherRegistry.morph(clazz, entry.getValue()));  
  112.         }  
  113.         return map;  
  114.     }  
  115.         
  116.     /**  
  117.      * json string convert to array 
  118.      */    
  119.     public static Object[] json2arrays(String jsonString) {    
  120.         JSONArray jsonArray = (JSONArray) JSONSerializer.toJSON(jsonString);  
  121. //      JSONArray jsonArray = JSONArray.fromObject(jsonString);    
  122.         JsonConfig jsonConfig = new JsonConfig();  
  123.         jsonConfig.setArrayMode(JsonConfig.MODE_OBJECT_ARRAY);  
  124.         Object[] objArray = (Object[]) JSONSerializer.toJava(jsonArray,jsonConfig);  
  125.         return objArray;  
  126.     }    
  127.         
  128.     /**  
  129.      * json string convert to list 
  130.      * @param <T> 
  131.      */    
  132.     @SuppressWarnings({ "unchecked", "deprecation" })  
  133.     public static <T> List<T> json2list(String jsonString, Class<T> pojoClass){    
  134.         JSONArray jsonArray = JSONArray.fromObject(jsonString);    
  135.         return JSONArray.toList(jsonArray, pojoClass);  
  136.     }    
  137.         
  138.     /**  
  139.      * object convert to xml string 
  140.      */    
  141.     public static String obj2xml(Object obj){    
  142.         XMLSerializer xmlSerializer = new XMLSerializer();    
  143.         return xmlSerializer.write(JSONSerializer.toJSON(obj));    
  144.     }    
  145.         
  146.     /**  
  147.      * json string convert to xml string 
  148.      */    
  149.     public static String json2xml(String jsonString){    
  150.         XMLSerializer xmlSerializer = new XMLSerializer();    
  151.         xmlSerializer.setTypeHintsEnabled(true);//是否保留元素类型标识，默认true  
  152.         xmlSerializer.setElementName("e");//设置元素标签，默认e  
  153.         xmlSerializer.setArrayName("a");//设置数组标签，默认a  
  154.         xmlSerializer.setObjectName("o");//设置对象标签，默认o  
  155.         return xmlSerializer.write(JSONSerializer.toJSON(jsonString));    
  156.     }  
  157.       
  158. }  

都是些比较常见的转换，写的不是很全，基本够用了，测试代码如下：

 

 

[java] view plaincopy
 
  1. import java.util.ArrayList;  
  2. import java.util.HashMap;  
  3. import java.util.List;  
  4. import java.util.Map;  
  5. import net.sf.ezmorph.test.ArrayAssertions;  
  6. import org.junit.Assert;  
  7. import org.junit.Test;  
  8.   
  9. public class JsonLibUtilsTest {  
  10.   
  11.     @Test  
  12.     public void pojo2json_test(){  
  13.         User user = new User(1, "张三");  
  14.         String json = JsonLibUtils.pojo2json(user);  
  15.         Assert.assertEquals("{\"id\":1,\"name\":\"张三\"}", json);  
  16.     }  
  17.       
  18.     @Test  
  19.     public void object2json_test(){  
  20.         int[] intArray = new int[]{1,4,5};  
  21.         String json = JsonLibUtils.object2json(intArray);  
  22.         Assert.assertEquals("[1,4,5]", json);  
  23.         User user1 = new User(1,"张三");  
  24.         User user2 = new User(2,"李四");  
  25.         User[] userArray = new User[]{user1,user2};  
  26.         String json2 = JsonLibUtils.object2json(userArray);  
  27.         Assert.assertEquals("[{\"id\":1,\"name\":\"张三\"},{\"id\":2,\"name\":\"李四\"}]", json2);  
  28.         List<User> userList = new ArrayList<>();  
  29.         userList.add(user1);  
  30.         userList.add(user2);  
  31.         String json3 = JsonLibUtils.object2json(userList);  
  32.         Assert.assertEquals("[{\"id\":1,\"name\":\"张三\"},{\"id\":2,\"name\":\"李四\"}]", json3);  
  33.         //这里的map的key必须为String类型  
  34.         Map<String,Object> map = new HashMap<>();  
  35.         map.put("id", 1);  
  36.         map.put("name", "张三");  
  37.         String json4 = JsonLibUtils.object2json(map);  
  38.         Assert.assertEquals("{\"id\":1,\"name\":\"张三\"}", json4);  
  39.         Map<String,User> map2 = new HashMap<>();  
  40.         map2.put("user1", user1);  
  41.         map2.put("user2", user2);  
  42.         String json5 = JsonLibUtils.object2json(map2);  
  43.         Assert.assertEquals("{\"user2\":{\"id\":2,\"name\":\"李四\"},\"user1\":{\"id\":1,\"name\":\"张三\"}}", json5);  
  44.     }  
  45.       
  46.     @Test  
  47.     public void xml2json_test(){  
  48.         String xml1 = "<User><id>1</id><name>张三</name></User>";  
  49.         String json = JsonLibUtils.xml2json(xml1);  
  50.         Assert.assertEquals("{\"id\":\"1\",\"name\":\"张三\"}", json);  
  51.         String xml2 = "<Response><CustID>1300000428</CustID><Items><Item><Sku_ProductNo>sku_0004</Sku_ProductNo></Item><Item><Sku_ProductNo>0005</Sku_ProductNo></Item></Items></Response>";  
  52.         String json2 = JsonLibUtils.xml2json(xml2);  
  53.         //处理数组时expected是处理结果，但不是我们想要的格式  
  54.         String expected = "{\"CustID\":\"1300000428\",\"Items\":[{\"Sku_ProductNo\":\"sku_0004\"},{\"Sku_ProductNo\":\"0005\"}]}";  
  55.         Assert.assertEquals(expected, json2);  
  56.         //实际上我们想要的是expected2这种格式,所以用json-lib来实现含有数组的xml to json是不行的  
  57.         String expected2 = "{\"CustID\":\"1300000428\",\"Items\":{\"Item\":[{\"Sku_ProductNo\":\"sku_0004\"},{\"Sku_ProductNo\":\"0005\"}]}}";  
  58.         Assert.assertEquals(expected2, json2);  
  59.     }  
  60.       
  61.     @Test  
  62.     public void json2arrays_test(){  
  63.         String json = "[\"张三\",\"李四\"]";  
  64.         Object[] array = JsonLibUtils.json2arrays(json);  
  65.         Object[] expected = new Object[] { "张三", "李四" };  
  66.         ArrayAssertions.assertEquals(expected, array);                                                                                              
  67.         //无法将JSON字符串转换为对象数组  
  68.         String json2 = "[{\"id\":1,\"name\":\"张三\"},{\"id\":2,\"name\":\"李四\"}]";  
  69.         Object[] array2 = JsonLibUtils.json2arrays(json2);  
  70.         User user1 = new User(1,"张三");  
  71.         User user2 = new User(2,"李四");  
  72.         Object[] expected2 = new Object[] { user1, user2 };  
  73.         ArrayAssertions.assertEquals(expected2, array2);  
  74.     }  
  75.       
  76.     @Test  
  77.     public void json2list_test(){  
  78.         String json = "[\"张三\",\"李四\"]";  
  79.         List<String> list = JsonLibUtils.json2list(json, String.class);  
  80.         Assert.assertTrue(list.size()==2&&list.get(0).equals("张三")&&list.get(1).equals("李四"));  
  81.         String json2 = "[{\"id\":1,\"name\":\"张三\"},{\"id\":2,\"name\":\"李四\"}]";  
  82.         List<User> list2 = JsonLibUtils.json2list(json2, User.class);  
  83.         Assert.assertTrue(list2.size()==2&&list2.get(0).getId()==1&&list2.get(1).getId()==2);  
  84.     }  
  85.       
  86.     @Test  
  87.     public void json2pojo_test(){  
  88.         String json = "{\"id\":1,\"name\":\"张三\"}";  
  89.         User user = (User) JsonLibUtils.json2pojo(json, User.class);  
  90.         Assert.assertEquals(json, user.toString());  
  91.     }  
  92.       
  93.     @Test  
  94.     public void json2map_test(){  
  95.         String json = "{\"id\":1,\"name\":\"张三\"}";  
  96.         Map map = JsonLibUtils.json2map(json);  
  97.         int id = Integer.parseInt(map.get("id").toString());  
  98.         String name = map.get("name").toString();  
  99.         System.out.println(name);  
  100.         Assert.assertTrue(id==1&&name.equals("张三"));  
  101.         String json2 = "{\"user2\":{\"id\":2,\"name\":\"李四\"},\"user1\":{\"id\":1,\"name\":\"张三\"}}";  
  102.         Map map2 = JsonLibUtils.json2map(json2, User.class);  
  103.         System.out.println(map2);  
  104.     }  
  105.       
  106.     @Test  
  107.     public void json2xml_test(){  
  108.         String json = "{\"id\":1,\"name\":\"张三\"}";  
  109.         String xml = JsonLibUtils.json2xml(json);  
  110.         Assert.assertEquals("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\r\n<o><id type=\"number\">1</id><name type=\"string\">张三</name></o>\r\n", xml);  
  111.         System.out.println(xml);  
  112.         String json2 = "[{\"id\":1,\"name\":\"张三\"},{\"id\":2,\"name\":\"李四\"}]";  
  113.         String xml2 = JsonLibUtils.json2xml(json2);  
  114.         System.out.println(xml2);  
  115.         Assert.assertEquals("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\r\n<a><e class=\"object\"><id type=\"number\">1</id><name type=\"string\">张三</name></e><e class=\"object\"><id type=\"number\">2</id><name type=\"string\">李四</name></e></a>\r\n", xml2);  
  116.     }  
  117.       
  118.     public static class User{  
  119.         private int id;  
  120.         private String name;  
  121.           
  122.         public User() {  
  123.         }  
  124.         public User(int id, String name) {  
  125.             this.id = id;  
  126.             this.name = name;  
  127.         }  
  128.         @Override  
  129.         public String toString() {  
  130.             return "{\"id\":"+id+",\"name\":\""+name+"\"}";  
  131.         }  
  132.         public int getId() {  
  133.             return id;  
  134.         }  
  135.         public void setId(int id) {  
  136.             this.id = id;  
  137.         }  
  138.         public String getName() {  
  139.             return name;  
  140.         }  
  141.         public void setName(String name) {  
  142.             this.name = name;  
  143.         }  
  144.     }  
  145. }  

json-lib在XML转换为JSON在有数组的情况下会有问题，还有在JSON转换为XML时都会有元素标识如<o><a><e>等，在一般情况下我们可能都不需要，暂时还不知道如何过滤这些元素名称。

 

 

因为json-lib的种种缺点，基本停止了更新，也不支持注解转换，后来便有了jackson流行起来，它比json-lib的转换效率要高很多，依赖很少，社区也比较活跃，它分为3个部分：

 

[plain] view plaincopy
 
  1. Streaming (docs) ("jackson-core") defines low-level streaming API, and includes JSON-specific implementations  
  2. Annotations (docs) ("jackson-annotations") contains standard Jackson annotations  
  3. Databind (docs) ("jackson-databind") implements data-binding (and object serialization) support on streaming package; it depends both on streaming and annotations packages  

我们依旧开始上代码，首先是它的依赖：

 

 

[plain] view plaincopy
 
  1.     <!-- for jackson -->  
  2. <dependency>  
  3.     <groupId>com.fasterxml.jackson.dataformat</groupId>  
  4.     <artifactId>jackson-dataformat-xml</artifactId>  
  5.     <version>2.1.3</version>  
  6. </dependency>  
  7. <dependency>  
  8.     <groupId>com.fasterxml.jackson.core</groupId>  
  9.     <artifactId>jackson-databind</artifactId>  
  10.     <version>2.1.3</version>  
  11.     <type>java-source</type>  
  12.     <scope>compile</scope>  
  13. </dependency>  

这里我要说下，有很多基于jackson的工具，大家可以按照自己的实际需求来需找对应的依赖，我这里为了方便转换xml所以用了dataformat-xml和databind

 

 

使用jackson实现多种转换：

 

[java] view plaincopy
 
  1. package cn.yangyong.fodder.util;  
  2.   
  3. import java.io.StringWriter;  
  4. import java.util.ArrayList;  
  5. import java.util.HashMap;  
  6. import java.util.List;  
  7. import java.util.Map;  
  8. import java.util.Map.Entry;  
  9.   
  10. import com.fasterxml.jackson.core.JsonGenerator;  
  11. import com.fasterxml.jackson.core.JsonParser;  
  12. import com.fasterxml.jackson.core.type.TypeReference;  
  13. import com.fasterxml.jackson.databind.JsonNode;  
  14. import com.fasterxml.jackson.databind.ObjectMapper;  
  15. import com.fasterxml.jackson.dataformat.xml.XmlMapper;  
  16.   
  17. /** 
  18.  * jsonson utils 
  19.  * @see http://jackson.codehaus.org/ 
  20.  * @see https://github.com/FasterXML/jackson 
  21.  * @see http://wiki.fasterxml.com/JacksonHome 
  22.  * @author magic_yy 
  23.  * 
  24.  */  
  25. public class JacksonUtils {  
  26.       
  27.     private static ObjectMapper objectMapper = new ObjectMapper();  
  28.     private static XmlMapper xmlMapper = new XmlMapper();  
  29.       
  30.     /** 
  31.      * javaBean,list,array convert to json string 
  32.      */  
  33.     public static String obj2json(Object obj) throws Exception{  
  34.         return objectMapper.writeValueAsString(obj);  
  35.     }  
  36.       
  37.     /** 
  38.      * json string convert to javaBean 
  39.      */  
  40.     public static <T> T json2pojo(String jsonStr,Class<T> clazz) throws Exception{  
  41.         return objectMapper.readValue(jsonStr, clazz);  
  42.     }  
  43.       
  44.     /** 
  45.      * json string convert to map 
  46.      */  
  47.     public static <T> Map<String,Object> json2map(String jsonStr)throws Exception{  
  48.         return objectMapper.readValue(jsonStr, Map.class);  
  49.     }  
  50.       
  51.     /** 
  52.      * json string convert to map with javaBean 
  53.      */  
  54.     public static <T> Map<String,T> json2map(String jsonStr,Class<T> clazz)throws Exception{  
  55.         Map<String,Map<String,Object>> map =  objectMapper.readValue(jsonStr, new TypeReference<Map<String,T>>() {  
  56.         });  
  57.         Map<String,T> result = new HashMap<String, T>();  
  58.         for (Entry<String, Map<String,Object>> entry : map.entrySet()) {  
  59.             result.put(entry.getKey(), map2pojo(entry.getValue(), clazz));  
  60.         }  
  61.         return result;  
  62.     }  
  63.       
  64.     /** 
  65.      * json array string convert to list with javaBean 
  66.      */  
  67.     public static <T> List<T> json2list(String jsonArrayStr,Class<T> clazz)throws Exception{  
  68.         List<Map<String,Object>> list = objectMapper.readValue(jsonArrayStr, new TypeReference<List<T>>() {  
  69.         });  
  70.         List<T> result = new ArrayList<>();  
  71.         for (Map<String, Object> map : list) {  
  72.             result.add(map2pojo(map, clazz));  
  73.         }  
  74.         return result;  
  75.     }  
  76.       
  77.     /** 
  78.      * map convert to javaBean 
  79.      */  
  80.     public static <T> T map2pojo(Map map,Class<T> clazz){  
  81.         return objectMapper.convertValue(map, clazz);  
  82.     }  
  83.       
  84.     /** 
  85.      * json string convert to xml string 
  86.      */  
  87.     public static String json2xml(String jsonStr)throws Exception{  
  88.         JsonNode root = objectMapper.readTree(jsonStr);  
  89.         String xml = xmlMapper.writeValueAsString(root);  
  90.         return xml;  
  91.     }  
  92.       
  93.     /** 
  94.      * xml string convert to json string 
  95.      */  
  96.     public static String xml2json(String xml)throws Exception{  
  97.         StringWriter w = new StringWriter();  
  98.         JsonParser jp = xmlMapper.getFactory().createParser(xml);  
  99.         JsonGenerator jg = objectMapper.getFactory().createGenerator(w);  
  100.         while (jp.nextToken() != null) {  
  101.             jg.copyCurrentEvent(jp);  
  102.         }  
  103.         jp.close();  
  104.         jg.close();  
  105.         return w.toString();  
  106.     }  
  107.       
  108. }  

只用了其中的一部分功能，有关annotation部分因为从没用到所以没写，大家可以自行研究下，我这里就不提了。jackson的测试代码如下：

 

 

[java] view plaincopy
 
  1. package cn.yangyong.fodder.util;  
  2.   
  3. import java.util.ArrayList;  
  4. import java.util.HashMap;  
  5. import java.util.List;  
  6. import java.util.Map;  
  7. import org.junit.Assert;  
  8. import org.junit.Test;  
  9. import cn.yangyong.fodder.util.JacksonUtils;  
  10.   
  11. public class JacksonUtilsTest {  
  12.   
  13.     @Test  
  14.     public void test_pojo2json() throws Exception{  
  15.         String json = JacksonUtils.obj2json(new User(1, "张三"));  
  16.         Assert.assertEquals("{\"id\":1,\"name\":\"张三\"}", json);  
  17.         List<User> list = new ArrayList<>();  
  18.         list.add(new User(1, "张三"));  
  19.         list.add(new User(2, "李四"));  
  20.         String json2 = JacksonUtils.obj2json(list);  
  21.         Assert.assertEquals("[{\"id\":1,\"name\":\"张三\"},{\"id\":2,\"name\":\"李四\"}]", json2);  
  22.         Map<String,User> map = new HashMap<>();  
  23.         map.put("user1", new User(1, "张三"));  
  24.         map.put("user2", new User(2, "李四"));  
  25.         String json3 = JacksonUtils.obj2json(map);  
  26.         Assert.assertEquals("{\"user2\":{\"id\":2,\"name\":\"李四\"},\"user1\":{\"id\":1,\"name\":\"张三\"}}", json3);  
  27.     }  
  28.       
  29.     @Test  
  30.     public void test_json2pojo() throws Exception{  
  31.         String json = "{\"id\":1,\"name\":\"张三\"}";  
  32.         User user = JacksonUtils.json2pojo(json, User.class);  
  33.         Assert.assertTrue(user.getId()==1&&user.getName().equals("张三"));  
  34.     }  
  35.       
  36.     @Test  
  37.     public void test_json2map() throws Exception{  
  38.         String json = "{\"id\":1,\"name\":\"张三\"}";  
  39.         Map<String,Object> map = JacksonUtils.json2map(json);  
  40.         Assert.assertEquals("{id=1, name=张三}", map.toString());  
  41.         String json2 = "{\"user2\":{\"id\":2,\"name\":\"李四\"},\"user1\":{\"id\":1,\"name\":\"张三\"}}";  
  42.         Map<String,User> map2 = JacksonUtils.json2map(json2, User.class);  
  43.         User user1 = map2.get("user1");  
  44.         User user2 = map2.get("user2");  
  45.         Assert.assertTrue(user1.getId()==1&&user1.getName().equals("张三"));  
  46.         Assert.assertTrue(user2.getId()==2&&user2.getName().equals("李四"));  
  47.     }  
  48.       
  49.     @Test  
  50.     public void test_json2list() throws Exception{  
  51.         String json = "[{\"id\":1,\"name\":\"张三\"},{\"id\":2,\"name\":\"李四\"}]";  
  52.         List<User> list = JacksonUtils.json2list(json,User.class);  
  53.         User user1 = list.get(0);  
  54.         User user2 = list.get(1);  
  55.         Assert.assertTrue(user1.getId()==1&&user1.getName().equals("张三"));  
  56.         Assert.assertTrue(user2.getId()==2&&user2.getName().equals("李四"));  
  57.     }  
  58.       
  59.     @Test  
  60.     public void test_map2pojo(){  
  61.         Map<String,Object> map = new HashMap<String, Object>();  
  62.         map.put("id", 1);  
  63.         map.put("name", "张三");  
  64.         User user = JacksonUtils.map2pojo(map, User.class);  
  65.         Assert.assertTrue(user.getId()==1&&user.getName().equals("张三"));  
  66.         System.out.println(user);  
  67.     }  
  68.       
  69.     @Test  
  70.     public void test_json2xml() throws Exception{  
  71.         String json = "{\"id\":1,\"name\":\"张三\"}";  
  72.         String xml = JacksonUtils.json2xml(json);  
  73.         Assert.assertEquals("<ObjectNode xmlns=\"\"><id>1</id><name>张三</name></ObjectNode>", xml);  
  74.         String json2 = "{\"Items\":{\"RequestInterfaceSku\":[{\"Sku_ProductNo\":\"sku_0004\"},{\"Sku_ProductNo\":\"sku_0005\"}]}}";  
  75.         String xml2 = JacksonUtils.json2xml(json2);  
  76.         Assert.assertEquals("<ObjectNode xmlns=\"\"><Items><RequestInterfaceSku><Sku_ProductNo>sku_0004</Sku_ProductNo></RequestInterfaceSku><RequestInterfaceSku><Sku_ProductNo>sku_0005</Sku_ProductNo></RequestInterfaceSku></Items></ObjectNode>", xml2);  
  77.     }  
  78.       
  79.     @Test  
  80.     public void test_xml2json() throws Exception{  
  81.         String xml = "<ObjectNode xmlns=\"\"><id>1</id><name>张三</name></ObjectNode>";  
  82.         String json = JacksonUtils.xml2json(xml);  
  83.         Assert.assertEquals("{\"id\":1,\"name\":\"张三\"}", json);  
  84.         String xml2 = "<ObjectNode xmlns=\"\"><Items><RequestInterfaceSku><Sku_ProductNo>sku_0004</Sku_ProductNo></RequestInterfaceSku><RequestInterfaceSku><Sku_ProductNo>sku_0005</Sku_ProductNo></RequestInterfaceSku></Items></ObjectNode>";  
  85.         String json2 = JacksonUtils.xml2json(xml2);  
  86.         //expected2是我们想要的格式，但实际结果确实expected1，所以用jackson实现xml直接转换为json在遇到数组时是不可行的  
  87.         String expected1 = "{\"Items\":{\"RequestInterfaceSku\":{\"Sku_ProductNo\":\"sku_0004\"},\"RequestInterfaceSku\":{\"Sku_ProductNo\":\"sku_0005\"}}}";  
  88.         String expected2 = "{\"Items\":{\"RequestInterfaceSku\":[{\"Sku_ProductNo\":\"sku_0004\"},{\"Sku_ProductNo\":\"sku_0005\"}]}}";  
  89.         Assert.assertEquals(expected1, json2);  
  90.         Assert.assertEquals(expected2, json2);  
  91.     }  
  92.       
  93.     private static class User{  
  94.         private int id;  
  95.         private String name;   
  96.           
  97.         public User() {  
  98.         }  
  99.         public User(int id, String name) {  
  100.             this.id = id;  
  101.             this.name = name;  
  102.         }  
  103.         @Override  
  104.         public String toString() {  
  105.             return "{\"id\":"+id+",\"name\":\""+name+"\"}";  
  106.         }  
  107.         public int getId() {  
  108.             return id;  
  109.         }  
  110.         public void setId(int id) {  
  111.             this.id = id;  
  112.         }  
  113.         public String getName() {  
  114.             return name;  
  115.         }  
  116.         public void setName(String name) {  
  117.             this.name = name;  
  118.         }  
  119.     }  
  120. }  

测试后发现xml转换为json时也有问题，居然不认识数组，真是悲剧。好吧就由它吧，也可能是我的方法不正确。

 


jackson一直很主流，社区和文档支持也很充足，但有人还是嫌它不够快，不够简洁，于是便有了fastjson，看名字就知道它的主要特点就是快，可能在功能和其他支持方面不能和jackson媲美，但天下武功，唯快不破，这就决定了fastjson有了一定的市场。不解释，直接上代码。

 

[plain] view plaincopy
 
  1. <!-- for fastjson -->  
  2. <dependency>  
  3.     <groupId>com.alibaba</groupId>  
  4.     <artifactId>fastjson</artifactId>  
  5.     <version>1.1.33</version>  
  6. </dependency>  

沃，除了自身零依赖，再看它的API使用。
使用fastjson实现多种转换：

 

 

[java] view plaincopy
 
  1. package cn.yangyong.fodder.util;  
  2.   
  3. import java.util.Date;  
  4. import java.util.List;  
  5. import java.util.Map;  
  6. import java.util.Map.Entry;  
  7. import com.alibaba.fastjson.JSON;  
  8. import com.alibaba.fastjson.JSONObject;  
  9. import com.alibaba.fastjson.TypeReference;  
  10. import com.alibaba.fastjson.serializer.SerializeConfig;  
  11. import com.alibaba.fastjson.serializer.SimpleDateFormatSerializer;  
  12.   
  13. /** 
  14.  * fastjson utils 
  15.  *  
  16.  * @author magic_yy 
  17.  * @see https://github.com/alibaba/fastjson 
  18.  * @see http://code.alibabatech.com/wiki/display/FastJSON 
  19.  */  
  20. public class FastJsonUtils {  
  21.       
  22.     private static SerializeConfig mapping = new SerializeConfig();  
  23.       
  24.     static{  
  25.         mapping.put(Date.class, new SimpleDateFormatSerializer("yyyy-MM-dd HH:mm:ss"));  
  26.     }  
  27.       
  28.     /** 
  29.      * javaBean、list、map convert to json string 
  30.      */  
  31.     public static String obj2json(Object obj){  
  32. //      return JSON.toJSONString(obj,SerializerFeature.UseSingleQuotes);//使用单引号  
  33. //      return JSON.toJSONString(obj,true);//格式化数据，方便阅读  
  34.         return JSON.toJSONString(obj,mapping);  
  35.     }  
  36.       
  37.     /** 
  38.      * json string convert to javaBean、map 
  39.      */  
  40.     public static <T> T json2obj(String jsonStr,Class<T> clazz){  
  41.         return JSON.parseObject(jsonStr,clazz);  
  42.     }  
  43.       
  44.     /** 
  45.      * json array string convert to list with javaBean 
  46.      */  
  47.     public static <T> List<T> json2list(String jsonArrayStr,Class<T> clazz){  
  48.         return JSON.parseArray(jsonArrayStr, clazz);  
  49.     }  
  50.       
  51.     /** 
  52.      * json string convert to map 
  53.      */  
  54.     public static <T> Map<String,Object> json2map(String jsonStr){  
  55.         return json2obj(jsonStr, Map.class);  
  56.     }  
  57.       
  58.     /** 
  59.      * json string convert to map with javaBean 
  60.      */  
  61.     public static <T> Map<String,T> json2map(String jsonStr,Class<T> clazz){  
  62.         Map<String,T> map = JSON.parseObject(jsonStr, new TypeReference<Map<String, T>>() {});  
  63.         for (Entry<String, T> entry : map.entrySet()) {  
  64.             JSONObject obj = (JSONObject) entry.getValue();  
  65.             map.put(entry.getKey(), JSONObject.toJavaObject(obj, clazz));  
  66.         }  
  67.         return map;  
  68.     }  
  69. }  

API真的很简洁，很方便，这里依旧只用了部分功能，关于注解部分请大家自行研究。测试代码如下：

 

 

[java] view plaincopy
 
  1. package cn.yangyong.fodder.util;  
  2.   
  3. import java.text.SimpleDateFormat;  
  4. import java.util.ArrayList;  
  5. import java.util.Date;  
  6. import java.util.HashMap;  
  7. import java.util.List;  
  8. import java.util.Map;  
  9.   
  10. import org.junit.Assert;  
  11. import org.junit.Test;  
  12.   
  13. public class FastJsonTest {  
  14.       
  15.     @Test  
  16.     public void test_dateFormat(){  
  17.         Date date = new Date();  
  18.         String json = FastJsonUtils.obj2json(date);  
  19.         String expected = "\""+new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(date)+"\"";  
  20.         Assert.assertEquals(expected, json);  
  21.     }  
  22.       
  23.     @Test  
  24.     public void test_obj2json(){  
  25.         User user = new User(1, "张三");  
  26.         String json = FastJsonUtils.obj2json(user);  
  27.         Assert.assertEquals("{\"id\":1,\"name\":\"张三\"}", json);  
  28.         List<User> list = new ArrayList<>();  
  29.         list.add(new User(1, "张三"));  
  30.         list.add(new User(2, "李四"));  
  31.         String json2 = FastJsonUtils.obj2json(list);  
  32.         Assert.assertEquals("[{\"id\":1,\"name\":\"张三\"},{\"id\":2,\"name\":\"李四\"}]", json2);  
  33.         Map<String,User> map = new HashMap<>();  
  34.         map.put("user1", new User(1, "张三"));  
  35.         map.put("user2", new User(2, "李四"));  
  36.         String json3 = FastJsonUtils.obj2json(map);  
  37.         Assert.assertEquals("{\"user1\":{\"id\":1,\"name\":\"张三\"},\"user2\":{\"id\":2,\"name\":\"李四\"}}", json3);  
  38.     }  
  39.       
  40.     @Test  
  41.     public void test_json2obj(){  
  42.         String json = "{\"id\":1,\"name\":\"张三\"}";  
  43.         User user = FastJsonUtils.json2obj(json, User.class);  
  44.         Assert.assertTrue(user.getId()==1&&user.getName().equals("张三"));  
  45.     }  
  46.       
  47.     @Test  
  48.     public void test_json2list(){  
  49.         String json = "[{\"id\":1,\"name\":\"张三\"},{\"id\":2,\"name\":\"李四\"}]";  
  50.         List<User> list = FastJsonUtils.json2list(json, User.class);  
  51.         User user1 = list.get(0);  
  52.         User user2 = list.get(1);  
  53.         Assert.assertTrue(user1.getId()==1&&user1.getName().equals("张三"));  
  54.         Assert.assertTrue(user2.getId()==2&&user2.getName().equals("李四"));  
  55.     }  
  56.       
  57.     @Test  
  58.     public void test_json2map() throws Exception{  
  59.         String json = "{\"id\":1,\"name\":\"张三\"}";  
  60.         Map<String,Object> map = FastJsonUtils.json2map(json);  
  61.         Assert.assertEquals("{id=1, name=张三}", map.toString());  
  62.         String json2 = "{\"user2\":{\"id\":2,\"name\":\"李四\"},\"user1\":{\"id\":1,\"name\":\"张三\"}}";  
  63.         Map<String,User> map2 = FastJsonUtils.json2map(json2, User.class);  
  64.         User user1 = map2.get("user1");  
  65.         User user2 = map2.get("user2");  
  66.         Assert.assertTrue(user1.getId()==1&&user1.getName().equals("张三"));  
  67.         Assert.assertTrue(user2.getId()==2&&user2.getName().equals("李四"));  
  68.     }  
  69.       
  70.     private static class User{  
  71.         private int id;  
  72.         private String name;   
  73.           
  74.         public User() {  
  75.         }  
  76.         public User(int id, String name) {  
  77.             this.id = id;  
  78.             this.name = name;  
  79.         }  
  80.         @Override  
  81.         public String toString() {  
  82.             return "{\"id\":"+id+",\"name\":\""+name+"\"}";  
  83.         }  
  84.         public int getId() {  
  85.             return id;  
  86.         }  
  87.         public void setId(int id) {  
  88.             this.id = id;  
  89.         }  
  90.         public String getName() {  
  91.             return name;  
  92.         }  
  93.         public void setName(String name) {  
  94.             this.name = name;  
  95.         }  
  96.     }  
  97.       
  98. }  

只有json和javaBean直接的相互转换，没有xml的转换，真可惜。好吧，谁叫人家定位不一样呢，要想功能全还是用jackson吧。

 

 

最后给大家介绍下json和xml之间不依赖javaBean直接相互转换的工具staxon，相比很多时候大家都想动态的将json和xml相互转换却不依赖其他javaBean，自己写真的是很麻烦，要人命，用jackson等其他转换工具时结果都不是我想要的

比如有下面xml和json，他们是等价的：

 

[plain] view plaincopy
 
  1. <Response>  
  2.     <CustID>1300000428</CustID>  
  3.     <CompID>1100000324</CompID>  
  4.     <Items>  
  5.         <Item>  
  6.             <Sku_ProductNo>sku_0004</Sku_ProductNo>  
  7.             <Wms_Code>1700386977</Wms_Code>  
  8.             <Sku_Response>T</Sku_Response>  
  9.             <Sku_Reason></Sku_Reason>  
  10.         </Item>  
  11.         <Item>  
  12.             <Sku_ProductNo>0005</Sku_ProductNo>  
  13.             <Wms_Code>1700386978</Wms_Code>  
  14.             <Sku_Response>T</Sku_Response>  
  15.             <Sku_Reason></Sku_Reason>  
  16.         </Item>  
  17.     </Items>  
  18. </Response>  

 

 

[plain] view plaincopy
 
  1. {  
  2.     "Response" : {  
  3.         "CustID" : 1300000428,  
  4.         "CompID" : 1100000324,  
  5.         "Items" : {  
  6.             "Item" : [ {  
  7.                 "Sku_ProductNo" : "sku_0004",  
  8.                 "Wms_Code" : 1700386977,  
  9.                 "Sku_Response" : "T",  
  10.                 "Sku_Reason" : null  
  11.             }, {  
  12.                 "Sku_ProductNo" : "0005",  
  13.                 "Wms_Code" : 1700386978,  
  14.                 "Sku_Response" : "T",  
  15.                 "Sku_Reason" : null  
  16.             } ]  
  17.         }  
  18.     }  
  19. }  

 

 

下面我们使用staxon来实现上面2种互转

 

[plain] view plaincopy
 
  1.       <!-- for staxon -->  
  2. lt;dependency>  
  3. <groupId>de.odysseus.staxon</groupId>  
  4. <artifactId>staxon</artifactId>  
  5. <version>1.2</version>  
  6. lt;/dependency>  

嗯，没有第三方依赖，上转换代码：

 

 

[java] view plaincopy
 
  1. package cn.yangyong.fodder.util;  
  2.   
  3. import java.io.IOException;  
  4. import java.io.StringReader;  
  5. import java.io.StringWriter;  
  6.   
  7. import javax.xml.stream.XMLEventReader;  
  8. import javax.xml.stream.XMLEventWriter;  
  9. import javax.xml.stream.XMLInputFactory;  
  10. import javax.xml.stream.XMLOutputFactory;  
  11.   
  12. import de.odysseus.staxon.json.JsonXMLConfig;  
  13. import de.odysseus.staxon.json.JsonXMLConfigBuilder;  
  14. import de.odysseus.staxon.json.JsonXMLInputFactory;  
  15. import de.odysseus.staxon.json.JsonXMLOutputFactory;  
  16. import de.odysseus.staxon.xml.util.PrettyXMLEventWriter;  
  17.   
  18. /** 
  19.  * json and xml converter 
  20.  * @author magic_yy 
  21.  * @see https://github.com/beckchr/staxon 
  22.  * @see https://github.com/beckchr/staxon/wiki 
  23.  * 
  24.  */  
  25. public class StaxonUtils {  
  26.       
  27.     /** 
  28.      * json string convert to xml string 
  29.      */  
  30.     public static String json2xml(String json){  
  31.         StringReader input = new StringReader(json);  
  32.         StringWriter output = new StringWriter();  
  33.         JsonXMLConfig config = new JsonXMLConfigBuilder().multiplePI(false).repairingNamespaces(false).build();  
  34.         try {  
  35.             XMLEventReader reader = new JsonXMLInputFactory(config).createXMLEventReader(input);  
  36.             XMLEventWriter writer = XMLOutputFactory.newInstance().createXMLEventWriter(output);  
  37.             writer = new PrettyXMLEventWriter(writer);  
  38.             writer.add(reader);  
  39.             reader.close();  
  40.             writer.close();  
  41.         } catch( Exception e){  
  42.             e.printStackTrace();  
  43.         } finally {  
  44.             try {  
  45.                 output.close();  
  46.                 input.close();  
  47.             } catch (IOException e) {  
  48.                 e.printStackTrace();  
  49.             }  
  50.         }  
  51.         if(output.toString().length()>=38){//remove <?xml version="1.0" encoding="UTF-8"?>  
  52.             return output.toString().substring(39);  
  53.         }  
  54.         return output.toString();  
  55.     }  
  56.       
  57.     /** 
  58.      * xml string convert to json string 
  59.      */  
  60.     public static String xml2json(String xml){  
  61.         StringReader input = new StringReader(xml);  
  62.         StringWriter output = new StringWriter();  
  63.         JsonXMLConfig config = new JsonXMLConfigBuilder().autoArray(true).autoPrimitive(true).prettyPrint(true).build();  
  64.         try {  
  65.             XMLEventReader reader = XMLInputFactory.newInstance().createXMLEventReader(input);  
  66.             XMLEventWriter writer = new JsonXMLOutputFactory(config).createXMLEventWriter(output);  
  67.             writer.add(reader);  
  68.             reader.close();  
  69.             writer.close();  
  70.         } catch( Exception e){  
  71.             e.printStackTrace();  
  72.         } finally {  
  73.             try {  
  74.                 output.close();  
  75.                 input.close();  
  76.             } catch (IOException e) {  
  77.                 e.printStackTrace();  
  78.             }  
  79.         }  
  80.         return output.toString();  
  81.     }  
  82. }  

当然，这里我也就只用到了它的部分功能，最主要的还是json和xml直接的转换了撒。其他功能自己看咯，不多做介绍了。测试代码如下：

 

 

[java] view plaincopy
 
  1. package cn.yangyong.fodder.util;  
  2.   
  3. import org.junit.Test;  
  4.   
  5. public class StaxonUtilsTest {  
  6.       
  7.     @Test  
  8.     public void test_json2xml(){  
  9.         String json = "{\"Response\" : {\"CustID\" : 1300000428,\"CompID\" : 1100000324,\"Items\" : {\"Item\" : [ {\"Sku_ProductNo\" : \"sku_0004\",\"Wms_Code\" : 1700386977,\"Sku_Response\" : \"T\",\"Sku_Reason\" : null}, {\"Sku_ProductNo\" : \"0005\",\"Wms_Code\" : 1700386978,\"Sku_Response\" : \"T\",\"Sku_Reason\" : null}]}}}";  
  10.         String xml = StaxonUtils.json2xml(json);  
  11.         System.out.println(xml);  
  12.     }  
  13.       
  14.     @Test  
  15.     public void test_xml2json(){  
  16.         String xml = "<Response><CustID>1300000428</CustID><CompID>1100000324</CompID><Items><Item><Sku_ProductNo>sku_0004</Sku_ProductNo><Wms_Code>1700386977</Wms_Code><Sku_Response>T</Sku_Response><Sku_Reason></Sku_Reason></Item><Item><Sku_ProductNo>0005</Sku_ProductNo><Wms_Code>1700386978</Wms_Code><Sku_Response>T</Sku_Response><Sku_Reason></Sku_Reason></Item></Items></Response>";  
  17.         String json = StaxonUtils.xml2json(xml);  
  18.         System.out.println(json);  
  19.     }  
  20. }  

 

 

 

 

json、javaBean、xml互转的几种工具介绍 （转载）,布布扣,bubuko.com

json、javaBean、xml互转的几种工具介绍 （转载）

上一篇：排序算法(1) 快速排序 C++实现


下一篇：spring中集成使用jedis（2）