使用XStream是实现XML与Java对象的转换(6)--持久化

2022-10-19 14:42:56

九、持久化

在第八节的示例中，当我们操作一组对象时，我们可以指定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;
  2. import java.io.File;
  3. import java.util.List;
  4. import com.thoughtworks.xstream.persistence.FilePersistenceStrategy;
  5. import com.thoughtworks.xstream.persistence.PersistenceStrategy;
  6. import com.thoughtworks.xstream.persistence.XmlArrayList;
  7. public class PersistenceMain {
  8. public static void main(String[] args) {
  9. //创建持久化策略（定义存储工具和存储位置）
  10. //注：d:/tmp是一个已存在的目录，否则会报错
  11. PersistenceStrategy strategy = new FilePersistenceStrategy(
  12. new File("d:/tmp"));
  13. //创建操作工具
  14. List list = new XmlArrayList(strategy);
  15. System.out.println("刚创建XmlArrayList对象时list.size()="+list.size());
  16. //添加数据
  17. list.add(new Person("张三"));
  18. list.add(new Person("李四"));
  19. list.add(new Person("毛毛"));
  20. list.add(new Person("大熊"));
  21. System.out.println("添加了4个元素之后list.size()="+list.size());
  22. //删除“李四”
  23. list.remove(1);
  24. System.out.println("删除了1个元素之后list.size()="+list.size());
  25. }
  26. }
  27. class Person {
  28. public Person(String name) {
  29. this.name = name;
  30. }
  31. private String name;
  32. public String getName() {
  33. return name;
  34. }
  35. public void setName(String name) {
  36. this.name = name;
  37. }
  38. public String toString() {
  39. return "Person对象的name=" + getName();
  40. }
  41. }

运行结果：

  1. 刚创建XmlArrayList对象时list.size()=0
  2. 添加了4个元素之后list.size()=4
  3. 删除了1个元素之后list.size()=3

现在我们查看d:/tmp目录，我们会发现有3个文件int@0.xml、int@1.xml和int@2.xml。这3个文件就是我们存储的3个Person对象，他们的内容分别是：

int@0.xml文件：

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

int@1.xml文件

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

int@2.xml文件：

  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;
  2. import java.io.File;
  3. import java.util.Iterator;
  4. import java.util.List;
  5. import com.thoughtworks.xstream.persistence.FilePersistenceStrategy;
  6. import com.thoughtworks.xstream.persistence.PersistenceStrategy;
  7. import com.thoughtworks.xstream.persistence.XmlArrayList;
  8. public class UsageTestMain {
  9. // XmlArrayList的用法
  10. public static void main(String[] args) {
  11. // 创建持久化策略（定义存储工具和存储位置）
  12. // 注：d:/tmp是一个已存在的目录，否则会报错
  13. PersistenceStrategy strategy = new FilePersistenceStrategy(new File(
  14. "d:/tmp"));
  15. // 创建操作工具
  16. List list = new XmlArrayList(strategy);
  17. System.out.println("刚创建XmlArrayList对象时list.size()="+list.size());
  18. System.out.println();
  19. //获取迭代器
  20. Iterator iter = list.iterator();
  21. System.out.println("******遍历每一个元素******");
  22. //遍历每一个元素
  23. while(iter.hasNext()){
  24. Person p = (Person)iter.next();
  25. System.out.println("当前元素p="+p);
  26. }
  27. }
  28. }

运行结果：

  1. 刚创建XmlArrayList对象时list.size()=3
  2. ******遍历每一个元素******
  3. 当前元素p=Person对象的name=张三
  4. 当前元素p=Person对象的name=毛毛
  5. 当前元素p=Person对象的name=大熊

3，定制自己的转换器(Local Converter)

由于内存中存储了大量数据，我们可以使用文件系统暂存，内存中只记录存放文件的目录即可，这是我们可以自己定义一个转换器：

  1. package cn.tjpu.zhw.xml.xstream6;
  2. import java.io.File;
  3. import java.util.ArrayList;
  4. import java.util.Collection;
  5. import com.thoughtworks.xstream.XStream;
  6. import com.thoughtworks.xstream.converters.Converter;
  7. import com.thoughtworks.xstream.converters.MarshallingContext;
  8. import com.thoughtworks.xstream.converters.UnmarshallingContext;
  9. import com.thoughtworks.xstream.io.HierarchicalStreamReader;
  10. import com.thoughtworks.xstream.io.HierarchicalStreamWriter;
  11. import com.thoughtworks.xstream.persistence.FilePersistenceStrategy;
  12. import com.thoughtworks.xstream.persistence.XmlArrayList;
  13. //自己定义一个局部转换器
  14. public final class LocalArrayListConverter implements Converter {
  15. private XStream xstream;
  16. public LocalArrayListConverter(XStream xstream) {
  17. this.xstream = xstream;
  18. }
  19. //将Collection对象序列化到文件中
  20. //注：序列化时内存中并没有存放集合中的内容，只是暂存了这些文件存放的目录
  21. public void marshal(Object source, HierarchicalStreamWriter writer,
  22. MarshallingContext context) {
  23. File dir = new File("d:/tmp");
  24. //创建持久化工具，并加载目录中的所有文件
  25. XmlArrayList list = new XmlArrayList(
  26. new FilePersistenceStrategy(dir,xstream));
  27. context.convertAnother(dir);
  28. //生成文件
  29. list.addAll((Collection) source);
  30. }
  31. //从文件中读取信息，反序列换为Collection对象
  32. //注：反序列化时会删除暂存目录下的所有文件
  33. public Object unmarshal(
  34. HierarchicalStreamReader reader,
  35. UnmarshallingContext context) {
  36. File directory = (File) context.convertAnother(null, File.class);
  37. //创建持久化工具，并加载目录中的所有文件
  38. XmlArrayList persistentList = new XmlArrayList(
  39. new FilePersistenceStrategy(directory, xstream));
  40. //将已加载的信息复制一份到list中
  41. ArrayList list = new ArrayList(persistentList);
  42. //删除所有文件
  43. persistentList.clear();
  44. //返回已加载的信息
  45. return list;
  46. }
  47. public boolean canConvert(Class type) {
  48. return type == ArrayList.class;
  49. }
  50. }

这个转换器是转换ArrayList对象的。

下面是我们的测试程序：

  1. package cn.tjpu.zhw.xml.xstream6;
  2. import java.util.ArrayList;
  3. import java.util.Collection;
  4. import java.util.List;
  5. import com.thoughtworks.xstream.XStream;
  6. public class LocalConverterMain {
  7. public static void main(String[] args) {
  8. XStream xstream = new XStream();
  9. xstream.alias("volume", Volume.class);
  10. //使用自定义的转换器LocalArrayListConverter来转换Volume类的documents字段
  11. //这个转换器是受限制的局部（local）转换器，只能转换Volume类的documents字段
  12. xstream.registerLocalConverter(Volume.class, "documents",
  13. new LocalArrayListConverter(xstream));
  14. //要转换的对象
  15. Volume volume = new Volume();
  16. //创建集合
  17. Collection coll = new ArrayList();
  18. coll.add(1);
  19. coll.add(2.123d);
  20. coll.add(new Person("张三"));
  21. volume.documents.addAll(coll);
  22. System.out.println("******序列化******");
  23. //转换XML
  24. String xml = xstream.toXML(volume);
  25. //输出XML
  26. System.out.println(xml);
  27. System.out.println("******反序列化******");
  28. Volume v2 = (Volume)xstream.fromXML(xml);
  29. for(Object obj:v2.documents){
  30. System.out.println("obj="+obj);
  31. }
  32. }
  33. }
  34. abstract class AbstractDocument {
  35. String title;
  36. }
  37. class TextDocument extends AbstractDocument {
  38. List chapters = new ArrayList();
  39. }
  40. class ScannedDocument {
  41. List images = new ArrayList();
  42. }
  43. class Volume {
  44. List documents = new ArrayList();
  45. }

运行结果：

  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=张三
上一篇：【Hadoop离线基础总结】linux的shell编程


下一篇：POJ 1018 Communication System（贪心）