Using XStream is the implementation of XML and Java Object Conversion (6)--persistence

Nine, The persistence of

In the example in section eighth, when we manipulate a set of objects, we can specify writer, outputstream to write out the serialized XML data, and we can also specify reader, InputStream to read the serialized XML data. We need to specify the input and output stream when we need to write and read the file, and we need to explicitly call the input and output method to implement the serialization and deserialization of the Java object, in fact, we can make the Java object serialization and deserialization operation Implicit, automatic Done, that's what we're going to learn: Persistencestrategy, Xmlarraylist, XmlMap and Xmlset.

Persistencestrategy is our persistence strategy, which defines our storage and reading protocols, and is the actual tool for storing and reading XML. The persistence strategy provided by the XStream framework is only filepersistencestrategy this one, persisting XML data to the file system, but we can define our own persistence policies (such as persisting into the database), Just inherit the Persistencestrategy interface.

Xmlarraylist, XmlMap, and Xmlset are 3 of our familiar collection tool classes that let us manipulate Java objects in a way we are very familiar with, and implicitly store and read the XML we need.

Here we take xmlarraylist as an example to learn.

1, Simple storage

The procedure is as follows:

Java code

2. Package CN.TJPU.ZHW.XML.XSTREAM6;
6. Import Java.io.File;
8. Import java.util.List;
12. Import Com.thoughtworks.xstream.persistence.FilePersistenceStrategy;
14. Import Com.thoughtworks.xstream.persistence.PersistenceStrategy;
16. Import com.thoughtworks.xstream.persistence.XmlArrayList;
20. public class Persistencemain {
24. public static void Main (string[] args) {
26. Create persistence policies (define storage tools and storage locations)
28. Note: D:/tmp is an existing directory, otherwise it will error
30. Persistencestrategy strategy = new Filepersistencestrategy (
32. New File ("d:/tmp"));
36. Create an Action tool
38. List List = new Xmlarraylist (strategy);
40. System.out.println ("list.size () =" +list.size () when the Xmlarraylist object was created);
44. Add data
46. List.add (New person ("Zhang San"));
48. List.add (New person ("John Doe"));
50. List.add (New person ("fluffy"));
52. List.add (New person ("Big Bear"));
56. System.out.println ("After adding 4 elements list.size () =" +list.size ());
58. Delete "John Doe"
60. List.remove (1);
62. System.out.println ("Removed 1 elements after list.size () =" +list.size ());
64. }
68. }
72. Class Person {
74. Public person (String name) {
76. THIS.name = name;
78. }
82. private String name;
86. Public String GetName () {
88. return name;
90. }
94. public void SetName (String name) {
96. THIS.name = name;
98. }
102. Public String toString () {
104. Return "name= of the Person object" + getName ();
106. }
108. }

Operation Result:

Java code

1. List.size () =0 when the Xmlarraylist object was first created
2. After adding 4 elements list.size () =4
3. After removing 1 elements list.size () =3

Now we look at the D:/tmp directory and we will find 3 files [email protected], [email protected] and [email protected]. These 3 files are the 3 person objects we store, and their contents are:

[Email protected] File:

XML code

1. <cn.tjpu.zhw.xml.xstream6.Person>
2. <name> Zhang San </name>
3. </cn.tjpu.zhw.xml.xstream6.Person>

[Email protected] File

XML code

1. <cn.tjpu.zhw.xml.xstream6.Person>
2. <name> Fluffy </name>
3. </cn.tjpu.zhw.xml.xstream6.Person>

[Email protected] File:

XML code

1. <cn.tjpu.zhw.xml.xstream6.Person>
2. <name> Big Bear </name>
3. </cn.tjpu.zhw.xml.xstream6.Person>

In fact, every time we call the Add method, there is a persistence process that writes the file to the D:/tmp directory each time.

2, all of our familiar methods of operation

Since Xmlarraylist, XmlMap, and xmlset inherit our familiarity with the various collection interfaces, we can manipulate our data to manipulate lists, maps, and sets, unlike the data in our collection in memory, which is now in our pre-defined persistence strategy.

Write the following procedure:

Java code

2. Package CN.TJPU.ZHW.XML.XSTREAM6;
6. Import Java.io.File;
8. Import Java.util.Iterator;
10. Import java.util.List;
14. Import Com.thoughtworks.xstream.persistence.FilePersistenceStrategy;
16. Import Com.thoughtworks.xstream.persistence.PersistenceStrategy;
18. Import com.thoughtworks.xstream.persistence.XmlArrayList;
22. public class Usagetestmain {
26. The use of xmlarraylist
28. public static void Main (string[] args) {
30. Create persistence policies (define storage tools and storage locations)
32. Note: D:/tmp is an existing directory, otherwise it will error
34. Persistencestrategy strategy = new Filepersistencestrategy (New File (
36. "D:/tmp"));
40. Create an Action tool
42. List List = new Xmlarraylist (strategy);
44. System.out.println ("list.size () =" +list.size () when the Xmlarraylist object was created);
48. System.out.println ();
52. Get iterators
54. Iterator iter = List.iterator ();
58. SYSTEM.OUT.PRINTLN ("****** traversal of each element ******");
60. Iterate through each of the elements
62. while (Iter.hasnext ()) {
64. Person P = (person) iter.next ();
66. SYSTEM.OUT.PRINTLN ("Current element p=" +p);
68. }
70. }
74. }

Operation Result:

Java code

1. List.size () =3 when the Xmlarraylist object was first created
3. Iterate through every element of ******
4. The name= of the current element P=person object Zhang San
5. The current element P=person object Name= Fluffy
6. Current element P=person Object Name= Big Bear

3. Customize your own converter (Local Converter)

Because of the large amount of data stored in memory, we can use file system staging, in memory only the directory where the files are stored, we can define a converter ourselves:

Java code

2. Package CN.TJPU.ZHW.XML.XSTREAM6;
6. Import Java.io.File;
8. Import java.util.ArrayList;
10. Import java.util.Collection;
14. Import Com.thoughtworks.xstream.XStream;
16. Import Com.thoughtworks.xstream.converters.Converter;
18. Import Com.thoughtworks.xstream.converters.MarshallingContext;
20. Import Com.thoughtworks.xstream.converters.UnmarshallingContext;
22. Import Com.thoughtworks.xstream.io.HierarchicalStreamReader;
24. Import Com.thoughtworks.xstream.io.HierarchicalStreamWriter;
26. Import Com.thoughtworks.xstream.persistence.FilePersistenceStrategy;
28. Import com.thoughtworks.xstream.persistence.XmlArrayList;
32. Define a local converter yourself
34. Public final class Localarraylistconverter implements Converter {
36. Private XStream XStream;
40. Public Localarraylistconverter (XStream XStream) {
42. This.xstream = XStream;
44. }
48. Serializing an collection object to a file
50. Note: The contents of the collection are not stored in memory while serializing, only the directory in which these files are stored is staged
52. public void Marshal (Object source, hierarchicalstreamwriter writer,
54. Marshallingcontext context) {
56. File dir = new file ("D:/tmp");
58. Create a persistence tool and load all the files in the directory
60. Xmlarraylist list = new Xmlarraylist (
62. New Filepersistencestrategy (Dir,xstream));
64. Context.convertanother (dir);
66. Generating files
68. List.addall ((Collection) source);
70. }
74. Read information from a file, reverse-sequence to collection object
76. Note: All files in the staging directory are deleted when deserializing
78. Public Object Unmarshal (
80. Hierarchicalstreamreader Reader,
82. Unmarshallingcontext context) {
84. File directory = (file) context.convertanother (null, file.class);
86. Create a persistence tool and load all the files in the directory
88. Xmlarraylist persistentlist = new Xmlarraylist (
90. New Filepersistencestrategy (directory, XStream));
92. Copy the loaded information to the list
94. ArrayList list = new ArrayList (persistentlist);
96. Delete all Files
98. Persistentlist.clear ();
100. Returns information that has been loaded
102. return list;
104. }
108. public boolean Canconvert (Class type) {
110. return type = = Arraylist.class;
112. }
114. }

This converter is the conversion of ArrayList objects.

Here are our test procedures:

Java code

2. Package CN.TJPU.ZHW.XML.XSTREAM6;
6. Import java.util.ArrayList;
8. Import java.util.Collection;
10. Import java.util.List;
14. Import Com.thoughtworks.xstream.XStream;
18. public class Localconvertermain {
22. public static void Main (string[] args) {
24. XStream XStream = new XStream ();
26. Xstream.alias ("volume", Volume.class);
30. Use a custom converter localarraylistconverter to convert the documents field of the volume class
32. This converter is a limited local converter and can only convert the documents field of the volume class
34. Xstream.registerlocalconverter (Volume.class, "documents",
36. New Localarraylistconverter (XStream));
40. The object to convert
42. Volume Volume = new Volume ();
46. Create a Collection
48. Collection coll = new ArrayList ();
50. Coll.add (1);
52. Coll.add (2.123d);
54. Coll.add (New person ("Zhang San"));
56. Volume.documents.addAll (coll);
60. SYSTEM.OUT.PRINTLN ("****** serialization ******");
62. Convert XML
64. String XML = xstream.toxml (volume);
68. Output XML
70. SYSTEM.OUT.PRINTLN (XML);
74. SYSTEM.OUT.PRINTLN ("****** deserialization ******");
76. Volume v2 = (Volume) xstream.fromxml (XML);
78. for (Object obj:v2.documents) {
80. System.out.println ("obj=" +obj);
82. }
84. }
88. }
92. Abstract class Abstractdocument {
94. String title;
96. }
100. Class TextDocument extends Abstractdocument {
102. List chapters = new ArrayList ();
104. }
108. Class Scanneddocument {
110. List images = new ArrayList ();
112. }
116. Class Volume {
118. List documents = new ArrayList ();
120. }

Operation Result:

Java code

1. Serialization of ******
2. <volume>
3. <documents>d:\tmp</documents>
4. </volume>
5. deserialization ******
6. Name= Zhang San for Obj=person objects
7. Obj=person object of Name= Fluffy
8. Obj=person object of Name= Big Bear
9. Obj=1
10. Obj=2.123
11. Name= Zhang San for Obj=person objects

Using XStream is the implementation of XML and Java Object Conversion (6)--persistence