使用Stax解析器将XML分解为不同对象的三个列表

Question

有没有一种方法可以使用Stax解析器有效解析具有不同类(POJO(对象的多个对象列表的XML文档。我的XML的确切结构如下(类名称不是真实(

<?xml version="1.0" encoding="utf-8"?>
<root>
    <notes />
    <category_alpha>
        <list_a>
            <class_a_object></class_a_object>
            <class_a_object></class_a_object>
            <class_a_object></class_a_object>
            <class_a_object></class_a_object>
            .
            .
            .
        </list_a>
        <list_b>
            <class_b_object></class_b_object>
            <class_b_object></class_b_object>
            <class_b_object></class_b_object>
            <class_b_object></class_b_object>
            .
            .
            .
        </list_b>
    </category_alpha>
    <category_beta>
        <class_c_object></class_c_object>
        <class_c_object></class_c_object>
        <class_c_object></class_c_object>
        <class_c_object></class_c_object>
        <class_c_object></class_c_object>
        .
        .
        .
        .
        .
    </category_beta>
</root>

我一直在使用stax解析器，即xstream库，链接：xstream

只要我的XML包含一类对象的列表，它的工作正常，但我不知道如何处理包含不同类的对象列表的XML。

任何帮助都将不胜感激，如果我没有提供足够的信息，或者我没有正确地提出问题，请告诉我。

Answer 1

您可以使用声明的流映射(DSM(流解析库轻松将复杂的XML转换为Java类。它使用Stax解析XML。

i跳过获取 notes 标签，并在 class_x_object 中添加一个字段。

这是xml：

<?xml version="1.0" encoding="utf-8"?>
<root>
    <notes />
    <category_alpha>
        <list_a>
            <class_a_object>
                <fieldA>A1</fieldA>
            </class_a_object>
            <class_a_object>
                <fieldA>A2</fieldA>
            </class_a_object>
            <class_a_object>
                <fieldA>A3</fieldA>
            </class_a_object>
        </list_a>
        <list_b>
            <class_b_object>
                <fieldB>B1</fieldB>
            </class_b_object>
            <class_b_object>
                <fieldB>B2</fieldB>
            </class_b_object>
            <class_b_object>
                <fieldB>B3</fieldB>
            </class_b_object>
        </list_b>
    </category_alpha>
    <category_beta>
        <class_c_object>
          <fieldC>C1</fieldC>
        </class_c_object>
        <class_c_object>
          <fieldC>C2</fieldC>
        </class_c_object>
        <class_c_object>
          <fieldC>C3</fieldC>
        </class_c_object>
    </category_beta>
</root>

首先，您必须以YAML或JSON格式定义XML数据和类字段之间的映射。

这是映射定义：

result:     
   type: object
   path: /root   
   fields:
     listOfA:
       type: array
       path: .*class_a_object  # path is regex
       fields:
          fieldOfA:
            path: fieldA
     listOfB:
       type: array
       path: .*class_b_object
       fields:
          fieldOfB:
            path: fieldB 
     listOfC:
       type: array
       path: .*class_c_object
       fields:
          fieldOfC:
            path: fieldC 

您想要的java类：

public class Root {
    public List<A> listOfA;
    public List<B> listOfB;
    public List<C> listOfC;
    public static class A{
        public String fieldOfA;
    }
    public static class B{
        public String fieldOfB;
    }
    public static class C{
        public String fieldOfC;
    }
}   

Java代码到分析XML：

DSM dsm=new DSMBuilder(new File("path/to/mapping.yaml")).setType(DSMBuilder.TYPE.XML).create(Root.class);
Root root =  (Root)dsm.toObject(xmlFileContent);
// write root object as json
dsm.getObjectMapper().writerWithDefaultPrettyPrinter().writeValue(System.out, object);

这是输出：

{
  "listOfA" : [ {"fieldOfA" : "A1"}, {"fieldOfA" : "A2"}, {"fieldOfA" : "A3"} ],
  "listOfB" : [ {"fieldOfB" : "B1"}, {"fieldOfB" : "B2"}, "fieldOfB" : "B3"} ],
  "listOfC" : [ {"fieldOfC" : "C1"}, {"fieldOfC" : "C2"}, {"fieldOfC" : "C3"} ]
}

更新：

我从您的评论中了解到，您想将大XML文件读为流。并在阅读文件时处理数据。

DSM允许您在阅读XML时执行过程数据。

声明三个不同的函数来处理部分数据。

FunctionExecutor processA=new FunctionExecutor(){
            @Override
            public void execute(Params params) {
                Root.A object=params.getCurrentNode().toObject(Root.A.class);
                // process aClass; save to db. call service etc.
            }
        };
FunctionExecutor processB=new FunctionExecutor(){
            @Override
            public void execute(Params params) {
                Root.B object=params.getCurrentNode().toObject(Root.B.class);
                // process aClass; save to db. call service etc.
            }
        };
FunctionExecutor processC=new FunctionExecutor(){
            @Override
            public void execute(Params params) {
                Root.C object=params.getCurrentNode().toObject(Root.C.class);
                // process aClass; save to db. call service etc.
            }
        };

注册功能到DSM

 DSMBuilder builder = new DSMBuilder(new File("path/to/mapping.yaml")).setType(DSMBuilder.TYPE.XML);
       // register function
        builder.registerFunction("processA",processA);
        builder.registerFunction("processB",processB);
        builder.registerFunction("processC",processC);
        DSM dsm= builder.create();
        Object object =  dsm.toObject(xmlContent);

将映射文件更改为呼叫注册功能

result:     
   type: object
   path: /root   
   fields:
     listOfA:
       type: object
       function: processA  # when 'class_a_object' tag closed processA function will be executed.
       path: .*class_a_object  # path is regex
       fields:
          fieldOfA:
            path: fieldA
     listOfB:
       type: object
       path: .*class_b_object
       function: processB# register function
       fields:
          fieldOfB:
            path: fieldB 
     listOfC:
       type: object
       path: .*class_c_object
       function: processC# register function
       fields:
          fieldOfC:
            path: fieldC 

Answer 2

您可以使用pojo类使用Java架构进行XML绑定Jaxb和Unmarshall。

首先创建POJO类(我从您的XML文件中获取了几个节点并创建POJO。您可以在其余部分中进行类似的节点(。以下是我考虑的XML。

<?xml version="1.0" encoding="utf-8"?>
<root>
    <category_alpha>
        <list_a>
            <class_a_object></class_a_object>
            <class_a_object></class_a_object>
            <class_a_object></class_a_object>
            <class_a_object></class_a_object>
        </list_a>
        <list_b>
            <class_b_object></class_b_object>
            <class_b_object></class_b_object>
            <class_b_object></class_b_object>
            <class_b_object></class_b_object>
        </list_b>
    </category_alpha>
</root>

以下是root，category_alpha，list_a，list_b，class_a_object和class_b_object

的POJO类

import java.util.List;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;

@XmlRootElement(name = "root")
@XmlAccessorType (XmlAccessType.FIELD)
public class Root {
    @XmlElement(name = "category_alpha")
    private List<CategoryAlpha> categoryAlphaList = null;
    public List<CategoryAlpha> getCategoryAlphaList() {
        return categoryAlphaList;
    }
    public void setCategoryAlphaList(List<CategoryAlpha> categoryAlphaList) {
        this.categoryAlphaList = categoryAlphaList;
    }
}

在以下类中将类似的Java导入到上述类。

@XmlRootElement(name = "category_alpha")
@XmlAccessorType (XmlAccessType.FIELD)
public class CategoryAlpha {
    @XmlElement(name = "list_a")
    private List<ListAClass> list_a_collectionlist = null;
    @XmlElement(name = "list_b")
    private List<ListBClass> list_b_collectionlist = null;

    public List<ListAClass> getList_a_collectionlist() {
        return list_a_collectionlist;
    }

    public void setList_a_collectionlist(List<ListAClass> list_a_collectionlist) {
        this.list_a_collectionlist = list_a_collectionlist;
    }

    public List<ListBClass> getList_b_collectionlist() {
        return list_b_collectionlist;
    }

    public void setList_b_collectionlist(List<ListBClass> list_b_collectionlist) {
        this.list_b_collectionlist = list_b_collectionlist;
    }
}
@XmlRootElement(name = "list_a")
@XmlAccessorType (XmlAccessType.FIELD)
public class ListAClass {
    @XmlElement(name = "class_a_object")
    private List<ClassAObject> classAObjectList = null;
    public List<ClassAObject> getClassAObjectList() {
        return classAObjectList;
    }
    public void setClassAObjectList(List<ClassAObject> classAObjectList) {
        this.classAObjectList = classAObjectList;
    }
}
@XmlRootElement(name = "list_b")
@XmlAccessorType (XmlAccessType.FIELD)
public class ListBClass {
    @XmlElement(name = "class_b_object")
    private List<ClassBObject> classBObjectList = null;
    public List<ClassBObject> getClassBObjectList() {
        return classBObjectList;
    }
    public void setClassBObjectList(List<ClassBObject> classBObjectList) {
        this.classBObjectList = classBObjectList;
    }
}
@XmlRootElement(name = "class_a_object")
@XmlAccessorType (XmlAccessType.FIELD)
public class ClassAObject {
}
@XmlRootElement(name = "class_b_object")
@XmlAccessorType (XmlAccessType.FIELD)
public class ClassBObject {
}

这是主要类

import java.io.File;
import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBException;
import javax.xml.bind.Unmarshaller;
public class UnmarshallMainClass {
    public static void main(String[] args) throws JAXBException {
        JAXBContext jaxbContext = JAXBContext.newInstance(Root.class);
        Unmarshaller jaxbUnmarshaller = jaxbContext.createUnmarshaller();
        // This root object contains all the list of objects you are looking for
        Root emps = (Root) jaxbUnmarshaller.unmarshal( new File("sample.xml") );
    }
}

通过使用root对象和其他对象中的getters，您可以检索类似于下面的根内所有对象的列表。

List<CategoryAlpha> categoryAlphaList = emps.getCategoryAlphaList();

Answer 3

我为提供的示例创建了一个解析器。https://github.com/sbzdev/stackoverflow/tree/master/question56087924

import com.thoughtworks.xstream.annotations.XStreamAlias;
import java.util.List;
@XStreamAlias("root")
public class Root {
    String notes;
    @XStreamAlias("category_alpha")
    CategoryAlpha categoryAlpha;

    @XStreamAlias("category_beta")
    List<C> listC;
    static class CategoryAlpha {
        @XStreamAlias("list_a")
        List<A> listA;
        @XStreamAlias("list_b")
        List<B> listB;
    }
    @XStreamAlias("class_a_object")
    static class A {
    }
    @XStreamAlias("class_b_object")
    static class B {
    }
    @XStreamAlias("class_c_object")
    static class C {
    }
}

解析器：

import com.thoughtworks.xstream.XStream;
public class SampleRootParser {
    public Root parse(String xmlContent){
        XStream xstream = new XStream();
        xstream.processAnnotations(Root.class);
        return  (Root)xstream.fromXML(xmlContent);
    }
}

也许您可以提供实际的XML和预期结果？