如何使用 Java 和 XmlSchema Core 解析 XSD 并读取所有复杂元素及其子元素

问题描述 投票：0回答：2

我正在使用 

Apache XmlSchema Core
库来解析 
XSD
文件并获取所有元素及其子类型（数据类型、maxOccurs 等）。我正在遵循文档 Apache XML SCHEMA CORE 并尝试这样做。但在导航到某个点后，我变得有点困惑。有人可以指导我如何遍历我的 
XSD
文件并获取所有元素及其子元素以及相关信息吗？

我能够获取我的 

schema
元素中的所有 XSD 信息，我只想知道如何从我的根 
RootFood
访问子元素并获取其相关信息。任何帮助将非常感激。

我尝试继续下去，这就是我到目前为止所得到的： 元素 

RootFood
属于类 
XmlSchemaGroupParticle
的实例。我尝试调试代码以查找与我的 
rootParticles
关联的元素，它有一个名为 
items
的字段，其中我有我的 
food
元素 
items->[0]->namedDelegate->qName->localPart
但是当我尝试添加 
GET
方法时
rootParticles
获取
items
则没有这样的方法。

XmlSchemaParticle
扩展了以下类：
XmlSchemaAnnotated
、
XmlSchemaObject
，并实现了接口
XmlSchemaObjectBase
，但它们都没有名为
Items
的字段。

以下是我到目前为止的Java代码，我尝试了几件事：

public class XMLSchemaCore {

    public static void main(String[] args) throws URISyntaxException,
        FileNotFoundException,
        UnsupportedEncodingException {
            String xsdPath = Paths.get(XMLSchemaCore.class.getClassLoader().getResource("test.xsd").toURI()).toFile().getAbsolutePath();
            String filePath = Path.of(xsdPath).toString();

            InputStream is = new FileInputStream(filePath);
            XmlSchemaCollection schemaCol = new XmlSchemaCollection();

            // Schema contain the complete XSD content which needs to be parsed
            XmlSchema schema = schemaCol.read(new StreamSource(is));
            // schema.write(System.out);
            for (Map.Entry<QName, XmlSchemaElement> entry: schema.getElements().entrySet()) {
                // Root element and its contents
                QName parentElementName = entry.getKey();
                XmlSchemaElement parentElementValues = entry.getValue();

                // Get the elements based on the Root element
                XmlSchemaElement root = schema.getElementByName(parentElementName);

                // Get the type of the root element
                XmlSchemaType type = root != null ? root.getSchemaType() : null;

                // Check if the root element is of Complex type
                if (type instanceof XmlSchemaComplexType) {
                    // Get the Particles associated with the element
                    XmlSchemaParticle rootParticles = ((XmlSchemaComplexType) type).getParticle();

                    // Check particle belongs to which type
                    if (rootParticles instanceof XmlSchemaAny) {
                        System.out.println("Any Schema Type");

                    } else if (rootParticles instanceof XmlSchemaElement) {
                        System.out.println("Element Schema Type");

                    } else if (rootParticles instanceof XmlSchemaGroupParticle) {
                        System.out.println("Group Schema Type");
                        System.out.println(rootParticles);
                        System.out.println(rootParticles);

                    } else if (rootParticles instanceof XmlSchemaGroupRef) {
                        System.out.println("Group Ref Schema Type");

                    }
                }
            }

        }

}

以下是我拥有的

XSD
文件：

<xs:schema attributeFormDefault="unqualified"
    elementFormDefault="qualified"
    xmlns:xs="http://www.w3.org/2001/XMLSchema">
    <xs:element name="RootFood">
        <xs:complexType>
            <xs:sequence>
                <xs:element name="food">
                    <xs:complexType>
                        <xs:sequence>
                            <xs:element type="xs:string" name="name" />
                            <xs:element type="xs:string" name="price" />
                            <xs:element type="xs:string" name="description" />
                            <xs:element type="xs:short" name="calories" />
                            <xs:element name="ingredients">
                                <xs:complexType>
                                    <xs:sequence>
                                        <xs:element type="xs:string" name="ingredient"
                                            maxOccurs="unbounded" minOccurs="0" />
                                    </xs:sequence>
                                </xs:complexType>
                            </xs:element>
                        </xs:sequence>
                    </xs:complexType>
                </xs:element>
            </xs:sequence>
        </xs:complexType>
    </xs:element>
</xs:schema>

enter image description here

java xml xsd xmlschema
2个回答
4
投票

在尝试了很多事情之后，我终于能够让代码工作了。在此处发布代码，因为它可能会对计划使用 Apache XMLSchema Core Library 进行 XML/XSD 解析 的人有所帮助。我知道这是多么令人沮丧，因为我们在互联网上没有这个解析库的一些好的例子。希望这有帮助。

基本上，此代码将解析整个 

XSD
文件，并根据其父元素和子元素将元素存储在 
HashMap
中。您可以获取任何 XSD 元素的父级，也可以获取与子级相关的信息，例如其父级等。检查 XmlSchemaElement 以获取有关每个子级信息的更多详细信息：

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStream;
import java.io.UnsupportedEncodingException;
import java.net.URISyntaxException;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

import javax.xml.namespace.QName;
import javax.xml.transform.stream.StreamSource;

import org.apache.ws.commons.schema.XmlSchema;
import org.apache.ws.commons.schema.XmlSchemaAny;
import org.apache.ws.commons.schema.XmlSchemaCollection;
import org.apache.ws.commons.schema.XmlSchemaComplexType;
import org.apache.ws.commons.schema.XmlSchemaElement;
import org.apache.ws.commons.schema.XmlSchemaGroupRef;
import org.apache.ws.commons.schema.XmlSchemaParticle;
import org.apache.ws.commons.schema.XmlSchemaSequence;
import org.apache.ws.commons.schema.XmlSchemaSequenceMember;
import org.apache.ws.commons.schema.XmlSchemaType;

public class XMLSchemaCore {

    private static XmlSchemaCollection xmlSchemaCollection;
    private static Map<QName, List<XmlSchemaElement>> xsdElements = new HashMap<QName, List<XmlSchemaElement>>();
    private static List<XmlSchemaElement> schemaElements = new ArrayList<XmlSchemaElement>();

    public static void main(String[] args) throws URISyntaxException, FileNotFoundException, UnsupportedEncodingException {
        // Path for the file which is stored within the Resource folder
        String xsdPath = Paths.get(XMLSchemaCore.class.getClassLoader().getResource("test.xsd").toURI()).toFile().getAbsolutePath();
        String filePath = Path.of(xsdPath).toString();

        InputStream is = new FileInputStream(filePath);
        xmlSchemaCollection = new XmlSchemaCollection();

        // Schema contain the complete XSD content which needs to be parsed
        XmlSchema schema = xmlSchemaCollection.read(new StreamSource(is));
        // schema.write(System.out);

        // Get the root element from XSD
        Map.Entry<QName, XmlSchemaElement> entry = schema.getElements().entrySet().iterator().next();
        QName rootElement = entry.getKey();

        // Get all the elements based on the parent element
        XmlSchemaElement childElement = xmlSchemaCollection.getElementByQName(rootElement);

        // Call method to get all the child elements
        getChildElementNames(childElement);

        String element = "" + xsdElements.entrySet().stream().map(e -> e.getKey() + " -- " + String.join(", ", e.getValue().stream().map(v -> v
                            .getQName().toString()).collect(Collectors.toList()))).collect(Collectors.toList());

        System.out.println(element);
    }

    // Method to check for the child elements and return list
    private static void getChildElementNames(XmlSchemaElement element) {

        // Get the type of the element
        XmlSchemaType elementType = element != null ? element.getSchemaType() : null;

        // Confirm if the element is of Complex type
        if (elementType instanceof XmlSchemaComplexType) {
            // Get all particles associated with that element Type
            XmlSchemaParticle allParticles = ((XmlSchemaComplexType) elementType).getParticle();

            // Check particle belongs to which type
            if (allParticles instanceof XmlSchemaAny) {
                System.out.println("Any Schema Type");

            } else if (allParticles instanceof XmlSchemaElement) {
                System.out.println("Element Schema Type");

            } else if (allParticles instanceof XmlSchemaSequence) {
                // System.out.println("Sequence Schema Type");
                final XmlSchemaSequence xmlSchemaSequence = (XmlSchemaSequence) allParticles;
                final List<XmlSchemaSequenceMember> items = xmlSchemaSequence.getItems();
                items.forEach((item) -> {
                    XmlSchemaElement itemElements = (XmlSchemaElement) item;
                    schemaElements.add(itemElements);
                    // System.out.println(" Parent : " + element.getQName() + " -- Child : " +
                    // itemElements.getQName());
                    //Call the method to add the current element as child
                    addChild(element.getQName(), itemElements);
                    // Call method recursively to get all subsequent element
                    getChildElementNames(itemElements);
                    schemaElements = new ArrayList<XmlSchemaElement>();
                });

            } else if (allParticles instanceof XmlSchemaGroupRef) {

            }
        }
    }

    // Add child elements based on its parent
    public static void addChild(QName qName, XmlSchemaElement child) {
        List<XmlSchemaElement> values = xsdElements.get(qName);
        if (values == null) {
            values = new ArrayList<XmlSchemaElement>();
        }
        values.add(child);
        xsdElements.put(qName, values);
    }

}
0
投票

我没有资格发表评论，所以我添加作为答案。如果这违反了协议，我向模组表示歉意。

我只是想感谢 BATMAN_2008 提供上面的代码。作为一种学习工具，它对我来说非常有用，并且节省了我自己的时间。谢谢！

最新问题
© www.soinside.com 2019 - 2024. All rights reserved.