1. 全栈程序员必看首页

XStream的简单使用

全栈程序员-站长 • • 未分类 • 阅读 3

XStream的简单使用XStream 是一种 OXMapping 技术 ObjectXMLMap 对象 XML 映射技术 是用来处理 XML 文件序列化的框架 在将 JavaBean 序列化 或将 XML 文件反序列化的时候 不需要其它辅助类和映射文件 使得 XML 序列化不再繁索 XStream 也可以将 JavaBean 序列化成 JSON 或反序列化 使用非常方便

文章目录

一、XStream概述

XStream 是一种 OXMapping 技术（Object XML Mapping，对象XML映射技术），是用来处理XML文件序列化的框架，在将 JavaBean序列化，或将XML文件反序列化的时候，不需要其它辅助类和映射文件，使得XML序列化不再繁索。XStream也可以将 JavaBean序列化 成 JSON 或反序列化，使用非常方便。
　
说白了就是：将XML转为JavaBean，或将JavaBean转为XML，也可以转JSON。




  • 所需Jar包

XStream不需要在配置文件中进行额外配置，只需要往工程中导入Jar包即可，以下是我使用的Jar包：

XStream使用Jar包

需要Jar包的小伙伴们可以点击这里下载：XStream依赖Jar包 和 jettison1.0.1源码及Jar包

二、Hello XStream（简单例子）

1、实体类（Person类）

public class Person { 
             
    private String name;
    private int age;
    
    public Person(String name, int age) { 
             
        this.name = name;
        this.age = age;
    }
    
    @Override
    public String toString() { 
             
        return "Person [name=" + name + ", age=" + age + "]";
    }
}

2、测试类（Test类）

public class Test { 
             
    public static void main(String[] args) { 
             
        // 创建Person对象
        Person person = new Person("张三", 19);
        // 创建XStream对象
        XStream xStream = new XStream();
        System.out.println("XML序列化与反序列化：");
        // XML序列化（Person --> XML）
        String xml = xStream.toXML(person);
        System.out.println(xml);
        // XML反序列化（XML --> Person）
        Person person2 = (Person) xStream.fromXML(xml);
        System.out.println(person2);
        
        System.out.println();
        System.out.println("JSON序列化与反序列化：");
        // 重新创建XStream对象，并设置JSON解析器（可支持序列化与反序列化）
        xStream = new XStream(new JettisonMappedXmlDriver());
        // JSON序列化（Person --> JSON）
        String json = xStream.toXML(person);
        System.out.println(json);
        // JSON反序列化（JSON --> Person）
        Person person3 = (Person) xStream.fromXML(json);
        System.out.println(person3);
    }
}

3、程序运行结果


Hello XStream

三、XStream使用

1、XStream序列化重命名

1）为包重命名

  • 语法格式： aliasPackage(别名, 原包名);
  • 演示代码：
public static void main(String[] args) { 
               
    // 创建Person对象
    Person person = new Person("张三", 19);
    // 创建XStream对象
    XStream xStream = new XStream();
    // 为包重命名
    xStream.aliasPackage("new.bean", "com.bean");
    // XML序列化（Person --> XML）
    String xml = xStream.toXML(person);
    System.out.println(xml);
    // XML反序列化（XML --> Person）
    Person person2 = (Person) xStream.fromXML(xml);
    System.out.println(person2);
}
  • 运行结果：


aliasPackage

  • 注意： 同样适用于JSON。

2）为类重命名

  • 语法格式： alias(别名, 类的字节码对象);
  • 演示代码：
public static void main(String[] args) { 
                
    // 创建Person对象
    Person person = new Person("张三", 19);
    // 创建XStream对象
    XStream xStream = new XStream();
    // 为类重命名
    xStream.alias("人", Person.class);
    // XML序列化（Person --> XML）
    String xml = xStream.toXML(person);
    System.out.println(xml);
    // XML反序列化（XML --> Person）
    Person person2 = (Person) xStream.fromXML(xml);
    System.out.println(person2);
}
  • 运行结果：


alias

  • 注意： 同样适用于JSON。

3）为字段重命名

  • 语法格式： aliasField(别名, 类的字节码对象, 原字段名);
  • 演示代码：
public static void main(String[] args) { 
                 
    // 创建Person对象
    Person person = new Person("张三", 19);
    // 创建XStream对象
    XStream xStream = new XStream();
    // 为字段重命名
    xStream.aliasField("姓名", Person.class, "name");
    // XML序列化（Person --> XML）
    String xml = xStream.toXML(person);
    System.out.println(xml);
    // XML反序列化（XML --> Person）
    Person person2 = (Person) xStream.fromXML(xml);
    System.out.println(person2);
}
  • 运行结果：


aliasField

  • 注意： 同样适用于JSON。

2、省略集合根节点

  • 语法格式： addImplicitCollection(类的字节码对象, 集合属性名);
  • 演示代码：
// 实体类
class Person { 
                  
    private String name;
    private int age;
    private List friends;
    
    public Person(String name, int age, List friends) { 
                  
        this.name = name;
        this.age = age;
        this.friends = friends;
    }
    
    @Override
    public String toString() { 
                  
        return "Person [name=" + name + ", age=" + age + ", friends=" + friends + "]";
    }
}

// 测试类
public class Test { 
                  
    public static void main(String[] args) { 
                  
        // 创建Person对象
        Person person = new Person("张三", 19, Arrays.asList("李四", "王五", "周七"));
        // 创建XStream对象
        XStream xStream = new XStream();
        // 省略集合根节点
        xStream.addImplicitCollection(Person.class, "friends");
        System.out.println("XML序列化与反序列化：");
        // XML序列化（Person --> XML）
        String xml = xStream.toXML(person);
        System.out.println(xml);
        // XML反序列化（XML --> Person）
        Person person2 = (Person) xStream.fromXML(xml);
        System.out.println(person2);
    }
}
  • 运行结果：


addImplicitCollection

  • 注意： 同样适用于JSON。

3、把字段节点设置成属性

  • 语法格式： useAttributeFor(类的字节码对象, 字段名);
  • 演示代码：
public static void main(String[] args) { 
                   
    // 创建Person对象
    Person person = new Person("张三", 19);
    // 创建XStream对象
    XStream xStream = new XStream();
    xStream.useAttributeFor(Person.class, "name");
    System.out.println("XML序列化与反序列化：");
    // XML序列化（Person --> XML）
    String xml = xStream.toXML(person);
    System.out.println(xml);
    // XML反序列化（XML --> Person）
    Person person2 = (Person) xStream.fromXML(xml);
    System.out.println(person2);

    System.out.println();
    System.out.println("JSON序列化与反序列化：");
    // 重新创建XStream对象，并设置JSON解析器（可支持序列化与反序列化）
    xStream = new XStream(new JettisonMappedXmlDriver());
    xStream.useAttributeFor(Person.class, "name");
    // JSON序列化（Person --> JSON）
    String json = xStream.toXML(person);
    System.out.println(json);
    // JSON反序列化（JSON --> Person）
    Person person3 = (Person) xStream.fromXML(json);
    System.out.println(person3);
}
  • 运行结果：


useAttributeFor

  • 注意： 同样适用于JSON。

4、隐藏字段

  • 语法格式： omitField(类的字节码对象, 字段名);
  • 演示代码：
public static void main(String[] args) { 
                    
    // 创建Person对象
    Person person = new Person("张三", 19);
    // 创建XStream对象
    XStream xStream = new XStream();
    // 隐藏字段
    xStream.omitField(Person.class, "name");
    // XML序列化（Person --> XML）
    String xml = xStream.toXML(person);
    System.out.println(xml);
    // XML反序列化（XML --> Person）
    Person person2 = (Person) xStream.fromXML(xml);
    System.out.println(person2);
}
  • 运行结果：


omitField

  • 注意： 同样适用于JSON。

5、XStream注解的使用

1）设置XStream应用注解

使用 XStream注解 前需要对 XStream 进行配置，可以使用两种方式：

  1. 检测某个 JavaBean类 的注解
  2. 自动检测所有 JavaBean类 的注解。
A. 自动检测指定类的注解
// 创建XStream对象
XStream xStream = new XStream();
// 指定检测Person类的注解
xStream.processAnnotations(Person.class);
B. 自动检测所有类的注解
// 创建XStream对象
XStream xStream = new XStream();
// 自动检测所有类的注解
xStream.autodetectAnnotations(true);

2）重命名注解（类、字段）

  • 语法格式： @XStreamAlias(别名)
  • 演示代码：
// 实体类
@XStreamAlias("人")
class Person { 
                      
	@XStreamAlias("名字")
	private String name;
	
	@XStreamAlias("年龄")
	private int age;

	public Person(String name, int age) { 
                      
		this.name = name;
		this.age = age;
	}

	@Override
	public String toString() { 
                      
		return "Person [name=" + name + ", age=" + age + "]";
	}
}

// 测试类
public class Test { 
                      
    public static void main(String[] args) { 
                      
        // 创建Person对象
        Person person = new Person("张三", 19);
        // 创建XStream对象
        XStream xStream = new XStream();
        // 自动检测所有类的注解
        xStream.autodetectAnnotations(true);
        // XML序列化（Person --> XML）
        String xml = xStream.toXML(person);
        System.out.println(xml);
        // XML反序列化（XML --> Person）
        Person person2 = (Person) xStream.fromXML(xml);
        System.out.println(person2);
    }
}
  • 运行结果：


注解重命名

  • 注意： 同样适用于JSON。

3）省略集合根节点

  • 语法格式： @XStreamImplicit
  • 演示代码：
// 实体类
class Person { 
                       
	private String name;
	private int age;
	
	// 隐藏集合根节点，使用默认的节点名，同样适合于JSON
	// @XStreamImplicit 
	// 隐藏集合根节点，并设置指定的节点名，只适合于XML，可能会导致无法反序列化
	@XStreamImplicit(itemFieldName="朋友")    
	private List friends;

	public Person(String name, int age, List friends) { 
                       
		super();
		this.name = name;
		this.age = age;
		this.friends = friends;
	}

	@Override
	public String toString() { 
                       
		return "Person [name=" + name + ", age=" + age + ", friends=" + friends + "]";
	}
}

// 测试类
public class Test { 
                       
    public static void main(String[] args) { 
                       
        // 创建Person对象
        Person person = new Person("张三", 19, Arrays.asList("李四", "王五", "周七"));
        // 创建XStream对象
        XStream xStream = new XStream();
        // 自动检测所有类的注解
        xStream.autodetectAnnotations(true);
        // XML序列化（Person --> XML）
        String xml = xStream.toXML(person);
        System.out.println(xml);
        // XML反序列化（XML --> Person）
        Person person2 = (Person) xStream.fromXML(xml);
        System.out.println(person2);
    }
}
  • 运行结果：


注解省略集合根节点

  • 注意：

@XStreamImplicit： 隐藏集合根节点，使用默认的节点名，同样适合于JSON；

@XStreamImplicit(itemFieldName=“别名”)： 隐藏集合根节点，并设置指定的节点名，只适合于XML，可能会导致无法反序列化。

4）把字段节点设置成属性

  • 语法格式： @XStreamAsAttribute
  • 演示代码：
// 实体类
class Person { 
                        
	@XStreamAsAttribute
	private String name;
	private int age;

	public Person(String name, int age) { 
                        
		this.name = name;
		this.age = age;
	}

	@Override
	public String toString() { 
                        
		return "Person [name=" + name + ", age=" + age + "]";
	}
}

// 测试类
public class Test { 
                        
    public static void main(String[] args) { 
                        
        // 创建Person对象
        Person person = new Person("张三", 19);
        // 创建XStream对象
        XStream xStream = new XStream();
        // 自动检测所有类的注解
        xStream.autodetectAnnotations(true);
        System.out.println("XML序列化与反序列化：");
        // XML序列化（Person --> XML）
        String xml = xStream.toXML(person);
        System.out.println(xml);
        // XML反序列化（XML --> Person）
        Person person2 = (Person) xStream.fromXML(xml);
        System.out.println(person2);
        
        System.out.println();
        System.out.println("JSON序列化与反序列化：");
        // 重新创建XStream对象，并设置JSON解析器（可支持序列化与反序列化）
        xStream = new XStream(new JettisonMappedXmlDriver());
        xStream.autodetectAnnotations(true);
        // JSON序列化（Person --> JSON）
        String json = xStream.toXML(person);
        System.out.println(json);
        // JSON反序列化（JSON --> Person）
        Person person3 = (Person) xStream.fromXML(json);
        System.out.println(person3);
    }
}
  • 运行结果：


注解把字段节点设置成属性

  • 注意： 同样适用于JSON。

5）隐藏字段

  • 语法格式： @XStreamOmitField
  • 演示代码：
// 实体类
class Person { 
                         
	@XStreamOmitField
	private String name;
	private int age;

	public Person(String name, int age) { 
                         
		this.name = name;
		this.age = age;
	}

	@Override
	public String toString() { 
                         
		return "Person [name=" + name + ", age=" + age + "]";
	}
}

// 测试类
public class Test { 
                         
    public static void main(String[] args) { 
                         
        // 创建Person对象
        Person person = new Person("张三", 19);
        // 创建XStream对象
        XStream xStream = new XStream();
        // 自动检测所有类的注解
        xStream.autodetectAnnotations(true);
        // XML序列化（Person --> XML）
        String xml = xStream.toXML(person);
        System.out.println(xml);
        // XML反序列化（XML --> Person）
        Person person2 = (Person) xStream.fromXML(xml);
        System.out.println(person2);
    }
}
  • 运行结果：


注解隐藏属性

  • 注意： 同样适用于JSON。

6）设置转换器

  • 语法格式： @XStreamOmitField
  • 演示代码：
// 实体类
class Person { 
                          
	@XStreamOmitField
	private String name;
	private int age;
	// 设置转换器，false为女，true为男
	@XStreamConverter(value = BooleanConverter.class, booleans = { 
                           false }, strings = { 
                           "男", "女" })
	private boolean sex;

	public Person(String name, int age, boolean sex) { 
                          
		this.name = name;
		this.age = age;
		this.sex = sex;
	}

	@Override
	public String toString() { 
                          
		return "Person [name=" + name + ", age=" + age + ", sex=" + sex + "]";
	}
}

// 测试类
public class Test { 
                          
    public static void main(String[] args) { 
                          
        // 创建Person对象
        Person person = new Person("张三", 19);
        // 创建XStream对象
        XStream xStream = new XStream();
        // 自动检测所有类的注解
        xStream.autodetectAnnotations(true);
        // XML序列化（Person --> XML）
        String xml = xStream.toXML(person);
        System.out.println(xml);
        // XML反序列化（XML --> Person）
        Person person2 = (Person) xStream.fromXML(xml);
        System.out.println(person2);
    }
}
  • 运行结果：


设置转换器

  • 注意： 同样适用于JSON。

6、XStream持久化API（存储与读取XML）

1）保存JavaBean对象（存储到XML文件）

public static void main(String[] args) { 
                           
    // PersistenceStrategy是存储和读取XML的工具
    // 创建PersistenceStrategy对象，交生成的XML文件保存到 D:\tmp 中
    PersistenceStrategy strategy = new FilePersistenceStrategy(new File("D:\\tmp"));
    // XML集合（返回XmlArrayList）
    List list = new XmlArrayList(strategy);
    list.add(new Person("张三",13));//保存数据
    list.add(new Person("李四",21));
    list.add(new Person("王五",17));
}


保存JavaBean对象

2）读取并删除JavaBean对象

public static void main(String[] args) { 
                            
    // PersistenceStrategy是存储和读取XML的工具
    // 创建PersistenceStrategy对象，交生成的XML文件保存到 D:\tmp 中
    PersistenceStrategy strategy = new FilePersistenceStrategy(new File("D:\\tmp"));
    // XML集合（返回XmlArrayList）
    List list = new XmlArrayList(strategy);
    // 遍历List集合，并删除每一个元素
    ListIterator lit = list.listIterator();
    while (lit.hasNext()) { 
                            
        Person person = (Person) lit.next();
        System.out.println(person);
        lit.remove();
    }
}


读取并删除JavaBean对象

四、注意事项

  • 1、用 XStream 把 JavaBean转为XML 时，转换后的内容不包括 XML文件的头（需要手动添加）：
  • 2、XStream 把 JavaBean转为XML 时，类名的节点会带包路径，如果不需要包路径，需要主动设置或者应用注解。 xStream.alias("door",Door.class);
  • 3、在 JavaBean中 添加的注解，需要在应用时进行注册，如需要用Door中的注解，则需要进行设置： 
xStream.processAnnotations(Door.class);  // 应用Door类的注解
xStream.autodetectAnnotations(true);     // 自动检测注解



博客中若有不恰当的地方，请您一定要告诉我。前路崎岖，望我们可以互相帮助，并肩前行！























































版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请联系我们举报，一经查实，本站将立刻删除。

发布者：全栈程序员-站长，转载请注明出处：https://javaforall.net/228549.html原文链接：https://javaforall.net

赞 (0)
0 0

关于作者

全栈程序员-站长的头像

全栈程序员-站长

133.5K 文章
3 粉丝
本网站汇聚当前互联网主流语音，持续更新，欢迎关注公众号“全栈程序员社区”
上一篇 2026年3月16日 下午6:46
下一篇 2026年3月16日 下午6:46


相关推荐

发表回复

您的邮箱地址不会被公开。 必填项已用 * 标注

关注全栈程序员社区公众号