`

使用XStream解析复杂的XML文件

 
阅读更多
XStream在实现Java、xml之间转换非常的出色。但是有时候一些比较复杂的XML文件就不好下手，在此以如下XML为例演示了XML to Object，Object to XML的过程。

依赖包：
xstream-1.3.1.jar
xpp3_min-1.1.4c.jar

XML文件：

<IR>
  <UserDetails>
    <UID>guest</UID>
    <UType>JLJE89dd8DasGds6es</UType>
    <UToken>DG8kxksEo903kdm8e2j4Kds8d</UToken>
  </UserDetails>
  <MainContext>
    <CID>ctx000001</CID>
    <Banner>
      <RepName>repname</RepName>
    </Banner>
    <GuidedFlows>
      <GFContext GFType="nav">
        <GFCID>gf0001</GFCID>
        <GFRep>
          <RepName>test</RepName>
        </GFRep>
        <Method Action="method">http://fdsf....</Method>
        <Parameters>
          <Param>
            <Location>location</Location>
            <ValidateMethod>validate method</ValidateMethod>
          </Param>
        </Parameters>
      </GFContext>
      <GFContext GFType="nav">
        <GFCID>gf0002</GFCID>
        <GFRep>
          <RepName>test2</RepName>
        </GFRep>
        <Method Action="method2">http://fdsf....</Method>
        <Parameters>
          <Param>
            <Location>location2</Location>
            <ValidateMethod>validate method2</ValidateMethod>
          </Param>
        </Parameters>
      </GFContext>
      <GFContext GFType="nav">
        <GFCID>gf0003</GFCID>
        <GFRep>
          <RepName>test3</RepName>
        </GFRep>
        <Method Action="method3">http://fdsf....</Method>
        <Parameters>
          <Param>
            <Location>location3</Location>
            <ValidateMethod>validate method3</ValidateMethod>
          </Param>
        </Parameters>
      </GFContext>
    </GuidedFlows>
  </MainContext>
</IR>
定义实体类：

UserDetails： 

public class UserDetails {
    
          private String UID;
          private String UType;
          private String UToken;
         
          public UserDetails(String UID, String UType, String uToken) {
               this.UID = UID;
               this.UType = UType;
               this.UToken = uToken;
          }
    
          public String getUID() {
               return UID;
          }
    
          public void setUID(String uID) {
               UID = uID;
          }
    
          public String getUType() {
               return UType;
          }
    
          public void setUType(String uType) {
               UType = uType;
          }
    
          public String getUToken() {
               return UToken;
          }
    
          public void setUToken(String uToken) {
               UToken = uToken;
          }
    
          @Override
          public String toString() {
               return "UserDetails [UID=" + UID + ", UType=" + UType + ", UToken="
                         + UToken + "]";
          }
     }

MainContext： 

import java.util.ArrayList;
     import java.util.List;
    
     public class MainContext {
         
          private String CID;
          private Banner Banner;
          private List<GFContext> GFContext = new ArrayList<GFContext>();
         
          public MainContext(String CID, Banner Banner, List<GFContext> GFContext) {
               this.CID = CID;
               this.Banner = Banner;
               this.GFContext = GFContext;
          }
    
          public String getCID() {
               return CID;
          }
    
          public void setCID(String cID) {
               CID = cID;
          }
    
          public Banner getBanner() {
               return Banner;
          }
    
          public void setBanner(Banner banner) {
               Banner = banner;
          }
    
          public List<GFContext> getGFContext() {
               return GFContext;
          }
    
          public void setGFContext(List<GFContext> gFContext) {
               GFContext = gFContext;
          }
    
          @Override
          public String toString() {
               return "MainContext [CID=" + CID + ", Banner=" + Banner
                         + ", GuidedFlows=" + GFContext + "]";
          }
     }

Banner： 

 public class Banner {
         
          private String RepName;
         
          public Banner(String RepName){
               this.RepName = RepName;
          }
    
          public String getRepName() {
               return RepName;
          }
    
          public void setRepName(String repName) {
               RepName = repName;
          }
    
          @Override
          public String toString() {
               return "Banner [RepName=" + RepName + "]";
          }
     }

GFContext： 

 public class GFContext {
         
          private String GFType;
          private String GFCID;
          private GFRep GFRep;
          private Method Method;
          private Parameters Parameters;
         
          public GFContext(String GFType, String GFCID, GFRep GFRep, Method Method, Parameters Parameters){
               this.GFType = GFType;
               this.GFCID = GFCID;
               this.GFRep = GFRep;
               this.Method = Method;
               this.Parameters = Parameters;
          }
    
          public String getGFType() {
               return GFType;
          }
    
          public void setGFType(String gFType) {
               this.GFType = gFType;
          }
    
          public String getGFCID() {
               return GFCID;
          }
    
          public void setGFCID(String gFCID) {
               this.GFCID = gFCID;
          }
    
          public GFRep getGFRep() {
               return GFRep;
          }
    
          public void setGFRep(GFRep gFRep) {
               this.GFRep = gFRep;
          }
    
          public Method getMethod() {
               return Method;
          }
    
          public void setMethod(Method Method) {
               this.Method = Method;
          }
    
          public Parameters getParameters() {
               return Parameters;
          }
    
          public void setParameters(Parameters parameters) {
               this.Parameters = parameters;
          }
    
          @Override
          public String toString() {
               return "GFContext [GFType=" + GFType + ", GFCID=" + GFCID + ", GFRep="
                         + GFRep + ", Method=" + Method + ", Parameters=" + Parameters
                         + "]";
          }
    
     }

GFRep： 

public class GFRep {
    
          private String RepName;
          private String RepURL;
         
          public GFRep(String RepName) {
               this.RepName = RepName;
          }
    
          public GFRep(String RepName, String RepURL) {
               this.RepName = RepName;
               this.RepURL = RepURL;
          }
    
          public String getRepName() {
               return RepName;
          }
    
          public void setRepName(String repName) {
               RepName = repName;
          }
    
          public String getRepURL() {
               return RepURL;
          }
    
          public void setRepURL(String repURL) {
               RepURL = repURL;
          }
    
          @Override
          public String toString() {
               return "GFRep [RepName=" + RepName + ", RepURL=" + RepURL + "]";
          }
    
     }

Method： 

public class Method {
         
          private String Action;
          private String value;
         
          public Method(){
          }
         
          public Method(String value){
               this.value = value;
          }
         
          public Method(String Action, String value){
               this.Action = Action;
               this.value = value;
          }
    
          public String getAction() {
               return Action;
          }
    
          public void setAction(String action) {
               Action = action;
          }
    
          public String getValue() {
               return value;
          }
    
          public void setValue(String value) {
               this.value = value;
          }
    
          @Override
          public String toString() {
               return "Method [Action=" + Action + ", value=" + value + "]";
          }
    
     }

Parameters： 

public class Parameters {
         
          private Param Param;
    
          public Parameters(Param Param) {
               this.Param = Param;
          }
    
          public Param getParam() {
               return Param;
          }
    
          public void setParam(Param param) {
               Param = param;
          }
    
          @Override
          public String toString() {
               return "Parameters [Param=" + Param + "]";
          }
     }


Param：

<span style="font-family:Courier New;font-size:12px;">public class Param {
    
          private String Location;
          private String ValidateMethod;
         
          public Param(String Location) {
               this.Location = Location;
          }
         
          public Param(String Location, String ValidateMethod) {
               this.Location = Location;
               this.ValidateMethod = ValidateMethod;
          }
    
          public String getLocation() {
               return Location;
          }
    
          public void setLocation(String location) {
               Location = location;
          }
    
          public String getValidateMethod() {
               return ValidateMethod;
          }
    
          public void setValidateMethod(String validateMethod) {
               ValidateMethod = validateMethod;
          }
    
          @Override
          public String toString() {
               return "Param [location=" + Location + ", validateMethod="
                         + ValidateMethod + "]";
          }
     }</span>
由于我们需要实现类似：<field name="value">I am a Field.</Method>这样的效果。因此，我们需要实现一个Converter。这个很关键，也是我试了好久才解决的问题，在此也分享一下：

MethodConverter.java:


<span style="font-family:Courier New;font-size:12px;">import com.thoughtworks.xstream.converters.Converter;
     import com.thoughtworks.xstream.converters.MarshallingContext;
     import com.thoughtworks.xstream.converters.UnmarshallingContext;
     import com.thoughtworks.xstream.io.HierarchicalStreamReader;
     import com.thoughtworks.xstream.io.HierarchicalStreamWriter;
    
     public class MethodConverter implements Converter {
    
          public boolean canConvert(Class clazz) {
               return clazz.equals(Method.class);
          }
         
          public void marshal(Object value, HierarchicalStreamWriter writer,
                 MarshallingContext context) {
             Method method = (Method)value;
             if (method!=null) {
                 writer.addAttribute("Action", method.getAction());
                 writer.setValue(method.getValue());
             }
          }
    
          @Override
          public Object unmarshal(HierarchicalStreamReader reader,
                    UnmarshallingContext context) {
               Method method = new Method();
               String action = reader.getAttribute("Action");
               method.setAction(action);
               System.out.println(">>> Action: "+action);
               String value = reader.getValue();
               System.out.println(">>> method: "+value+", NodeName: "+reader.getNodeName());
               method.setValue(value);
              
               return method;
          }
     }</span>

测试代码：

1. Object生成XML

xStreanTest.java

<span style="font-family:Courier New;font-size:12px;"> import java.util.ArrayList;
     import java.util.List;
    
     import com.thoughtworks.xstream.XStream;
    
     public class xStreanTest {
    
          /**
          * @param args
          */
          public static void main(String[] args) {
              
               GFRep gfrep = new GFRep("test");
              
               Param param = new Param("location","validate method");
              
               Parameters p = new Parameters(param);
              
               List<GFContext> ls = new ArrayList<GFContext>();
               GFContext gfcontext = new GFContext("nav", "gf0001", gfrep, new Method("method","http://fdsf...."), p);
               ls.add(gfcontext);
              
               gfrep = new GFRep("test2");
               param = new Param("location2","validate method2");
               p = new Parameters(param);
               gfcontext = new GFContext("nav", "gf0002", gfrep, new Method("method2","http://fdsf...."), p);
               ls.add(gfcontext);
              
               gfrep = new GFRep("test3");
               param = new Param("location3","validate method3");
               p = new Parameters(param);
               gfcontext = new GFContext("nav", "gf0003", gfrep, new Method("method3","http://fdsf...."), p);
               ls.add(gfcontext);
              
              
              
               //GuidedFlows gf = new GuidedFlows(ls);
              
               Banner banner = new Banner("repname");
              
               MainContext mc = new MainContext("ctx000001", banner, ls);
              
               UserDetails ud = new UserDetails("guest","JLJE89dd8DasGds6es", "starhub");
              
               MLoginIR mir = new MLoginIR(ud, mc);
              
               XStream xstream = new XStream();
               xstream.registerConverter(new MethodConverter());
               xstream.alias("IR", MLoginIR.class);
               xstream.alias("UserDetails", UserDetails.class);
               xstream.alias("MainContext", MainContext.class);
               xstream.alias("Banner", Banner.class);
               //xstream.alias("GuidedFlows", GuidedFlows.class);
               xstream.alias("GFContext", GFContext.class);
               xstream.alias("GFRep", GFRep.class);
               xstream.alias("Parameters", Parameters.class);
               xstream.alias("Param", Param.class);
               //xstream.alias("RepName", RepName.class);
              
               xstream.aliasField("GuidedFlows", MainContext.class, "GFContext");
               xstream.useAttributeFor(GFContext.class, "GFType");
               xstream.useAttributeFor(Method.class, "Action");
               String xml = xstream.toXML(mir);
               System.out.println(xml);
              
               MLoginIR m = (MLoginIR)xstream.fromXML(xml);
               System.out.println(m);
          }
    
     }</span>

2. XML转Object

xStreanTest2.java

<span style="font-family:Courier New;font-size:12px;">import java.util.ArrayList;
import java.util.List;

import com.thoughtworks.xstream.XStream;

public class xStreanTest2 {

     /**
     * @param args
     */
     public static void main(String[] args) {
    
          String xml = "TODO";
    
          XStream xstream = new XStream();
          xstream.registerConverter(new MethodConverter());
          xstream.alias("IR", MLoginIR.class);
          xstream.alias("UserDetails", UserDetails.class);
          xstream.alias("MainContext", MainContext.class);
          xstream.alias("Banner", Banner.class);
          xstream.alias("GFContext", GFContext.class);
          xstream.alias("GFRep", GFRep.class);
          xstream.alias("Parameters", Parameters.class);
          xstream.alias("Param", Param.class);
          //xstream.alias("RepName", RepName.class);
          xstream.alias("Method", Method.class);
          xstream.aliasField("GuidedFlows", MainContext.class, "GFContext");
          xstream.useAttributeFor(GFContext.class, "GFType");
          xstream.useAttributeFor(Method.class, "Action");
          MLoginIR newIR = (MLoginIR)xstream.fromXML(xml);
          System.out.println(newIR.getUserDetails());
          List<GFContext> ls_gf = newIR.getMainContext().getGFContext();
          Banner banner = newIR.getMainContext().getBanner();
          System.out.println(banner);
          for(GFContext gf : ls_gf){
               System.out.println("gf:"+gf);
               GFRep gfrep = gf.getGFRep();
               System.out.println(gfrep);
               Parameters p = gf.getParameters();
               System.out.println(p);
               Param p2 = p.getParam();
               System.out.println(p2);
               Method m = gf.getMethod();
               System.out.println(m);
               System.out.println("==================================");
          }
    
     }
    
}     </span>



分享到：
| Java生成CSV文件
评论
发表评论

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

相关推荐

    XStream解析XML实例

    **XStream解析XML实例** 在Java开发中，处理XML数据是一项常见的任务，XStream库提供了一个简单而强大的方式来将Java对象序列化为XML，以及从XML反序列化回Java对象。这个实例将深入探讨如何使用XStream进行XML操作...

    使用xstream解析xml，xml与pojo的双向转化，完整的java 工程

    以下是使用XStream解析XML和POJO双向转化的基本步骤： 1. 引入XStream库：在Java工程中，需要添加XStream的jar包，通常可以通过Maven或Gradle等构建工具管理依赖。在这个项目中，"lib"目录下应该包含XStream的jar...

    xstream轻松解析xml到java对象

    如果你使用的是Maven，可以在pom.xml文件中添加以下依赖： ```xml &lt;groupId&gt;com.thoughtworks.xstream&lt;/groupId&gt; &lt;artifactId&gt;xstream &lt;version&gt;1.4.18 ``` 对于其他构建工具，如Gradle或 Ivy，也有相应的...

    xstream方式解析xml文件

    xstream方式解析及生成xml文件

    Xstream解析xml

    总的来说，使用Xstream解析XML文件并存入MySQL数据库是一个常见的数据处理任务，它涉及XML解析、Java对象映射以及数据库操作等多个技术点。通过合理地组织代码，可以高效地完成这项工作，实现数据的无缝迁移和存储。

    XStream XML解析

    **XStream XML解析** XStream 是一个开源的 Java 库，它提供了一种简单而有效的方式来将 Java 对象序列化为 XML 和从 XML 反序列化回 Java 对象。这个库的强大之处在于其简洁的API和对复杂Java对象模型的处理能力。...

    xml解析及使用XStream实现javaBean与xml之间的转换

    在`xmlAnalysis`文件夹中，可能包含了一个简单的Java程序，演示了如何使用DOM、SAX、StAX和XStream解析XML文件，并展示了XStream如何在JavaBean与XML之间进行转换。你可以运行这些代码，观察输出结果，以加深理解。...

    java 利用Xstream注解生成和解析xml

    如果你使用的是Maven，可以在pom.xml文件中添加以下依赖： ```xml &lt;groupId&gt;com.thoughtworks.xstream&lt;/groupId&gt; &lt;artifactId&gt;xstream &lt;version&gt;1.4.15 ``` 一旦引入了Xstream，我们就可以开始定义我们的Java...

    XStream解析xml 转换成对象案例

    如果你使用的是Maven，可以在pom.xml文件中添加以下依赖： ```xml &lt;groupId&gt;com.thoughtworks.xstream&lt;/groupId&gt; &lt;artifactId&gt;xstream &lt;version&gt;1.4.18 ``` 然后，你可以创建一个XStream实例，并配置它以处理...

    使用XStream是实现XML与Java对象的转换(5)--Object Stream

    如果你的项目是Maven管理的，可以在pom.xml文件中添加如下依赖： ```xml &lt;groupId&gt;com.thoughtworks.xstream&lt;/groupId&gt; &lt;artifactId&gt;xstream &lt;version&gt;1.4.17 ``` 一旦引入了XStream，我们可以创建一个简单的...

    Xstream生产xml和解析xml

    Xstream是一款强大的Java库，用于实现Java对象与XML文档之间的转换。这种转换不仅支持基本数据类型，也适用于复杂的数据结构，包括自定义类和集合。Xstream的设计旨在简化序列化过程，使得开发者能够轻松地在Java...

    使用XStream解析MXL文件用到的jar包---xpp3_min-1.1.3.4.O.jar和xstream-1.3.1.jar

    在XStream解析XML文件时，通常需要两个关键的jar包： 1. **xpp3_min-1.1.3.4.O.jar**：这是Minimal XML Pull Parser（XPP3）的轻量级版本，它是一个高效的XML解析器，用于读取XML文档。XPP3被XStream用来解析XML流...

    使用xstream进行java类与xml文件互转解析--代码

    本教程将深入探讨如何使用XStream进行Java类与XML文件之间的互转解析。 首先，我们需要引入XStream库。在Maven项目中，可以在pom.xml文件中添加以下依赖： ```xml &lt;groupId&gt;com.thoughtworks.xstream&lt;/groupId&gt; ...

    xstream解析xml

    在压缩包中的"xml"文件可能是示例的XML数据，用于演示如何使用XStream进行序列化和反序列化操作。实际应用中，开发者可以根据这些知识对XML数据进行读取、解析和存储，提升开发效率和代码可读性。

    Xstream生成和解析xml.rar

    如果你的项目是Maven工程，可以在pom.xml文件中添加以下依赖： ```xml &lt;groupId&gt;com.thoughtworks.xstream&lt;/groupId&gt; &lt;artifactId&gt;xstream &lt;version&gt;1.4.19 ``` 对于Gradle项目，可以在build.gradle文件中...

    利用XStream读写xml文件

    通过本篇内容的学习，我们了解了XStream的基本原理以及如何使用它来读写XML文件。XStream不仅简化了XML与Java对象之间的转换过程，还提高了开发效率。在实际项目中，合理利用XStream可以有效地管理复杂的数据结构。

    使用XStream是实现XML与Java对象的转换(6)--持久化

    这篇博客“使用XStream是实现XML与Java对象的转换(6)--持久化”深入探讨了如何利用XStream进行持久化操作，使得对象状态能够持久保存到磁盘，同时也能够从XML文档中恢复。 首先，我们需要理解XStream的核心概念。...

    xstream解析依赖包

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

    java XStream xml解析 jar包.zip

    - `xmlpull-1.1.3.1.jar`：XML Pull API，它是轻量级的解析XML的库，用于XPP3。 5. **XML Pull Parsing**： - XML Pull Parsing是一种事件驱动的解析模型，与SAX类似，但更简单，不需要解析器的回调函数。XPP3库...

    xStream xml to bean

    接着，使用`fromXML()` 方法解析XML字符串： ```java YourBeanClass bean = (YourBeanClass) xstream.fromXML(xmlString); ``` 在`beanToXml()` 方法中，同样需要初始化xStream实例，然后使用`toXML()` 方法将Bean...

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