【转】使用XStream实现xml和java对象相互转换

XStream是一个开源项目，一套简单实用的类库，用于序列化对象与XML对象之间的相互转换。将XML文件内容解析为一个对象或将一个对象序列化为XML文件。

 

XStream的相关信息可以到http://xstream.codehaus.org/下查看，它有专门的JavaDoc，可以方便的阅读Xstream的函数及方法。

 

        基本原理
Xstream这个组件也提供了一个XML自省(introspection)机制用来把Java Bean映射成XML信息或者把XML信息映射成Java Bean。不同的是在解析xml信息时采用的是DOM方式。

 

        核心类,方法及步骤简介
Xstream在把xml信息和java bean相互转换的过程中用到同一个应用类。
com.thoughtworks.xstream.XStream

 

--------------------------------------------------------------
常用的方法：
 XStream xstream = new XStream();
 

Person newJoe = (Person)xstream.fromXML(xml);   用于从xml中将对象解析出来。
 

String xml = xstream.toXML(joe);  用于将对象序列化为xml文件。

 

ObjectOutputStream out = xstream.createObjectOutputStream(someWriter);

 

ObjectInputStream in = xstream.createObjectInputStream(someReader);

--------------------------------------------------------------

 

另附官方示例用法文档：

Two Minute Tutorial

 

This is a very quick introduction to XStream. Skim read it to get an idea of how simple it is to convert objects to XML and back again. I'm sure you'll have questions afterwards.

Create classes to be serialized

Here's a couple of simple classes. XStream can convert instances of these to XML and back again.

 

public class Person {
  private String firstname;
  private String lastname;
  private PhoneNumber phone;
  private PhoneNumber fax;
  // ... constructors and methods
}

 

public class PhoneNumber {
  private int code;
  private String number;
  // ... constructors and methods
}

 

Note: Notice that the fields are private. XStream doesn't care about the visibility of the fields. No getters or setters are needed. Also, XStream does not limit you to having a default constructor.

Initializing XStream

 

To use XStream, simply instantiate the XStream class:

XStream xstream = new XStream();

 

You require xstream-[version].jar and xpp3-[version].jar in the classpath. XPP3 is a very fast XML pull-parser implementation. If you do not want to include this dependency, you can use a standard JAXP DOM parser instead:

XStream xstream = new XStream(new DomDriver()); // does not require XPP3 library

 

Note: This class is a simple facade designed for common operations. For more flexibility you may choose to create your own facade that behaves differently.

 

Now, to make the XML outputted by XStream more concise, you can create aliases for your custom class names to XML element names. This is the only type of mapping required to use XStream and even this is optional.

 

xstream.alias("person", Person.class);
xstream.alias("phonenumber", PhoneNumber.class);

 

Note: This is an optional step. Without it XStream would work fine, but the XML element names would contain the fully qualified name of each class (including package) which would bulk up the XML a bit.

Serializing an object to XML

Let's create an instance of Person and populate its fields:

 

Person joe = new Person("Joe", "Walnes");
joe.setPhone(new PhoneNumber(123, "1234-456");
joe.setFax(new PhoneNumber(123, "9999-999");

 

Now, to convert it to XML, all you have to do is make a simple call to XStream:

String xml = xstream.toXML(joe);

 

The resulting XML looks like this:

<person>
  <firstname>Joe</firstname>
  <lastname>Walnes</lastname>
  <phone>
    <code>123</code>
    <number>1234-456</number>
  </phone>
  <fax>
    <code>123</code>
    <number>9999-999</number>
  </fax>
</person>

 

It's that simple. Look at how clean the XML is.

Deserializing an object back from XML

To reconstruct an object, purely from the XML:

Person newJoe = (Person)xstream.fromXML(xml);

And that's how simple XStream is!

Summary

To recap:

    * Create element name to class name aliases for any custom classes using xstream.alias(String elementName, Class cls);
    * Convert an object to XML using xstream.toXML(Object obj);
    * Convert XML back to an object using xstream.fromXML(String xml);

 

Object Streams

XStream provides alternative implementations of java.io.ObjectInputStream and java.io.ObjectOutputStream, allowing streams of objects to be serialized or deserialized from XML.

 

This is useful when processing large sets of objects, as only one needs to be in memory at a time.

Using the Object Streams

The interface to the object streaming capabilities of XStream is through the standard java.io.ObjectOutputStream and java.io.ObjectInputStream objects.

Example

To serialize a stream of objects to XML:

 

ObjectOutputStream out = xstream.createObjectOutputStream(someWriter);

out.writeObject(new Person("Joe", "Walnes"));
out.writeObject(new Person("Someone", "Else"));
out.writeObject("hello");
out.writeInt(12345);

out.close();

 

 

The resulting XML:

<object-stream>
  <com.blah.Person>
    <firstname>Joe</firstname>
    <lastname>Walnes</lastname>
  </com.blah.Person>
  <com.blah.Person>
    <firstname>Someone</firstname>
    <lastname>Else</lastname>
  </com.blah.Person>
  <string>hello</string>
  <int>123</int>
</object-stream>

 

 

To deserialze the stream of objects from the XML:

 

ObjectInputStream in = xstream.createObjectInputStream(someReader);

Person a = (Person)in.readObject();
Person b = (Person)in.readObject();
String c = (String)in.readObject();
int    d = in.readInt();

 

 

Considerations
Root node

 

Because an XML document can only have a single root node, all the serialized elements must be wrapped in an additional root node. This root node defaults to <object-stream>, as shown in the example above.

 

This can be changed by using the overloaded method: xstream.createObjectOutputStream(Writer writer, String rootNodeName);

Close the ObjectOutputStream

Remember to call ObjectOutputStream.close(), otherwise the stream will contain incomplete XML.

Detecting the end of the ObjectInputStream

When there are no more objects left to read in the stream, ObjectInputStream.readObject() (or primitive equivalent) will throw java.io.EOFException.