XStream使用方法总结附实例代码 XML---对象 转换
xstream中几个注解的含义和用法(转)

xstream中⼏个注解的含义和⽤法(转)XStream是个很强⼤的⼯具,能将对象和xml之间相互转化。
xstream不在意java类中成员变量是私有还是公有,也不在乎是否有默认构造函数。
它调⽤⽅式也⾮常简单:从xml对象转化为java对象,使⽤fromXML()⽅法;从java对象序列化为xml,toXML()即可,很⽅便。
xstream 也⽀持注解⽅式,这些都是为了简化输出⽽设计,下⾯为⼤家简单说⼀下这⼏个注解的含义和⽤法。
1. 当没有任何注解情况下[java]1. public class Cat {2. //名字3. private String name;4. //⼤⼩5. private Integer age;6. //玩具球球具有颜⾊属性7. private List<Ball> balls;8.9. Cat(String name,Integer age,List<Ball> balls){10. = name;11. this.age = age;12. this.balls=balls;13. }14. //getter/setter⽅法为了赋值使⽤其中Ball定义如下:[java]1. public class Ball {2. //颜⾊3. private String color;4.5. Ball(String color){6. this.color = color;7. }没有任何注解,输出如下:[java]1. public static void main(String[] args) throws Exception{2. //初始化cat3. List<Ball> balls = new ArrayList<Ball>();4. balls.add(new Ball("red"));5. Cat cat = new Cat("馄饨",1,balls);6. //初始化结束7. //为了⽅便查找将⽂件制定到D盘cat.xml中8. FileOutputStream fout = new FileOutputStream("D:/cat.xml");9. XStream xs = new XStream();10. xs.toXML(cat,fout);11. }<span style="font-size:14px;">12. </span>得到Cat.xml如下[java]1. <com.timejob.node.Cat>2. <name>馄饨</name>3. <age>1</age>4. <balls>5. <com.timejob.node.Ball>6. <color>red</color>7. </com.timejob.node.Ball>8. </balls>9. </com.timejob.node.Cat>1. @XStreamAlias("cat") 等同于 xstream.alias("cat", Cat.class);[java]1. @XStreamAlias("cat") //here2. public class Cat {3. //名字4. private String name;5. //⼤⼩6. private Integer age;7. //玩具球球具有颜⾊属性8. private List<Ball> balls;我们需要明确给出,哪个类的注解需要被激活:[java]1. public static void main(String[] args) throws Exception{2. //初始化cat3. List<Ball> balls = new ArrayList<Ball>();4. balls.add(new Ball("red"));5. Cat cat = new Cat("馄饨",1,balls);6. //初始化结束7. //为了⽅便查找将⽂件制定到D盘cat.xml中8. FileOutputStream fout = new FileOutputStream("D:/cat.xml");9. XStream xs = new XStream();10. //xs.alias("cat", Cat.class); //等同于 @XStreamAlias("cat")11. xs.processAnnotations(Cat.class);//将Cat.class类上的注解将会使⽤12. xs.toXML(cat,fout);13. }当我们在Cat类名使⽤该注解时,表明该类序列化为xml时,类名com.timejob.node.Cat将替换成cat输出,这样使得xml更清晰简短:[java]1. <cat>2. <name>馄饨</name>3. <age>1</age>4. <balls>5. <com.timejob.node.Ball>6. <color>red</color>8. </balls>9. </cat>2. XStreamAsAttribute 作⽤是将类内成员作为⽗节点属性输出,等同于eAttributeFor(Cat.class, "name")[java]1. @XStreamAlias("cat")2. public class Cat {3. //名字4. @XStreamAsAttribute // here 将name作为Cat属性输出在⽗节点5. private String name;6. //⼤⼩7. private Integer age;8. //玩具球球具有颜⾊属性9. private List<Ball> balls;10.其他代码保持不变,输出后cat.xml如下:[java]1. <cat name="馄饨">2. <age>1</age>3. <balls>4. <com.timejob.node.Ball>5. <color>red</color>6. </com.timejob.node.Ball>7. </balls>8. </cat>我们看到name属性已经作为 cat的属性输出在根节点上3. @XStreamAlias 作⽤就是将属性按照别名输出,等同于xstream.aliasField("catAge", Cat.class, "age"); [java]1. @XStreamAlias("cat")2. public class Cat {3. //名字4. @XStreamAsAttribute5. private String name;6. //⼤⼩7. @XStreamAlias("catAge") //here8. private Integer age;9. //玩具球球具有颜⾊属性10. private List<Ball> balls;得到cat.xml⽂件如下:[java]1. <cat name="馄饨">2. <catAge>1</catAge>3. <balls>4. <com.timejob.node.Ball>5. <color>red</color>6. </com.timejob.node.Ball>7. </balls>8. </cat>4.对于集合常⽤的注解 @XStreamImplicit 去除<Balls></Balls>显⽰,只显⽰之间的<Ball></Ball>节点元素[java]1. @XStreamAlias("cat")2. public class Cat {3. //名字4. @XStreamAsAttribute5. private String name;6. //⼤⼩7. @XStreamAlias("catAge")8. private Integer age;9. //玩具球球具有颜⾊属性10. @XStreamImplicit //here11. private List<Ball> balls;此时输出如下:[java]1. <cat name="馄饨">2. <catAge>1</catAge>3. <com.timejob.node.Ball>4. <color>red</color>5. </com.timejob.node.Ball>6. </cat>这样看起来就更加简洁了。
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或反序列化为Java对象的开源库,它提供了一种简单而强大的方式来处理XML数据。
在使用xstream进行XML序列化或反序列化时,经常会遇到空值处理的情况。
空值是指对象属性的取值为空,这在实际应用中是一个很常见的情况。
本文将探讨如何在xstream中处理对象属性为空的情况,以及如何进行空值转换处理。
1. 空值处理的重要性空值处理在实际应用开发中是一个常见的问题,特别是在数据交换和持久化过程中。
在将Java对象序列化为XML或将XML反序列化为Java对象的过程中,如果对象属性的取值为空,就需要进行空值处理。
否则,空值可能会导致数据丢失或格式错误,影响系统的稳定性和可靠性。
空值处理是很重要的。
2. xstream中的空值转换在xstream中,可以通过实现Converter接口来自定义空值转换处理。
Converter接口是xstream中用于类型转换的核心接口,它定义了将Java对象序列化为XML或将XML反序列化为Java对象的方法。
通过实现Converter接口,可以自定义空值转换处理的逻辑,以满足实际应用的需求。
3. 自定义空值转换处理在实际应用中,可以通过编写自定义的Converter来实现空值转换处理。
假设有一个User类,包含了id、name和age三个属性,当属性的取值为空时,可以通过自定义Converter来将空值转换为指定的默认值,或者忽略空值。
下面是一个示例代码:```javapublic class User {private Long id;private String name;private Integer age;// 省略getter和setter方法}public class UserConverter implements Converter {public boolean canConvert(Class type) {return type.equals(User.class);}public void marshal(Object source, HierarchicalStreamWriter writer, MarshallingContext context) {User user = (User) source;writer.startNode("id");writer.setValue(user.getId() != null ?String.valueOf(user.getId()) : "");writer.endNode();writer.startNode("name");writer.setValue(user.getName() != null ? user.getName() : "");writer.endNode();writer.startNode("age");writer.setValue(user.getAge() != null ?String.valueOf(user.getAge()) : "");writer.endNode();}public Object unmarshal(HierarchicalStreamReader reader, UnmarshallingContext context) {User user = new User();while (reader.hasMoreChildren()) {reader.moveDown();String nodeName = reader.getNodeName();String nodeValue = reader.getValue();if ("id".equals(nodeName)) {user.setId(StringUtils.isNotEmpty(nodeValue) ? Long.valueOf(nodeValue) : null);} else if ("name".equals(nodeName)) {user.setName(StringUtils.isNotEmpty(nodeValue) ? nodeValue : null);} else if ("age".equals(nodeName)) {user.setAge(StringUtils.isNotEmpty(nodeValue) ? Integer.valueOf(nodeValue) : null);}reader.moveUp();}return user;}}```在上面的示例代码中,实现了一个UserConverter来处理User对象的空值转换。
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");// }}。
微信开发,对象转换为xml时候引用XStream这个类报错处理方案

微信开发,对象转换为xml时候引⽤XStream这个类报错处理⽅案报错的信息为:/*** 扩展XStream ⽀持CDATA*/private static XStream xstream = new XStream(new XppDriver(){public HierarchicalStreamWriter createWriter(Writer out) {return new PrettyPrintWriter(out){//对全部XML节点的转换加⼊CDATA标志boolean cdata =true;@SuppressWarnings("unchecked")public void starNode(String name,Class clazz) {super.startNode(name,clazz);}protected void writeText(QuickWriter writer,String text) {if(cdata){writer.write("<![CDATA[");writer.write(text);writer.write("]]>");}else {writer.write(text);}}};}});/*** ⽂本消息对象转换为xml* @param textMessage ⽂本消息对象* @return*/public static String messageToXml(TextMessage textMessage) {xstream.alias("xml", textMessage.getClass());return xstream.toXML(textMessage);}/*** 图⽚消息对象转换为xml* @param imageMessage 图⽚消息对象* @return*/public static String messageToXml(ImageMessage imageMessage) {xstream.alias("xml", imageMessage.getClass());return xstream.toXML(imageMessage);}/*** 语⾳消息对象转换为xml* @param voiceMessage 语⾳消息对象* @return*/public static String messageToXml(VoiceMessage voiceMessage) {xstream.alias("xml", voiceMessage.getClass());return xstream.toXML(voiceMessage);}/*** 视频消息对象转换为xml* @param videoMessage 视频消息对象* @return*/public static String messageToXml(VideoMessage videoMessage) {xstream.alias("xml", videoMessage.getClass());return xstream.toXML(videoMessage);}/*** ⾳乐消息对象转换为xml* @param musicMessage ⾳乐消息对象* @return*/public static String messageToXml(MusicMessage musicMessage) {xstream.alias("xml", musicMessage.getClass());return xstream.toXML(musicMessage);}/*** 图⽂消息对象转换为xml* @param newsMessage 图⽂消息对象* @return*/public static String messageToXml(NewsMessage newsMessage) {xstream.alias("xml", newsMessage.getClass());xstream.alias("item", new Article().getClass());return xstream.toXML(newsMessage);}}处理的⽅法就是在当前类的第⼀⾏(package位置)会提⽰:Multiple markers at this line- The type org.xmlpull.v1.XmlPullParser cannot be resolved. It is indirectly referenced from required .class files- The type org.xmlpull.v1.XmlPullParser cannot be resolved. It is indirectly referenced from required .class files- The type org.xmlpull.v1.XmlPullParserException cannot be resolved. It is indirectly referenced fromrequired .class files这种信息,这是由于XStream仅仅是⼀个jar⽂件,可是它⾥⾯会依赖⼀个jar包,依赖的jar包是:xmlpull_1_0_5.jar、仅仅要把这个jar包引⼊之后。
使用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.<br>
* <b>User</b>: leizhimin<br>
* <b>Date</b>: 2008-5-22 21:10:13<br>
* <b>Note</b>: 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 +
XStream实用指南

XStream实用指南XStream实用指南—— XuSweeter @ 2011-04-17XStream是thoughtworks公司发布的一个简单的Java类库,用于将JavaBean序列化为XML,并且能够将XML文件反向转换为JavaBean。
本文根据XStream1.3.1版本对其基本使用做简单介绍,参考资料来源于官方教程和API。
壹、快速上手通过一个简单的示例来演示XStream的基本使用,你会发现使用XStream在JavaBean和XML之间的转换会有多么的便捷。
1.1 创建序列化的类注意:请注意上面两个类的字段都是私有的,XStream并不关心字段的可见性,没有getter/setter也没关系,也不要求具有默认的构造函数。
1.2 初始化XStream要使用XStream,使用如下代码实例化XStream类:你需要将xstream-[版本].jar和xpp3-[版本].jar引入到项目的classpath中。
XPP3是一个速度非常快的拉解析(pull-parse)的实现,如果你不想使用XPP3,你可以使用标准的JAXP DOM解析器来代替:称更加简洁,这是使用Xstream过程中唯一需要映射的,并且这是可选的。
注意:这是可选的步骤,没有这一步Xstream也能够正常工作,但是XML的元素名会包含类的完全路径(包含报名),造成XML不够简洁。
1.3 序列化对象至XML创建一个Person类的实例,并填充实例的字段:要想将以上创建的对象序列化为XML,只需调用Xstream对象的toXML(Object)方法即可。
输出的的XML如下:根据序列化的XML重建一个JavaBean,只需调用Xstream对象的fromXML(String)方法即可。
1.5 快速上手小结(1) xstream.alias(String elementName, Class cls);该方法用于创建自定义类类名所对应XML元素的名称。
Java对象转换XML文件:XStream+XPP

Java对象转换XML文件:XStream+XPP不需要生成dtd,无用配置,不需要生成辅助类,速度快。
这就是xstream+xpp超强黄金组合。
xstream大家都知道啦,XML Pull Parser是一种高速的解析xml 文件的方式,速度要比传统方式快很多(发现pull式解析现在比较流行了)。
下面我给出多种使用方法的例子。
1.最简单的使用方法因为这个太简单,所以我从moogle的blog 取下面的例子1. public static void write() {2. XStream sm = new XStream();3. mytest t = new mytest();4. t.setName("moogle");5. t.setXb("男");6. try {7. FileOutputStream ops = new FileOutputStream(new File("C:\\111.xml"));8. sm.toXML(t, ops);9. ops.close();10. } catch (Exception e) {11. e.printStackTrace();12. }13. }14. public static void read() {15. XStream sm = new XStream(new DomDriver());16. try {17. FileInputStream ops = new FileInputStream(new File("C:\\111.xml"));18. mytest t = (mytest)sm.fromXML(ops);19. System.out.println(t.getName());20. ops.close();21. } catch (Exception e) {22. e.printStackTrace();23. }24. }生成 XML是# <mytest># <name>asd</name># <xb>男</xb>2.中等方法(需要1.2版以上才有这个功能)XStream stream = new XStream();stream.alias("schema", SchemaObject.class);eAttributeFor("url", String.class);eAttributeFor("jdbcDriverClass", String.class);eAttributeFor("user", String.class);eAttributeFor("password", String.class);FileOutputStream s = new FileOutputStream(file);stream.toXML(theObject, s);s.close();alias和useAttributeFor是用作把<com.hongsoft.model.SchemaObject>修改为<schema>3.高级方法XStream stream = new XStream();stream.registerConverter(new SchemaXMLConvertor());stream.alias("schema", SchemaObject.class);FileInputStream s = new FileInputStream(file);object = (SchemaObject) stream.fromXML(s);s.close();registerConverter可以实现把任何schema的XML和object互相转换,这个其实已经否定了很多朋友说的“xstream+xpp”功能不强的说法。
xstream解析xml报文

xstream解析xml报⽂⼀、xml⼀种格式的数据转换为对象pom.xml引⼊<!--javaBean和XML的双向转换--><dependency><groupId>com.thoughtworks.xstream</groupId><artifactId>xstream</artifactId><version>1.4.10</version></dependency>xml⽂件模板<?xml version="1.0" encoding="GBK"?><MESSAGE><MESSAGEHEAD><MESSAGEID/><SRC/></MESSAGEHEAD><MESSAGEBODY><TRANLIST><TRAN_DATE/><TRAN_TIME/></TRANLIST></MESSAGEBODY></MESSAGE>后台需要创建1、总类Totalclass Totalprivate static final String headInfo = "<?xml version=\"1.0\" encoding=\"GBK\"?>";@XStreamAlias("MESSAGEHEAD")private Head head;@XStreamAlias("MESSAGEBODY")private Body body; // getter setter2、头部信息Headclass Head@XStreamAlias("MESSAGEID")private String messageId;@XStreamAlias("SRC")private String src;// getter settter3、Body,明细类集合class Body@XStreamImplicit(itemFieldName = "TRANLIST")private List<Detail> detail;4、Detail明细类class Detail@XStreamConverter(value = XStreamDateConverter.class)@XStreamAsAttribute@XStreamAlias("TRAN_DATE")private Date tranDate;@XStreamAlias("TRAN_TIME")private String tranTime; // getter setter需要强调的是: String类型不需要转换,其他的类型都可以通过实现接⼝SingleValueConverter来实现转换格式,编写⼀个转换⽇期Date格式的转换,其他类似public class XStreamDateConverter implements SingleValueConverter {private final String YMD = "yyyyMMdd";SimpleDateFormat dateFormat = new SimpleDateFormat(YMD);@Overridepublic String toString(Object o) {String result = null;if (o instanceof Date) {Date date = (Date) o;result = dateFormat.format(date);}return result;}@Overridepublic Object fromString(String s) {Date date = null;if (s != null && !"".equals(s)) {try {date = dateFormat.parse(s);} catch (ParseException e) {e.printStackTrace();}}return date;}@Overridepublic boolean canConvert(Class aClass) {return Date.class == aClass;}}基础⼯作已经完成,接下来就是将xml转换为对象实体public static Total transXmlToObject(String xmlBody) {XStream xStream = new XStream();xStream.alias("MESSAGE", Total.class);xStream.alias("MESSAGEHEAD", Head.class);xStream.alias("MESSAGEBODY", Body.class);xStream.alias("TRANLIST", Detail.class);xStream.processAnnotations(new Class[]{Total.class, Head.class, Body.class, Detail.class}); Object object = xStream.fromXML(xmlBody);Total data = (Total) object;return data;}。
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;/*** <b>function:</b>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;/*** <b>function:</b>初始化资源准备* @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);}/*** <b>function:</b>释放对象资源* @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与Java对象的转换详解

xml与Java对象的转换详解xml与Java对象的转换详解1.xstream解析报⽂XStreamComponent x = XStreamComponent.newInstance();x.processAnnotations(new Class[]{EquityExchangeDetail.class,PearTicketCustomerDTO.class,Date.class,Integer.class}); EquityExchangeDetail ptd = (EquityExchangeDetail) x.fromXML(xml);2.xstream封装报⽂XStreamComponent xres = XStreamComponent.newInstance();xres.processAnnotations(new Class[]{TransResult.class});String result=xres.toXML(transResult);3.注解:@XStreamAlias("customerInfo") //报⽂中<customerInfo>节点对应类名“PearTicketCustomerDTO”public class PearTicketCustomerDTO {@XStreamAlias("idno") //报⽂中<idno>节点对应类属性“idno”private String idno;@XStreamOmitFieldprivate Long ticketId; //报⽂中⽆<ticketId>节点,解析时忽略类属性ticketId4.⽅法⽐较x.processAnnotations(new Class[]{PearTicketDTO.class}):读取类名注解x.alias(new Class[]{PearTicketDTO.class}):不读取类名注解5.解析报⽂x.alias("Equities", List.class);--把报⽂节点<Equities> 转化为List对象x.alias("Equity", Equity.class);--把报⽂节点<Equity> 转化为Equity类对象List<Equity> equities = (List<Equity>) x.fromXML(xml);--开始转化感谢阅读,希望能帮助到⼤家,谢谢⼤家对本站的⽀持!。
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());}}。
XML转换——XStream

附件:
可以把实体类和XML相互转换。
需要在客户端中加入两个jar包文件。
需要在服务器中加入一个jar包文件。
转换方法:
1 把实体类转换成XML文件
//实例化一个XStream
XStream stream = new XStream();
//命名一个别名,指定别名和类名
stream.alias("User", User.class);
//toXML(Object arg0)方法把相应的类转化
String xml = stream.toXML(new User(1,"tom","123"));
2 把XML文件转化成实体类
在客户端内的实体类一定要有一个无参的构造方法
//实例化一个XStream
XStream xStream = new XStream();
//客户端的别名一定要和服务器端一样,且必须有
xStream.alias("User", User.class);
//fromXML()方法把存放着XML信息的字符串转化成实体类
User u = (User) xStream.fromXML(str);。
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处理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简介

开源项目Xstream简介开源项目Xstream简介 ---用于序列化对象与XML对象之间的相互转换开源项目Xstream简介目录•项目简介 4•典型的应用场合 5•系统架构分析 5•实例讲解 6•创建需要序列化的对象类 6•初始化XStream类 9•注册需要转换的类的别名 10•将对象序列化为XML文档 10•从XML文件反序列化成对象 11•结束语 11•参考资料 11项目简介开源项目XStream是一套简单实用的类库,用于序列化对象与XML对象之间的相互转换。
本文以XStream 1.1.2版进行说明,它具有以下几个特点:1.灵活易用:在更高的层次上提供了简单、灵活、易用的统一接口,用户无需了解项目的底层细节2.无需映射:大多数对象都可以在无需映射的情况下进行序列化与反序列化的操作3.高速稳定:设计时力求达到的最重要的指标是解析速度快、占用内存少,以使之能够适用于大的对象处理或是对信息吞吐量要求高的系统4.清晰易懂:项目采用reflection机制得到无冗余信息的XML文件。
所生成的XML文件较本地Java序列化产物更简洁,格式更清晰,更便于用户阅读5.无需修改:完全序列化包括private和final类型在内的全部内部字段。
支持非公有类和内部类,类可以没有缺省的构造函数6.易于集成:通过实现特定的接口,XStream可以直接与其它任何树型结构进行序列化与反序列化操作(而不仅仅是XML格式)7.灵活转换:转换策略是可以定制的,允许用户自定义特殊类型的对象如何以XML格式存储。
8.错误处理:由于XML资料不合法而造成异常时,会提供详细地诊断信息帮助处理问题。
典型的应用场合XStream主要应用于以下场合:•数据对象的持久化•数据交换•配置文件XStream系统架构分析XStream的架构主要由四部分组成:Converters(转换器)当XStream遇到需要轮换的对象时,它会委派给合适的转换器实现,XStream为通用类型提供了多种转换器实现,包括基本数据类型、String、Collections、Arrays、null、Date,等等。
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到对象;。
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注解就好了.。
androidXMl解析神奇xstream四:将复杂的xml文件解析为对象

androidXMl解析神奇xstream四:将复杂的xml⽂件解析为对象前⾔:对xstream不理解的请看:1、⽂件准备把⼀个预先写好的xml⽂件放在android项⽬⽬录的 asset ⽂件夹。
⽂件内容为:<blog><age>30</age><name>jhon</name><person><pAge>36</pAge><pName>saliy</pName></person></blog>2、javaBeenpackage com.android10;public class Person {String pName ;String pAge ;public String getpName() {return pName;}public void setpName(String pName) {this.pName = pName;}public String getpAge() {return pAge;}public void setpAge(String pAge) {this.pAge = pAge;}}package com.android10;public class Product {private String name ;private String age ;private Person person ;public String getName() {return name;}public void setName(String name) { = name;}public String getAge() {return age;}public void setAge(String age) {this.age = age;}public Person getPerson() {return person;}public void setPerson(Person person) {this.person = person;}}3、主要⽅法package com.android10;import java.io.IOException;import java.io.InputStream;import android.app.Activity;import android.os.Bundle;import com.thoughtworks.xstream.XStream;public class MainActivity extends Activity {@Overridepublic void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContentView( yout.activity_main );//得到资源中的数据流String fileName = "aa.xml" ; //⽂件名字try {InputStream in = getResources().getAssets().open( fileName ) ;XStream xstream = new XStream() ;//这个blog标识⼀定要和Xml中的保持⼀直,否则会报错xstream.alias( "blog" , Product.class );Product product = (Product) xstream.fromXML( in );System.out.println("sss " + product.getName() + product.getAge() );} catch (IOException e) { e.printStackTrace();}}}4、运⾏结果product jhon30 person saliy36。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
使 用起来也非常简便。目前还用不到,暂不考虑。
如果这些基本的操作还不能满足你应用的需求,XStream提供丰富的扩展点。你可以实现自己的转 换器。还可以利用XStream完成更负责的功能,比如输出其他非xml格式的数据,还可以输出html,还支持XML Dom类型数据,这些应用起来稍微复杂些。当然这些不是XStream应用的重点,也不用理会,真正需要的时候再查看API和源码研究研究。
1、类别名,用alias(String name, Class type)。
2、 类成员别名,用aliasField(String alias, Class definedIn, String fieldName)
3、 类成员作为属性别名,用 aliasAttribute(Class definedIn, String attributeName, String alias),单独命名没有意义,还要通过useAttributeFor(Class definedIn, String fieldName) 应用到某个类上。
2010/06/10 11:30 [java ] XStream中的核心类就是XStream类,一般来说,熟悉这个类基本就够用了,如果你用的更多,估计是你设计有问题,否则不需要。
XStream 对象相当Java对象和XML之间的转换器,转换过程是双向的。创建XSteam对象的方式很简单,只需要new XStream()即可。
Java 到xml,用toXML()方法。
Xml到Java,用fromXML()方法。
在没有任何设置默认情况下,java到xml的映 射,是java成员名对应xml的元素名,java类的全名对应xml根元素的名字。而实际中,往往是xml和java类都有了,要完成相互转换,必须进 行别名映射。
别名配置包含三种情况:
* <b>Note</b>: XStream学习[]
*/
public class TestXStream {
public static void main(String args[]) {
test();
}
public static void test() {
List<Address> addList = new ArrayList<Address>();
addList.add(address1);
addList.add(address2);
Profile profile = new Profile("软件工程师", "13512129933", "备注说明");
public Person(String name, String age, Profile profile, List<Address> addlist) {
= name;
this.age = age;
this.profile = profile;
this.addlist = addlist;
output(2, xStream, person);
/******* 设置类成员为xml一个元素上的属性 *******/
eAttributeFor(Address.class, "zipcode");
/************* 设置属性的别名 ***************/
}
public String toString() {
return "Address{" +
"add='" + add + '\'' +
", zipcode='" + zipcode + '\''ckage test;
import com.thoughtworks.xstream.XStream;
XStream 的优点很多,但是也有一些小bug,比如在定义别名中的下划线“_”转换为xml后会变成“__”这个符号,很变态。因此,尽量避免在别名中实用任何符 号,却是需要下划线的时候,可以考虑实用连接符“-”,这个没有问题。
另外,我们的Java Bean中,常常有一些常量,在转换过程,XStream也会将这些常量转换过去,形成常量的xml节点,这显然不是想要的结果,对于常量字段,就不做转 换了。
Person person = new Person("熔岩", "27", profile, addList);
//转换装配
XStream xStream = new XStream();
/************** 设置类别名 ****************/
xStream.alias("PERSON", test.Person.class);
* 如果成员profile的别名和Profile的别名不一致,则profile成员生成的xml片段不可
* 直接转换为Profile对象,需要重新创建XStream对象,这岂不给自己找麻烦? */
xStream.aliasField("PROFILE", test.Person.class, "profile");
别名的配置是非常重要的,但是其中有些细节问题很重要,在例子中会专门做详细说明。
另外还有不太常用的方法:
addImplicitCollection(Class ownerType, String fieldName),去掉集合类型生成xml的父节点。
registerConverter(Converter converter) ,注册一个转换器。
*/
public class Profile {
private String job;
private String tel;
private String remark;
public Profile(String job, String tel, String remark) {
this.job = job;
" <Name>熔岩</Name>\n" +
" <age>27</age>\n" +
" <PROFILE>\n" +
" <Job>软件工程师</Job>\n" +
" <tel>13512129933</tel>\n" +
" <remark>备注说明</remark>\n" +
" </PROFILE>\n" +
下面给出一个非常典型的而且实用的例子,作为对总结的补充:
package test;
import java.util.List;
/**
* Created by IntelliJ IDEA.<br>
* <b>User</b>: leizhimin<br>
* <b>Date</b>: 2008-5-22 21:10:13<br>
xStream.aliasField("ADDLIST", test.Person.class, "addlist");
xStream.aliasField("Add", test.Address.class, "add");
xStream.aliasField("Job", test.Profile.class, "job");
}
}
package test;
import java.sql.Date;
/**
* Created by IntelliJ IDEA.<br>
* <b>User</b>: leizhimin<br>
* <b>Date</b>: 2008-5-22 21:10:32<br>
* <b>Note</b>: Please add comment here!
}
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age='" + age + '\'' +
", profile=" + profile +
", addlist=" + addlist +
'}';
this.tel = tel;
this.remark = remark;
}
public String toString() {
return "Profile{" +