`
yutianl
  • 浏览: 9243 次
  • 性别: Icon_minigender_1
  • 来自: 北京
文章分类
社区版块
存档分类
最新评论

xstream文章转载

XMLHibernateBlogIDEA 
阅读更多 
<?xml version="1.0" encoding="UTF-8"?>   
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd" >   
<hibernate-mapping package="com">   
  <class name="Person" table="novem">   
    <id name="id" column="ID" type="integer">   
      <generator class="increment"/>   
    </id>   
    <property name="name" column="NAME"/>   
    <property name="email" column="EMAIL"/>   
  </class>   
</hibernate-mapping>  

import java.io.BufferedWriter;   
import java.io.File;   
import java.io.FileNotFoundException;   
import java.io.FileWriter;   
import java.io.IOException;   
import java.util.ArrayList;   
import java.util.List;   
   
import com.thoughtworks.xstream.XStream;   
import com.thoughtworks.xstream.io.xml.DomDriver;   
   
public class createHbmXmlTest {   
   
    /**  
     * @param args  
     */   
    public static void main(String[] args) {   
        // TODO Auto-generated method stub   
        XStream xstream = new XStream(new DomDriver());   
        try{   
            File write = new File("d:\\Data\\Person.hbm.xml");   
            BufferedWriter brWriter= new BufferedWriter(new FileWriter(write));   
              
            String xmlHead="\n\n";   
            String xmlBody;   
            // give the class or property an alias   
            xstream.alias("hibernate-mapping", HibernateMapping.class);   
            xstream.alias("class", Class.class);   
            xstream.alias("property", Property.class);   
            xstream.aliasAttribute("class","generatorClass");   
            xstream.aliasAttribute("package", "tpackage");   
            xstream.aliasField("class", HibernateMapping.class, "tclass");   
            // hiden properties   
            xstream.addImplicitCollection(Class.class,"properties");   
            xstream.addImplicitCollection(Generator.class, "generatorClass");   
          
            List proList=new ArrayList ();   
            Property pro1=new Property();   
            pro1.setName("name");   
            pro1.setColumn("NAME");   
            Property pro2=new Property();   
            pro2.setName("email");   
            pro2.setColumn("EMAIL");   
            proList.add(pro1);   
            proList.add(pro2);   
                      
            Generator gen = new Generator("increment");   
            ID id=new ID("id","ID","integer",gen);      
              
            Class hClass=new Class("Person","novem");   
            hClass.setId(id);   
            hClass.setProperties(proList);   
            //set Package name add  class   
            HibernateMapping hMapping= new HibernateMapping("com",hClass);      
              
            //take as Attribute   
            xstream.useAttributeFor(ID.class,"name");   
            xstream.useAttributeFor(ID.class, "column");   
            xstream.useAttributeFor(ID.class, "type");   
            xstream.useAttributeFor(Class.class, "name");   
            xstream.useAttributeFor(Class.class, "table");   
            xstream.useAttributeFor(Property.class, "name");   
            xstream.useAttributeFor(Property.class, "column");   
            xstream.useAttributeFor(Generator.class, "generatorClass");   
            xstream.useAttributeFor(HibernateMapping.class, "tpackage");              
            xstream.registerConverter(new PropertyConverter());   
              
            xmlBody=xstream.toXML(hMapping);   
            System.out.println(xmlHead+xmlBody);   
              
            brWriter.write(xmlHead+xmlBody);   
            brWriter.close();   
        }catch(FileNotFoundException e){   
            System.out.println(e);   
        }catch(IOException e){   
            e.printStackTrace();   
        }   
    }   
   
}

XStream定制转换
XStream在实现Java、xml之间转换非常的出色。但也有一些问题需要解决：Java到XML，默认转换过去就使用Java成员属性的名字作为xml Element名，反过来亦如此。但这些都是不是实际中我们所要的结果。

为此，我又研读了XStream的文档，终于解决了这个问题，下面是测试代码。

package test;

import java.util.ArrayList;
import java.util.List;

/**
* Created by IntelliJ IDEA.<br>
* <b>User</b>: leizhimin<br>
* <b>Date</b>: 2008-5-21 10:48:43<br>
* <b>Note</b>: 主体信息
*/
public class MainBody {
    private int id;
    private String name;
    private List<Investor> investorList = new ArrayList<Investor>();

    public MainBody(int id, String name, List<Investor> investorList) {
        this.id = id;
        this.name = name;
        this.investorList = investorList;
    }


    public String toString() {
        return "MainBody{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", investorList=" + investorList +
                '}';
    }
}

package test;

/**
* Created by IntelliJ IDEA.<br>
* <b>User</b>: leizhimin<br>
* <b>Date</b>: 2008-5-21 10:51:08<br>
* <b>Note</b>: 投资人
*/
public class Investor {
    private int id;
    private String name;
    private int age;

    public Investor(int id, String name) {
        this.id = id;
        this.name = name;
    }

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

    public String toString() {
        return "Investor{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age='" + age + '\'' +
                '}';
    }
}

package test;

import com.thoughtworks.xstream.XStream;

import java.util.List;
import java.util.ArrayList;

/**
* Created by IntelliJ IDEA.<br>
* <b>User</b>: leizhimin<br>
* <b>Date</b>: 2008-5-21 10:54:05<br>
* <b>Note</b>: 测试
*/
public class TestConvert {

    public static void main(String args[]) {
        test();
    }

    public static void test() {
        System.out.println("----------test()----------");
        Investor investor1 = new Investor(1, "gaici");
        Investor investor2 = new Investor(2, "hahhah", 33);
        List<Investor> investorList = new ArrayList<Investor>();
        investorList.add(investor1);
        investorList.add(investor2);
        MainBody mainBody = new MainBody(1000, "微软", investorList);

        XStream xStream = new XStream();

        /************** 别名定义 Object －> xml ***************/

        //没有做任何别名定义直接转换
        outXML(1, xStream, mainBody);

        //类别名
        xStream.alias("MainBody", test.MainBody.class);
        xStream.alias("Investor", test.Investor.class);
        outXML(2, xStream, mainBody);

        //列表节点别名
        xStream.aliasField("Investor-List", MainBody.class, "investorList");
        outXML(3, xStream, mainBody);

        //一般属性节点别名
        xStream.aliasField("ztbs", test.MainBody.class, "id");
        xStream.aliasField("gdbs", test.Investor.class, "id");
        outXML(4, xStream, mainBody);

        //将name成员作为属性添加到Investor对应xml节点里
//        xStream.aliasAttribute(Investor.class,"name","GDXM");
        xStream.useAttributeFor(Investor.class, "name");
        outXML(5, xStream, mainBody);

        xStream.aliasAttribute(Investor.class, "age", "NL");
        xStream.useAttributeFor(Investor.class, "age");
        outXML(6, xStream, mainBody);

        /***********************xml －> Object*************************/
        String newxml = "<MainBody>\n" +
                "  <ztbs>1000</ztbs>\n" +
                "  <name>微软</name>\n" +
                "  <Investor-List>\n" +
                "    <Investor name=\"gaici\" NL=\"0\">\n" +
                "      <gdbs>1</gdbs>\n" +
                "    </Investor>\n" +
                "    <Investor name=\"hahhah\" NL=\"33\">\n" +
                "      <gdbs>2</gdbs>\n" +
                "    </Investor>\n" +
                "  </Investor-List>\n" +
                "</MainBody>";
        MainBody m = (MainBody) xStream.fromXML(newxml);
        System.out.println("将最后一次所得的xml结果转换为Java对象输出：");
        System.out.println(m);
    }

    public static void outXML(int index, XStream xStream, MainBody m) {
        String xml = xStream.toXML(m);
        System.out.println(">>>>>>>>>>第" + index + "次输出XML:");
        System.out.println(xml + "\n");
    }
}

运行结果：
----------test()----------
>>>>>>>>>>第1次输出XML:
<test.MainBody>
  <id>1000</id>
  <name>微软</name>
  <investorList>
    <test.Investor>
      <id>1</id>
      <name>gaici</name>
      <age>0</age>
    </test.Investor>
    <test.Investor>
      <id>2</id>
      <name>hahhah</name>
      <age>33</age>
    </test.Investor>
  </investorList>
</test.MainBody>

>>>>>>>>>>第2次输出XML:
<MainBody>
  <id>1000</id>
  <name>微软</name>
  <investorList>
    <Investor>
      <id>1</id>
      <name>gaici</name>
      <age>0</age>
    </Investor>
    <Investor>
      <id>2</id>
      <name>hahhah</name>
      <age>33</age>
    </Investor>
  </investorList>
</MainBody>

>>>>>>>>>>第3次输出XML:
<MainBody>
  <id>1000</id>
  <name>微软</name>
  <Investor-List>
    <Investor>
      <id>1</id>
      <name>gaici</name>
      <age>0</age>
    </Investor>
    <Investor>
      <id>2</id>
      <name>hahhah</name>
      <age>33</age>
    </Investor>
  </Investor-List>
</MainBody>

>>>>>>>>>>第4次输出XML:
<MainBody>
  <ztbs>1000</ztbs>
  <name>微软</name>
  <Investor-List>
    <Investor>
      <gdbs>1</gdbs>
      <name>gaici</name>
      <age>0</age>
    </Investor>
    <Investor>
      <gdbs>2</gdbs>
      <name>hahhah</name>
      <age>33</age>
    </Investor>
  </Investor-List>
</MainBody>

>>>>>>>>>>第5次输出XML:
<MainBody>
  <ztbs>1000</ztbs>
  <name>微软</name>
  <Investor-List>
    <Investor name="gaici">
      <gdbs>1</gdbs>
      <age>0</age>
    </Investor>
    <Investor name="hahhah">
      <gdbs>2</gdbs>
      <age>33</age>
    </Investor>
  </Investor-List>
</MainBody>

>>>>>>>>>>第6次输出XML:
<MainBody>
  <ztbs>1000</ztbs>
  <name>微软</name>
  <Investor-List>
    <Investor name="gaici" NL="0">
      <gdbs>1</gdbs>
    </Investor>
    <Investor name="hahhah" NL="33">
      <gdbs>2</gdbs>
    </Investor>
  </Investor-List>
</MainBody>

将最后一次所得的xml结果转换为Java对象输出：
MainBody{id=1000, name='微软', investorList=[Investor{id=1, name='gaici', age='0'}, Investor{id=2, name='hahhah', age='33'}]}

Process finished with exit code 0

还有一个测试：


运行结果：
----------test()----------
MainBody{id=1000, name='微软', investorList=[Investor{id=1, name='gaici', age='0'}, Investor{id=2, name='hahhah', age='0'}]}
Investor{id=1, name='gaici', age='0'}
Investor{id=2, name='hahhah', age='0'}
Investor{id=2, name='hahhah', age='0'}

Process finished with exit code 0



说明：
1、XStream不要求Java类的属性必须有getter、setter方法，因此省略。

2、设置java成员属性别名
        xStream.aliasField("Investor-List",MainBody.class,"investorList");
        outXML(3,xStream,mainBody);
运行结果会产生：
  <Investor-List>

3、将java成员映射为xml元素的一个属性

        //将name成员作为属性添加到Investor对应xml节点里       
        xStream.useAttributeFor(Investor.class,"name");

运行结果会产生：
            <Investor name="hahhah">


下面这两句是相关联的：
        xStream.aliasAttribute(Investor.class,"name","GDXM");
        xStream.useAttributeFor(Investor.class,"name");
        意思是先为java成员定义个别名，然后在将别名应用于xml属性上。

运行结果会产生：
            <Investor GDXM="hahhah">

这些问题虽然解决了，但又发现了新的问题：xml转java时，当java中没有定义xml元素节点时，这时候会抛出异常。也许通过XStream本身的API可以解决，也许是XStream本身所不能处理的问题，时间有限，也没来得及深究。有知道的朋友，还望留言。

4、再进行xml到java 的转换过程中,XStream对象别名可以定义很多，涵盖的类的范围超过xml所能表达的范围，这个也没有关系，XStream还是会忠实地将xml还原为对象。但是如果xml范围大于XStream所涵盖类的范围，那么转换过程会出错。比如，要将一个Investor节点转换为ManiBody对象，肯定会出错。



存在的问题
设想我们的客户端定义了一个用于XStream读写的XML文件：
我们将设计一些模型类并配置XStream按照这个XML文件格式执行读写操作。

<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>
2，模型：
首先，建立一个简单的Blog对象：

package com.thoughtworks.xstream;
public class Blog {
private Author author;
private List entries = new ArrayList();
public Blog(Author author) {
this.author = author;
}
public void add(Entry entry) {
entries.add(entry);
}
public List getContent() {
return entries;
}
}

然后是一个带有名字的作者对象：

package com.thoughtworks.xstream;
public class Author {
private String name;
public Author(String name) {
this.name = name;
}
public String getName() {
return name;
}
}
具体的blog内容对象：

package com.thoughtworks.xstream;
public class Entry {
private String title, description;
public Entry(String title, String description) {
this.title = title;
this.description = description;
}
}

虽然我们没有创建getters/setters方法，但这并不影响XStream对XML->Object文件的解析。
3，简单的测试
首先初始化一个blog实例，然后使用XStream来序列化

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();
System.out.println(xstream.toXML(teamBlog));
}

由该Blog实例解析出的XML文件为：

<com.thoughtworks.xstream.Blog>
<author>
<name>Guilherme Silveira</name>
</author>
<entries>
<com.thoughtworks.xstream.Entry>
<title>first</title>
<description>My first blog entry.</description>
</com.thoughtworks.xstream.Entry>
<com.thoughtworks.xstream.Entry>
<title>tutorial</title>
<description>
Today we have developed a nice alias tutorial. Tell your friends! NOW!
</description>
</com.thoughtworks.xstream.Entry>
</entries>
</com.thoughtworks.xstream.Blog>
4，为类取别名
首先我们来改变XStream对com.thoughtworks.xstream.Blog的输出名称。我们只想使用一个简单的blog来取代。下面为Blog类创建一个别名：
Xstream.alias("blog",Blog.class);
同样的，为Entry类创建一个别名：
Xstream.alias("entry",Entry.class);
好，到此输出的XML变为：
<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>




5，去掉entries标记

下面，我们将实施叫做"implicit collection"的过程（即取消标记）：所有的集合类型，都不需要显示他的根标签(root tag)，你可以直接使用一个implicit collection去映射。

在我们的例子里面，我们不希望出现entries标签，只需要一个接一个的列出所有的entry标签即可。

要做到这点，只需要简单的调用XStream对象上的addImplicitCollection方法，就可以配置XStream取消对entries的输出：

package com.thoughtworks.xstream;
import java.util.ArrayList;
import java.util.List;
public class Test {
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.alias("blog", Blog.class);
xstream.alias("entry", Entry.class);
xstream.addImplicitCollection(Blog.class, "entries");
System.out.println(xstream.toXML(teamBlog));
}
}


注意addImplicitCollection方法的调用，需要描述在某个类上的某个成员变量不需要被显示。

得到的结果基本上达到了要求： <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>

7，为属性添加别名
下一步是要把author成员变量设置为XML的属性。要做到这点，我们需要告诉XStream将author属性作为Blog类的"author"属性。
xstream.useAttributeFor(Blog.class,"author")；
现在留给我们一个问题，XStream怎么讲一个Author转换成一个String对象让他在Blog节点中以author属性显示？
只需要使用SimpleValeConverter并且实现我们自己的Author转换器：
class AuthorConverter implements SingleValueConverter {
}
第一个需要实现的方法是告诉XStream该转化器是用来转换什么类型的对象：
        public boolean canConvert(Class type) {
                return type.equals(Author.class);
        }
接下来是将一个Author实例转化成字符串：
public String toString(Object obj) {
                return ((Author) obj).getName();
        }
最后是相反的工作：怎么从一个字符串中得到Author实例
        public Object fromString(String name) {
                return new Author(name);
        }
最后，该转化器看起来是这样：
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);
        }
}
然后将这个转化器注册到XStream：

public class Test {
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 devel
分享到：
| 如何查询这样的数据？
评论
发表评论

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

相关推荐

    最齐全的xstream1.4.8.jar

    最齐全的xstream1.4.8.jar 最齐全的xstream1.4.8.jar 最齐全的xstream1.4.8.jar 最齐全的xstream1.4.8.jar 最齐全的xstream1.4.8.jar 最齐全的xstream1.4.8.jar 最齐全的xstream1.4.8.jar 最齐全的xstream1.4.8.jar ...

    xstream-1.4.15.jar

    XStream 反序列化漏洞（CVE-2020-26258 & 26259）,修复jar包 xstream-1.4.15.jar Xstream 是 Java 类库，用来将对象序列化成 XML (JSON) 或反序列化为对象。XStream 是一款开源软件，允许在 BSD 许可证的许可下分发...

    xstream最新版 - xstream-1.4.18.jar

    xstream最新版jar包

    xstream-1.4.2.jar

    《XStream详解与应用》 XStream是一款强大的Java库，用于将对象序列化为XML，同时也能从XML数据中反序列化回对象。在标题"xstream-1.4.2.jar"中，我们看到的是XStream的一个特定版本——1.4.2。这个版本包含了...

    转载 xStream完美转换XML、JSON

    标题 "xStream完美转换XML、JSON" 指的是使用xStream库在Java中进行XML与JSON数据格式之间的转换。xStream是一个强大的库，它提供了一种简单的方式来序列化和反序列化Java对象到XML，反之亦然。在这个场景中，它同样...

    xstream-1.4.5.jar

    xstream xstream-1.4.5.jar

    xStream完整Jar包

    **XStream 概述** XStream 是一个 Java 库，用于将对象序列化为 XML，以及从 XML 反序列化回对象。它提供了一种简单而直观的方式来处理 XML 数据，使得 XML 文档与 Java 对象之间的转换变得轻而易举。这个“xStream...

    xstream-1.3.1.zip

    《XStream 1.3.1：Java对象到XML的高效转换工具》 XStream是一款强大的Java库，它能够将Java对象序列化为XML，并能从XML反序列化回Java对象。这个“xstream-1.3.1.zip”文件包含了一个名为“xstream-1.3.1.jar”的...

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

    XStream库提供了一个简单、直观的方式来实现这种转换，使得XML序列化和反序列化变得非常方便。本篇将详细介绍XStream如何处理XML与Java对象的相互转换，以及如何处理List、Map等集合类型的数据。 首先，XStream是一...

    xstream学习文档及实例

    XStream 是一个强大的 Java 库，它允许程序员将 Java 对象序列化为 XML，反之亦然。这个库因其简单易用、灵活性高以及性能优异而备受赞誉。在本学习文档中，我们将深入探讨 XStream 的核心概念、用法以及如何在实际...

    xstream-1.4.20.jar

    xstream-1.4.20.jar

    xstream解析依赖包

    《XStream解析依赖包详解》 在Java开发中，数据序列化是一个不可或缺的环节，它使得对象的状态可以被保存和恢复。XStream是一款强大的Java库，用于将Java对象转换为XML，反之亦然，极大地简化了序列化和反序列化的...

    xstream-1.4.19.jar

    xstream-1.4.19.jar

    xstream相关的jar包

    XStream是一款强大的Java库，用于将Java对象序列化为XML，反之亦然。这个库的主要优点在于其简单易用的API和对复杂对象图的处理能力。在标题中提到的"Xstream相关的jar包"，是指为了使用XStream库，需要引入的依赖...

    Java用xStream拼接xml

    当需要将数据转换为XML格式以便于传输或处理时，工具如xStream就显得尤为重要。Java中的xStream库提供了一个简单易用的方式来将Java对象序列化为XML，反之亦然，即反序列化XML回Java对象。 **xStream简介** xStream...

    xstream-1.4.11-API文档-中文版.zip

    赠送jar包：xstream-1.4.11.jar； 赠送原API文档：xstream-1.4.11-javadoc.jar； 赠送源代码：xstream-1.4.11-sources.jar； 赠送Maven依赖信息文件：xstream-1.4.11.pom； 包含翻译后的API文档：xstream-1.4.11-...

    xstream-1.4.8最齐全的jar包

    XStream是一款强大的Java库，主要用于将Java对象序列化为XML，以及将XML反序列化回Java对象。在Java开发中，这种能力对于数据持久化、网络传输或配置存储等场景非常有用。标题中的"xstream-1.4.8最齐全的jar包"表明...

    xstream-1.4-API

    **XStream 1.4 API 深度解析** XStream 是一个强大的 Java 库，它的主要功能是将 Java 对象序列化为 XML，并能够从 XML 数据中反序列化回原来的对象。这个库的设计目标是提供简单易用的 API，同时保持高性能和安全...

    XStream简单应用实例

    **XStream简介** XStream是一款强大的Java库，用于将Java对象序列化为XML，反之亦然。它由Joe Walnes创建，提供了一种简洁而直观的方式来处理对象与XML之间的转换。XStream的核心理念是通过简单的API，使得XML绑定...

    XStream解析xml demo

    本篇文章将深入探讨XStream解析XML的示例，帮助你理解和掌握这一强大的工具。 首先，我们需要理解XStream的基本用法。XStream的核心概念是通过为Java对象定义一个映射，使得对象的字段与XML元素一一对应。这可以...

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