• 使用XStream是实现XML与Java对象的转换(4)--转换器

    七、转换器(Converter)

    我们程序中的POJO是千变万化的，而且需求也是千奇百怪的，所以XStream中的内置的转换器的功能不一定能够满足我们的要求，所以我们就需要自己构建转换器。

    1，一个基本的转换器

    有如下代码：

    Java代码  
    1. import com.thoughtworks.xstream.XStream;  
    2. import com.thoughtworks.xstream.io.xml.DomDriver;  
    3.    
    4. public class XStreamTest4 {  
    5.    public static void main(String[] args) {  
    6.       Person person = new Person();  
    7.       person.setName("张三");  
    8.    
    9.       XStream xstream = new XStream(new DomDriver());  
    10.       xstream.alias("person", Person.class);  
    11.       System.out.println(xstream.toXML(person));  
    12.    }  
    13. }  
    14.    
    15. class Person {  
    16.    
    17.    private String name;  
    18.    
    19.    public String getName() {  
    20.       return name;  
    21.    }  
    22.    
    23.    public void setName(String name) {  
    24.       this.name = name;  
    25.    }  
    26.    
    27.    public String toString() {  
    28.       return getName();  
    29.    }  
    30. }  

    运行结果是：

    Java代码  
    1. <person>  
    2.   <name>张三</name>  
    3. </person>  

    如果我们需要输出如下信息：

    Java代码  
    1. <person>  
    2.   <fullname>张三</fullname>  
    3. </person>  

    该怎么办？

    当然，我们可以使用XStream默认的转换器

    Java代码  
    1. xstream.aliasField("fullname", Person.class,"name");  

    ，甚至我们可以直接使用注解@XStreamAlias。但是这不是我们要介绍的，我们需要创建自己的转换器PersonConverter。

    PersonConverter需要有3个功能：

    a)告诉XStream对象，它能够转换Person类的对象（canConvert方法）

    b)能够将Person对象转换为XML（marshal方法）

    c)能够将XML转换成为Person对象（unmarshal方法）

    现在，我们实现第一个功能（canConvert方法）：

    Java代码  
    1. //告诉XStream对象，它能够转换Person类的对象  
    2.    public boolean canConvert(Class clazz) {  
    3.       return clazz.equals(Person.class);  
    4.    }  

    就这么简单！

    然后，我们实现第二个功能（marshal方法）：

    Java代码  
    1. //能够将Person对象转换为XML  
    2.    public void marshal(  
    3.         Object value,            //我们将要转换的对象，这里是Person对象  
    4.         HierarchicalStreamWriter writer,//用于输出XML结果的writer  
    5.         MarshallingContext context     //序列化环境上下文  
    6.         ) {  
    7.       //写入顺序  
    8.       //1，强制转换为我们我们需要的类型  
    9.       Person person = (Person) value;  
    10.       //2，开始写入fullname节点，相当于写入<fullname>  
    11.       writer.startNode("fullname");  
    12.       //3，给fullname节点赋值  
    13.       writer.setValue(person.getName());  
    14.       //4，结束fullname节点，相当于写入</fullname>  
    15.       writer.endNode();  
    16.        
    17.        
    18. //    //如果你愿意，顺便也可以写一点其他的东西  
    19. //    writer.startNode("otherContent");  
    20. //    writer.setValue("这是一大串其他内容，你可以根据自己的需要写内容！");  
    21. //    writer.endNode();  
    22.    }  

    最后，我们实现第三个功能（unmarshal方法）：

    Java代码  
    1. //能够将XML转换成为Person对象  
    2.    public Object unmarshal(  
    3.         HierarchicalStreamReader reader,//用于读取XML的reader  
    4.         UnmarshallingContext context   //反序列化环境上下文  
    5.         ) {  
    6.       //1，先创建一个Person对象  
    7.       Person person = new Person();  
    8.       //2，判断<person>节点下还有没有其他可以读取的节点  
    9.       while(reader.hasMoreChildren()){  
    10.         //3，开始读取下一个（也可能是第一个）节点，选择当前<person>节点的子节点作为当前节点  
    11.         reader.moveDown();  
    12.         //4，获取当前节点的值  
    13.         String value = reader.getValue();  
    14.         if("fullname".equals(reader.getNodeName())){  
    15.            person.setName(value);  
    16.         }  
    17.         //输出当前节点的内容  
    18.         System.out.println("node="+reader.getNodeName()+";value="+value);  
    19.         //5，返回上一层节点<person>  
    20.         reader.moveUp();  
    21.       }  
    22.       return person;  
    23.    }  

    于是我们的PersonConverter就是：

    Java代码  
    1. package cn.tjpu.zhw.xml.xstream4;  
    2.    
    3. import com.thoughtworks.xstream.converters.Converter;  
    4. import com.thoughtworks.xstream.converters.MarshallingContext;  
    5. import com.thoughtworks.xstream.converters.UnmarshallingContext;  
    6. import com.thoughtworks.xstream.io.HierarchicalStreamReader;  
    7. import com.thoughtworks.xstream.io.HierarchicalStreamWriter;  
    8.    
    9. public class PersonConverter implements Converter {  
    10.    
    11.    //告诉XStream对象，它能够转换Person类的对象  
    12.    public boolean canConvert(Class clazz) {  
    13.       return clazz.equals(Person.class);  
    14.    }  
    15.    
    16.    //能够将Person对象转换为XML  
    17.    public void marshal(  
    18.         Object value,            //我们将要转换的对象，这里是Person对象  
    19.         HierarchicalStreamWriter writer,//用于输出XML结果的writer  
    20.         MarshallingContext context     //序列化环境上下文  
    21.         ) {  
    22.       //写入顺序  
    23.       //1，强制转换为我们我们需要的类型  
    24.       Person person = (Person) value;  
    25.       //2，开始写入fullname节点，相当于写入<fullname>  
    26.       writer.startNode("fullname");  
    27.       //3，给fullname节点赋值  
    28.       writer.setValue(person.getName());  
    29.       //4，结束fullname节点，相当于写入</fullname>  
    30.       writer.endNode();  
    31.        
    32.        
    33. //    //如果你愿意，顺便也可以写一点其他的东西  
    34. //    writer.startNode("otherContent");  
    35. //    writer.setValue("这是一大串其他内容，你可以根据自己的需要写内容！");  
    36. //    writer.endNode();  
    37.    }  
    38.    
    39.    //能够将XML转换成为Person对象  
    40.    public Object unmarshal(  
    41.         HierarchicalStreamReader reader,//用于读取XML的reader  
    42.         UnmarshallingContext context   //反序列化环境上下文  
    43.         ) {  
    44.       //1，先创建一个Person对象  
    45.       Person person = new Person();  
    46.       //2，判断<person>节点下还有没有其他可以读取的节点  
    47.       while(reader.hasMoreChildren()){  
    48.         //3，开始读取下一个（也可能是第一个）节点，选择当前<person>节点的子节点作为当前节点  
    49.         reader.moveDown();  
    50.         //4，获取当前节点的值  
    51.         String value = reader.getValue();  
    52.         if("fullname".equals(reader.getNodeName())){  
    53.            person.setName(value);  
    54.         }  
    55.         //输出当前节点的内容  
    56.         System.out.println("node="+reader.getNodeName()+";value="+value);  
    57.         //5，返回上一层节点<person>  
    58.         reader.moveUp();  
    59.       }  
    60.       return person;  
    61.    }  
    62. }  

    同时我们修改main方法文件：

    Java代码  
    1. package cn.tjpu.zhw.xml.xstream4;  
    2.    
    3.    
    4. import com.thoughtworks.xstream.XStream;  
    5. import com.thoughtworks.xstream.io.xml.DomDriver;  
    6.    
    7. public class XStreamTest4 {  
    8.    public static void main(String[] args) {  
    9.       //创建Person对象  
    10.       Person person = new Person();  
    11.       person.setName("张三");  
    12.    
    13.       //创建XStream对象  
    14.       XStream xstream = new XStream(new DomDriver());  
    15.       xstream.alias("person", Person.class);  
    16.        
    17.       //注册PersonConverter转换器  
    18.       xstream.registerConverter(new PersonConverter());  
    19.        
    20.       //使用marshal方法，将Person对象转换成为XML  
    21.       System.out.println("****使用marshal方法，将Person对象转换成为XML==>");  
    22.       String xml = xstream.toXML(person);  
    23.       System.out.println(xml);  
    24.        
    25.       //使用unmarshal方法，将XML转换成为Person对象  
    26.       System.out.println();  
    27.       System.out.println("****使用unmarshal方法，将XML转换成为Person对象==>");  
    28.       Person p = (Person)xstream.fromXML(xml);  
    29.        
    30.       //输出Person对象  
    31.       System.out.println();  
    32.       System.out.println("****输出Person对象==>");  
    33.       System.out.println(p);  
    34.    }  
    35. }  
    36.    
    37. class Person {  
    38.    
    39.    private String name;  
    40.    
    41.    public String getName() {  
    42.       return name;  
    43.    }  
    44.    
    45.    public void setName(String name) {  
    46.       this.name = name;  
    47.    }  
    48.    
    49.    public String toString() {  
    50.       return "Person对象的name="+getName();  
    51.    }  
    52. }  

    运行结果如下：

    Java代码  
    1. ****使用marshal方法，将Person对象转换成为XML==>  
    2. <person>  
    3.   <fullname>张三</fullname>  
    4. </person>  
    5.    
    6. ****使用unmarshal方法，将XML转换成为Person对象==>  
    7. node=fullname;value=张三  
    8.    
    9. ****输出Person对象==>  
    10. Person对象的name=张三  

    我们成功了！！！！！！

    2，另一个简单的转换器

    现在我们需要程序输出如下：

    <person>张三</person>

    该咋办？

    我们再创建一个转换器：

    Java代码  
    1. package cn.tjpu.zhw.xml.xstream4;  
    2.    
    3. import com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter;  
    4.    
    5. public class AnotherPersonConverter extends AbstractSingleValueConverter {  
    6.    
    7.    // 告诉XStream对象，它能够转换Person类的对象  
    8.    public boolean canConvert(Class clazz) {  
    9.       return clazz.equals(Person.class);  
    10.    }  
    11.    
    12.    // 将Person对象转换为XML，参数obj就是要转换的Person对象，返回值就是<person>节点的值  
    13.    public String toString(Object obj) {  
    14.       Person p = (Person) obj;  
    15.       return p.getName();  
    16.    }  
    17.    
    18.    // 将XML转换成为Person对象，参数str就是<person>节点的值，返回值就是转换得到的Person对象  
    19.    public Object fromString(String str) {  
    20.       Person person = new Person();  
    21.       person.setName(str);  
    22.       System.out.println("参数str="+str);  
    23.       return person;  
    24.    }  
    25. }  

    修改Main方法：

    Java代码  
    1. public class XStreamTest4 {  
    2.    public static void main(String[] args) {  
    3.       //创建Person对象  
    4.       Person person = new Person();  
    5.       person.setName("张三");  
    6.    
    7.       //创建XStream对象  
    8.       XStream xstream = new XStream(new DomDriver());  
    9.       xstream.alias("person", Person.class);  
    10.        
    11. //    //注册PersonConverter转换器  
    12. //    xstream.registerConverter(new PersonConverter());  
    13.        
    14.       //注册AnotherPersonConverter转换器  
    15.       xstream.registerConverter(new AnotherPersonConverter());  
    16.        
    17.       //使用toString方法，将Person对象转换成为XML  
    18.       System.out.println("****使用toString方法，将Person对象转换成为XML==>");  
    19.       String xml = xstream.toXML(person);  
    20.       System.out.println(xml);  
    21.        
    22.       //使用fromString方法，将XML转换成为Person对象  
    23.       System.out.println();  
    24.       System.out.println("****使用fromString方法，将XML转换成为Person对象==>");  
    25.       Person p = (Person)xstream.fromXML(xml);  
    26.        
    27.       //输出Person对象  
    28.       System.out.println();  
    29.       System.out.println("****输出Person对象==>");  
    30.       System.out.println(p);  
    31.    }  
    32. }  

    运行结果：

    Java代码  
    1. ****使用toString方法，将Person对象转换成为XML==>  
    2. <person>张三</person>  
    3.    
    4. ****使用fromString方法，将XML转换成为Person对象==>  
    5. 参数str=张三  
    6.    
    7. ****输出Person对象==>  
    8. Person对象的name=张三  

    这正是我们预期的结果！！！

    3，时间转换器

    通过上面两个例子我们知道了Converter接口的简单工作方式，现在我们创建一个新的时间转换器DateConverter，这个时间转换器将以Local对象作为构造方法的参数。

    这个时间转换器同样有类似PersonConverter转换器的功能：

    a)告诉XStream对象，它能够转换Calendar类的对象（canConvert方法）

    b)能够将Calendar对象转换为XML（marshal方法）

    c)能够将XML转换成为Calendar对象（unmarshal方法）

    现在实现第一个功能：

    Java代码  
    1. // 告诉XStream对象，它能够转换Calendar类及其所有子类定义的对象  
    2.    public boolean canConvert(Class clazz) {  
    3.       return Calendar.class.isAssignableFrom(clazz);  
    4.    }  

    然后，实现第二个功能：

    Java代码  
    1. // 能够将Calendar对象转换为XML  
    2.    public void marshal(Object value, HierarchicalStreamWriter writer,  
    3.         MarshallingContext context) {  
    4.       //value是将要转换的Calendar对象  
    5.       Calendar calendar = (Calendar) value;  
    6.       Date date = calendar.getTime();  
    7.        
    8.       //设定格式化格式  
    9.       DateFormat formatter = DateFormat.getDateInstance(DateFormat.FULL,  
    10.            this.locale);  
    11.        
    12.       //格式化并输出Calendar对象  
    13.       writer.setValue(formatter.format(date));  
    14.    }  

    最后，实现最后一个功能：

    Java代码  
    1. // 能够将XML转换成为Calendar对象  
    2.    public Object unmarshal(HierarchicalStreamReader reader,  
    3.         UnmarshallingContext context) {  
    4.       //创建一个Calendar对象  
    5.       GregorianCalendar calendar = new GregorianCalendar();  
    6.        
    7.       //设定解析格式  
    8.       DateFormat formatter = DateFormat.getDateInstance(DateFormat.FULL,  
    9.            this.locale);  
    10.       try {  
    11.         //解析指定格式的Calendar对象  
    12.         calendar.setTime(formatter.parse(reader.getValue()));  
    13.       } catch (ParseException e) {  
    14.         throw new ConversionException(e.getMessage(), e);  
    15.       }  
    16.       //返回解析成功的Calendar对象  
    17.       return calendar;  
    18.    }  

    于是，我们的DateConverter定义如下：

    Java代码  
    1. package cn.tjpu.zhw.xml.xstream4;  
    2.    
    3. import java.text.DateFormat;  
    4. import java.text.ParseException;  
    5. import java.util.Calendar;  
    6. import java.util.Date;  
    7. import java.util.GregorianCalendar;  
    8. import java.util.Locale;  
    9.    
    10. import com.thoughtworks.xstream.converters.ConversionException;  
    11. import com.thoughtworks.xstream.converters.Converter;  
    12. import com.thoughtworks.xstream.converters.MarshallingContext;  
    13. import com.thoughtworks.xstream.converters.UnmarshallingContext;  
    14. import com.thoughtworks.xstream.io.HierarchicalStreamReader;  
    15. import com.thoughtworks.xstream.io.HierarchicalStreamWriter;  
    16.    
    17. public class DateConverter implements Converter {  
    18.    
    19.    private Locale locale;  
    20.    
    21.    public DateConverter(Locale locale) {  
    22.       super();  
    23.       this.locale = locale;  
    24.    }  
    25.    
    26.    // 告诉XStream对象，它能够转换Calendar类及其所有子类定义的对象  
    27.    public boolean canConvert(Class clazz) {  
    28.       return Calendar.class.isAssignableFrom(clazz);  
    29.    }  
    30.    
    31.    // 能够将Calendar对象转换为XML  
    32.    public void marshal(Object value, HierarchicalStreamWriter writer,  
    33.         MarshallingContext context) {  
    34.       //value是将要转换的Calendar对象  
    35.       Calendar calendar = (Calendar) value;  
    36.       Date date = calendar.getTime();  
    37.        
    38.       //设定格式化格式  
    39.       DateFormat formatter = DateFormat.getDateInstance(DateFormat.FULL,  
    40.            this.locale);  
    41.        
    42.       //格式化并输出Calendar对象  
    43.       writer.setValue(formatter.format(date));  
    44.    }  
    45.    
    46.    // 能够将XML转换成为Calendar对象  
    47.    public Object unmarshal(HierarchicalStreamReader reader,  
    48.         UnmarshallingContext context) {  
    49.       //创建一个Calendar对象  
    50.       GregorianCalendar calendar = new GregorianCalendar();  
    51.        
    52.       //设定解析格式  
    53.       DateFormat formatter = DateFormat.getDateInstance(DateFormat.FULL,  
    54.            this.locale);  
    55.       try {  
    56.         //解析指定格式的Calendar对象  
    57.         calendar.setTime(formatter.parse(reader.getValue()));  
    58.       } catch (ParseException e) {  
    59.         throw new ConversionException(e.getMessage(), e);  
    60.       }  
    61.       //返回解析成功的Calendar对象  
    62.       return calendar;  
    63.    }  
    64. }  

    再写我们的main方法：

    Java代码  
    1. package cn.tjpu.zhw.xml.xstream4;  
    2.    
    3. import java.text.DateFormat;  
    4. import java.util.Calendar;  
    5. import java.util.GregorianCalendar;  
    6. import java.util.Locale;  
    7.    
    8. import com.thoughtworks.xstream.XStream;  
    9. import com.thoughtworks.xstream.io.xml.DomDriver;  
    10.    
    11. public class DateMain {  
    12.    
    13.    public static void main(String[] args) {  
    14.       // 获取当前时间  
    15.       Calendar calendar = new GregorianCalendar();  
    16.    
    17.       // 创建XStream对象  
    18.       XStream xstream = new XStream(new DomDriver());  
    19.       xstream.alias("date", Calendar.class);  
    20.    
    21.       // 注册我们定义的时间转换器  
    22.       xstream.registerConverter(new DateConverter(new Locale("zh", "cn")));  
    23.    
    24.       // 转换并输出XML  
    25.       String xml = xstream.toXML(calendar);  
    26.       System.out.println(xstream.toXML(calendar));  
    27.    
    28.       // 加载XML中的时间数据  
    29.       Calendar loaded = (Calendar) xstream.fromXML(xml);  
    30.       //格式化并输出时间  
    31.       System.out.println(DateFormat.getDateInstance(DateFormat.MEDIUM).format(  
    32.            loaded.getTime()));  
    33.    }  
    34. }  

    运行，结果如下：

    Java代码  
    1. <date>2013年12月24日 星期二</date>  
    2. 2013-12-24  

    4，更加复杂的转换器

    复杂的转换器都是由一系列基本的转换器组成的，我们只需要将这些基本的转换器按照适当的顺序排列组合就行了。

    下面有一个复杂的Birthday类：

    Java代码  
    1. package cn.tjpu.zhw.xml.xstream4;  
    2.    
    3. import java.util.Calendar;  
    4.    
    5.    
    6. public class Birthday {  
    7.    
    8.    private Person person;  
    9.    private Calendar date;  
    10.    private char gender;  
    11.    
    12.    public Person getPerson() {  
    13.       return person;  
    14.    }  
    15.    
    16.    public void setPerson(Person person) {  
    17.       this.person = person;  
    18.    }  
    19.    
    20.    public Calendar getDate() {  
    21.       return date;  
    22.    }  
    23.    
    24.    public void setDate(Calendar date) {  
    25.       this.date = date;  
    26.    }  
    27.    
    28.    public char getGender() {  
    29.       return gender;  
    30.    }  
    31.    
    32.    public void setGenderMale() {  
    33.       this.gender = 'm';  
    34.    }  
    35.    
    36.    public void setGenderFemale() {  
    37.       this.gender = 'f';  
    38.    }  
    39.     
    40.    public String toString(){  
    41.       return "{person="+person+"};{date="+date.getTime()+"};{gender="+gender+"}";  
    42.    }  
    43.    
    44. }  

    我们将怎样转换这个类呢？

    答案是，我们只需要将现有的转换器组合成一个BirthdayConverter转换器就成了！

    Java代码  
    1. package cn.tjpu.zhw.xml.xstream4;  
    2.    
    3. import java.util.Calendar;  
    4.    
    5. import com.thoughtworks.xstream.converters.ConversionException;  
    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.    
    12. public class BirthdayConverter implements Converter {  
    13.    
    14.    // 告诉XStream对象，它能够转换Birthday类的对象  
    15.    public boolean canConvert(Class clazz) {  
    16.       return Birthday.class == clazz;  
    17.    }  
    18.    
    19.    // 能够将Birthday对象转换为XML  
    20.    public void marshal(Object value, HierarchicalStreamWriter writer,  
    21.         MarshallingContext context) {  
    22.       //value是将要被转换的Birthday对象  
    23.       Birthday birthday = (Birthday) value;  
    24.        
    25.       //给<birthday>节点添加gender属性  
    26.       if (birthday.getGender() != '') {  
    27.         writer.addAttribute("gender",  
    28.               Character.toString(birthday.getGender()));  
    29.       }  
    30.        
    31.       //给<birthday>节点添加子节点<person>  
    32.       if (birthday.getPerson() != null) {  
    33.         writer.startNode("person");  
    34.         context.convertAnother(birthday.getPerson());  
    35.         writer.endNode();  
    36.       }  
    37.        
    38.       //给<birthday>节点添加子节点<birth>  
    39.       if (birthday.getDate() != null) {  
    40.         writer.startNode("birth");  
    41.         context.convertAnother(birthday.getDate());  
    42.         writer.endNode();  
    43.       }  
    44.    }  
    45.    
    46.    // 能够将XML转换成为Birthday对象  
    47.    public Object unmarshal(HierarchicalStreamReader reader,  
    48.         UnmarshallingContext context) {  
    49.       //创建Birthday对象  
    50.       Birthday birthday = new Birthday();  
    51.        
    52.       //当前节点是<birthday>  
    53.       //解析<birthday>节点的gender属性  
    54.       String gender = reader.getAttribute("gender");  
    55.       if (gender != null) {  
    56.         if (gender.length() > 0) {  
    57.            if (gender.charAt(0) == 'f') {  
    58.               birthday.setGenderFemale();  
    59.            } else if (gender.charAt(0) == 'm') {  
    60.               birthday.setGenderMale();  
    61.            } else {  
    62.               throw new ConversionException("Invalid gender value: "  
    63.                     + gender);  
    64.            }  
    65.         } else {  
    66.            throw new ConversionException(  
    67.                  "Empty string is invalid gender value");  
    68.         }  
    69.       }  
    70.        
    71.       //遍历解析<birthday>节点的所有子节点  
    72.       while (reader.hasMoreChildren()) {  
    73.         //将下一个（也可能是第一个）子节点作为当前节点  
    74.         reader.moveDown();  
    75.          
    76.         //解析<person>节点  
    77.         if ("person".equals(reader.getNodeName())) {  
    78.            Person person = (Person) context.convertAnother(birthday,  
    79.                  Person.class);  
    80.            birthday.setPerson(person);  
    81.         }  
    82.         //解析<birth>节点  
    83.         else if ("birth".equals(reader.getNodeName())) {  
    84.            Calendar date = (Calendar) context.convertAnother(birthday,  
    85.                  Calendar.class);  
    86.            birthday.setDate(date);  
    87.         }  
    88.         //返回到<birthday>节点作为当前节点  
    89.         reader.moveUp();  
    90.       }  
    91.        
    92.       //返回解析得到的Birthday对象  
    93.       return birthday;  
    94.    }  
    95.    
    96. }  

    下面写main方法：

    Java代码  
    1. package cn.tjpu.zhw.xml.xstream4;  
    2.    
    3. import java.util.GregorianCalendar;  
    4.    
    5. import com.thoughtworks.xstream.XStream;  
    6.    
    7. public class BirthdayMain {  
    8.    
    9.    public static void main(String[] args) {  
    10.    
    11.       //创建Birthday对象  
    12.       Birthday birthday = new Birthday();  
    13.       Person p = new Person();  
    14.       p.setName("张三");  
    15.       birthday.setPerson(p);  
    16.       birthday.setDate(new GregorianCalendar());  
    17.       birthday.setGenderMale();  
    18.        
    19.       //创建XStream对象  
    20.       XStream xstream = new XStream();  
    21.       xstream.alias("birthday", Birthday.class);  
    22.        
    23.       //注册BirthdayConverter转换器  
    24.       xstream.registerConverter(new BirthdayConverter());  
    25.        
    26.       //将Birthday对象转换成为XML并输出  
    27.       String xml = xstream.toXML(birthday);  
    28.       System.out.println("**************将Birthday对象转换成为XML并输出**************");  
    29.       System.out.println(xml);  
    30.        
    31.       //将XML转换成为Birthday对象  
    32.       Birthday b = (Birthday)xstream.fromXML(xml);  
    33.       //输出Birthday对象  
    34.       System.out.println();  
    35.       System.out.println("**************将XML转换成为Birthday对象**************");  
    36.       System.out.println(b);  
    37.        
    38.    }  
    39.    
    40. }  

    运行结果：

    Java代码  
    1. **************将Birthday对象转换成为XML并输出**************  
    2. <birthday gender="m">  
    3.   <person>  
    4.     <name>张三</name>  
    5.   </person>  
    6.   <birth>  
    7.     <time>1387897906531</time>  
    8.     <timezone>Asia/Shanghai</timezone>  
    9.   </birth>  
    10. </birthday>  
    11.    
    12. **************将XML转换成为Birthday对象**************  
    13. {person=Person对象的name=张三};{date=Tue Dec 24 23:11:46 CST 2013};{gender=m}  
  • 相关阅读:
    MySQL日期比较
    MySQL日期函数、时间函数总结（MySQL 5.X）
    MySQL日期、字符串、时间戳互转
    通过 zxing 生成二维码
    前台时间格式 2019-03-09T16:00:00.000Z
    基于vue-cli配置手淘的lib-flexible + rem，实现移动端自适应
    python爬虫实例大全
    python3 BeautifulSoup模块使用
    Python 通过sgmllib模块解析HTML
    如何搭建一个合理的数值框架？
  • 原文地址：https://www.cnblogs.com/eer123/p/7894910.html
Copyright © 2020-2023  润新知