XStream 用法总结

 XStream是一个Java对象和XML相互转换的工具,很好很强大。提供了所有的基础类型、数组、集合等类型直接转换的支持。因此XML常用于数据交换、对象序列化(这种序列化和Java对象的序列化技术有着本质的区别)。
        XStream对象相当Java对象和XML之间的转换器,转换过程是双向的。创建XSteam对象的方式很简单,只需要new XStream()即可。
              Java到xml,用toXML()方法。  
              Xml到Java,用fromXML()方法。 

      在没有任何设置默认情况下,java到xml的映射,是java成员名对应xml的元素名,java类的全名对应xml根元素的名字。而实际中,往往是xml和java类都有了,要完成相互转换,必须进行别名映射。

别名配置包含三种情况: 
1、类别名,用alias(String name, Class type)。 
2、类成员别名,用aliasField(String alias, Class definedIn, String fieldName) 
3、类成员作为属性别名,用 aliasAttribute(Class definedIn, String attributeName, String alias),单独命名没有意义,还要通过useAttributeFor(Class definedIn, String fieldName) 应用到某个类上。
别名的配置是非常重要的,但是其中有些细节问题很重要,在例子中会专门做详细说明。 

另外还有不太常用的方法: 
addImplicitCollection(Class ownerType, String fieldName),去掉集合类型生成xml的父节点。 
registerConverter(Converter converter) ,注册一个转换器。 

如果你的xml很大,或者为了安全性,以流的方式传输,那么XStream也提供丰富的API, 

如果这些基本的操作还不能满足你应用的需求,XStream提供丰富的扩展点。你可以实现自己的转换器。还可以利用XStream完成更负责的功能,比如输出其他非xml格式的数据,还可以输出html,还支持XML Dom类型数据,这些应用起来稍微复杂些。当然这些不是XStream应用的重点,也不用理会,真正需要的时候再查看API和源码研究研究。

XStream的优点很多,但是也有一些小bug,比如在定义别名中的下划线“_”转换为xml后会变成“__”这个符号,很变态。因此,尽量避免在别名中实用任何符号,却是需要下划线的时候,可以考虑实用连接符“-”,这个没有问题。  

另外,我们的Java Bean中,常常有一些常量,在转换过程,XStream也会将这些常量转换过去,形成常量的xml节点,这显然不是想要的结果,对于常量字段,就不做转换了。

下面给出一个非常典型的而且实用的例子,作为对总结的补充: 

[java]  view plain  copy
 print ?
  1. import java.util.List;  
  2.   
  3. public class Person {  
  4.     private String name;  
  5.     private String age;  
  6.     private Profile profile;  
  7.     private List
     addlist;  
  8.   
  9.     public Person(String name, String age, Profile profile, List
     addlist) {  
  10.         this.name = name;  
  11.         this.age = age;  
  12.         this.profile = profile;  
  13.         this.addlist = addlist;  
  14.     }  
  15.   
  16.     public String toString() {  
  17.         return "Person{" + "name='" + name + '\'' + ", age='" + age + '\'' + ", profile=" + profile + ", addlist=" + addlist + '}';  
  18.     }  
  19.   
  20. }  
[java]  view plain  copy
 print ?
  1. public class Profile {  
  2.     private String job;  
  3.     private String tel;  
  4.     private String remark;  
  5.   
  6.     public Profile(String job, String tel, String remark) {  
  7.         this.job = job;  
  8.         this.tel = tel;  
  9.         this.remark = remark;  
  10.     }  
  11.   
  12.     public String toString() {  
  13.         return "Profile{" + "job='" + job + '\'' + ", tel='" + tel + '\'' + ", remark='" + remark + '\'' + '}';  
  14.     }  
  15.   
  16. }  
[java]  view plain  copy
 print ?
  1. import java.util.List;  
  2.   
  3. public class Person {  
  4.     private String name;  
  5.     private String age;  
  6.     private Profile profile;  
  7.     private List
     addlist;  
  8.   
  9.     public Person(String name, String age, Profile profile, List
     addlist) {  
  10.         this.name = name;  
  11.         this.age = age;  
  12.         this.profile = profile;  
  13.         this.addlist = addlist;  
  14.     }  
  15.   
  16.     public String toString() {  
  17.         return "Person{" + "name='" + name + '\'' + ", age='" + age + '\'' + ", profile=" + profile + ", addlist=" + addlist + '}';  
  18.     }  
  19.   
  20. }  
[java]  view plain  copy
 print ?
  1. import java.util.ArrayList;  
  2. import java.util.List;  
  3.   
  4. import com.thoughtworks.xstream.XStream;  
  5. import com.thoughtworks.xstream.io.xml.DomDriver;  
  6.   
  7. public class TestXStream {  
  8.   
  9.     public static void main(String args[]) {  
  10.         Address address1 = new Address("郑州市经三路""450001");  
  11.         Address address2 = new Address("北京市海淀区""100000");  
  12.         List
     addList = new ArrayList
    ();  
  13.         addList.add(address1);  
  14.         addList.add(address2);  
  15.         Profile profile = new Profile("软件工程师""13051594850""备注说明");  
  16.         Person person = new Person("X-rapido""22", profile, addList);  
  17.   
  18.         // 转换装配  
  19.         XStream xStream = new XStream(new DomDriver());  
  20.   
  21.         /************** 设置类别名,不设默认类全路径 ****************/  
  22.         xStream.alias("PERSON", Person.class);  
  23.         xStream.alias("PROFILE", Profile.class);  
  24.         xStream.alias("ADDRESS", Address.class);  
  25.           
  26.         String xml = xStream.toXML(person);  
  27.         System.out.println("----------------第1次输出, 设置类别名---------------- \n"+ xml + "\n");  
  28.   
  29.         /************* 设置类成员的别名 ***************/  
  30.         // 设置Person类的name成员别名Name  
  31.         xStream.aliasField("Name", Person.class"name");  
  32.         /* 
  33.          * [注意] 设置Person类的profile成员别名PROFILE,这个别名和Profile类的别名一致, 
  34.          * 这样可以保持XStream对象可以从profile成员生成的xml片段直接转换为Profile成员, 
  35.          * 如果成员profile的别名和Profile的别名不一致,则profile成员生成的xml片段不可 
  36.          * 直接转换为Profile对象,需要重新创建XStream对象,这岂不给自己找麻烦? 
  37.          */  
  38.         xStream.aliasField("PROFILE", Person.class"profile");  
  39.         xStream.aliasField("ADDLIST", Person.class"addlist");  
  40.         xStream.aliasField("Add", Address.class"add");  
  41.         xStream.aliasField("Job", Profile.class"job");  
  42.           
  43.         String xml2 = xStream.toXML(person);  
  44.         System.out.println("----------------第2次输出, 设置类、字段别名---------------- \n"+ xml2 + "\n");  
  45.   
  46.           
  47.         /******* 设置类成员为xml一个元素上的属性 *******/  
  48.         xStream.useAttributeFor(Address.class"zipcode");  
  49.         /************* 设置属性的别名 ***************/  
  50.         xStream.aliasAttribute(Address.class"zipcode""Zipcode");  
  51.           
  52.         String xml3 = xStream.toXML(person);  
  53.         System.out.println("----------------第3次输出, 设置类、字段别名,并在xml字段节点上增加属性---------------- \n"+ xml3 + "\n");  
  54.   
  55.           
  56.         /************* 将xml转为java对象 ******× ****/  
  57.          String person_xml = "\n" +    
  58.                             "  熔岩\n" +    
  59.                             "  27\n" +    
  60.                             "  \n" +    
  61.                             "    软件工程师\n" +    
  62.                             "    13512129933\n" +    
  63.                             "    备注说明\n" +    
  64.                             "  \n" +    
  65.                             "  \n" +    
  66.                             "    \n" +    
  67.                             "      郑州市经三路\n" +    
  68.                             "    \n" +    
  69.                             "    \n" +    
  70.                             "      西安市雁塔路\n" +    
  71.                             "    \n" +    
  72.                             "  \n" +    
  73.                             "";    
  74.         String profile_xml = "\n" +    
  75.                             "    软件工程师\n" +    
  76.                             "    13512129933\n" +    
  77.                             "    备注说明\n" +    
  78.                             " ";    
  79.         String address_xml = "\n" +    
  80.                             "      西安市雁塔路\n" +    
  81.                             " ";    
  82.   
  83.         // 同样使用上面的XStream对象将xml转换为Java对象  
  84.         System.out.println(xStream.fromXML(person_xml).toString());  
  85.         System.out.println(xStream.fromXML(profile_xml).toString());  
  86.         System.out.println(xStream.fromXML(address_xml).toString());  
  87.     }  
  88.       
  89. }  
xStream.toXML()和xStream.fromXML()的常用方法

XStream 用法总结_第1张图片
XStream 用法总结_第2张图片

比如写入文件方法

[java]  view plain  copy
 print ?
  1. FileOutputStream fs = new FileOutputStream("d:/employeedata.txt");  
  2. xs.toXML(e, fs);  
读取

[java]  view plain  copy
 print ?
  1. public static void main(String[] args) {  
  2.     XStream xs = new XStream(new DomDriver());  
  3.     Employee e = new Employee();  
  4.     try {  
  5.         FileInputStream fis = new FileInputStream("d:/employeedata.txt");  
  6.         xs.fromXML(fis, e);  
  7.           
  8.         // 打印从对象已被读取的数据  
  9.         System.out.println(e.toString());  
  10.     } catch (FileNotFoundException ex) {  
  11.         ex.printStackTrace();  
  12.     }  
  13. }  
[java]  view plain  copy
 print ?
  1. public static void main(String[] args) {  
  2.     Employee e = new Employee();  
  3.     e.setName("X-rapido");  
  4.     e.setDesignation("Manager");  
  5.     e.setDepartment("法国");  
  6.   
  7.     XStream xs = new XStream();  
  8.     try {  
  9.         FileOutputStream fs = new FileOutputStream("d:/employeedata.txt");  
  10.         xs.toXML(e, fs);  
  11.           
  12.         System.out.println("XML写入成功");  
  13.     } catch (FileNotFoundException e1) {  
  14.         e1.printStackTrace();  
  15.     }  
  16. }  

在实际中,类的属性很多,嵌套层次也很复杂,如果仅仅使用XStream原生API来硬编码设置别名等属性,显得太生硬也难以维护。完全可以考虑通过一个xml配置文件来定义所有用到的类的别名定义(包括其成员),然后,通过读取配置构建一个XStream的工厂,在用到时候直接去取,而不是让实用者组装。我目前的一个项目中,就是这么实现的,效果非常的好。

下面我给出针对上面提出的问题一个解决方案: 

思想:考虑做一个过滤器,在xml转java之前,在Java转xml之后,应用这个过滤器。这个过滤器提供将xml中的“__”替换为“-”,并且将xml中的不需要的节点剔除。
在过滤之前,我实现了个转换器装配,这一步通过xml来配置,并在java中获取。 
代码就省略了,这一步很灵活,关键看你的应用了。 

[html]  view plain  copy
 print ?
  1. // 解决XStream对出现双下划线的bug  
  2. XStream xStreamForRequestPostData = new XStream(new DomDriver("UTF-8", new XmlFriendlyNameCoder("-_", "_")));  
为了能过滤xml,我们需要用Dom4j递归遍历xml文档。下面一些算法代码: 

[java]  view plain  copy
 print ?
  1. //递归算法:遍历配置文件,找出所有有效的xpath    
  2. private static void recursiveElement(Element element) {    
  3.     List elements = element.elements();    
  4.     validXPathList.add(element.getPath());    
  5.     if (elements.size() == 0) {    
  6.         //没有子元素    
  7.     } else {    
  8.         //有子元素    
  9.         for (Iterator it = elements.iterator(); it.hasNext();) {    
  10.             //递归遍历    
  11.             recursiveElement(it.next());    
  12.         }    
  13.     }    
  14. }    
  15.   
  16. //递归算法:遍历xml,标识无效的元素节点    
  17. private static void recursiveFixElement(Element element) {    
  18.     List elements = element.elements();    
  19.     if (!validXPathList.contains(element.getPath())) {    
  20.         element.addAttribute("delete""true");    
  21.     }    
  22.     if (elements.size() == 0) {    
  23.         //没有子元素    
  24.     } else {    
  25.         //有子元素    
  26.         for (Iterator it = elements.iterator(); it.hasNext();) {    
  27.             Element e = it.next();    
  28.             if (!validXPathList.contains(e.getPath())) {    
  29.                 e.addAttribute("delete""true");    
  30.             }    
  31.             //递归遍历    
  32.             recursiveFixElement(e);    
  33.         }    
  34.     }    
  35. }    
  36.   
  37. /**   
  38.  * 过滤器接口方法,转换不规范字符,剔除无效节点   
  39.  *   
  40.  * @param xmlStr 要过滤的xml   
  41.  * @return 符合转换器要求的xml   
  42.  */    
  43. public static String filter(String xmlStr) {    
  44.     Document document = null;    
  45.     try {    
  46.         document = DocumentHelper.parseText(xmlStr.replaceAll("__""_"));    
  47.         //递归的调用:标记要剔除的xml元素    
  48.         recursiveFixElement(document.getRootElement());         
  49.         List nodeList = document.selectNodes("//@delete");    
  50.         for (Node node : nodeList) {    
  51.             node.getParent().detach();  //剔除xml元素    
  52.         }    
  53.     } catch (DocumentException e) {    
  54.         System.out.println(e.getMessage());    
  55.         e.printStackTrace();    
  56.     }    
  57.     return document.asXML();    
  58. }   
输出内容如下

[plain]  view plain  copy
 print ?
  1. ----------------第1次输出, 设置类别名----------------   
  2.   
  3.   X-rapido  
  4.   22  
  5.     
  6.     软件工程师  
  7.     13051594850  
  8.     备注说明  
  9.     
  10.     
  11.     
      
  12.       郑州市经三路  
  13.       450001  
  14.       
  15.     
      
  16.       北京市海淀区  
  17.       100000  
  18.       
  19.     
  20.   
  21.   
  22. ----------------第2次输出, 设置类、字段别名----------------   
  23.   
  24.   X-rapido  
  25.   22  
  26.     
  27.     软件工程师  
  28.     13051594850  
  29.     备注说明  
  30.     
  31.     
  32.     
      
  33.       郑州市经三路  
  34.       450001  
  35.       
  36.     
      
  37.       北京市海淀区  
  38.       100000  
  39.       
  40.     
  41.   
  42.   
  43. ----------------第3次输出, 设置类、字段别名,并在xml字段节点上增加属性----------------   
  44.   
  45.   X-rapido  
  46.   22  
  47.     
  48.     软件工程师  
  49.     13051594850  
  50.     备注说明  
  51.     
  52.     
  53.       
  54.       郑州市经三路  
  55.       
  56.       
  57.       北京市海淀区  
  58.       
  59.     
  60.   
  61.   
  62. Person{name='熔岩', age='27', profile=Profile{job='软件工程师', tel='13512129933', remark='备注说明'}, addlist=[Address{add='郑州市经三路', zipcode='450001'}, Address{add='西安市雁塔路', zipcode='710002'}]}  
  63. Profile{job='软件工程师', tel='13512129933', remark='备注说明'}  
  64. Address{add='西安市雁塔路', zipcode='710002'}  
转换装配方式有几种,比如上面代码中使用是DomDriver方式,也有StaxDriver方式,等默认XppDriver方式,但是xpp方式经常解析xml会出错,比如将上面的代码修改

[java]  view plain  copy
 print ?
  1. // 转换装配  
  2. // XStream xStream = new XStream(new DomDriver());  
  3.    XStream xStream = new XStream(new StaxDriver());  
解析的输出就变成以下结果

[plain]  view plain  copy
 print ?
  1. ----------------第1次输出, 设置类别名----------------   
  2. X-rapido22软件工程师13051594850备注说明
    郑州市经三路450001
    北京市海淀区100000
      
  3.   
  4. ----------------第2次输出, 设置类、字段别名----------------   
  5. X-rapido22软件工程师13051594850备注说明
    郑州市经三路450001
    北京市海淀区100000
      
  6.   
  7. ----------------第3次输出, 设置类、字段别名,并在xml字段节点上增加属性----------------   
  8. X-rapido22软件工程师13051594850备注说明郑州市经三路北京市海淀区  
  9.   
  10. Person{name='熔岩', age='27', profile=Profile{job='软件工程师', tel='13512129933', remark='备注说明'}, addlist=[Address{add='郑州市经三路', zipcode='450001'}, Address{add='西安市雁塔路', zipcode='710002'}]}  
  11. Profile{job='软件工程师', tel='13512129933', remark='备注说明'}  
  12. Address{add='西安市雁塔路', zipcode='710002'}  

Java转换JSON

xStream对JSON也有非常好的支持,它提供了2个模型驱动。用这2个驱动可以完成Java对象到JSON的相互转换。使用JettisonMappedXmlDriver驱动,将Java对象转换成json,需要添加jettison.jar,JSON的转换和XML的转换用法一样,只是创建XStream需要传递一个参数,这个参数就是xml到JSON映射转换的驱动。这里会讲到两个驱动,分别是JettisonMappedXmlDriver、JsonHierarchicalStreamDriver。

1、 用JettisonMappedXmlDriver转换

[java]  view plain  copy
 print ?
  1. public static void main(String args[]) {  
  2.     Address address1 = new Address("郑州市经三路""450001");  
  3.     Address address2 = new Address("北京市海淀区""100000");  
  4.     List
     addList = new ArrayList
    ();  
  5.     addList.add(address1);  
  6.     addList.add(address2);  
  7.     Profile profile = new Profile("软件工程师""13051594850""备注说明");  
  8.     Person person = new Person("X-rapido""22", profile, addList);  
  9.   
  10.     XStream xStreamJ = new XStream(new JettisonMappedXmlDriver());  
  11.     xStreamJ.setMode(XStream.NO_REFERENCES);  
  12.       
  13.     xStreamJ.alias("person", Person.class);  
  14.     xStreamJ.alias("profile", Profile.class);  
  15.     xStreamJ.alias("address", Address.class);  
  16.       
  17.     String xml = xStreamJ.toXML(person);  
  18.     System.out.println("JSON:"+ xml);  
  19. }  
[plain]  view plain  copy
 print ?
  1. {"person":{"name":"X-rapido","age":22,"profile":{"job":"软件工程师","tel":13051594850,"remark":"备注说明"},"addlist":[{"address":[{"add":"郑州市经三路","zipcode":450001},{"add":"北京市海淀区","zipcode":100000}]}]}}  

2、 用JsonHierarchicalStreamDriver转换

[java]  view plain  copy
 print ?
  1. public static void main(String args[]) {  
  2.     Address address1 = new Address("郑州市经三路""450001");  
  3.     Address address2 = new Address("北京市海淀区""100000");  
  4.     List
     addList = new ArrayList
    ();  
  5.     addList.add(address1);  
  6.     addList.add(address2);  
  7.     Profile profile = new Profile("软件工程师""13051594850""备注说明");  
  8.     Person person = new Person("X-rapido""22", profile, addList);  
  9.       
  10.     XStream xStreamJ = new XStream(new JsonHierarchicalStreamDriver());  
  11.       
  12.     xStreamJ.alias("person", Person.class);  
  13.     xStreamJ.alias("profile", Profile.class);  
  14.     xStreamJ.alias("address", Address.class);  
  15.       
  16.     String xml = xStreamJ.toXML(person);  
  17.     System.out.println("JSON:"+ xml);  
  18. }  
[plain]  view plain  copy
 print ?
  1. JSON:{"person": {  
  2.   "name": "X-rapido",  
  3.   "age": "22",  
  4.   "profile": {  
  5.     "job": "软件工程师",  
  6.     "tel": "13051594850",  
  7.     "remark": "备注说明"  
  8.   },  
  9.   "addlist": [  
  10.     {  
  11.       "add": "郑州市经三路",  
  12.       "zipcode": "450001"  
  13.     },  
  14.     {  
  15.       "add": "北京市海淀区",  
  16.       "zipcode": "100000"  
  17.     }  
  18.   ]  
  19. }}  

使用JsonHierarchicalStreamDriver转换默认会给转换后的对象添加一个根节点,但是在构建JsonHierarchicalStreamDriver驱动的时候,你可以重写createWriter方法,删掉根节点。

看上面的结果,一个是默认带根节点的JSON对象,它只是将类名作为一个属性,将对象作为该属性的一个值。而另一个没有带根属性的JSON就是通过重写createWriter方法完成的。

增加上面代码,返回没有根节点JSON

[java]  view plain  copy
 print ?
  1. //删除根节点  
  2. StreamJ = new XStream(new JsonHierarchicalStreamDriver() {  
  3.    public HierarchicalStreamWriter createWriter(Writer out) {  
  4.        return new JsonWriter(out, JsonWriter.DROP_ROOT_MODE);  
  5.    }  
  6. );  
[plain]  view plain  copy
 print ?
  1. JSON:{  
  2.   "name": "X-rapido",  
  3.   "age": "22",  
  4.   "profile": {  
  5.     "job": "软件工程师",  
  6.     "tel": "13051594850",  
  7.     "remark": "备注说明"  
  8.   },  
  9.   "addlist": [  
  10.     {  
  11.       "add": "郑州市经三路",  
  12.       "zipcode": "450001"  
  13.     },  
  14.     {  
  15.       "add": "北京市海淀区",  
  16.       "zipcode": "100000"  
  17.     }  
  18.   ]  
  19. }  

将JSON转换java对象

[java]  view plain  copy
 print ?
  1. public static void main(String args[]) {  
  2.     Address address1 = new Address("郑州市经三路""450001");  
  3.     Address address2 = new Address("北京市海淀区""100000");  
  4.     List
     addList = new ArrayList
    ();  
  5.     addList.add(address1);  
  6.     addList.add(address2);  
  7.     Profile profile = new Profile("软件工程师""13051594850""备注说明");  
  8.     Person person = new Person("X-rapido""22", profile, addList);  
  9.       
  10.     String json = "{\"person\":{\"name\":\"X-rapido\",\"age\":22,\"profile\":{\"job\":\"软件工程师\",\"tel\":13051594850,\"remark\":\"备注说明\"},\"addlist\":[{\"address\":[{\"add\":\"郑州市经三路\",\"zipcode\":450001},{\"add\":\"北京市海淀区\",\"zipcode\":100000}]}]}}";  
  11.     XStream xStreamJ = new XStream(new JettisonMappedXmlDriver());  
  12.       
  13.     xStreamJ.alias("person", Person.class);  
  14.     xStreamJ.alias("profile", Profile.class);  
  15.     xStreamJ.alias("address", Address.class);  
  16.       
  17.     person = (Person) xStreamJ.fromXML(json);  
  18.     System.out.println(person.toString());  
  19. }  
[plain]  view plain  copy
 print ?
  1. Person{name='X-rapido', age='22', profile=Profile{job='软件工程师', tel='13051594850', remark='备注说明'}, addlist=[Address{add='郑州市经三路', zipcode='450001'}, Address{add='北京市海淀区', zipcode='100000'}]}  

以上举例使用的JavaBean对象,对于Map,List对象也是通用的,具有同样功能的还有JsonLib包
XStream还提供了注解放方式,比如在字段上增加@XStreamOmitField表示忽略该字段,等等,这里就不做讲解了

示例代码下载地址:http://download.csdn.net/detail/xiaokui_wingfly/8800295


参考文献:http://www.jb51.net/article/14542.htm 、http://www.cnblogs.com/hoojo/archive/2011/04/22/2025197.html

转载地址:http://blog.csdn.net/xiaokui_wingfly/article/details/46470145

你可能感兴趣的:(xstream,java,xstream,xml,json)