`

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

javaxmlxstreamxstream转换器示例xstream转换器入门 
阅读更多

七、转换器(Converter)

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

1，一个基本的转换器

有如下代码：

import com.thoughtworks.xstream.XStream;
import com.thoughtworks.xstream.io.xml.DomDriver;
 
public class XStreamTest4 {
   public static void main(String[] args) {
      Person person = new Person();
      person.setName("张三");
 
      XStream xstream = new XStream(new DomDriver());
      xstream.alias("person", Person.class);
      System.out.println(xstream.toXML(person));
   }
}
 
class Person {
 
   private String name;
 
   public String getName() {
      return name;
   }
 
   public void setName(String name) {
      this.name = name;
   }
 
   public String toString() {
      return getName();
   }
}

 

运行结果是：

<person>
  <name>张三</name>
</person>

 

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

<person>
  <fullname>张三</fullname>
</person>

 

该怎么办？

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

xstream.aliasField("fullname", Person.class,"name");

 

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

PersonConverter需要有3个功能：

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

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

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

 

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

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

 

就这么简单！

 

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

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

 

 

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

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

 

 

于是我们的PersonConverter就是：

package cn.tjpu.zhw.xml.xstream4;
 
import com.thoughtworks.xstream.converters.Converter;
import com.thoughtworks.xstream.converters.MarshallingContext;
import com.thoughtworks.xstream.converters.UnmarshallingContext;
import com.thoughtworks.xstream.io.HierarchicalStreamReader;
import com.thoughtworks.xstream.io.HierarchicalStreamWriter;
 
public class PersonConverter implements Converter {
 
   //告诉XStream对象，它能够转换Person类的对象
   public boolean canConvert(Class clazz) {
      return clazz.equals(Person.class);
   }
 
   //能够将Person对象转换为XML
   public void marshal(
        Object value,            //我们将要转换的对象，这里是Person对象
        HierarchicalStreamWriter writer,//用于输出XML结果的writer
        MarshallingContext context     //序列化环境上下文
        ) {
      //写入顺序
      //1，强制转换为我们我们需要的类型
      Person person = (Person) value;
      //2，开始写入fullname节点，相当于写入<fullname>
      writer.startNode("fullname");
      //3，给fullname节点赋值
      writer.setValue(person.getName());
      //4，结束fullname节点，相当于写入</fullname>
      writer.endNode();
     
     
//    //如果你愿意，顺便也可以写一点其他的东西
//    writer.startNode("otherContent");
//    writer.setValue("这是一大串其他内容，你可以根据自己的需要写内容！");
//    writer.endNode();
   }
 
   //能够将XML转换成为Person对象
   public Object unmarshal(
        HierarchicalStreamReader reader,//用于读取XML的reader
        UnmarshallingContext context   //反序列化环境上下文
        ) {
      //1，先创建一个Person对象
      Person person = new Person();
      //2，判断<person>节点下还有没有其他可以读取的节点
      while(reader.hasMoreChildren()){
        //3，开始读取下一个（也可能是第一个）节点，选择当前<person>节点的子节点作为当前节点
        reader.moveDown();
        //4，获取当前节点的值
        String value = reader.getValue();
        if("fullname".equals(reader.getNodeName())){
           person.setName(value);
        }
        //输出当前节点的内容
        System.out.println("node="+reader.getNodeName()+";value="+value);
        //5，返回上一层节点<person>
        reader.moveUp();
      }
      return person;
   }
}

 

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

package cn.tjpu.zhw.xml.xstream4;
 
 
import com.thoughtworks.xstream.XStream;
import com.thoughtworks.xstream.io.xml.DomDriver;
 
public class XStreamTest4 {
   public static void main(String[] args) {
      //创建Person对象
      Person person = new Person();
      person.setName("张三");
 
      //创建XStream对象
      XStream xstream = new XStream(new DomDriver());
      xstream.alias("person", Person.class);
     
      //注册PersonConverter转换器
      xstream.registerConverter(new PersonConverter());
     
      //使用marshal方法，将Person对象转换成为XML
      System.out.println("****使用marshal方法，将Person对象转换成为XML==>");
      String xml = xstream.toXML(person);
      System.out.println(xml);
     
      //使用unmarshal方法，将XML转换成为Person对象
      System.out.println();
      System.out.println("****使用unmarshal方法，将XML转换成为Person对象==>");
      Person p = (Person)xstream.fromXML(xml);
     
      //输出Person对象
      System.out.println();
      System.out.println("****输出Person对象==>");
      System.out.println(p);
   }
}
 
class Person {
 
   private String name;
 
   public String getName() {
      return name;
   }
 
   public void setName(String name) {
      this.name = name;
   }
 
   public String toString() {
      return "Person对象的name="+getName();
   }
}

 

 

运行结果如下：

****使用marshal方法，将Person对象转换成为XML==>
<person>
  <fullname>张三</fullname>
</person>
 
****使用unmarshal方法，将XML转换成为Person对象==>
node=fullname;value=张三
 
****输出Person对象==>
Person对象的name=张三

 

 

我们成功了！！！！！！

 

2，另一个简单的转换器

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

<person>张三</person>

该咋办？

我们再创建一个转换器：

package cn.tjpu.zhw.xml.xstream4;
 
import com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter;
 
public class AnotherPersonConverter extends AbstractSingleValueConverter {
 
   // 告诉XStream对象，它能够转换Person类的对象
   public boolean canConvert(Class clazz) {
      return clazz.equals(Person.class);
   }
 
   // 将Person对象转换为XML，参数obj就是要转换的Person对象，返回值就是<person>节点的值
   public String toString(Object obj) {
      Person p = (Person) obj;
      return p.getName();
   }
 
   // 将XML转换成为Person对象，参数str就是<person>节点的值，返回值就是转换得到的Person对象
   public Object fromString(String str) {
      Person person = new Person();
      person.setName(str);
      System.out.println("参数str="+str);
      return person;
   }
}

 

 

修改Main方法：

public class XStreamTest4 {
   public static void main(String[] args) {
      //创建Person对象
      Person person = new Person();
      person.setName("张三");
 
      //创建XStream对象
      XStream xstream = new XStream(new DomDriver());
      xstream.alias("person", Person.class);
     
//    //注册PersonConverter转换器
//    xstream.registerConverter(new PersonConverter());
     
      //注册AnotherPersonConverter转换器
      xstream.registerConverter(new AnotherPersonConverter());
     
      //使用toString方法，将Person对象转换成为XML
      System.out.println("****使用toString方法，将Person对象转换成为XML==>");
      String xml = xstream.toXML(person);
      System.out.println(xml);
     
      //使用fromString方法，将XML转换成为Person对象
      System.out.println();
      System.out.println("****使用fromString方法，将XML转换成为Person对象==>");
      Person p = (Person)xstream.fromXML(xml);
     
      //输出Person对象
      System.out.println();
      System.out.println("****输出Person对象==>");
      System.out.println(p);
   }
}

 

运行结果：

****使用toString方法，将Person对象转换成为XML==>
<person>张三</person>
 
****使用fromString方法，将XML转换成为Person对象==>
参数str=张三
 
****输出Person对象==>
Person对象的name=张三

 

 

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

 

3，时间转换器

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

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

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

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

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

 

现在实现第一个功能：

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

 

 

然后，实现第二个功能：

// 能够将Calendar对象转换为XML
   public void marshal(Object value, HierarchicalStreamWriter writer,
        MarshallingContext context) {
      //value是将要转换的Calendar对象
      Calendar calendar = (Calendar) value;
      Date date = calendar.getTime();
     
      //设定格式化格式
      DateFormat formatter = DateFormat.getDateInstance(DateFormat.FULL,
           this.locale);
     
      //格式化并输出Calendar对象
      writer.setValue(formatter.format(date));
   }

 

 

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

// 能够将XML转换成为Calendar对象
   public Object unmarshal(HierarchicalStreamReader reader,
        UnmarshallingContext context) {
      //创建一个Calendar对象
      GregorianCalendar calendar = new GregorianCalendar();
     
      //设定解析格式
      DateFormat formatter = DateFormat.getDateInstance(DateFormat.FULL,
           this.locale);
      try {
        //解析指定格式的Calendar对象
        calendar.setTime(formatter.parse(reader.getValue()));
      } catch (ParseException e) {
        throw new ConversionException(e.getMessage(), e);
      }
      //返回解析成功的Calendar对象
      return calendar;
   }

 

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

package cn.tjpu.zhw.xml.xstream4;
 
import java.text.DateFormat;
import java.text.ParseException;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.Locale;
 
import com.thoughtworks.xstream.converters.ConversionException;
import com.thoughtworks.xstream.converters.Converter;
import com.thoughtworks.xstream.converters.MarshallingContext;
import com.thoughtworks.xstream.converters.UnmarshallingContext;
import com.thoughtworks.xstream.io.HierarchicalStreamReader;
import com.thoughtworks.xstream.io.HierarchicalStreamWriter;
 
public class DateConverter implements Converter {
 
   private Locale locale;
 
   public DateConverter(Locale locale) {
      super();
      this.locale = locale;
   }
 
   // 告诉XStream对象，它能够转换Calendar类及其所有子类定义的对象
   public boolean canConvert(Class clazz) {
      return Calendar.class.isAssignableFrom(clazz);
   }
 
   // 能够将Calendar对象转换为XML
   public void marshal(Object value, HierarchicalStreamWriter writer,
        MarshallingContext context) {
      //value是将要转换的Calendar对象
      Calendar calendar = (Calendar) value;
      Date date = calendar.getTime();
     
      //设定格式化格式
      DateFormat formatter = DateFormat.getDateInstance(DateFormat.FULL,
           this.locale);
     
      //格式化并输出Calendar对象
      writer.setValue(formatter.format(date));
   }
 
   // 能够将XML转换成为Calendar对象
   public Object unmarshal(HierarchicalStreamReader reader,
        UnmarshallingContext context) {
      //创建一个Calendar对象
      GregorianCalendar calendar = new GregorianCalendar();
     
      //设定解析格式
      DateFormat formatter = DateFormat.getDateInstance(DateFormat.FULL,
           this.locale);
      try {
        //解析指定格式的Calendar对象
        calendar.setTime(formatter.parse(reader.getValue()));
      } catch (ParseException e) {
        throw new ConversionException(e.getMessage(), e);
      }
      //返回解析成功的Calendar对象
      return calendar;
   }
}

 

 

再写我们的main方法：

package cn.tjpu.zhw.xml.xstream4;
 
import java.text.DateFormat;
import java.util.Calendar;
import java.util.GregorianCalendar;
import java.util.Locale;
 
import com.thoughtworks.xstream.XStream;
import com.thoughtworks.xstream.io.xml.DomDriver;
 
public class DateMain {
 
   public static void main(String[] args) {
      // 获取当前时间
      Calendar calendar = new GregorianCalendar();
 
      // 创建XStream对象
      XStream xstream = new XStream(new DomDriver());
      xstream.alias("date", Calendar.class);
 
      // 注册我们定义的时间转换器
      xstream.registerConverter(new DateConverter(new Locale("zh", "cn")));
 
      // 转换并输出XML
      String xml = xstream.toXML(calendar);
      System.out.println(xstream.toXML(calendar));
 
      // 加载XML中的时间数据
      Calendar loaded = (Calendar) xstream.fromXML(xml);
      //格式化并输出时间
      System.out.println(DateFormat.getDateInstance(DateFormat.MEDIUM).format(
           loaded.getTime()));
   }
}

 

 

运行，结果如下：

<date>2013年12月24日 星期二</date>
2013-12-24

 

 

 

4，更加复杂的转换器

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

下面有一个复杂的Birthday类：

package cn.tjpu.zhw.xml.xstream4;
 
import java.util.Calendar;
 
 
public class Birthday {
 
   private Person person;
   private Calendar date;
   private char gender;
 
   public Person getPerson() {
      return person;
   }
 
   public void setPerson(Person person) {
      this.person = person;
   }
 
   public Calendar getDate() {
      return date;
   }
 
   public void setDate(Calendar date) {
      this.date = date;
   }
 
   public char getGender() {
      return gender;
   }
 
   public void setGenderMale() {
      this.gender = 'm';
   }
 
   public void setGenderFemale() {
      this.gender = 'f';
   }
  
   public String toString(){
      return "{person="+person+"};{date="+date.getTime()+"};{gender="+gender+"}";
   }
 
}

 

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

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

package cn.tjpu.zhw.xml.xstream4;
 
import java.util.Calendar;
 
import com.thoughtworks.xstream.converters.ConversionException;
import com.thoughtworks.xstream.converters.Converter;
import com.thoughtworks.xstream.converters.MarshallingContext;
import com.thoughtworks.xstream.converters.UnmarshallingContext;
import com.thoughtworks.xstream.io.HierarchicalStreamReader;
import com.thoughtworks.xstream.io.HierarchicalStreamWriter;
 
public class BirthdayConverter implements Converter {
 
   // 告诉XStream对象，它能够转换Birthday类的对象
   public boolean canConvert(Class clazz) {
      return Birthday.class == clazz;
   }
 
   // 能够将Birthday对象转换为XML
   public void marshal(Object value, HierarchicalStreamWriter writer,
        MarshallingContext context) {
      //value是将要被转换的Birthday对象
      Birthday birthday = (Birthday) value;
     
      //给<birthday>节点添加gender属性
      if (birthday.getGender() != '\0') {
        writer.addAttribute("gender",
              Character.toString(birthday.getGender()));
      }
     
      //给<birthday>节点添加子节点<person>
      if (birthday.getPerson() != null) {
        writer.startNode("person");
        context.convertAnother(birthday.getPerson());
        writer.endNode();
      }
     
      //给<birthday>节点添加子节点<birth>
      if (birthday.getDate() != null) {
        writer.startNode("birth");
        context.convertAnother(birthday.getDate());
        writer.endNode();
      }
   }
 
   // 能够将XML转换成为Birthday对象
   public Object unmarshal(HierarchicalStreamReader reader,
        UnmarshallingContext context) {
      //创建Birthday对象
      Birthday birthday = new Birthday();
     
      //当前节点是<birthday>
      //解析<birthday>节点的gender属性
      String gender = reader.getAttribute("gender");
      if (gender != null) {
        if (gender.length() > 0) {
           if (gender.charAt(0) == 'f') {
              birthday.setGenderFemale();
           } else if (gender.charAt(0) == 'm') {
              birthday.setGenderMale();
           } else {
              throw new ConversionException("Invalid gender value: "
                    + gender);
           }
        } else {
           throw new ConversionException(
                 "Empty string is invalid gender value");
        }
      }
     
      //遍历解析<birthday>节点的所有子节点
      while (reader.hasMoreChildren()) {
        //将下一个（也可能是第一个）子节点作为当前节点
        reader.moveDown();
       
        //解析<person>节点
        if ("person".equals(reader.getNodeName())) {
           Person person = (Person) context.convertAnother(birthday,
                 Person.class);
           birthday.setPerson(person);
        }
        //解析<birth>节点
        else if ("birth".equals(reader.getNodeName())) {
           Calendar date = (Calendar) context.convertAnother(birthday,
                 Calendar.class);
           birthday.setDate(date);
        }
        //返回到<birthday>节点作为当前节点
        reader.moveUp();
      }
     
      //返回解析得到的Birthday对象
      return birthday;
   }
 
}

 

下面写main方法：

 

package cn.tjpu.zhw.xml.xstream4;
 
import java.util.GregorianCalendar;
 
import com.thoughtworks.xstream.XStream;
 
public class BirthdayMain {
 
   public static void main(String[] args) {
 
      //创建Birthday对象
      Birthday birthday = new Birthday();
      Person p = new Person();
      p.setName("张三");
      birthday.setPerson(p);
      birthday.setDate(new GregorianCalendar());
      birthday.setGenderMale();
     
      //创建XStream对象
      XStream xstream = new XStream();
      xstream.alias("birthday", Birthday.class);
     
      //注册BirthdayConverter转换器
      xstream.registerConverter(new BirthdayConverter());
     
      //将Birthday对象转换成为XML并输出
      String xml = xstream.toXML(birthday);
      System.out.println("**************将Birthday对象转换成为XML并输出**************");
      System.out.println(xml);
     
      //将XML转换成为Birthday对象
      Birthday b = (Birthday)xstream.fromXML(xml);
      //输出Birthday对象
      System.out.println();
      System.out.println("**************将XML转换成为Birthday对象**************");
      System.out.println(b);
     
   }
 
}

 

运行结果：

**************将Birthday对象转换成为XML并输出**************
<birthday gender="m">
  <person>
    <name>张三</name>
  </person>
  <birth>
    <time>1387897906531</time>
    <timezone>Asia/Shanghai</timezone>
  </birth>
</birthday>
 
**************将XML转换成为Birthday对象**************
{person=Person对象的name=张三};{date=Tue Dec 24 23:11:46 CST 2013};{gender=m}

 

 

 

 

 

 

 

 

 

 

 

2
顶
0
踩
分享到：
| 使用XStream是实现XML与Java对象的转换(3 ...
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

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

    这篇博客“使用XStream是实现XML与Java对象的转换(6)--持久化”深入探讨了如何利用XStream进行持久化操作，使得对象状态能够持久保存到磁盘，同时也能够从XML文档中恢复。 首先，我们需要理解XStream的核心概念。...

    使用XStream是实现XML与Java对象的转换(5)--Object Stream

    标题中的“使用XStream是实现XML与Java对象的转换(5)--Object Stream”指的是一个关于XStream库在Java中如何将XML数据与Java对象进行互相转换的教程系列的第五部分，重点可能是关于“Object Stream”的内容。XStream...

    使用XStream是实现XML与Java对象的转换(3)--注解

    在“xstream使用3”这个压缩包文件中，可能包含了使用XStream注解实现XML与Java对象转换的示例代码、测试用例以及相关的说明文档。通过对这些文件的深入学习，开发者可以更好地理解如何在实际项目中运用XStream的...

    xStream 实现xml与 java对象的转换

    【标题】：“xStream 实现xml与 java对象的转换” 在Java开发中，XML作为一种常见的数据交换格式，常用于存储和传输数据。然而，XML与Java对象之间的转换并不总是直观和简便的。这时，xStream库应运而生，它提供了...

    xstream轻松解析xml到java对象

    以下是一个简单的示例，演示如何使用XStream进行XML与Java对象的转换： ```java import com.thoughtworks.xstream.XStream; class User { private String name; private int age; // getters and setters ...

    xml解析及使用XStream实现javaBean与xml之间的转换

    只需添加额外的转换器，如使用Jettison库，即可实现JavaBean与JSON的转换。 5. **实战演示** 在`xmlAnalysis`文件夹中，可能包含了一个简单的Java程序，演示了如何使用DOM、SAX、StAX和XStream解析XML文件，并展示...

    好用的xStream XML和JAVA对象互相转换的简单示例

    XStream是一个轻量级、高性能的库，能够将Java对象序列化为XML，同时也能将XML反序列化回Java对象，实现XML和Java对象的互相转换。 首先，我们需要引入XStream库。在给定的描述中提到了两个依赖文件：xstream-1.3.1...

    com.thoughtworks.xstream.XStream操作XML和java对象的一些用法

    XStream还提供了许多高级功能，比如自定义转换器来改变默认的XML表示，或者处理复杂的继承关系。此外，为了提高安全性，XStream提供了一种叫做"alias"的机制，可以将类名映射为更友好的XML标签。 总的来说，XStream...

    使用xstream进行java类与xml文件互转解析--代码

    为了将一个Java对象转换成XML，首先需要创建该对象实例，然后使用XStream的`toXML()`方法： ```java import com.thoughtworks.xstream.XStream; public class Person { private String name; private int age; ...

    Xstream_java对象和xml的互相转换

    XStream 的核心概念是通过自动映射 Java 类和 XML 节点来实现对象和 XML 的转换。它通过反射和自定义转换器机制来完成这一过程。默认情况下，XStream 可以处理大多数标准的 Java 类型，包括基本类型、集合、Map 等。...

    Java用xStream拼接xml

    xStream简化了Java对象与XML之间的转换，使得在处理XML数据时，开发者无需关注底层的XML构造细节。在Web Service接口对接时，如果需要传递XML内容，使用xStream可以高效、便捷地完成XML的拼接。通过合理配置和使用，...

    XStream在Java对象和XML之间相互转换

    XStream是一款强大的Java库，主要用于将Java对象序列化为XML，并能从XML反序列化回Java对象。这个功能对于数据存储、网络传输或者XML配置文件的解析非常有用。标题和描述提到的三个JAR文件——xstream-1.3.jar、kxml...

    xstream-1.4.9实现xml与对象互转

    XStream 是一个强大的 Java 库，它允许程序员将 Java 对象序列化为 XML，反之亦然。这个过程称为对象-XML 映射。在 XStream 1.4.9 版本中，开发者可以轻松地处理 XML 文档，将其转换为 Java 对象，或者将 Java 对象...

    xStream学习xml，JASON,JAVA对象转换

    XStream库则是Java世界中一个强大的工具，它能够方便地实现XML和JSON与Java对象之间的互相转换。这篇博客文章，标题为“xStream学习xml，JASON，JAVA对象转换”，显然会探讨如何利用XStream来处理这两种数据格式。 ...

    xml 与java 对象转换

    下面我们将详细探讨`XStream`库的工作原理以及如何使用它来实现XML和Java对象的互换。 首先，`XStream`的核心功能是将Java对象转换为XML字符串，这被称为序列化。它通过反射机制自动解析Java对象的字段并生成相应的...

    使用 XStream 把 Java 对象序列化为 XML

    在实际项目中，了解并熟练掌握XStream可以帮助我们更有效地处理Java对象与XML之间的转换，特别是在需要序列化大量数据或者构建RESTful API时。 在提供的压缩包中，`sample.xml`可能是使用XStream序列化后的Java对象...

    springMVC整合xStream实现对象和xml转换

    通过使用注解或自定义转换器，我们可以控制XML的结构和Java对象的映射关系。XStream的优点在于它能自动处理基本数据类型、集合和自定义类的转换，使得XML序列化和反序列化变得极其简单。 要实现"springMVC整合...

Magicbox
Global site tag (gtag.js) - Google Analytics