xstream简介（bean与xml转换工具）

xstream简介（bean与xml转换工具）

本文
解决了"_"显示为"__"的问题。
解决了当xml的element属性多余bean的映射问题
解决了生成xml换行的问题

作用：
能够简单的通过
xstreamInstance.fromXML(xmlContent); 获取到对象
xstreamInstance.toXML(beanInstance); 将对象转换为xml

官网:
http://xstream.codehaus.org/

适用场景
bean与xml存在相互转换的场景：配置文件读取，报文解析，生成报文
从官方的版本演进上看，还提供了hibernate,json配置文件的读取。从1.4版本以后，新加入hibernate相关处理的逻辑，该部分功能尚未详细了解。

不适用场景
xml文件较大（比如有个10M的xml文件解析，就不太适用，因一次性解析，以及生成对象将会造成内存溢出）

效率
经过实测对象10个属性，对应xml。
xstream采用默认xml引擎，效率是dom4j解析的10倍左右（具体效率与代码实现有关，dom4j也能实现较高性能的解析）
总体来说，利用xstream能够大大提高，xml解析的入门，以及编写方便

具体事例：


如何应用：
从xstream的pom文件分析
只需要将xstream.jar xpp3.jar xmlpull.jar放入项目即可
如果为maven项目
只需要添加：

        <dependency>
            <groupId>com.thoughtworks.xstream</groupId>
            <artifactId>xstream</artifactId>
            <version>1.4.3</version>
        </dependency>

使用实例：
例子一：
定义类

public class Person {
  private String firstname;
  private String lastname;
  private PhoneNumber phone;
  private PhoneNumber fax;
  // ... constructors and methods
}
public class PhoneNumber {
  private int code;
  private String number;
  // ... constructors and methods
}

初始化解析对象

XStream xstream = new XStream();

如果不想使用xpp作为xml解析引擎，也可写为new XStream(new Dom4jDriver());
设置映射规则：

xstream.alias("person", Person.class);
xstream.alias("phonenumber", PhoneNumber.class);

将对象序列化为xml

Person joe = new Person("Joe", "Walnes");
joe.setPhone(new PhoneNumber(123, "1234-456"));
joe.setFax(new PhoneNumber(123, "9999-999"));

String xml = xstream.toXML(joe);

结果：

<person>
  <firstname>Joe</firstname>
  <lastname>Walnes</lastname>
  <phone>
    <code>123</code>
    <number>1234-456</number>
  </phone>
  <fax>
    <code>123</code>
    <number>9999-999</number>
  </fax>
</person>

由xml生成对象

Person newJoe = (Person)xstream.fromXML(xml);

当然xstream也支持注解，一下代码中使用到了 XstreamUtils 这个是在xstream基础上的封装，解决了现在xstream在日常使用中会出现的一些问题

    @XStreamAlias("TestBeanRoot")
    class TestBean
    {
        private String testEl1;
        @XStreamAlias("test_Rename_El2")
        private String testEl2;
        @XStreamAsAttribute
        private String testAttr;
        @XStreamOmitField
        private String testSkip;
        @XStreamImplicit(itemFieldName = "itemName", keyFieldName = "keyName")
        private List<String> testList;
        ...getAndSet
    }
    XStream testBeanXstream = XstreamUtils.getXstream(XstreamUtilsTest.TestBean.class);
    XstreamUtilsTest.TestBean tt = createTestBean(); 
    System.out.println(testBeanXstream.toXML(tt));

    "<TestBeanRoot testAttr=\"attr\">"
    "<testEl1>el1</testEl1>"
  + "<test_Rename_El2>el2</test_Rename_El2>"
  + "<itemName>listItem1</itemName>"
  + "<itemName>listItem2</itemName>" 
  + "</TestBeanRoot>" 

如果存在多级el的情况，可以通过引用其他类的形式 如 private TestBean2 testBean2;,新的类内部又可以具有其他结构

xstream常用的注解有：

  @XStreamAlias
   @XStreamAsAttribute
   @XStreamOmitField
   @XStreamImplicit

但看到很多文章，有这样的说法
1、xstream有bug，在转换过程中，会将 定义别名中的下划线“_”转换为xml后会变成“__”
2、在xml生成对象时，xml有多出来的元素时，对象生成将会抛出异常。

事实上从xstream源代码分析，这两个都不是问题，xstream都提供了对应的处理方式

具体参看工具类

/**
  * xstream工具封装
  * 用以处理xml与bean的转换
  * 
  * @author  PengQingyang
  * @version  [版本号, 2012-10-5]
  * @see  [相关类/方法]
  * @since  [产品/模块版本]
 */
public class XstreamUtils
{
    private static Logger logger = LoggerFactory.getLogger(XstreamUtils.class);

    private static Map<Class<?>, XStream> xstreamMap = new WeakHashMap<Class<?>, XStream>();

    /**
     * 转换过程中特殊字符转码
     */
    private static NameCoder nameCoder = new NameCoder()
    {
        public String encodeNode(String arg0)
        {
            return arg0;
        }

        public String encodeAttribute(String arg0)
        {
            return arg0;
        }

        public String decodeNode(String arg0)
        {
            return arg0;
        }

        public String decodeAttribute(String arg0)
        {
            return arg0;
        }
    };

    /**
      * 在xml中多余的节点生成bean时会抛出异常
      * 通过该mapperWrapper跳过不存在的属性
      * @param mapper
      * @return [参数说明]
      * 
      * @return MapperWrapper [返回类型说明]
      * @exception throws [异常类型] [异常说明]
      * @see [类、类#方法、类#成员]
     */
    private static MapperWrapper createSkipOverElementMapperWrapper(
            Mapper mapper)
    {
        MapperWrapper resMapper = new MapperWrapper(mapper)
        {
            /**
             * @param elementName
             * @return
             */
            @SuppressWarnings("rawtypes")
            @Override
            public Class realClass(String elementName)
            {
                Class res = null;
                ;
                try
                {
                    res = super.realClass(elementName);
                }
                catch (CannotResolveClassException e)
                {
                    logger.warn("xstream change xml to object. filed (0) not exsit. ",
                            elementName);
                }
                return res;
            }
        };

        return resMapper;
    }

    /**
     * 获取xstream转换对象
     * @param classType
     * @return [参数说明]
     * 
     * @return XStream [返回类型说明]
     * @exception throws [异常类型] [异常说明]
     * @see [类、类#方法、类#成员]
    */
    public static XStream getXstream(Class<?> classType)
    {
        return getXstream(classType, true);
    }

    /**
      * 获取xstream转换对象
      * @param classType
      * @param isSkipOverElement
      * @return [参数说明]
      * 
      * @return XStream [返回类型说明]
      * @exception throws [异常类型] [异常说明]
      * @see [类、类#方法、类#成员]
     */
    public static XStream getXstream(Class<?> classType,
            boolean isSkipOverElement)
    {
        if (xstreamMap.containsKey(classType))
        {
            return xstreamMap.get(classType);
        }

        XStream res = null;
        if (isSkipOverElement)
        {
            res = new XStream(new Xpp3DomDriver(nameCoder))
            {

                /**
                 * @param next
                 * @return
                 */
                protected MapperWrapper wrapMapper(MapperWrapper next)
                {
                    return createSkipOverElementMapperWrapper(next);
                }

            };
        }
        else
        {
            res = new XStream(new Xpp3DomDriver(nameCoder));
        }

        logger.info("create xstream by {0} , parameter {1}", new Object[] {
                classType.getName(), isSkipOverElement });

        res.processAnnotations(classType);

        xstreamMap.put(classType, res);

        return res;
    }

}

封装后的使用：

     private static xxxxXstream = XstreamUtils.getXstream(Xxxx.class);

     method(){
        xxxxXstream.toXML
        xxxxXstream.fromXML
     }

2012-10-22追加
如果想生成的xml是否换行，自己进行控制，可这样写

/**
      *<获取xstream转换对象>
      *<功能详细描述>
      * @param classType
      * @param isSkipOverElement
      * @param isNewLine
      * @return [参数说明]
      * 
      * @return XStream [返回类型说明]
      * @exception throws [异常类型] [异常说明]
      * @see [类、类#方法、类#成员]
     */
    public static XStream getXstream(Class<?> classType,
            boolean isSkipOverElement, boolean isNewLine) {
        if (xstreamMap.containsKey(classType)) {
            return xstreamMap.get(classType);
        }

        /**
         * 生成domDriver 重写createWriter方法，使生成的domDriver在新的节点不会信生成一行
         */
        HierarchicalStreamDriver domDriver = null;
        if (isNewLine) {
            domDriver = new Xpp3DomDriver(nameCoder);
        } else {
            domDriver = new Xpp3DomDriver(nameCoder) {
                public HierarchicalStreamWriter createWriter(Writer out) {
                    return new PrettyPrintWriter(out, getNameCoder()) {
                        protected String getNewLine() {
                            return "";
                        }
                    };
                }
            };
        }

        XStream res = null;
        if (isSkipOverElement) {
            res = new XStream(domDriver) {
                protected MapperWrapper wrapMapper(MapperWrapper next) {
                    return createSkipOverElementMapperWrapper(next);
                }
            };
        } else {
            res = new XStream(domDriver);
        }

        logger.info("create xstream by {0} , parameter {1}", new Object[] {
                classType.getName(), isSkipOverElement });

        res.processAnnotations(classType);

        xstreamMap.put(classType, res);

        return res;
    }