Reproduced -xstream Parsing of XML parsing

Reprint Source: http://hwy584624785.iteye.com/blog/1168680

This example uses XStream to generate an XML file and then to serialize the contents of the XML file.

XStream is a simple class library that can serialize objects to XML, and can also restore XML to an object.
XStream Official website: http://xstream.codehaus.org/
The attachment provides XStream and XPP3 related jar downloads:
Xstream-1.2.2.jar
Xpp3-1.1.3.3_min.jar
In order to use XStream, you need to initialize it, there are two ways to initialize it:

• XStream XStream = new XStream (); The initialization of this method requires Xpp3-[version].jar support. XPP is a parser that parses XML files quickly.
• XStream XStream = new XStream (new Domdriver ()); XStream XStream = new XStream (New Domdriver ("Utf-8") This approach does not need to rely on Xpp3.jar support, it is used to parse it using the standard JAXP dom.

Also here is a simple description of the mode parameter:
When XStream serializes or deserializes an object, it creates two classes Marshallingcontext and Unmarshallingcontext, which process the data and delegate the appropriate converters. XStream provides a three default implementation of the context, with subtle differences between them. The default value can be changed by Method Xstream.setmode (), and one of the following parameters needs to be passed:

• Xstream.xpath_relative_references: (the default) is used to identify duplicate references using XPATH and relative path representations.
• Xstream.xpath_absolute_references: An XPATH is used to identify duplicate references, using an absolute path representation.
• Xstream.id_references: Use ID citation to identify duplicate references. On some occasions (when writing XML), it will be easier to manipulate
• Xstream.no_references: This situation loses support for graphical objects, and only looks at the object as a tree structure. Repeated references are considered to be two different objects, and circular references can cause an exception to occur. This mode is faster compared to the above two modes, and memory consumption is more

This example contains 3 simple Java classes, of which two are JavaBean and the other is a logical processing class. Two classes of JavaBean are as follows: Person.javajava code

2. Public class Person {
4. private int id;
6. private String name;
8. private int age;
10. private PhoneNumber phone;
12. public int getId () {
14. return ID;
16. }
18. public void setId (int id) {
20. this.id = ID;
22. }
24. Public String GetName () {
26. return name;
28. }
30. public void SetName (String name) {
32. this.name = name;
34. }
36. public int getage () {
38. return age;
40. }
42. public void Setage (int.) {
44. this.age = age;
46. }
48. Public PhoneNumber Getphone () {
50. return phone;
52. }
54. public void Setphone (PhoneNumber phone) {
56. this.phone = phone;
58. }
60. @Override
62. Public String toString () {
64. return "person [id=] + ID + ", name= "+ name + ", age= "+ Age
66. + ", phone=" + Phone + "]";
68. }
70. }

Phonenumber.javajava Code

2. Public class PhoneNumber {
4. private int code;
6. private String number;
8. public int GetCode () {
10. return code;
12. }
14. public void Setcode (int code) {
16. This.code = code;
18. }
20. Public String GetNumber () {
22. return number;
24. }
26. public void Setnumber (String number) {
28. this.number = number;
30. }
32. @Override
34. Public String toString () {
36. return "PhoneNumber [code=" + code + ", number=" + number + "]";
38. }
40. }

The main implementation of the function is the following class: Xstreamtest.javajava code

2. Import Java.io.File;
4. Import Java.io.FileInputStream;
6. Import Java.io.FileOutputStream;
10. Import Com.thoughtworks.xstream.XStream;
14. Public class Xstreamtest {
16. public static void Main (string[] args) throws Exception {
18. Person person = Initperson ();
20. XStream XStream = new XStream ();
22. Xstream.alias (' person ', person.   Class);
24. FileOutputStream fileoutputstream=New FileOutputStream (new File ("Test.xml"));
26. Xstream.toxml (Person,fileoutputstream);
30. //Deserialization
32. FileInputStream fileinputstream=New FileInputStream (new File ("Test.xml"));
34. Person person1= (person) xstream.fromxml (FileInputStream);
36. System.out.println (Person1.tostring ());
38. }
42. public static Person Initperson () {
44. Person person = new Person ();
46. Person.setid (20);
48. Person.setname ("Huangwei");
50. Person.setage (24);
54. PhoneNumber PhoneNumber = new PhoneNumber ();
56. Phonenumber.setcode (222);
58. Phonenumber.setnumber ("15200000000");
60. Person.setphone (PhoneNumber);
64. return person;
66. }
68. }

The contents of the generated XML file are printed as follows: XML code

2. <person>
4. <ID>20</ID>
6. <name>huangwei</name>
8. <age>24</age>
10. <phone>
12. <code>222</code>
14. <number>15200000000</number>
16. </phone>
18. </person>

The inverse sequence has been resolved as follows: Java code

1. person [id=,Name=huangwei, age=, Phone=phonenumber [code=222, number=15200000000]

Reproduced -xstream Parsing of XML parsing