九、持久化

在第八節的示例中，當我們操作一組對象時，我們可以指定Writer、OutputStream來寫出序列化後的XML數據，我們還可以指定Reader、InputStream來讀取序列化後的XML數據。當我們需要寫出和讀取文件時都需要指定輸入輸出流，並且需要明確的調用輸入輸出方法來實現Java對象的序列化和反序列化，其實我們完全可以讓Java對象的序列化和反序列化操作隱性的、自動的完成，這就是我們要學的內容：PersistenceStrategy、XmlArrayList、XmlMap和XmlSet。

PersistenceStrategy是我們的持久化策略，定義了我們的存儲和讀取協議，是實際做存儲和讀取XML的工具。XStream框架提供的持久化策略只有FilePersistenceStrategy這一種，即將XML數據持久化到文件系統中，但是我們可以定義自己的持久化策略（比如持久化到數據庫中），只要繼承PersistenceStrategy接口就行了。

XmlArrayList、XmlMap和XmlSet是我們熟悉的3個集合工具類，它們可以讓我們以我們非常熟悉的方式操作Java對象，並且隱性的存儲和讀取為我們需要的XML。

下面我們以XmlArrayList為例來學習。

1，簡單的存儲

程序如下：

1. package cn.tjpu.zhw.xml.xstream6;
3. import java.io.File;
4. import java.util.List;
6. import com.thoughtworks.xstream.persistence.FilePersistenceStrategy;
7. import com.thoughtworks.xstream.persistence.PersistenceStrategy;
8. import com.thoughtworks.xstream.persistence.XmlArrayList;
10. public class PersistenceMain {
12. public static void main(String[] args) {
13. //創建持久化策略（定義存儲工具和存儲位置）
14. //註：d:/tmp是一個已存在的目錄，否則會報錯
15. PersistenceStrategy strategy = new FilePersistenceStrategy(
16. new File("d:/tmp"));
18. //創建操作工具
19. List list = new XmlArrayList(strategy);
20. System.out.println("剛創建XmlArrayList對象時list.size()="+list.size());
22. //添加數據
23. list.add(new Person("張三"));
24. list.add(new Person("李四"));
25. list.add(new Person("毛毛"));
26. list.add(new Person("大熊"));
28. System.out.println("添加了4個元素之後list.size()="+list.size());
29. //刪除“李四”
30. list.remove(1);
31. System.out.println("刪除了1個元素之後list.size()="+list.size());
32. }
34. }
36. class Person {
37. public Person(String name) {
38. this.name = name;
39. }
41. private String name;
43. public String getName() {
44. return name;
45. }
47. public void setName(String name) {
48. this.name = name;
49. }
51. public String toString() {
52. return "Person對象的name=" + getName();
53. }
54. }

運行結果：

1. 剛創建XmlArrayList對象時list.size()=0
2. 添加了4個元素之後list.size()=4
3. 刪除了1個元素之後list.size()=3

現在我們查看d:/tmp目錄，我們會發現有3個文件[email protected]、[email protected]和[email protected]。這3個文件就是我們存儲的3個Person對象，他們的內容分別是：

[email protected]文件：

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

[email protected]文件

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

[email protected]文件：

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

其實，在我們每一次調用add方法的時候，都有一次持久化過程，每次都會將文件寫入到d:/tmp目錄。

2，所有我們熟悉的操作方法

由於XmlArrayList、XmlMap和XmlSet繼承我們熟悉各個集合接口，所以我們可以向操作List、Map和Set一樣來操作我們的數據，所不同的是原來我們集合中的數據在內存中，現在卻在我們預定義的持久化策略中。

編寫程序如下：

1. package cn.tjpu.zhw.xml.xstream6;
3. import java.io.File;
4. import java.util.Iterator;
5. import java.util.List;
7. import com.thoughtworks.xstream.persistence.FilePersistenceStrategy;
8. import com.thoughtworks.xstream.persistence.PersistenceStrategy;
9. import com.thoughtworks.xstream.persistence.XmlArrayList;
11. public class UsageTestMain {
13. // XmlArrayList的用法
14. public static void main(String[] args) {
15. // 創建持久化策略（定義存儲工具和存儲位置）
16. // 註：d:/tmp是一個已存在的目錄，否則會報錯
17. PersistenceStrategy strategy = new FilePersistenceStrategy(new File(
18. "d:/tmp"));
20. // 創建操作工具
21. List list = new XmlArrayList(strategy);
22. System.out.println("剛創建XmlArrayList對象時list.size()="+list.size());
24. System.out.println();
26. //獲取叠代器
27. Iterator iter = list.iterator();
29. System.out.println("******遍歷每一個元素******");
30. //遍歷每一個元素
31. while(iter.hasNext()){
32. Person p = (Person)iter.next();
33. System.out.println("當前元素p="+p);
34. }
35. }
37. }

運行結果：

1. 剛創建XmlArrayList對象時list.size()=3
3. ******遍歷每一個元素******
4. 當前元素p=Person對象的name=張三
5. 當前元素p=Person對象的name=毛毛
6. 當前元素p=Person對象的name=大熊

3，定制自己的轉換器(Local Converter)

由於內存中存儲了大量數據，我們可以使用文件系統暫存，內存中只記錄存放文件的目錄即可，這是我們可以自己定義一個轉換器：

1. package cn.tjpu.zhw.xml.xstream6;
3. import java.io.File;
4. import java.util.ArrayList;
5. import java.util.Collection;
7. import com.thoughtworks.xstream.XStream;
8. import com.thoughtworks.xstream.converters.Converter;
9. import com.thoughtworks.xstream.converters.MarshallingContext;
10. import com.thoughtworks.xstream.converters.UnmarshallingContext;
11. import com.thoughtworks.xstream.io.HierarchicalStreamReader;
12. import com.thoughtworks.xstream.io.HierarchicalStreamWriter;
13. import com.thoughtworks.xstream.persistence.FilePersistenceStrategy;
14. import com.thoughtworks.xstream.persistence.XmlArrayList;
16. //自己定義一個局部轉換器
17. public final class LocalArrayListConverter implements Converter {
18. private XStream xstream;
20. public LocalArrayListConverter(XStream xstream) {
21. this.xstream = xstream;
22. }
24. //將Collection對象序列化到文件中
25. //註：序列化時內存中並沒有存放集合中的內容，只是暫存了這些文件存放的目錄
26. public void marshal(Object source, HierarchicalStreamWriter writer,
27. MarshallingContext context) {
28. File dir = new File("d:/tmp");
29. //創建持久化工具，並加載目錄中的所有文件
30. XmlArrayList list = new XmlArrayList(
31. new FilePersistenceStrategy(dir,xstream));
32. context.convertAnother(dir);
33. //生成文件
34. list.addAll((Collection) source);
35. }
37. //從文件中讀取信息，反序列換為Collection對象
38. //註：反序列化時會刪除暫存目錄下的所有文件
39. public Object unmarshal(
40. HierarchicalStreamReader reader,
41. UnmarshallingContext context) {
42. File directory = (File) context.convertAnother(null, File.class);
43. //創建持久化工具，並加載目錄中的所有文件
44. XmlArrayList persistentList = new XmlArrayList(
45. new FilePersistenceStrategy(directory, xstream));
46. //將已加載的信息復制一份到list中
47. ArrayList list = new ArrayList(persistentList);
48. //刪除所有文件
49. persistentList.clear();
50. //返回已加載的信息
51. return list;
52. }
54. public boolean canConvert(Class type) {
55. return type == ArrayList.class;
56. }
57. }

這個轉換器是轉換ArrayList對象的。

下面是我們的測試程序：

1. package cn.tjpu.zhw.xml.xstream6;
3. import java.util.ArrayList;
4. import java.util.Collection;
5. import java.util.List;
7. import com.thoughtworks.xstream.XStream;
9. public class LocalConverterMain {
11. public static void main(String[] args) {
12. XStream xstream = new XStream();
13. xstream.alias("volume", Volume.class);
15. //使用自定義的轉換器LocalArrayListConverter來轉換Volume類的documents字段
16. //這個轉換器是受限制的局部（local）轉換器，只能轉換Volume類的documents字段
17. xstream.registerLocalConverter(Volume.class, "documents",
18. new LocalArrayListConverter(xstream));
20. //要轉換的對象
21. Volume volume = new Volume();
23. //創建集合
24. Collection coll = new ArrayList();
25. coll.add(1);
26. coll.add(2.123d);
27. coll.add(new Person("張三"));
28. volume.documents.addAll(coll);
30. System.out.println("******序列化******");
31. //轉換XML
32. String xml = xstream.toXML(volume);
34. //輸出XML
35. System.out.println(xml);
37. System.out.println("******反序列化******");
38. Volume v2 = (Volume)xstream.fromXML(xml);
39. for(Object obj:v2.documents){
40. System.out.println("obj="+obj);
41. }
42. }
44. }
46. abstract class AbstractDocument {
47. String title;
48. }
50. class TextDocument extends AbstractDocument {
51. List chapters = new ArrayList();
52. }
54. class ScannedDocument {
55. List images = new ArrayList();
56. }
58. class Volume {
59. List documents = new ArrayList();
60. }

運行結果：

1. ******序列化******
2. <volume>
3. <documents>d:\tmp</documents>
4. </volume>
5. ******反序列化******
6. obj=Person對象的name=張三
7. obj=Person對象的name=毛毛
8. obj=Person對象的name=大熊
9. obj=1
10. obj=2.123
11. obj=Person對象的name=張三

使用XStream是實現XML與Java對象的轉換(6)--持久化