xStream完美转换XML、JSON

合集下载

XStream轻松搞定JAVA对象与XMLJSON之间相互转换

XStream轻松搞定JAVA对象与XMLJSON之间相互转换上一遍已对xstream进行了初步认识，此处就不再多作介绍，直入主题,以下主要主要为,JavaBean --> XML / JSON 、XML / JSON --> JavaBean之间相互转换：一| 先写实体类：Address.javaJava代码1.public class Address {2.private String oldAddress;3.private String newAddress;4.5.public String getOldAddress() {6.return oldAddress;7.}8.public void setOldAddress(String oldAddress) {9.this.oldAddress = oldAddress;10.}11.public String getNewAddress() {12.return newAddress;13.}14.public void setNewAddress(String newAddress) {15.this.newAddress = newAddress;16.}17.18.Person.javaJava代码1.public class Person {2.private String name;3.private String sex;4.private int age;5.private Address address;6.7.public String getName() {8.return name;9.}10.public void setName(String name) { = name;12.}13.public String getSex() {14.return sex;15.}16.public void setSex(String sex) {17.this.sex = sex;18.}19.public int getAge() {20.return age;21.}22.public void setAge(int age) {23.this.age = age;24.}25.public Address getAddress() {26.return address;27.}28.public void setAddress(Address address) {29.this.address = address;30.}31.32.Test.javaJava代码1.import java.io.PrintWriter;2.3.import vo.Address;4.import vo.Person;5.6.import com.thoughtworks.xstream.XStream;7.import com.thoughtworks.xstream.io.json.JettisonMappe dXmlDriver;8.import com.thoughtworks.xstream.io.json.JsonHierarchica lStreamDriver;9.import com.thoughtworks.xstream.io.xml.DomDriver;10.11./**12.*@class Description:13.*@author like14.*@version create on May 19, 201115.*/16.public class Test {17.public static void main(String[] args) {18.//JavaBean --> XML19.Address address=new Address();20.Person person=new Person();21.address.setOldAddress("湖南长沙");22.address.setNewAddress("广州白云");23.person.setName("理科");24.person.setSex("男");25.person.setAge(22);26.person.setAddress(address);27.XStream xstream = new XStream(new DomDriver());28.xstream.alias("person", Person.class);29.xstream.alias("address", Address.class);30.xstream.toXML(person,new PrintWriter(System.out));31.32.//XML --> JavaBean33.String strxml="<person><name>理科</name><sex>男</sex><age>19</age><address><oldAddress>湖南长沙</oldAddress><newAddress>广州白云</newAddress></address></person>";34.XStream xstream2 = new XStream(new DomDriver());35.xstream2.alias("person", Person.class);36.xstream2.alias("address", Address.class);37.Person person2=(Person) xstream2.fromXML(strxml);38.System.out.println(person2.getName());39.System.out.println(person2.getSex());40.System.out.println(person2.getAddress().getOldAddre ss());41.System.out.println(person2.getAddress().getNewAddr ess());42.43.//JavaBean --> JSON44.Address address3=new Address();45.Person person3=new Person();46.address3.setOldAddress("湖南长沙");47.address3.setNewAddress("广州白云");48.person3.setName("理科");49.person3.setSex("男");50.person3.setAge(22);51.person3.setAddress(address3);52.//new JsonHierarchicalStreamDriver()53.XStream xstream3 = new XStream(new JsonHierarchic alStreamDriver());54.xstream3.alias("person", Person.class);55.xstream3.alias("address", Address.class);56.//new PrintWriter(System.out) 输出去控制台57.xstream3.toXML(person3,new PrintWriter(System.out)) ;58.59.//JSON--> JavaBean60.String jsonstr="{\"person\": {\"name\": \"理科\",\"sex\": \"男\",\"age\": \"19\",\"address\": {\"oldAddress\": \"湖南长沙\",\"newAddress\": \"广州白云\"}}}";61.//new JettisonMappedXmlDriver()62.XStream xstream4 = new XStream(new JettisonMappe dXmlDriver());63.xstream4.alias("person", Person.class);64.xstream4.alias("address", Address.class);65.Person person4=(Person) xstream4.fromXML(jsonstr);66.System.out.println(person4.getName());67.System.out.println(person4.getSex());68.System.out.println(person4.getAddress().getOldAddre ss());69.System.out.println(person4.getAddress().getNewAddr ess());70.}71.}注：1）、使用xStream.alias(String elementName, Class cls)为任何一个自定义类创建到类到元素的别名,如果不使用别名，则生成的标签名为类全名；2）、使用xStream.toXML(Object obj)转换对象到XML；3）、使用xStream.fromXML(String xml)转换XML到对象；。

XStream使用详解

XStream使⽤详解阅读⽬录1.Xstream介绍(1)Xstream介绍Xstream是⼀种OXMapping 技术，是⽤来处理XML⽂件序列化的框架,在将JavaBean序列化，或将XML⽂件反序列化的时候，不需要其它辅助类和映射⽂件，使得XML序列化不再繁索。

Xstream也可以将JavaBean序列化成Json或反序列化，使⽤⾮常⽅便。

(2)Xstream的简单例⼦1. class Person//JavaBean实体类2. {3. private String name;4. private int age;5. public Person(String name,int age)6. {7. =name;8. this.age=age;9. }10. @Override11. public String toString()12. {13. return "Person [name=" + name + ", age=" + age + "]";14. }15. }16. public class Test17. {18. public static void main(String[] args)19. {20. Person bean=new Person("张三",19);21. XStream xstream = new XStream();22. //XML序列化23. String xml = xstream.toXML(bean);24. System.out.println(xml);25. //XML反序列化26. bean=(Person)xstream.fromXML(xml);27. System.out.println(bean);28.29. xstream = new XStream(new JettisonMappedXmlDriver());30. xstream.setMode(XStream.NO_REFERENCES);31. //Json序列化32. String json=xstream.toXML(bean);33. System.out.println(json);34. //Json反序列35. bean=(Person)xstream.fromXML(json);36. System.out.println(bean);37. }38. }程序运⾏结果：1. <test.Person>2. <name>张三</name>3. <age>19</age>4. </test.Person>5. Person [name=张三, age=19]6. {"test.Person":{"name":"张三","age":19}}7. Person [name=张三, age=19注意：Xstream序列化XML时需要引⽤的jar包：xstream-[version].jar、xpp3-[version].jar、xmlpull-[version].jar。

xstream 高级用法

XStream 是一个用于在Java 对象与XML 之间进行相互转换的开源框架。

它允许你轻松地将对象序列化成XML 或将XML 反序列化成对象。

下面是一些XStream 的高级用法：自定义转换器（Converter）：通过实现Converter 接口，你可以自定义对象和XML 之间的转换规则。

这对于处理特殊类型或者调整默认转换行为非常有用。

xstream.registerConverter(new YourCustomConverter());别名与映射：使用别名和映射可以定制XML 元素的名称，使其更符合你的需求。

可以使用alias 方法为类设置别名，或者使用aliasField 设置字段别名。

xstream.alias("customAlias", YourClass.class);xstream.aliasField("customField", YourClass.class, "fieldName");属性重命名：如果你想为XML 元素的属性指定不同的名称，可以使用useAttributeFor 和aliasAttribute。

eAttributeFor(YourClass.class, "propertyName");xstream.aliasAttribute("customAlias", "propertyName");注解支持：XStream 支持使用注解为类和字段提供转换信息。

通过在类和字段上添加@XStreamAlias、@XStreamAsAttribute 等注解，你可以更灵活地控制转换规则。

@XStreamAlias("customAlias")public class YourClass {@XStreamAsAttributeprivate String propertyName;}自动类型转换：XStream 默认会在生成的XML 中包含类的全限定名以支持类型信息。

、jackson、xStream、castor、jibx、jaxb2

SpringMVC 利用XML、JSON视图SpringMVC中整合了JSON、XML的视图，可以通过这些视图完成Java对象到XML、JSON 的转换。

转换XML提供了MarshallingView，开发者只需用注入相应的marshaller、和属性配置，即可自动完成Java的Model对象中的数据到XML的编组。

Blog：一、准备工作1、本次程序会涉及到Jackson、xStream、Jibx、Jaxb2、castor等技术，如果你对这些技术还不是很了解。

建议阅读：这篇文章中涉及到的内容应该对你有不少帮助。

2、jar包下载spring各版本jar下载地址：相关的依赖包也可以在这里找到：3、至少需要以下jar包4<?xml version="1.0"encoding="UTF-8"?><web-app version="2.4"xmlns=" ://java.sun /xml/ns/j2ee"xmlns:xsi=" :// /2001/XMLSchema-instance"xsi:schemaLocation=://java.sun /xml/ns/j2ee/web-app_2_4.xsd"><servlet><servlet-name>dispatcher</servlet-name><servlet-class>org.</servlet-class><init-param><param-name>contextConfigLocation</param-name><param-value></param-value></init-param><load-on-startup>1</load-on-startup></servlet><servlet-mapping><servlet-name>dispatcher</servlet-name><url-pattern>*.do</url-pattern></servlet-mapping><filter><filter-name>characterEncodingFilter</filter-name><filter-class></filter-class><init-param><param-name>encoding</param-name><param-value>UTF-8</param-value></init-param></filter><filter-mapping><filter-name>characterEncodingFilter</filter-name><url-pattern>/*</url-pattern></filter-mapping><welcome-file-list><welcome-file></welcome-file></welcome-file-list></web-app>56、启动后，可以看到index.jsp 没有出现异常或错误。

Xstream之常用方式与常用注解

Xstream之常用方式与常用注解Xstream之常用方式与常用注解博客分类：JavaJavaBlogjsonITeyeXML参考资料1xStream框架完美实现Java对象和xml文档JSON、XML 相互转换/hoojo/archive/2011/04/22/202519 7.html2 xStream完美转换XML、JSON/a/2025197/官网:/download.html相关jar包可在:XStream之初识/blog/1059453下载示例代码Java代码Blog teamBlog = new Blog(new Author("Guilherme Silveira"));teamBlog.add(new Entry("first","My first blog entry.")); eamBlog.add(new Entry("tutorial","Today we have developed a nice alias tutorial. Tell your friends! NOW!"));XStream xstream = new XStream();System.out.println(xstream.toXML(teamBlog)); Blog teamBlog = new Blog(new Author("Guilherme Silveira")); teamBlog.add(new Entry("first","My first blog entry.")); eamBlog.add(new Entry("tutorial","Today we have developed a nice alias tutorial. Tell your friends! NOW!")); XStream xstream = new XStream();System.out.println(xstream.toXML(teamBlog));打印结果为: Java代码<xtream.Blog><writer><name>Guilherme Silveira</name></writer><entries><xtream.Entry><title>first</title><description>My first blog entry.</description></xtream.Entry><xtream.Entry><title>tutorial</title><description>Today we have developed a nice alias tutorial. Tell your friends! NOW!</description></xtream.Entry></entries></xtream.Blog> <xtream.Blog><writer><name>Guilherme Silveira</name></writer><entries><xtream.Entry><title>first</title><description>My first blog entry.</description> </xtream.Entry><xtream.Entry><title>tutorial</title><description>Today we have developed a nice alias tutorial. Tell your friends! NOW!</description></xtream.Entry></entries></xtream.Blog>以上节点就包含了包名,如包名很长,就很难看了,怎样才能重新命名这个节点呀！以下的1,2设置效果一样Java代码1 //xstream.aliasPackage("", "xtream");2 xstream.alias("blog", Blog.class);3 xstream.alias("entry", Entry.class); 1//xstream.aliasPackage("", "xtream");2 xstream.alias("blog", Blog.class);3 xstream.alias("entry", Entry.class);通过这样设置就完成了节点名称的设置.如下: Java代码<blog><writer><name>Guilherme Silveira</name></writer><entries><entry><title>first</title><description>My first blog entry.</description></entry><entry><title>tutorial</title><description>Today we have developed a nice alias tutorial. Tell your friends! NOW!</description></entry></entries></blog> <blog><writer><name>Guilherme Silveira</name></writer><entries><entry><title>first</title><description>My first blog entry.</description> </entry><entry><title>tutorial</title><description>Today we have developed a nice alias tutorial. Tell your friends! NOW!</description></entry></entries></blog>修改子节点属性名称将writer属性名称修改为:autor Java代码xstream.aliasField("author", Blog.class, "writer"); xstream.aliasField("author", Blog.class, "writer");输出如下:Java代码<blog><author><name>Guilherme Silveira</name></author><entries><entry><title>first</title><description>My first blog entry.</description></entry><entry><title>tutorial</title><description>Today we have developed a nice alias tutorial. Tell your friends! NOW!</description></entry></entries></blog> <blog><author><name>Guilherme Silveira</name></author><entries><entry><title>first</title><description>My first blog entry.</description> </entry><entry><description>Today we have developed a nice alias tutorial. Tell your friends! NOW!</description></entry></entries></blog>删除集合节点名称的设置Java代码xstream.addImplicitCollection(Blog.class, "entries"); xstream.addImplicitCollection(Blog.class, "entries");输出如下:Java代码<blog><author><name>Guilherme Silveira</name></author><entry><title>first</title><description>My first blog entry.</description></entry><entry><description>Today we have developed a nice alias tutorial. Tell your friends! NOW!</description></entry></blog> <blog><author><name>Guilherme Silveira</name></author><entry><title>first</title><description>My first blog entry.</description> </entry><entry><title>tutorial</title><description>Today we have developed a nice alias tutorial. Tell your friends! NOW!</description></entry></blog>将Blog类的元素设置为:它的节点属性//使用这个属性名作为节点上的元素Java代码eAttributeFor(Blog.class, "writer");eAttributeFor(Blog.class, "writer");//重新命名Java代码xstream.aliasField("author", Blog.class, "writer"); xstream.aliasField("author", Blog.class, "writer");//注册转换器Java代码xstream.registerConverter(new AuthorConverter()); xstream.registerConverter(new AuthorConverter());转换器:Java代码importcom.thoughtworks.xstream.converters.SingleValueConver ter;class AuthorConverter implements SingleValueConverter {//显示节点属性值public String toString(Object obj) {return ((Author) obj).getName();}public Object fromString(String name) {return new Author(name);}public boolean canConvert(Class type) {return type.equals(Author.class);}} importcom.thoughtworks.xstream.converters.SingleValueConver ter;class AuthorConverter implements SingleValueConverter { //显示节点属性值public String toString(Object obj) {return ((Author) obj).getName();} public Object fromString(String name) {return new Author(name);} public boolean canConvert(Class type) {return type.equals(Author.class);}}显示结果: Java代码<blog author="Guilherme Silveira"><entry><title>first</title><description>My first blog entry.</description></entry><entry><title>tutorial</title><description>Today we have developed a nice alias tutorial. Tell your friends! NOW!</description></entry></blog> <blog author="Guilherme Silveira"><entry><title>first</title><description>My first blog entry.</description></entry><entry><title>tutorial</title><description>Today we have developed a nice alias tutorial. Tell your friends! NOW!</description></entry></blog>注解的使用方式,使用之前必须加上注解类才有作用:Java代码XStream xstream = new XStream();xstream.processAnnotations(Blog.class);xstream.processAnnotations(Entry.class); XStream xstream = new XStream();xstream.processAnnotations(Blog.class);xstream.processAnnotations(Entry.class);1 @XStreamAlias注解可在类与属性上使用设置名称,相当于: xstream.alias("blog",Blog.class); Java代码@XStreamAlias("blog")public class Blog {@XStreamAlias("author")private Author writer;.....} @XStreamAlias("blog")public class Blog {@XStreamAlias("author")private Author writer; .....}当然Entry类也要设置同样的类属性:@XStreamAlias("entity")2 @XStreamImplicit去集合节点名:相当于xstream.addImplicitCollection(Blog.class, "entries");3@XStreamConverter(AuthorConverter.class),参见以上的转换器类相当于: Java代码eAttributeFor(Blog.class, "writer");//重新命名xstream.aliasField("author", Blog.class, "writer");//注册转换器xstream.registerConverter(new AuthorConverter()); eAttributeFor(Blog.class, "writer");//重新命名xstream.aliasField("author", Blog.class, "writer");//注册转换器xstream.registerConverter(new AuthorConverter()); 要使用这个注解AuthorConverter必须符合二个条件a 必须要有个默认的无参构造函数Java代码public AuthorConverter() {} public AuthorConverter() {}b 类声明必须为:public Java代码public class AuthorConverter implements SingleValueConverter {...} public class AuthorConverter implements SingleValueConverter {...}不用注解这二点都可以不强制要求!完整代码如下: Java代码import com.thoughtworks.xstream.XStream;importcom.thoughtworks.xstream.annotations.XStreamAlias;importcom.thoughtworks.xstream.annotations.XStreamAsAttribut e;importcom.thoughtworks.xstream.annotations.XStreamConverter ;importcom.thoughtworks.xstream.annotations.XStreamImplicit;@XStreamAlias("blog")public class Blog {@XStreamAsAttribute@XStreamAlias("author")@XStreamConverter(AuthorConverter.class)private Author writer;@XStreamImplicitprivate List entries = new ArrayList();public Blog(Author writer) {this.writer = writer;}public void add(Entry entry) {entries.add(entry);}public List getContent() {return entries;}public static void main(String[] args) {Blog teamBlog = new Blog(new Author("Guilherme Silveira"));teamBlog.add(new Entry("first", "My first blog entry.")); teamBlog.add(new Entry("tutorial","Today we have developed a nice alias tutorial. Tell your friends! NOW!"));XStream xstream = new XStream();xstream.processAnnotations(Blog.class);xstream.processAnnotations(Entry.class);// 重新命名节点名// xstream.aliasPackage("", "xtream");/** xstream.alias("blog", Blog.class); xstream.alias("entry",* Entry.class); //重新命名属性名//xstream.aliasField("author", Blog.class,* "writer"); //去节点xstream.addImplicitCollection(Blog.class,* "entries"); // eAttributeFor(Blog.class, "writer"); //* xstream.aliasField("author", Blog.class, "writer"); //* xstream.addImplicitCollection(Blog.class, "entries");* //使用这个属性名作为节点上的元素eAttributeFor(Blog.class, "writer");* //重新命名xstream.aliasField("author", Blog.class, "writer"); //注册转换器* xstream.registerConverter(new AuthorConverter());*/System.out.println(xstream.toXML(teamBlog));}}。

xstream实现JAVA对象和XML的相互转化

xstream实现JAVA对象和XML的相互转化首页/文档/converter-tutorial.html下载得到文件xstream-distribution-1.3.1-bin.zip如果是用MAVEN2来管理，那么pom.xml文件需要导入以下包<dependency><groupId>com.thoughtworks.xstream</groupId><artifactId>xstream</artifactId><version>1.3.1</version></dependency>参考官方网站上的文档，其实已经很清楚了一个JAVA的POJO类package com.sillycat.easybase.mock;import java.util.Date;public class Person {private String name;private String email;private Date gmtCreate;...省略了get和set方法}一个工具类package com.sillycat.easybase.utils;import com.thoughtworks.xstream.XStream;import com.thoughtworks.xstream.io.xml.DomDriver;public class XmlUtil {//将对象转为XMLpublic static String simpleobject2xml(Object obj) {XStream xStream = new XStream(new DomDriver());xStream.alias(obj.getClass().getSimpleName(),obj.getClass());String xml = xStream.toXML(obj);return xml;}//将XML转为对象public static Object simplexml2object(String xml,Object obj) {XStream xStream = new XStream(new DomDriver());xStream.alias(obj.getClass().getSimpleName(),obj.getClass());Object reobj = xStream.fromXML(xml);return reobj;}}一个测试类package com.sillycat.easybase.mock;import java.util.Date;import com.sillycat.easybase.utils.XmlUtil;public class PersonTest {public static void main(String[] args) {Person person = new Person();person.setName("sillycat");person.setEmail("*************");person.setGmtCreate(new Date());String xml = XmlUtil.simpleobject2xml(person);System.out.println(xml);Person temp = (Person) XmlUtil.simplexml2object(xml,new Person());System.out.println(temp);System.out.println(temp.getName());System.out.println(temp.getEmail());System.out.println(temp.getGmtCreate());}}。

JAVABean和XML之间的相互转换-XStream简单入门

JAVABean和XML之间的相互转换-XStream简单⼊门JAVA Bean和XML之间的相互转换 - XStream简单⼊门背景介绍我们在⼯作中经常遇到⽂件解析为数据或者数据转化为xml⽂件的情况,之前我⼀直采⽤的⽅式都是⼿动的来解析或拼接XML⽂件,这个做法固然是可以的,但是代码部分会显得⾮常臃肿,所以就查找了相关的资料,发现了⼀个名为XStream的类库可以做这件事,下⾯我们来看⼀下.XStream的简介官⽹地址:从官⽹介绍我们能看到以下⼏个特性:易⽤不需要Mapping⽂件不需要额外提供Mapping⽂件即可完成映射⾼性能⾼速且低内存消耗整洁的XML⽂件⽣成的XML的相当简洁不需要修改对象可以序列化private修饰的属性,且不需要提供get/set⽅法完整的对象结构⽀持⽀持循环引⽤情况下的输出兼容其他的XML API可以对任何的树形结构进⾏序列化或反序列化可以⾃定义的转换策略可以通过策略的注册,允许⾃定义特定类型的转化为XML的样式安全的框架对未分组的类型进⾏精细化的控制,防⽌输⼊错误⽽导致的安全问题良好的异常反馈当XML⽂件格式错误的时候,能够提供诊断信息帮助处理多样的输出格式不⽌是XML他还⽀持JSON及其变种注解简介从XStream的官⽹我们了解到,XStream不需要Mapping⽂件就能完成JavaBean和XML之间的转变,但⼤部分时候我们需要对⽣成的XML⽂件进⾏定制,name我们需要了解XStream提供的注解注解作⽤适⽤范围@XStreamAlias设置别名类或属性@XStreamImplicit忽略属性集合类型的属性注解作⽤适⽤范围@XStreamAsAttribute将JavaBean转换成节点属性属性@XStreamOmitField忽略属性属性@XStreamConverter注⼊转换器类应⽤实例⾸先在我们的项⽬中加⼊依赖:<dependency><groupId>com.thoughtworks.xstream</groupId><artifactId>xstream</artifactId><version>1.4.11.1</version></dependency>假定环境为Computer和CPU两个类:public class Computer implements Serializable {private static final long serialVersionUID = 567119860357020081L;private String name;private String brand;private List<CPU> processors;public Computer() {}public String getName() {return name;}public void setName(String name) { = name;}public String getBrand() {return brand;}public void setBrand(String brand) {this.brand = brand;}public List<CPU> getProcessors() {return processors;}public void setProcessors(List<CPU> processors) {this.processors = processors;}}public class CPU implements Serializable {private static final long serialVersionUID = -718438777162957779L;private String name;private String generation;public CPU() {}public String getName() {return name;}public void setName(String name) { = name;}public String getGeneration() {return generation;}public void setGeneration(String generation) {this.generation = generation;}}写⼀个测试⽅法:import com.hykj.facheck.entity.CPU;import puter;import com.thoughtworks.xstream.XStream;import com.thoughtworks.xstream.io.xml.DomDriver;import java.util.ArrayList;import java.util.List;public class XStreamTest {public static void main(String[] args) {List<CPU> cpuList = new ArrayList<>();CPU cpu1 = new CPU();cpu1.setGeneration("8-i5-K");cpu1.setName("第⼀个");cpuList.add(cpu1);CPU cpu2 = new CPU();cpu2.setGeneration("8-i5-U");cpu2.setName("第⼆个");cpuList.add(cpu2);Computer computer = new Computer();computer.setBrand("huawei");computer.setName("wej-laptop");computer.setProcessors(cpuList);XStream xstream = new XStream(new DomDriver());xstream.ignoreUnknownElements();xstream.processAnnotations(Computer.class);//javabean to xmlString xml = xstream.toXML(computer);System.out.println(xml);//xml to javabeanComputer computerFromXml = (Computer) xstream.fromXML(xml);System.out.println(computer.getName());}}运⾏程序,控制台打结果如下:Connected to the target VM, address: '127.0.0.1:53977', transport: 'socket'<puter><name>wej-laptop</name><brand>huawei</brand><processors><com.hykj.facheck.entity.CPU><name>第⼀个</name><generation>8-i5-K</generation></com.hykj.facheck.entity.CPU><com.hykj.facheck.entity.CPU><name>第⼆个</name><generation>8-i5-U</generation></com.hykj.facheck.entity.CPU></processors></puter>Security framework of XStream not initialized, XStream is probably vulnerable. wej-laptopDisconnected from the target VM, address: '127.0.0.1:53977', transport: 'socket' Process finished with exit code 0也就是说这样就可以⽤了,很棒棒但是这个XML和我们的需求不太⼀样,我们加上注解,代码变成了这样: import com.thoughtworks.xstream.annotations.XStreamAlias;import java.io.Serializable;import java.util.List;@XStreamAlias("my")public class Computer implements Serializable {private static final long serialVersionUID = 567119860357020081L;private String name;private String brand;@XStreamAlias("cpuList")private List<CPU> processors;public Computer() {}public String getName() {return name;}public void setName(String name) { = name;}public String getBrand() {return brand;}public void setBrand(String brand) {this.brand = brand;}public List<CPU> getProcessors() {return processors;}public void setProcessors(List<CPU> processors) {this.processors = processors;}}import com.thoughtworks.xstream.annotations.XStreamAlias;import java.io.Serializable;@XStreamAlias("oneCpu")public class CPU implements Serializable {private static final long serialVersionUID = -718438777162957779L;private String name;private String generation;public CPU() {}public String getName() {return name;}public void setName(String name) { = name;}public String getGeneration() {return generation;}public void setGeneration(String generation) {this.generation = generation;}}测试⽅法不变,结果如下:Connected to the target VM, address: '127.0.0.1:54181', transport: 'socket'<my><name>wej-laptop</name><brand>huawei</brand><cpuList><oneCpu><name>第⼀个</name><generation>8-i5-K</generation></oneCpu><oneCpu><name>第⼆个</name><generation>8-i5-U</generation></oneCpu></cpuList></my>Security framework of XStream not initialized, XStream is probably vulnerable. wej-laptopDisconnected from the target VM, address: '127.0.0.1:54181', transport: 'socket' Process finished with exit code 0这个XML就很舒服啦.我们载试⼀下循环引⽤的情况吧,代码如下:import com.thoughtworks.xstream.annotations.XStreamAlias;import java.io.Serializable;import java.util.List;@XStreamAlias("my")public class Computer implements Serializable {private static final long serialVersionUID = 567119860357020081L;private String name;private String brand;@XStreamAlias("cpuList")private List<CPU> processors;public Computer() {}public String getName() {return name;}public void setName(String name) { = name;}public String getBrand() {return brand;}public void setBrand(String brand) {this.brand = brand;}public List<CPU> getProcessors() {return processors;}public void setProcessors(List<CPU> processors) {this.processors = processors;}}import com.thoughtworks.xstream.annotations.XStreamAlias; import java.io.Serializable;@XStreamAlias("oneCpu")public class CPU implements Serializable {private static final long serialVersionUID = -718438777162957779L; private String name;private String generation;private Computer computer;public CPU() {}public String getName() {return name;}public void setName(String name) { = name;}public String getGeneration() {return generation;}public void setGeneration(String generation) {this.generation = generation;}public Computer getComputer() {return computer;}public void setComputer(Computer computer) {puter = computer;}}import com.thoughtworks.xstream.XStream;import com.thoughtworks.xstream.io.xml.DomDriver;import java.util.ArrayList;import java.util.List;public class XStreamTest {public static void main(String[] args) {Computer computer = new Computer();computer.setBrand("huawei");computer.setName("wej-laptop");List<CPU> cpuList = new ArrayList<>();CPU cpu1 = new CPU();cpu1.setGeneration("8-i5-K");cpu1.setName("第⼀个");cpu1.setComputer(computer);cpuList.add(cpu1);CPU cpu2 = new CPU();cpu2.setGeneration("8-i5-U");cpu2.setName("第⼆个");cpuList.add(cpu2);cpu1.setComputer(computer);computer.setProcessors(cpuList);XStream xstream = new XStream(new DomDriver());xstream.ignoreUnknownElements();xstream.processAnnotations(Computer.class);//javabean to xmlString xml = xstream.toXML(computer);System.out.println(xml);//xml to javabeanComputer computerFromXml = (Computer) xstream.fromXML(xml);System.out.println(computer.getName());}}运⾏⼀下,先查看是否构成循环引⽤:确认有循环引⽤,继续运⾏代码,控制台打印如下:Connected to the target VM, address: '127.0.0.1:54221', transport: 'socket'<my><name>wej-laptop</name><brand>huawei</brand><cpuList><oneCpu><name>第⼀个</name><generation>8-i5-K</generation><computer reference="../../.."/></oneCpu><oneCpu><name>第⼆个</name><generation>8-i5-U</generation></oneCpu></cpuList></my>Security framework of XStream not initialized, XStream is probably vulnerable. wej-laptopDisconnected from the target VM, address: '127.0.0.1:54221', transport: 'socket' Process finished with exit code 0可以看到⽣成的XML中采⽤类似路径的reference属性来标识了位置,实际上我们⼀般是需要忽略这个属性的,采⽤@XStreamOmitField注解就好了.。

Xstream（对象和xml转换）

Xstream（对象和xml转换）package com.vcredit.framework.utils;import java.io.Writer;import ng3.StringUtils;import com.thoughtworks.xstream.XStream;import com.thoughtworks.xstream.core.util.QuickWriter;import com.thoughtworks.xstream.io.HierarchicalStreamWriter;import com.thoughtworks.xstream.io.xml.PrettyPrintWriter;import com.thoughtworks.xstream.io.xml.XmlFriendlyNameCoder;import com.thoughtworks.xstream.io.xml.XppDriver;/*** XML⼯具类*/public class XmlUtils {/*** 创建XStream*/private static XStream createXstream() {XStream xstream = new XStream(new MyXppDriver(false));xstream.autodetectAnnotations(true);return xstream;}/*** ⽀持注解转化XML*/public static String toXML(Object obj, Class<?> cls) {if (obj == null) {return null;}XStream xstream = createXstream();xstream.processAnnotations(cls);return getDefaultXMLHeader() + xstream.toXML(obj);}/*** Object 转化 XML*/public static String toXML(Object obj) {if (obj == null) {return null;}XStream xstream = createXstream();return getDefaultXMLHeader() + xstream.toXML(obj);}/*** XML转化为JAVA对象*/@SuppressWarnings("unchecked")public static <T> T xml2Obj(String xml, Class<?> cls) {if (StringUtils.isBlank(xml)) {return null;}XStream xstream = createXstream();if (cls != null) {xstream.processAnnotations(cls);}return (T) xstream.fromXML(xml);}/*** XML转化为JAVA对象*/public static <T> T xml2Obj(String xml) {return xml2Obj(xml, null);}private static String getDefaultXMLHeader() {return "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n";}/**** @description XppDriver** @author lixining* @version $Id: XmlUtils.java, v 0.1 2015年8⽉18⽇上午9:46:57 lixining Exp $*/public static class MyXppDriver extends XppDriver {boolean useCDATA = false;MyXppDriver(boolean useCDATA) {super(new XmlFriendlyNameCoder("__", "_"));eCDATA = useCDATA;}@Overridepublic HierarchicalStreamWriter createWriter(Writer out) {if (!useCDATA) {return super.createWriter(out);}return new PrettyPrintWriter(out) {boolean cdata = true;@Overridepublic void startNode(String name, @SuppressWarnings("rawtypes") Class clazz) {super.startNode(name, clazz);}@Overrideprotected void writeText(QuickWriter writer, String text) {if (cdata) {writer.write(cDATA(text));} else {writer.write(text);}}private String cDATA(String text) {return "<![CDATA[" + text + "]]>";}};}}}调⽤⽅法String xmlForMobileScore = XmlUtils.toXML(decisionReqForMobileScore);再写到⽂件中：String decisionReqName = getSaveFile(timestamp, modelName, "req");String decisionResName = getSaveFile(timestamp, modelName, "res");("DecisionClient->Request->" + timestamp + "->" + xml);FileUtils.write(new File(decisionReqName), xml, "utf-8");解析xml：dom4jprivate DecisionResponse parseDecisionRespXML(String resultXml) throws BusinessException { if (StringUtils.isBlank(resultXml)) {throw new BusinessException("决策⽆数据返回");}DecisionResponse result = new DecisionResponse();Element root = Dom4jUtils.getRoot(resultXml);Element decisionResult = root.element("DecisionResult");// 决策结果-建议拒绝 or 通过Element resultElement = decisionResult.element("Result");result.setResult(resultElement.getStringValue());// 解析拒绝原因if (!StringUtils.equals(result.getResult(), "通过")) {Element ruleSetElement = decisionResult.element("RuleResultSets");List<String> modList = parseRejectRules(decisionResult.element("RejectReasonList")); parseRuleSet(result, ruleSetElement, modList);}// 解析决策评分卡结果Element vbInfoSetElement = decisionResult.element("VBInfo");parseVBInfoSet(result,vbInfoSetElement);// 解析决策评分细节Element ruleResultElement = decisionResult.element("RuleResultCanShowSets"); parseruleResult(result,ruleResultElement);Element ruleResultCanShowSets = decisionResult.element("RuleResultCanShowSets"); parseRelatedRate(result, ruleResultCanShowSets);("Decision Result -> " + GsonUtils.toJson(result));return result;}package com.vcredit.framework.utils;import ng3.StringUtils;import org.dom4j.Document;import org.dom4j.DocumentHelper;import org.dom4j.Element;import org.slf4j.Logger;import org.slf4j.LoggerFactory;public class Dom4jUtils {private static final Logger logger = LoggerFactory.getLogger(Dom4jUtils.class);public static Document getDocument(String xml) {Document document = null;try {document = DocumentHelper.parseText(xml);if (document == null) {throw new RuntimeException("document is null");}return document;} catch (Exception e) {logger.error("parse xml fail", e);throw new RuntimeException("get document fail", e);}}/*** 解析XML获取Root节点** @param xml* @return Element*/public static Element getRoot(String xml) {Document document = getDocument(xml);return document.getRootElement();}/*** 获取节点值** @param root* @param nodeName* @return String*/public static String getValue(Element root, String nodeName) {try {if (root == null || StringUtils.isBlank(nodeName)) {return null;}Element nodeElement = root.element(nodeName);if (nodeElement == null) {return null;}return nodeElement.getTextTrim();} catch (Exception e) {logger.error("get node(" + nodeName + ") value fail");return null;}}// public static void main(String[] args) throws IOException {// Document doc = getDocument(FileUtils.readFileToString(new File("e:\\test\\result.xml"), "utf-8")); // Element root = doc.getRootElement();// List<Element> elementList = root.elements();// for (Element element : elementList) {// System.err.println("-------------------------->" + element.getName());// System.err.println(element.getStringValue());// }// System.err.println("test");// }}。

XStream处理XML用法

XStream处理XML⽤法1.简介： XStream是⼀个简单的基于Java库，Java对象序列化到XML，反之亦然(即：可以轻易的将Java对象和xml⽂档相互转换)。

特点：使⽤⽅便 - XStream的API提供了⼀个⾼层次外观，以简化常⽤的⽤例。

⽆需创建映射 - XStream的API提供了默认的映射⼤部分对象序列化。

性能 - XStream快速和低内存占⽤，适合于⼤对象图或系统。

⼲净的XML - XStream创建⼀个⼲净和紧凑XML结果，这很容易阅读。

不需要修改对象 - XStream可序列化的内部字段，如私有和最终字段，⽀持⾮公有制和内部类。

默认构造函数不是强制性的要求。

完整对象图⽀持 - XStream允许保持在对象模型中遇到的重复引⽤，并⽀持循环引⽤。

可⾃定义的转换策略 - 定制策略可以允许特定类型的定制被表⽰为XML的注册。

安全框架 - XStream提供了⼀个公平控制有关解组的类型，以防⽌操纵输⼊安全问题。

错误消息 - 出现异常是由于格式不正确的XML时，XStream抛出⼀个统⼀的例外，提供了详细的诊断，以解决这个问题。

另⼀种输出格式 - XStream⽀持其它的输出格式，如JSON。

2.API使⽤0.使⽤的beanUser.javapackage cn.qlq.bean;import java.util.Date;import java.util.List;public class User {private String name;private int age;private Date birthDay;private List<Group> groups;public String getName() {return name;}public void setName(String name) { = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}public Date getBirthDay() {return birthDay;}public void setBirthDay(Date birthDay) {this.birthDay = birthDay;}public User(String name, int age, Date birthDay) {super(); = name;this.age = age;this.birthDay = birthDay;}public List<Group> getGroups() {return groups;}public void setGroups(List<Group> groups) {this.groups = groups;}@Overridepublic String toString() {return "User [name=" + name + ", age=" + age + ", birthDay=" + birthDay + ", groups=" + groups + "]";}}Group.javapackage cn.qlq.bean;import java.util.List;public class Group {private Integer id;private String name;private List<User> users;public Integer getId() {return id;}public void setId(Integer id) {this.id = id;}public String getName() {return name;}public void setName(String name) { = name;}public Group(Integer id, String name) {super();this.id = id; = name;}public List<User> getUsers() {return users;}public void setUsers(List<User> users) {ers = users;}@Overridepublic String toString() {return "Group [id=" + id + ", name=" + name + ", users=" + users + "]";}}1.⼊门package cn.qlq.test;import java.io.File;import java.io.FileNotFoundException;import java.io.FileOutputStream;import java.util.ArrayList;import java.util.Date;import java.util.List;import com.thoughtworks.xstream.XStream;import com.thoughtworks.xstream.io.xml.StaxDriver;import cn.qlq.bean.Group;import er;public class XStreamtest {public static void main(String[] args) throws FileNotFoundException {// StaxDriverXStream xstream = new XStream(new StaxDriver());// DomDriver// XStream xstream = new XStream(new DomDriver());// JDomDriver// XStream xstream = new XStream(new JDomDriver());// JsonHierarchicalStreamDriver// XStream xstream = new XStream(new JsonHierarchicalStreamDriver() { // public HierarchicalStreamWriter createWriter(Writer writer) {// return new JsonWriter(writer, JsonWriter.DROP_ROOT_MODE);// }//// });// 构造beanUser user = new User("zhangsan", 2, new Date());List<Group> groups = new ArrayList<>();groups.add(new Group(1, "g1"));groups.add(new Group(2, "g2"));user.setGroups(groups);// Object to XML ConversionString xml = xstream.toXML(user);System.out.println(xml);// XML String 转beanUser user2 = (User) xstream.fromXML(xml);System.out.println(user2);// ⽣成到xml⽂件xstream.toXML(user, new FileOutputStream(new File("G:/user.xml")));// 从xml⽂件读取User user3 = (User) xstream.fromXML(new File("G:/user.xml"));System.out.println(user3);}}结果：<?xml version='1.0' encoding='UTF-8'?><er><name>zhangsan</name><age>2</age><birthDay>2019-12-03 11:26:59.584 UTC</birthDay><groups> <cn.qlq.bean.Group><id>1</id><name>g1</name></cn.qlq.bean.Group><cn.qlq.bean.Group><id>2</id><name>g2</name></cn.qlq.bean.Group></groups></er>User [name=zhangsan, age=2, birthDay=Tue Dec 03 19:26:59 CST 2019, groups=[Group [id=1, name=g1, users=null], Group [id=2, name=g2, users=null]]]User [name=zhangsan, age=2, birthDay=Tue Dec 03 19:26:59 CST 2019, groups=[Group [id=1, name=g1, users=null], Group [id=2, name=g2, users=null]]]使⽤步骤：(1)创建创建XStream对象。

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

使⽤XStream是实现XML与Java对象的转换（3）--注解六、使⽤注解(Annotation)总是使⽤XStream对象的别名⽅法和注册转换器，会让⼈感到⾮常的乏味，⼜会产⽣很多重复性代码，于是我们可以使⽤注解的⽅式来配置要序列化的POJO对象。

1，最基本的注解:类的别名性注解和字段的别名性注解(XStreamAlias)有这样⼀段代码：Java代码import com.thoughtworks.xstream.XStream;public class XStreamTest3 {public static void main(String[] args) {XStream stream = new XStream();RendezvousMessage msg = new RendezvousMessage(15);System.out.println(stream.toXML(msg));}}class RendezvousMessage {private int messageType;public RendezvousMessage(int messageType) {this.messageType = messageType;}}运⾏结果是：Java代码<cn.tjpu.zhw.xml.RendezvousMessage><messageType>15</messageType></cn.tjpu.zhw.xml.RendezvousMessage>如果我们需要将输出的XML⽂本是这样：Java代码<message><type>15</type></message>该怎么办？我们当然可以在main⽅法中调⽤XStream对象的别名映射⽅法进⾏处理，但我们也可以使⽤更简单的注解的⽅式进⾏处理。

XStream使用方法总结L-对象-转换

package test;
import java.util.List;
/**
* Created by IntelliJ IDEA. 
* User: leizhimin 
* Date: 2008-5-22 21:10:13 
* Note: Please add comment here!
你可以实现自己的转换器。还可以利用XStream完成更负责的功能，比如输出其他非xml格式的数据，还可以输出html，还支持XML Dom类型数据，
这些应用起来稍微复杂些。当然这些不是XStream应用的重点，也不用理会，真正需要的时候再查看API和源码研究研究。
XStream 的优点很多，但是也有一些小bug，比如在定义别名中的下划线“_”转换为xml后会变成“__”这个符号，很变态。
xStream.aliasField("Add", test.Address.class, "add");
xStream.aliasField("Job", test.Profile.class, "job");
output(2, xStream, person);
/******* 设置类成员为xml一个元素上的属性 *******/
", age='" + age + '\'' +
", profile=" + profile +

SpringMVC关于json、xml自动转换的原理研究

SpringMVC关于json、xml自动转换的原理研究<mvc:resources location="/static/"mapping="/static/**"/><mvc:annotation-driven/><context:component-scanbase-package="org.format.demo.controller" />视图配置省略.....pom中需要有以下依赖(Spring依赖及其他依赖不显示)：<dependency> <groupId>org.codehaus.jackson</groupId><artifactId>jackson-core-asl</artifactId> <version>1.9.13</version> </dependency> <dependency> <groupId>org.codehaus.jackson</groupId><artifactId>jackson-mapper-asl</artifactId> <version>1.9.13</version> </dependency>这个依赖分别是json序列化的依赖。

ok。

我们在Controller中添加一个method：@RequestMapping("/)@ResponseBodypublic Map<String, Object> <String, Object> map = new HashMap<String, Object>();map.put("list", employeeService.list());return map;}直接访问地址：我们看到，短短几行配置。

xstreamomitfield 注解

xstreamomitfield 注解一、概述XStream是一款强大的Java对象与XML、JSON等数据格式之间的转换库。

在XStream中，注解是一种用于简化对象与XML之间的转换的方式。

其中，XStreamOmitField注解用于指示XStream在序列化和反序列化过程中忽略指定的字段。

二、注解详解XStreamOmitField注解用于指示XStream忽略指定的字段。

它可以应用于类的字段、嵌套类、方法以及构造方法参数。

当使用XStreamOmitField注解时，XStream将忽略带有该注解的字段在序列化和反序列化过程中的处理。

语法：注解的使用取决于被标注的元素类型。

对于字段，通常将注解直接放置在字段上；对于嵌套类、方法以及构造方法参数，需要在方法/参数名前使用它。

注意：对于构造函数参数，应确保所有相关的字段都在构造函数中有对应的初始化。

示例：假设有一个类Person，包含姓名(name)和年龄(age)两个字段，现在希望在序列化和反序列化过程中忽略年龄字段，可以按照以下方式使用XStreamOmitField注解：```javapublic class Person {private int age;private String name;// 其他属性和方法...}```或者直接使用在方法或参数上：```javapublic void createPerson(String name, @XStreamOmitField int age) {// 其他代码...}```三、应用场景XStreamOmitField注解主要用于在序列化和反序列化过程中忽略不需要处理的字段。

以下是一些常见的应用场景：1. 忽略私有字段：当一个类的字段被声明为私有时，通常不需要在序列化和反序列化过程中处理这些字段。

使用XStreamOmitField注解可以方便地忽略这些字段。

2. 忽略非必要字段：在某些情况下，可能存在一些非必要的字段，如临时生成的ID等。

XStream使用文档

XStream使用文档作者：胡少锋Email：hsf@2011年11月1 基本介绍1.1前言XStream 是一个轻量级的、简单易用的开放源代码Java库，用于将Java 对象序列化为XML 或者再转换回来。

而且XStream还能将java对象转成其它格式，比如JSon。

官方上的XStream特点：●使用简单●不需要配置映射●速度快，占用内存小●生成的XML文件简洁●不需要修改序列化对象的类型●支持类嵌套●详细的错误日志●可转成其它格式XStream相比其它框架有如下的优点：●XStream 不关心序列化/逆序列化的类的字段的可见性。

●序列化/逆序列化类的字段不需要getter 和setter 方法。

●序列化/逆序列化的类不需要有默认构造函数。

2 安装和使用2.1下载XStream的网站/download.html上面可以下载到各种版本。

目前用最新版本是1.4.1，下载这个版本即可。

2.2安装XStream的安装方法比较简单，将xstream-1.4.1.jar以及kxml2-2.3.0.jar 放置到类路径下面即可使用。

如下图所示：3 开始一个例子3.1新建一个空的java project工程通过eclipse向导新建一个Java Project工程，并将上面提的两个类添加到类路径下。

工程如下：3.2编写Java后台类，代码如下新建一个cn的package，然后在cn下面新建两个Java类，Person和PhoneNumber，代码分别如下：Person.javapackage cn;public class Person {private String firstname;private String lastname;private PhoneNumber phone;private PhoneNumber fax;public Person(String firstName, String lastName) {this.firstname = firstName;stname = lastName;}public String getFirstname() {return firstname;}public void setFirstname(String firstname) {this.firstname = firstname;}public String getLastname() {return lastname;}public void setLastname(String lastname) {stname = lastname;}public PhoneNumber getPhone() {return phone;}public void setPhone(PhoneNumber phone) { this.phone = phone;}public PhoneNumber getFax() {return fax;}public void setFax(PhoneNumber fax) {this.fax = fax;}}PhoneNumber.javapackage cn;public class PhoneNumber {private int code;private String number;public PhoneNumber(int code, String number) { this.code = code;this.number = number;}public int getCode() {return code;}public void setCode(int code) {this.code = code;}public String getNumber() {return number;}public void setNumber(String number) {this.number = number;}}以上是两个很普通的Java对象。

Xstream

XstreamxStream完美转换XML、JSONxStream框架xStream可以轻易的将Java对象和xml⽂档相互转换，⽽且可以修改某个特定的属性和节点名称，⽽且也⽀持json的转换；它们都完美⽀持JSON，但是对xml的⽀持还不是很好。

⼀定程度上限制了对Java对象的描述，不能让xml完全体现到对Java对象的描述。

这⾥将会介绍xStream对JSON、XML的完美⽀持。

xStream不仅对XML的转换⾮常友好，⽽且提供annotation注解，可以在JavaBean中完成对xml节点、属性的描述。

以及对JSON也⽀持，只需要提供相关的JSONDriver就可以完成转换。

⼀、准备⼯作1、下载jar包、及官⽅资源xStream的jar下载地址：添加xstream-1.3.1.jar⽂件到⼯程中，就可以开始下⾯的⼯作；需要的jar如下：clip_image0022、测试⽤例代码package com.hoo.test;import java.io.IOException;import java.io.ObjectInputStream;import java.io.ObjectOutputStream;import java.io.StringReader;import java.io.Writer;import java.util.ArrayList;import java.util.HashMap;import java.util.Iterator;import java.util.List;import java.util.Map;import java.util.Set;import org.codehaus.jettison.json.JSONException;import org.junit.After;import org.junit.Before;import org.junit.Test;import com.hoo.entity.Birthday;import com.hoo.entity.Classes;import com.hoo.entity.ListBean;import com.hoo.entity.Student;import com.thoughtworks.xstream.XStream;import com.thoughtworks.xstream.io.HierarchicalStreamWriter;import com.thoughtworks.xstream.io.json.JettisonMappedXmlDriver;import com.thoughtworks.xstream.io.json.JsonHierarchicalStreamDriver;import com.thoughtworks.xstream.io.json.JsonWriter;/*** function:Java对象和XML字符串的相互转换* jar-lib-version: xstream-1.3.1* @author hoojo* @createDate Nov 27, 2010 12:15:15 PM* @file XStreamTest.java* @package com.hoo.test* @project WebHttpUtils* @blog /IBM_hoojo* @email hoojo_@* @version 1.0*/@SuppressWarnings("unchecked")public class XStreamTest {private XStream xstream = null;private ObjectOutputStream out = null;private ObjectInputStream in = null;private Student bean = null;/*** function:初始化资源准备* @author hoojo* @createDate Nov 27, 2010 12:16:28 PM*/@Beforepublic void init() {try {xstream = new XStream();//xstream = new XStream(new DomDriver()); // 需要xpp3 jar } catch (Exception e) {e.printStackTrace();}bean = new Student();bean.setAddress("china");bean.setEmail("jack@");bean.setId(1);bean.setName("jack");Birthday day = new Birthday();day.setBirthday("2010-11-22");bean.setBirthday(day);}/*** function:释放对象资源* @author hoojo* @createDate Nov 27, 2010 12:16:38 PM*/@Afterpublic void destory() {xstream = null;bean = null;try {if (out != null) {out.flush();out.close();}if (in != null) {in.close();}} catch (IOException e) {e.printStackTrace();}System.gc();}public final void fail(String string) {System.out.println(string);}public final void failRed(String string) {System.err.println(string);}}通过XStream对象的toXML⽅法就可以完成Java对象到XML的转换，toXML⽅法还有2个相同签名的⽅法，需要传递⼀个流。

XStream介绍及简单使用

XStream介绍及简单使用XStream 是一个Java库，用于将对象序列化为XML格式或将XML格式反序列化为对象。

它提供了一个简单的API，可以通过注解或编程方式进行配置和使用。

XStream 的目标是使XML序列化和反序列化变得简单、快速和灵活。

1. 对象序列化为XML：XStream 可以将Java对象序列化为XML格式。

它会将对象的属性和字段转换为XML元素，并将其值存储为元素的文本内容。

XStream 支持嵌套对象、集合和数组，可以将它们转换为XML的子元素或属性。

2. XML反序列化为对象：XStream 可以将XML格式的数据反序列化为Java对象。

它会解析XML元素和属性，并将它们转换为对象的属性和字段。

XStream 支持嵌套对象、集合和数组的反序列化，可以将它们转换为相应的Java对象。

3. 注解支持：XStream 支持使用注解配置对象的序列化和反序列化。

通过在对象的类和字段上添加注解，可以指定XML元素的名称、属性和顺序。

这使得开发人员可以更精确地控制对象的序列化和反序列化过程。

4. 别名和隐式集合：XStream 支持为类和字段定义别名，以便在生成的XML中使用更友好的名称。

它还支持隐式集合，可以将多个对象的集合存储为单个XML元素。

5. 自定义转换器：XStream 允许开发人员自定义转换器，以实现特定类型的高级序列化和反序列化逻辑。

通过实现接口或继承适当的类，可以编写自定义转换器，并将其注册到XStream中。

下面是一个简单的示例，演示了如何使用XStream将对象序列化为XML并进行反序列化：```javapublic class Mainpublic static void main(String[] args)// 创建XStream对象//将对象序列化为XMLPerson person = new Person("John", 30);String xml = xstream.toXML(person);System.out.println(xml);//将XML反序列化为对象Person deserializedPerson = (Person) xstream.fromXML(xml);System.out.println(deserializedPerson.getName();System.out.println(deserializedPerson.getAge();}class Personprivate String name;private int age;public Person(String name, int age) = name;this.age = age;}public String getNamreturn name;}public int getAgreturn age;}```在上面的示例中，我们首先创建了一个XStream对象。

json 转 xml 方法

json 转 xml 方法
将JSON转换为XML可以通过多种方法实现。

以下是一种常见的
方法：
1. 使用编程语言的库或工具，许多编程语言都提供了用于处理JSON和XML的库或工具，例如在Python中，你可以使用json库解
析JSON数据，然后使用xml.etree.ElementTree库将其转换为XML。

在Java中，你可以使用Jackson库解析JSON数据，然后使用JAXB
库将其转换为XML。

类似的库和工具在其他编程语言中也有相应的
实现。

2. 手动转换，你可以编写自定义的脚本或程序来手动将JSON
转换为XML。

这通常涉及遍历JSON对象并根据其结构构建相应的
XML元素。

这种方法需要对JSON和XML的结构有深入的了解，以确
保转换过程正确无误。

3. 在线工具，也可以使用在线的JSON到XML转换工具，这些
工具通常提供了简单易用的界面，只需将JSON数据粘贴到指定的区域，点击转换按钮即可得到相应的XML数据。

无论使用哪种方法，都需要注意JSON和XML在数据表示上的差异，例如JSON是一种轻量级的数据交换格式，而XML则更为结构化和具有层次性。

因此，在转换过程中需要考虑到数据的结构、嵌套关系以及特定的数据类型等因素。

希望这些信息能够帮助到你。

xstream 转xml 简书

xstream 是一个开源的 Java 库，用于将 Java 对象序列化为 XML 或从 XML 反序列化为 Java 对象。

它提供了一种简单而有效的方式来处理 XML 数据，能够帮助开发人员轻松地将 Java 对象转换为 XML 格式，以便于在不同系统之间进行数据传输和存储。

xstream 的主要特点包括：1. 强大的对象转换功能：xstream 能够轻松地将 Java 对象序列化为XML 格式，同时也可以将 XML 数据反序列化为 Java 对象，实现了两者之间的无缝转换。

2. 灵活的配置选项：开发人员可以通过配置文件或代码来自定义转换规则，满足不同项目的需求。

3. 对象关系的处理：xstream 支持处理对象之间的关系，包括引用和循环引用等，能够在转换过程中保持对象之间的关联关系。

4. 支持多种数据格式：除了 XML 格式外，xstream 还支持 JSON 等多种数据格式，能够为开发人员提供更多的选择。

5. 大型数据的处理：xstream 能够高效地处理大型数据，保证在数据转换过程中的性能和效率。

使用 xstream 转换 Java 对象为 XML 的基本步骤：1. 导入 xstream 库：首先需要在项目中导入 xstream 相关的 jar 包，以便在代码中使用其功能。

2. 创建 Java 对象：定义需要转换的 Java 对象，并为其添加相应的字段和方法。

3. 创建 xstream 对象：在代码中创建 xstream 对象，用于进行对象和 XML 之间的转换。

可以根据需要配置 xstream 对象的相关选项。

4. 转换为 XML：通过调用 xstream 对象的相关方法，将 Java 对象转换为 XML 格式的数据。

5. 存储或传输：将生成的 XML 数据存储到文件中或通过网络传输到其他系统。

使用 xstream 将 XML 转换为 Java 对象的基本步骤：1. 导入 xstream 库：与转换 Java 对象为 XML 的步骤相同，首先需要导入 xstream 相关的 jar 包。

XML之与Json或String的相互转换

XML之与Json或String的相互转换1、XML与String的相互转换[1] XML 转为 String//载⼊Xml⽂件XmlDocument xdoc = new XmlDocument();xdoc.Load("xml⽂件");string xmlStr = xdoc.InnerXml;[2] String 转为 XML//载⼊Xml字符串XmlDocument xdoc = new XmlDocument();xdoc.LoadXml("xml字符串");//保存为Xml⽂件xdoc.Save("xml⽂件");2、XML 与 Json 的相互转换[1] XML 转换为 Jsonusing System.Xml;using Newtonsoft.Json;string xml = "<xml><Name>Test class</Name><X>100</X><Y>200</Y></xml>";XmlDocument doc = new XmlDocument();doc.LoadXml(xml);string json = Newtonsoft.Json.JsonConvert.SerializeXmlNode(doc);[2] Json 转换为 XML⽅法⼀：string json = Newtonsoft.Json.JsonConvert.SerializeXmlNode(xml);XmlDocument xmlDoc = Newtonsoft.Json.JsonConvert.DeserializeXmlNode(json);xmlDoc.Save("F:/example.xml");⽅法⼆： using System.Xml; using System.Runtime.Serialization.Json; using System.Web.Script.Serialization; ///<summary>/// json字符串转换为Xml对象/// XmlDictionaryReader命名空间为using System.Runtime.Serialization.Json;/// JavaScriptSerializer需添加System.Web.Extensions.dll引⽤ /// JavaScriptSerializer命名空间为System.Web.Script.Serialization;///</summary>///<param name="sJson"></param>///<returns></returns>public static XmlDocument Json2Xml(string sJson){//XmlDictionaryReader reader = JsonReaderWriterFactory.CreateJsonReader(Encoding.UTF8.GetBytes(sJson), XmlDictionaryReaderQuotas.Max); //XmlDocument doc = new XmlDocument();//doc.Load(reader);JavaScriptSerializer oSerializer = new JavaScriptSerializer();Dictionary<string, object> Dic = (Dictionary<string, object>)oSerializer.DeserializeObject(sJson);XmlDocument doc = new XmlDocument();XmlDeclaration xmlDec = doc.CreateXmlDeclaration("1.0", "UTF-8", "yes");doc.InsertBefore(xmlDec, doc.DocumentElement);XmlElement nRoot = doc.CreateElement("root");doc.AppendChild(nRoot);foreach (KeyValuePair<string, object> item in Dic){XmlElement element = doc.CreateElement(item.Key);KeyValue2Xml(element, item);nRoot.AppendChild(element);}return doc;}private static void KeyValue2Xml(XmlElement node, KeyValuePair<string, object> Source) {object kValue = Source.Value;if (kValue.GetType() == typeof(Dictionary<string, object>)){foreach (KeyValuePair<string, object> item in kValue as Dictionary<string, object>){XmlElement element = node.OwnerDocument.CreateElement(item.Key);KeyValue2Xml(element, item);node.AppendChild(element);}}else if (kValue.GetType() == typeof(object[])){object[] o = kValue as object[];for (int i = 0; i < o.Length; i++){XmlElement xitem = node.OwnerDocument.CreateElement("Item");KeyValuePair<string, object> item = new KeyValuePair<string, object>("Item", o[i]); KeyValue2Xml(xitem, item);node.AppendChild(xitem);}}else{XmlText text = node.OwnerDocument.CreateTextNode(kValue.ToString());node.AppendChild(text);}}。

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

xStream框架xStream可以轻易的将Java对象和xml文档相互转换，而且可以修改某个特定的属性和节点名称，而且也支持json的转换；json-lib框架，以及Jackson框架，它们都完美支持JSON，但是对xml的支持还不是很好。

一定程度上限制了对Java对象的描述，不能让xml完全体现到对Java对象的描述。

这里将会介绍xStream对JSON、XML的完美支持。

xStream不仅对XML的转换非常友好，而且提供annotation注解，可以在JavaBean中完成对xml节点、属性的描述。

以及对JSON也支持，只需要提供相关的JSONDriver就可以完成转换。

一、准备工作1、下载jar包、及官方资源xStream的jar下载地址：https:///content/repositories/releases/com/thoughtworks/xstre am/xstream-distribution/1.3.1/xstream-distribution-1.3.1-bin.zip官方的示例很全，官方参考示例：/tutorial.html添加xstream-1.3.1.jar文件到工程中，就可以开始下面的工作；需要的jar如下：2、测试用例代码package com.hoo.test;import java.io.IOException;import java.io.ObjectInputStream;import java.io.ObjectOutputStream;import java.io.StringReader;import java.io.Writer;import java.util.ArrayList;import java.util.HashMap;import java.util.Iterator;import java.util.List;import java.util.Map;import java.util.Set;import org.codehaus.jettison.json.JSONException;import org.junit.After;import org.junit.Before;import org.junit.Test;import com.hoo.entity.Birthday;import com.hoo.entity.Classes;import com.hoo.entity.ListBean;import com.hoo.entity.Student;import com.thoughtworks.xstream.XStream;import com.thoughtworks.xstream.io.HierarchicalStreamWriter;import com.thoughtworks.xstream.io.json.JettisonMappedXmlDriver; import com.thoughtworks.xstream.io.json.JsonHierarchicalStreamDriver; import com.thoughtworks.xstream.io.json.JsonWriter;/*** function:Java对象和XML字符串的相互转换* jar-lib-version: xstream-1.3.1* @author hoojo* @createDate Nov 27, 2010 12:15:15 PM* @file XStreamTest.java* @package com.hoo.test* @project WebHttpUtils* @blog /IBM_hoojo* @email hoojo_@* @version 1.0*/@SuppressWarnings("unchecked")public class XStreamTest {private XStream xstream = null;private ObjectOutputStream out = null;private ObjectInputStream in = null;private Student bean = null;/*** function:初始化资源准备* @author hoojo* @createDate Nov 27, 2010 12:16:28 PM*/@Beforepublic void init() {try {xstream = new XStream();//xstream = new XStream(new DomDriver()); // 需要xpp3 jar } catch (Exception e) {e.printStackTrace();}bean = new Student();bean.setAddress("china");bean.setEmail("jack@");bean.setId(1);bean.setName("jack");Birthday day = new Birthday();day.setBirthday("2010-11-22");bean.setBirthday(day);}/*** function:释放对象资源* @author hoojo* @createDate Nov 27, 2010 12:16:38 PM*/@Afterpublic void destory() {xstream = null;bean = null;try {if (out != null) {out.flush();out.close();}if (in != null) {in.close();}} catch (IOException e) {e.printStackTrace();}System.gc();}public final void fail(String string) {System.out.println(string);}public final void failRed(String string) {System.err.println(string);}}通过XStream对象的toXML方法就可以完成Java对象到XML的转换，toXML方法还有2个相同签名的方法，需要传递一个流。

然后通过流来完成xml信息的输出。

3、需要的JavaBeanpackage com.hoo.entity;public class Student {private int id;private String name;private String email;private String address;private Birthday birthday;//getter、setterpublic String toString() {return + "#" + this.id + "#" + this.address + "#" + this.birthday + "#" + this.email;}}二、Java转换成XML1、 JavaBean转换XM/*** function:Java对象转换成XML字符串* @author hoojo* @createDate Nov 27, 2010 12:19:01 PM*/@Testpublic void writeBean2XML() {try {fail("------------Bean->XML------------");fail(xstream.toXML(bean));fail("重命名后的XML");//类重命名//xstream.alias("account", Student.class);//xstream.alias("生日", Birthday.class);//xstream.aliasField("生日", Student.class, "birthday");//xstream.aliasField("生日", Birthday.class, "birthday");//fail(xstream.toXML(bean));//属性重命名xstream.aliasField("邮件", Student.class, "email");//包重命名xstream.aliasPackage("hoo", "com.hoo.entity");fail(xstream.toXML(bean));} catch (Exception e) {e.printStackTrace();}}看结果中的第一份xml内容，是没有经过然后修改或重命名的文档，按照原样输出。

文档中的第二份文档的package经过重命名，email属性也经过重命名以及类名也可以进行重命名的。

运行后结果如下：------------Bean->XML------------<com.hoo.entity.Student><id>1</id><name>jack</name><email>jack@</email><address>china</address><birthday><birthday>2010-11-22</birthday></birthday></com.hoo.entity.Student>重命名后的XML<hoo.Student><id>1</id><name>jack</name><邮件>jack@</邮件><address>china</address><birthday><birthday>2010-11-22</birthday></birthday></hoo.Student>2、将List集合转换成xml文档/*** function:将Java的List集合转换成XML对象* @author hoojo* @createDate Nov 27, 2010 12:20:07 PM*/@Testpublic void writeList2XML() {try {//修改元素名称xstream.alias("beans", ListBean.class);xstream.alias("student", Student.class);fail("----------List-->XML----------");ListBean listBean = new ListBean();listBean.setName("this is a List Collection");List<Object> list = new ArrayList<Object>();list.add(bean);list.add(bean);//引用bean//list.add(listBean);//引用listBean，父元素bean = new Student();bean.setAddress("china");bean.setEmail("tom@");bean.setId(2);bean.setName("tom");Birthday day = new Birthday("2010-11-22");bean.setBirthday(day);list.add(bean);listBean.setList(list);//将ListBean中的集合设置空元素，即不显示集合元素标签//xstream.addImplicitCollection(ListBean.class, "list");//设置reference模型//xstream.setMode(XStream.NO_REFERENCES);//不引用xstream.setMode(XStream.ID_REFERENCES);//id引用//xstream.setMode(XStream.XPATH_ABSOLUTE_REFERENCES);//绝对路径引用//将name设置为父类（Student）的元素的属性eAttributeFor(Student.class, "name");eAttributeFor(Birthday.class, "birthday");//修改属性的namexstream.aliasAttribute("姓名", "name");xstream.aliasField("生日", Birthday.class, "birthday");fail(xstream.toXML(listBean));} catch (Exception e) {e.printStackTrace();}}上面的代码运行后，结果如下：----------List-->XML----------<beans id="1"><name>this is a List Collection</name><list id="2"><student id="3" 姓名="jack"><id>1</id><email>jack@</email><address>china</address><birthday id="4" 生日="2010-11-22"/></student><student reference="3"/><student id="5" 姓名="tom"><id>2</id><email>tom@</email><address>china</address><birthday id="6" 生日="2010-11-22"/></student></list></beans>如果不加xstream.addImplicitCollection(ListBean.class, "list");这个设置的话，会出现一个List节点包裹着Student节点元素。