来XStream了解一下！

​​

1、XStream官网

    http://x-stream.github.io

2、XStream是什么

    XStream是一个简单的基于Java的类库，用来将Java对象序列化成XML（JSON）或反序列化为对象(即：可以轻易的将Java对象和XML文档相互转换)

3、XSteam能干什么

    XStream在运行时使用Java反射机制对要进行序列化的对象树的结构进行探索，并不需要对对象作出修改。XStream可以序列化内部字段，包括私private和final字段，并且支持非公开类以及内部类。

    在缺省情况下，XStream不需要配置映射关系，对象和字段将映射为同名XML元素。但是当对象和字段名与XML中的元素名不同时，XStream支持指定别名。XStream支持以方法调用的方式，或是Java 标注的方式指定别名。

    XStream在进行数据类型转换时，使用系统缺省的类型转换器。同时，也支持用户自定义的类型转换器。

4、XStream特点

  • 使用方便 – XStream的API提供了一个高层次外观，以简化常用的用例

  • 无需创建映射 – XStream的API提供了默认的映射大部分对象序列化

  • 性能  – XStream快速和低内存占用，适合于大对象图或系统

  • 干净的XML  – XStream创建一个干净和紧凑XML结果，这很容易阅读

  • 不需要修改对象 – XStream可序列化的内部字段，如private和final字段，支持非公开类和内部类。默认构造函数不是强制性的要求

  • 完整对象图支持 – XStream允许保持在对象模型中遇到的重复引用，并支持循环引用

  • 可自定义的转换策略 – 定制策略可以允许特定类型的定制被表示为XML的注册

  • 安全框架 – XStream提供了一个公平控制有关解组的类型，以防止操纵输入安全问题

  • 错误消息 – 出现异常是由于格式不正确的XML时，XStream抛出一个统一的例外，提供了详细的诊断，以解决这个问题

  • 另一种输出格式 – XStream支持其它的输出格式，如JSON

5、XStream常见的用途

    传输、持久化、配置、单元测试

1、添加XSteam依赖

  1. <dependency>
  2.     <groupId>com.thoughtworks.xstream</groupId>
  3.     <artifactId>xstream</artifactId>
  4.     <version>1.4.12</version>
  5. </dependency>
  6.  <dependency>
  7.     <groupId>org.codehaus.jettison</groupId>
  8.     <artifactId>jettison</artifactId>
  9.     <version>1.4.1</version>
  10. </dependency>

2、XStream基本使用

  1. package io.github.xstream.test01;
  2. ​
  3. import com.thoughtworks.xstream.XStream;
  4. import com.thoughtworks.xstream.io.json.JettisonMappedXmlDriver;
  5. import lombok.AllArgsConstructor;
  6. import lombok.ToString;
  7. ​
  8. public class XStreamTest01 {
  9.     public static void main(String[] args) {
  10.         Student student = new Student("张三", 20);
  11.         XStream xStream = new XStream();//需要XPP3库
  12.         //XStream xStream = new XStream(new DomDriver());//不需要XPP3库
  13.         //XStream xStream = new XStream(new StaxDriver());//不需要XPP3库开始使用Java 6
  14.         //XML序列化
  15.         String xml = xStream.toXML(student);
  16.         System.out.println(xml);
  17.         //XML反序列化
  18.         student = (Student) xStream.fromXML(xml);
  19.         System.out.println(student);
  20. ​
  21.         xStream = new XStream(new JettisonMappedXmlDriver());
  22.         xStream.setMode(XStream.NO_REFERENCES);
  23.         //Json序列化
  24.         String json = xStream.toXML(student);
  25.         System.out.println(json);
  26.         //Json反序列
  27.         student = (Student) xStream.fromXML(json);
  28.         System.out.println(student);
  29.     }
  30. }
  31. ​
  32. @AllArgsConstructor
  33. @ToString
  34. class Student {
  35.     private String name;
  36.     private int age;
  37. }

3、程序运行结果

  1. <io.github.xstream.test01.Student>
  2.   <name>张三</name>
  3.   <age>20</age>
  4. </io.github.xstream.test01.Student>
  5. Security framework of XStream not initialized, XStream is probably vulnerable.
  6. Student(name=张三, age=20)
  7. {"io.github.xstream.test01.Student":{"name":"张三","age":20}}
  8. Student(name=张三, age=20)
  9. Security framework of XStream not initialized, XStream is probably vulnerable.

注意：文中使用到的Lombok注解，Lombok依赖自行添加；XStream序列化XML时需要引用的jar包：xstream-[version].jar、xpp3-[version].jar、xmlpull-[version].jar，当引入xstream依赖后会自动依赖xpp3、xmlpull依赖。XStream序列化JSON需要引用的jar包：jettison-[version].jar。

    使用XStream序列化时，对JavaBean没有任何限制。JavaBean的字段可以是私有的，也可以没有getter或setter方法，还可以没有默认的构造函数。

    XStream序列化XML时可以允许用户使用不同的XML解析器，用户可以使用一个标准的JAXP DOM解析器或自Java 6集成STAX解析器。这样用户就不需要依赖xpp3-[version].jar。

1、混叠是一种技术来定制生成XML或者使用XStream特定的格式化XML。假设，一个下面的XML格式是用于序列化/反序列化Student对象。

  1. <student name="张三">
  2.     <phone>
  3.         <brand>小米</brand>
  4.         <description>小米手机的描述</description>
  5.     </phone>
  6.     <phone>
  7.         <brand>苹果</brand>
  8.         <description>苹果手机的描述</description>
  9.     </phone>
  10. </student>

2、根椐上面的XML格式，我们创建实体类

  1. @AllArgsConstructor
  2. @ToString
  3. class Student {
  4.     private String studentName;
  5.     private List<Phone> phones;
  6. }
  7. ​
  8. @AllArgsConstructor
  9. @ToString
  10. class Phone {
  11.     private String brand;
  12.     private String description;
  13. }

3、执行代码

  1. package io.github.xstream.test02;
  2. ​
  3. import com.thoughtworks.xstream.XStream;
  4. import lombok.AllArgsConstructor;
  5. import lombok.ToString;
  6. ​
  7. import java.util.ArrayList;
  8. import java.util.List;
  9. ​
  10. public class XStreamTest02 {
  11.     public static void main(String[] args) {
  12.         List<Phone> phones = new ArrayList<>();
  13.         phones.add(new Phone("小米手机", "小米手机的描述"));
  14.         phones.add(new Phone("苹果手机", "苹果手机的描述"));
  15.         Student student = new Student("张三", phones);
  16. ​
  17.         XStream xStream = new XStream();//需要XPP3库
  18.         //XML序列化
  19.         String xml = xStream.toXML(student);
  20.         System.out.println(xml);
  21.     }
  22. }
  23. ​
  24. @AllArgsConstructor
  25. @ToString
  26. class Student {
  27.     private String studentName;
  28.     private List<Phone> phones;
  29. }
  30. ​
  31. @AllArgsConstructor
  32. @ToString
  33. class Phone {
  34.     private String brand;
  35.     private String description;
  36. }

4、验证输出

  1. <io.github.xstream.test02.Student>
  2.   <studentName>张三</studentName>
  3.   <phones>
  4.     <io.github.xstream.test02.Phone>
  5.       <brand>小米手机</brand>
  6.       <description>小米手机的描述</description>
  7.     </io.github.xstream.test02.Phone>
  8.     <io.github.xstream.test02.Phone>
  9.       <brand>苹果手机</brand>
  10.       <description>苹果手机的描述</description>
  11.     </io.github.xstream.test02.Phone>
  12.   </phones>
  13. </io.github.xstream.test02.Student>

    在上面的结果，我们已经看到了Student对象名称是完全合格的。要替换它作为学生的标签，按照四、XStream类混叠的步骤

    另外，在上述结果中可以看出，所需studentName要重命名来命名。要替换它，按照五、XStream字段混叠的步骤

    在上面的结果，我们可以看到手机标记被添加成为手机列表。替换它，按照六、XStream隐式集合混叠的步骤

    在上面的结果，我们可以看到这个名字来作为一个子节点，需要将它作为根节点的属性。替换它，按照七、XStream属性混叠的步骤

1、类混叠是用来创建一个类的XML完全限定名称的别名。让我们修改XStreamTest02例子，将下面的代码添加到XStreamTest02例子里面

  1. xStream.alias("student", Person02.class);
  2. xStream.alias("phone", Phone.class);

2、执行代码

  1. package io.github.xstream.test02;
  2. ​
  3. import com.thoughtworks.xstream.XStream;
  4. import lombok.AllArgsConstructor;
  5. import lombok.ToString;
  6. ​
  7. import java.util.ArrayList;
  8. import java.util.List;
  9. ​
  10. public class XStreamTest02 {
  11.     public static void main(String[] args) {
  12.         List<Phone> phones = new ArrayList<>();
  13.         phones.add(new Phone("小米手机", "小米手机的描述"));
  14.         phones.add(new Phone("苹果手机", "苹果手机的描述"));
  15.         Student student = new Student("张三", phones);
  16. ​
  17.         XStream xStream = new XStream();//需要XPP3库
  18.         xStream.alias("student", Student.class);
  19.         xStream.alias("phone", Phone.class);
  20. ​
  21.         //XML序列化
  22.         String xml = xStream.toXML(student);
  23.         System.out.println(xml);
  24.     }
  25. }
  26. ​
  27. @AllArgsConstructor
  28. @ToString
  29. class Student {
  30.     private String studentName;
  31.     private List<Phone> phones;
  32. }
  33. ​
  34. @AllArgsConstructor
  35. @ToString
  36. class Phone {
  37.     private String brand;
  38.     private String description;
  39. }

3、执行结果

  1. <student>
  2.   <studentName>张三</studentName>
  3.   <phones>
  4.     <phone>
  5.       <brand>小米手机</brand>
  6.       <description>小米手机的描述</description>
  7.     </phone>
  8.     <phone>
  9.       <brand>苹果手机</brand>
  10.       <description>苹果手机的描述</description>
  11.     </phone>
  12.   </phones>
  13. </student>

可以看到<io.github.xstream.test02.Student>和<io.github.xstream.test02.Phone>分别被修改为了<student>和<phone>

1、字段混叠用于创建以XML字段的别名。让我们再次修改原来的XStreamTest02例子，将下面的代码添加到XStreamTest02例子里面

  1. xStream.aliasField("name", Student.class, "studentName");

2、执行代码

  1. package io.github.xstream.test02;
  2. ​
  3. import com.thoughtworks.xstream.XStream;
  4. import lombok.AllArgsConstructor;
  5. import lombok.ToString;
  6. ​
  7. import java.util.ArrayList;
  8. import java.util.List;
  9. ​
  10. public class XStreamTest02 {
  11.     public static void main(String[] args) {
  12.         List<Phone> phones = new ArrayList<>();
  13.         phones.add(new Phone("小米手机", "小米手机的描述"));
  14.         phones.add(new Phone("苹果手机", "苹果手机的描述"));
  15.         Student student = new Student("张三", phones);
  16. ​
  17.         XStream xStream = new XStream();//需要XPP3库
  18.         xStream.alias("student", Student.class);
  19.         xStream.alias("phone", Phone.class);
  20.         xStream.aliasField("name", Student.class, "studentName");
  21. ​
  22.         //XML序列化
  23.         String xml = xStream.toXML(student);
  24.         System.out.println(xml);
  25.     }
  26. }
  27. ​
  28. @AllArgsConstructor
  29. @ToString
  30. class Student {
  31.     private String studentName;
  32.     private List<Phone> phones;
  33. }
  34. ​
  35. @AllArgsConstructor
  36. @ToString
  37. class Phone {
  38.     private String brand;
  39.     private String description;
  40. }

3、执行结果

  1. <student>
  2.   <name>张三</name>
  3.   <phones>
  4.     <phone>
  5.       <brand>小米手机</brand>
  6.       <description>小米手机的描述</description>
  7.     </phone>
  8.     <phone>
  9.       <brand>苹果手机</brand>
  10.       <description>苹果手机的描述</description>
  11.     </phone>
  12.   </phones>
  13. </student>

可以看到<studentName>被修改为了<name>

1、隐式集合混叠时使用的集合是表示在XML无需显示根。例如，在我们的例子中，我们需要一个接一个，但不是在根节点来显示每一个节点。让我们再次修改原来的XStreamTest02例子，将下面的代码添加到XStreamTest02例子里面

  1. xStream.addImplicitCollection(Student.class, "phones");

2、执行代码

  1. package io.github.xstream.test02;
  2. ​
  3. import com.thoughtworks.xstream.XStream;
  4. import lombok.AllArgsConstructor;
  5. import lombok.ToString;
  6. ​
  7. import java.util.ArrayList;
  8. import java.util.List;
  9. ​
  10. public class XStreamTest02 {
  11.     public static void main(String[] args) {
  12.         List<Phone> phones = new ArrayList<>();
  13.         phones.add(new Phone("小米手机", "小米手机的描述"));
  14.         phones.add(new Phone("苹果手机", "苹果手机的描述"));
  15.         Student student = new Student("张三", phones);
  16. ​
  17.         XStream xStream = new XStream();//需要XPP3库
  18.         xStream.alias("student", Student.class);
  19.         xStream.alias("phone", Phone.class);
  20.         xStream.aliasField("name", Student.class, "studentName");
  21.         xStream.addImplicitCollection(Student.class, "phones");
  22. ​
  23.         //XML序列化
  24.         String xml = xStream.toXML(student);
  25.         System.out.println(xml);
  26.     }
  27. }
  28. ​
  29. @AllArgsConstructor
  30. @ToString
  31. class Student {
  32.     private String studentName;
  33.     private List<Phone> phones;
  34. }
  35. ​
  36. @AllArgsConstructor
  37. @ToString
  38. class Phone {
  39.     private String brand;
  40.     private String description;
  41. }

3、执行结果

  1. <student>
  2.   <name>张三</name>
  3.   <phone>
  4.     <brand>小米手机</brand>
  5.     <description>小米手机的描述</description>
  6.   </phone>
  7.   <phone>
  8.     <brand>苹果手机</brand>
  9.     <description>苹果手机的描述</description>
  10.   </phone>
  11. </student>

可以看到<phones>被隐藏了

1、属性混叠用于创建一个成员变量作为XML属性序列化。让我们再次修改原来的XStreamTest02例子，将下面的代码添加到XStreamTest02例子里面

  1. xStream.useAttributeFor(Student.class, "studentName");

2、执行代码

  1. package io.github.xstream.test02;
  2. ​
  3. import com.thoughtworks.xstream.XStream;
  4. import lombok.AllArgsConstructor;
  5. import lombok.ToString;
  6. ​
  7. import java.util.ArrayList;
  8. import java.util.List;
  9. ​
  10. public class XStreamTest02 {
  11.     public static void main(String[] args) {
  12.         List<Phone> phones = new ArrayList<>();
  13.         phones.add(new Phone("小米手机", "小米手机的描述"));
  14.         phones.add(new Phone("苹果手机", "苹果手机的描述"));
  15.         Student student = new Student("张三", phones);
  16. ​
  17.         XStream xStream = new XStream();//需要XPP3库
  18.         xStream.alias("student", Student.class);
  19.         xStream.alias("phone", Phone.class);
  20.         xStream.aliasField("name", Student.class, "studentName");
  21.         xStream.addImplicitCollection(Student.class, "phones");
  22.         xStream.useAttributeFor(Student.class, "studentName");
  23. ​
  24.         //XML序列化
  25.         String xml = xStream.toXML(student);
  26.         System.out.println(xml);
  27.     }
  28. }
  29. ​
  30. @AllArgsConstructor
  31. @ToString
  32. class Student {
  33.     private String studentName;
  34.     private List<Phone> phones;
  35. }
  36. ​
  37. @AllArgsConstructor
  38. @ToString
  39. class Phone {
  40.     private String brand;
  41.     private String description;
  42. }

3、执行结果

  1. <student name="张三">
  2.   <phone>
  3.     <brand>小米手机</brand>
  4.     <description>小米手机的描述</description>
  5.   </phone>
  6.   <phone>
  7.     <brand>苹果手机</brand>
  8.     <description>苹果手机的描述</description>
  9.   </phone>
  10. </student>

可以看到<name>被作为了<student>的属性

1、包混叠用于创建一个类XML的完全限定名称的别名到一个新的限定名称。让我们再次修改原来的XStreamTest02例子，将下面代码

  1. xStream.alias("student", Student.class);
  2. xStream.alias("phone", Phone.class);

修改为

  1. xStream.aliasPackage("xx.xx.xx.xx", "io.github.xstream.test02");

2、执行代码

  1. package io.github.xstream.test02;
  2. ​
  3. import com.thoughtworks.xstream.XStream;
  4. import lombok.AllArgsConstructor;
  5. import lombok.ToString;
  6. ​
  7. import java.util.ArrayList;
  8. import java.util.List;
  9. ​
  10. public class XStreamTest02 {
  11.     public static void main(String[] args) {
  12.         List<Phone> phones = new ArrayList<>();
  13.         phones.add(new Phone("小米手机", "小米手机的描述"));
  14.         phones.add(new Phone("苹果手机", "苹果手机的描述"));
  15.         Student student = new Student("张三", phones);
  16. ​
  17.         XStream xStream = new XStream();//需要XPP3库
  18. //        xStream.alias("student", Student.class);
  19. //        xStream.alias("phone", Phone.class);
  20.         xStream.aliasPackage("xx.xx.xx.xx", "io.github.xstream.test02");
  21.         xStream.aliasField("name", Student.class, "studentName");
  22.         xStream.addImplicitCollection(Student.class, "phones");
  23.         xStream.useAttributeFor(Student.class, "studentName");
  24. ​
  25.         //XML序列化
  26.         String xml = xStream.toXML(student);
  27.         System.out.println(xml);
  28.     }
  29. }
  30. ​
  31. @AllArgsConstructor
  32. @ToString
  33. class Student {
  34.     private String studentName;
  35.     private List<Phone> phones;
  36. }
  37. ​
  38. @AllArgsConstructor
  39. @ToString
  40. class Phone {
  41.     private String brand;
  42.     private String description;
  43. }

3、执行结果

  1. <xx.xx.xx.xx.Student name="张三">
  2.   <xx.xx.xx.xx.Phone>
  3.     <brand>小米手机</brand>
  4.     <description>小米手机的描述</description>
  5.   </xx.xx.xx.xx.Phone>
  6.   <xx.xx.xx.xx.Phone>
  7.     <brand>苹果手机</brand>
  8.     <description>苹果手机的描述</description>
  9.   </xx.xx.xx.xx.Phone>
  10. </xx.xx.xx.xx.Student>

可以看到包名由io.github.xstream.test02替换为了xx.xx.xx.xx

1、前面的四、五、六、七、八步骤都是通过代码操作的

  1. //xStream.alias("student", Student.class);
  2. //xStream.alias("phone", Phone.class);
  3. xStream.aliasPackage("xx.xx.xx.xx", "io.github.xstream.test02");
  4. xStream.aliasField("name", Student.class, "studentName");
  5. xStream.addImplicitCollection(Student.class, "phones");
  6. xStream.useAttributeFor(Student.class, "studentName");

2、XStream同时也支持注解，使用注解会变得简单也会达到相同的效果

  1. package io.github.xstream.test03;
  2. ​
  3. import com.thoughtworks.xstream.XStream;
  4. import com.thoughtworks.xstream.annotations.*;
  5. import com.thoughtworks.xstream.converters.basic.BooleanConverter;
  6. import lombok.AllArgsConstructor;
  7. import lombok.Data;
  8. import lombok.ToString;
  9. ​
  10. import java.util.ArrayList;
  11. import java.util.List;
  12. ​
  13. public class XStreamTest03 {
  14.     public static void main(String[] args) {
  15.         List<Phone> phones = new ArrayList<>();
  16.         phones.add(new Phone("小米手机", "小米手机的描述"));
  17.         phones.add(new Phone("苹果手机", "苹果手机的描述"));
  18.         Student student = new Student("张三", phones, 20, true);
  19.         
  20.         XStream xStream = new XStream();//需要XPP3库
  21.         //xStream.processAnnotations(new Class[]{Student.class});
  22.         xStream.autodetectAnnotations(true);
  23.         //XML序列化
  24.         String xml = xStream.toXML(student);
  25.         System.out.println(xml);
  26.     }
  27. }
  28. ​
  29. @AllArgsConstructor
  30. @ToString
  31. //别名注解
  32. @XStreamAlias("student")
  33. class Student {
  34.     @XStreamAlias("name")
  35.     //把字段节点设置成属性
  36.     @XStreamAsAttribute
  37.     private String studentName;
  38.     //省略集合根节点
  39.     @XStreamImplicit
  40.     private List<Phone> phones;
  41.     //隐藏字段
  42.     @XStreamOmitField
  43.     private int age;
  44.     //设置转换器
  45.     @XStreamConverter(value = BooleanConverter.class, booleans = {false}, strings = {"男", "女"})
  46.     private boolean sex;
  47. }
  48. ​
  49. @AllArgsConstructor
  50. @ToString
  51. @XStreamAlias("phone")
  52. class Phone {
  53.     private String brand;
  54.     private String description;
  55. }

3、使用注解的话，需要XML序列化之前添加如下代码

  1. xStream.autodetectAnnotations(true);

或者

  1. xStream.processAnnotations(new Class[]{Student.class});

4、执行结果

  1. <student name="张三">
  2.   <phone>
  3.     <brand>小米手机</brand>
  4.     <description>小米手机的描述</description>
  5.   </phone>
  6.   <phone>
  7.     <brand>苹果手机</brand>
  8.     <description>苹果手机的描述</description>
  9.   </phone>
  10.   <sex>男</sex>
  11. </student>

使用注解我们也可以看到也能达到相同的效果

注意：当使用XStream对象处理一个被注解的类型时，XStream对象也会处理所有与其相关的类型的注解信息，即该类型的父类、父接口、所有子类的注解。

1、XStream自带的转换器

    XStream内部有许多转换器，用于JavaBean对象到XML或JSON之间的转换。这些转换器的详细信息网址：http://x-stream.github.io/converters.html

2、使用自定义转换器

  1. package io.github.xstream.test04;
  2. ​
  3. import com.thoughtworks.xstream.XStream;
  4. import com.thoughtworks.xstream.annotations.XStreamAlias;
  5. import lombok.AllArgsConstructor;
  6. import lombok.Getter;
  7. import lombok.Setter;
  8. import lombok.ToString;
  9. ​
  10. public class XStreamTest04 {
  11.     public static void main(String[] args) {
  12.         Student student =new Student("张三",19);
  13.         XStream xStream = new XStream();
  14.         //注册转换器
  15.         xStream.registerConverter(new StudentConverter());
  16.         //序列化
  17.         String xml = xStream.toXML(student);
  18.         System.out.println(xml);
  19.         //反序列化
  20.         student=(Student)xStream.fromXML(xml);
  21.         System.out.println(student);
  22.     }
  23. }
  24. ​
  25. @Getter
  26. @Setter
  27. @ToString
  28. @AllArgsConstructor
  29. class Student {
  30.     private String name;
  31.     private int age;
  32. }

自定义转换器

  1. package io.github.xstream.test04;
  2. ​
  3. import com.thoughtworks.xstream.converters.Converter;
  4. import com.thoughtworks.xstream.converters.MarshallingContext;
  5. import com.thoughtworks.xstream.converters.UnmarshallingContext;
  6. import com.thoughtworks.xstream.io.HierarchicalStreamReader;
  7. import com.thoughtworks.xstream.io.HierarchicalStreamWriter;
  8. ​
  9. public class StudentConverter implements Converter {
  10.     //定义转换器能转换的JavaBean类型
  11.     @Override
  12.     public boolean canConvert(Class type) {
  13.         return type.equals(Student.class);
  14.     }
  15. ​
  16.     //把对象序列化成XML或JSON
  17.     @Override
  18.     public void marshal(Object value, HierarchicalStreamWriter writer,
  19.                         MarshallingContext context) {
  20.         Student student = (Student) value;
  21.         writer.startNode("姓名");
  22.         writer.setValue(student.getName());
  23.         writer.endNode();
  24.         writer.startNode("年龄");
  25.         writer.setValue(student.getAge() + "");
  26.         writer.endNode();
  27.         writer.startNode("转换器");
  28.         writer.setValue("自定义的转换器");
  29.         writer.endNode();
  30.     }
  31. ​
  32.     //把XML或JSON反序列化成对象
  33.     @Override
  34.     public Object unmarshal(HierarchicalStreamReader reader,
  35.                             UnmarshallingContext context) {
  36.         Student student = new Student("", -1);
  37.         reader.moveDown();
  38.         student.setName(reader.getValue());
  39.         reader.moveUp();
  40.         reader.moveDown();
  41.         student.setAge(Integer.parseInt(reader.getValue()));
  42.         reader.moveUp();
  43.         return student;
  44.     }
  45. }

3、执行结果

  1. <student>
  2.   <姓名>张三</姓名>
  3.   <年龄>19</年龄>
  4.   <转换器>自定义的转换器</转换器>
  5. </student>
  6. Security framework of XStream not initialized, XStream is probably vulnerable.
  7. Student(name=张三, age=19)

4、常用的转换器接口与抽象类

  1. SingleValueConverter：单值转换接口
  2. AbstractSingleValueConverter：单值转换抽象类
  3. Converter：常规转换器接口

1、对象输出流

  1. package io.github.xstream.test05;
  2. ​
  3. import com.thoughtworks.xstream.XStream;
  4. import com.thoughtworks.xstream.annotations.XStreamAlias;
  5. import com.thoughtworks.xstream.annotations.XStreamAsAttribute;
  6. import lombok.AllArgsConstructor;
  7. import lombok.ToString;
  8. ​
  9. import java.io.*;
  10. ​
  11. public class XStreamTest05 {
  12.     public static void main(String[] args) throws IOException, ClassNotFoundException {
  13.         XStreamTest05 xStreamTest04 = new XStreamTest05();
  14.         String path = "F:\\test.txt";
  15.         XStream xStream = new XStream();//需要XPP3库
  16.         xStream.processAnnotations(Student.class);
  17.         xStream.autodetectAnnotations(true);
  18.         xStreamTest04.writeObject(xStream, path);
  19.     }
  20. ​
  21.     //对象输出流方法
  22.     public void writeObject(XStream xStream, String path) throws IOException {
  23.         Student zs = new Student("张三", 20);
  24.         Student ls = new Student("李四", 21);
  25.         Student ww = new Student("王五", 22);
  26.         ObjectOutputStream objectOutputStream = xStream.createObjectOutputStream(new FileOutputStream(path));
  27.         objectOutputStream.writeObject(zs);
  28.         objectOutputStream.writeObject(ls);
  29.         objectOutputStream.writeObject(ww);
  30.         objectOutputStream.writeObject("totalStudent");
  31.         objectOutputStream.writeInt(3);
  32.         objectOutputStream.close();
  33.     }
  34. }
  35. ​
  36. @AllArgsConstructor
  37. @ToString
  38. //别名注解
  39. @XStreamAlias("student")
  40. class Student {
  41.     @XStreamAlias("name")
  42.     //把字段节点设置成属性
  43.     @XStreamAsAttribute
  44.     private String studentName;
  45.     private int age;
  46. }

2、在指定路径中打开test.txt文件，查看执行结果

  1. <object-stream>
  2.   <student name="张三">
  3.     <age>20</age>
  4.   </student>
  5.   <student name="李四">
  6.     <age>21</age>
  7.   </student>
  8.   <student name="王五">
  9.     <age>22</age>
  10.   </student>
  11.   <string>totalStudent</string>
  12.   <int>3</int>
  13. </object-stream>

注意：XStream对象流是通过标准java.io.ObjectOutputStream和java.io.ObjectInputStream对象。因为XML文档只能有一个根节点，必须包装在一个序列化的所有元素额外的根节点。这个根节点默认为<object-stream>上面的例子所示。 

3、对象输入流

  1. package io.github.xstream.test05;
  2. ​
  3. import com.thoughtworks.xstream.XStream;
  4. import com.thoughtworks.xstream.annotations.XStreamAlias;
  5. import com.thoughtworks.xstream.annotations.XStreamAsAttribute;
  6. import lombok.AllArgsConstructor;
  7. import lombok.ToString;
  8. ​
  9. import java.io.*;
  10. ​
  11. public class XStreamTest05 {
  12.     public static void main(String[] args) throws IOException, ClassNotFoundException {
  13.         XStreamTest05 xStreamTest04 = new XStreamTest05();
  14.         String path = "F:\\test.txt";
  15.         XStream xStream = new XStream();//需要XPP3库
  16.         xStream.processAnnotations(Student.class);
  17.         xStream.autodetectAnnotations(true);
  18.         xStreamTest04.readObject(xStream, path);
  19.     }
  20. ​
  21.     //对象输入流方法
  22.     public void readObject(XStream xStream, String path) throws IOException, ClassNotFoundException {
  23.         ObjectInputStream objectInputStream = xStream.createObjectInputStream(new FileInputStream(path));
  24.         System.out.println((Student) objectInputStream.readObject());
  25.         System.out.println((Student) objectInputStream.readObject());
  26.         System.out.println((Student) objectInputStream.readObject());
  27.         System.out.println(objectInputStream.readObject());
  28.         System.out.println(objectInputStream.readInt());
  29.     }
  30. }
  31. ​
  32. @AllArgsConstructor
  33. @ToString
  34. //别名注解
  35. @XStreamAlias("student")
  36. class Student {
  37.     @XStreamAlias("name")
  38.     //把字段节点设置成属性
  39.     @XStreamAsAttribute
  40.     private String studentName;
  41.     private int age;
  42. }

4、执行结果

  1. Student(studentName=张三, age=20)
  2. Student(studentName=李四, age=21)
  3. Student(studentName=王五, age=22)
  4. totalStudent
  5. 3

1、保存Java对象

  1. ​package io.github.xstream.test06;
  2. ​
  3. import com.thoughtworks.xstream.persistence.FilePersistenceStrategy;
  4. import com.thoughtworks.xstream.persistence.PersistenceStrategy;
  5. import com.thoughtworks.xstream.persistence.XmlArrayList;
  6. import lombok.AllArgsConstructor;
  7. import lombok.ToString;
  8. ​
  9. import java.io.File;
  10. import java.util.List;
  11. ​
  12. public class XStreamTest06 {
  13.     public static void main(String[] args) {
  14.         XStreamTest06 xStreamTest06=new XStreamTest06();
  15.         xStreamTest06.saveObject();
  16.     }
  17. ​
  18.     //保存Java对象
  19.     public void saveObject(){
  20.         PersistenceStrategy strategy = new FilePersistenceStrategy(new File("F:\\"));
  21.         List list = new XmlArrayList(strategy);
  22.         list.add(new Student("张三",13));
  23.         list.add(new Student("李四",21));
  24.         list.add(new Student("王五",17));
  25.     }
  26. }
  27. ​
  28. @ToString
  29. @AllArgsConstructor
  30. class Student {
  31.     private String name;
  32.     private int age;
  33. }

2、运行程序结果，在F磁盘的根路径可以看到有三个文件:int@0.xml、int@1.xml、int@2.xml，每个对象都被序列化到XML文件里

3、读取并删除JavaBean对象

  1. package io.github.xstream.test06;
  2. ​
  3. import com.thoughtworks.xstream.persistence.FilePersistenceStrategy;
  4. import com.thoughtworks.xstream.persistence.PersistenceStrategy;
  5. import com.thoughtworks.xstream.persistence.XmlArrayList;
  6. import lombok.AllArgsConstructor;
  7. import lombok.ToString;
  8. ​
  9. import java.io.File;
  10. import java.util.Iterator;
  11. import java.util.List;
  12. ​
  13. public class XStreamTest06 {
  14.     public static void main(String[] args) {
  15.         XStreamTest06 xStreamTest06 = new XStreamTest06();
  16.         xStreamTest06.deleteObject();
  17.     }
  18.     
  19.     //读取并删除Java对象
  20.     public void deleteObject() {
  21.         PersistenceStrategy strategy = new FilePersistenceStrategy(new File("F:\\"));
  22.         List list = new XmlArrayList(strategy);
  23.         for (Iterator it = list.iterator(); it.hasNext(); ) {
  24.             System.out.println((Student) it.next());
  25.             //删除对象序列化文件
  26.             it.remove();
  27.         }
  28.     }
  29. }
  30. ​
  31. @ToString
  32. @AllArgsConstructor
  33. class Student {
  34.     private String name;
  35.     private int age;
  36. }

4、运行程序结果，可以看到把F磁盘的根路径int@0.xml、int@1.xml、int@2.xml文件删除了

  1. Security framework of XStream not initialized, XStream is probably vulnerable.
  2. Student(name=张三, age=13)
  3. Student(name=李四, age=21)
  4. Student(name=王五, age=17)

1、XStream序列化JSON的重命名

  1. package io.github.xstream.test07;
  2. ​
  3. import com.thoughtworks.xstream.XStream;
  4. import com.thoughtworks.xstream.annotations.XStreamAlias;
  5. import com.thoughtworks.xstream.io.json.JettisonMappedXmlDriver;
  6. import io.github.xstream.test04.StudentConverter;
  7. import lombok.AllArgsConstructor;
  8. import lombok.Getter;
  9. import lombok.Setter;
  10. import lombok.ToString;
  11. ​
  12. public class XStreamTest07 {
  13.     public static void main(String[] args) {
  14.         XStreamTest07 xStreamTest07 = new XStreamTest07();
  15.         xStreamTest07.serializeJson();
  16.     }
  17. ​
  18.     public void serializeJson() {
  19.         Student student = new Student("张三", 19);
  20.         XStream xStream = new XStream(new JettisonMappedXmlDriver());//设置Json解析器
  21.         xStream.autodetectAnnotations(true);
  22.         //JSON序列化
  23.         String xml = xStream.toXML(student);
  24.         System.out.println(xml);
  25.         //JSON反序列化
  26.         student = (Student) xStream.fromXML(xml);
  27.         System.out.println(student);
  28.     }
  29. }
  30. ​
  31. @ToString
  32. @AllArgsConstructor
  33. @XStreamAlias("人")
  34. class Student {
  35.     @XStreamAlias("姓名")
  36.     private String name;
  37.     @XStreamAlias("年龄")
  38.     private int age;
  39. }

2、运行结果

  1. {"人":{"姓名":"张三","年龄":19}}
  2. Student(name=张三, age=19)
  3. Security framework of XStream not initialized, XStream is probably vulnerable.

注意：XStream序列化JSON的重命名的方式与其序列化成XML的方式一样！

3、去掉序列化JSON的根节点

  1. ​package io.github.xstream.test07;
  2. ​
  3. import com.thoughtworks.xstream.XStream;
  4. import com.thoughtworks.xstream.annotations.XStreamAlias;
  5. import com.thoughtworks.xstream.io.HierarchicalStreamWriter;
  6. import com.thoughtworks.xstream.io.json.JettisonMappedXmlDriver;
  7. import com.thoughtworks.xstream.io.json.JsonHierarchicalStreamDriver;
  8. import com.thoughtworks.xstream.io.json.JsonWriter;
  9. import io.github.xstream.test04.StudentConverter;
  10. import lombok.AllArgsConstructor;
  11. import lombok.Getter;
  12. import lombok.Setter;
  13. import lombok.ToString;
  14. ​
  15. import java.io.Writer;
  16. ​
  17. public class XStreamTest07 {
  18.     public static void main(String[] args) {
  19.         XStreamTest07 xStreamTest07 = new XStreamTest07();
  20.         xStreamTest07.removeRootNode();
  21.     }
  22. ​
  23.     public void removeRootNode() {
  24.         Student student = new Student("张三", 19);
  25.         XStream xStream = new XStream(new JsonHierarchicalStreamDriver() {
  26.             public HierarchicalStreamWriter createWriter(Writer writer) {
  27.                 return new JsonWriter(writer, JsonWriter.DROP_ROOT_MODE);
  28.             }
  29.         });
  30.         //Json序列化
  31.         String xml = xStream.toXML(student);
  32.         System.out.println(xml);
  33.     }
  34. }
  35. ​
  36. @ToString
  37. @AllArgsConstructor
  38. @XStreamAlias("人")
  39. class Student {
  40.     @XStreamAlias("姓名")
  41.     private String name;
  42.     @XStreamAlias("年龄")
  43.     private int age;
  44. }

4、运行结果

  1. {
  2.   "name": "张三",
  3.   "age": 19
  4. }

注意：去掉根节点后的JSON串是不能反序列化的，因为XStream不知道它的类型。

5、JSON的解析器区别

前面两个例子使用了不同的JSON解析器，这里说明他们的不同之处：

  1. JettisonMappedXmlDriver：是支持序列化和反序列化Json的。

  2. JsonHierarchicalStreamDriver：只支持序列化，不支持反序列化。

 

参考：

    http://x-stream.github.io

    https://www.yiibai.com/xstream

    https://www.cnblogs.com/LiZhiW/p/4313493.html

​

● 别在 Java 代码里乱打日志了，这才是正确的打日志姿势！

● 高可用Redis服务架构分析与搭建

● 8 种方案，帮你解决重复提交问题！请拿走

● IDEA 解决 Maven 依赖冲突的高能神器，这一篇够不够？

● 你连微服务的网关都说不清楚，还天天鼓捣着要把项目拆分微服务？

​

来都来了 点个赞再走吧~~~

​

版权声明：本文为coding-farmer原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://www.cnblogs.com/coding-farmer/p/13042087.html