java - 如何根据 XSD 文件验证 XML 文件？

Question

我正在生成一些需要符合给我的 xsd 文件的 xml 文件。我应该如何验证它们是否符合？

score 351 · Accepted Answer

Java 运行时库支持验证。上次我检查这是幕后的 Apache Xerces 解析器。您可能应该使用javax.xml.validation.Validator。

import javax.xml.XMLConstants;
import javax.xml.transform.Source;
import javax.xml.transform.stream.StreamSource;
import javax.xml.validation.*;
import java.net.URL;
import org.xml.sax.SAXException;
//import java.io.File; // if you use File
import java.io.IOException;
...
URL schemaFile = new URL("http://host:port/filename.xsd");
// webapp example xsd: 
// URL schemaFile = new URL("http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd");
// local file example:
// File schemaFile = new File("/location/to/localfile.xsd"); // etc.
Source xmlFile = new StreamSource(new File("web.xml"));
SchemaFactory schemaFactory = SchemaFactory
    .newInstance(XMLConstants.W3C_XML_SCHEMA_NS_URI);
try {
  Schema schema = schemaFactory.newSchema(schemaFile);
  Validator validator = schema.newValidator();
  validator.validate(xmlFile);
  System.out.println(xmlFile.getSystemId() + " is valid");
} catch (SAXException e) {
  System.out.println(xmlFile.getSystemId() + " is NOT valid reason:" + e);
} catch (IOException e) {}

架构工厂常量是http://www.w3.org/2001/XMLSchema定义 XSD 的字符串。上面的代码根据 URL 验证 WAR 部署描述符，http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd但您也可以轻松地针对本地文件进行验证。

您不应该使用 DOMParser 来验证文档（除非您的目标是无论如何创建文档对象模型）。这将在解析文档时开始创建 DOM 对象——如果您不打算使用它们，那就太浪费了。

score 25 · Accepted Answer

这是使用Xerces2的方法。这里有一个教程（req. signup）。

原始出处：从这里公然复制：

import org.apache.xerces.parsers.DOMParser;
import java.io.File;
import org.w3c.dom.Document;

public class SchemaTest {
  public static void main (String args[]) {
      File docFile = new File("memory.xml");
      try {
        DOMParser parser = new DOMParser();
        parser.setFeature("http://xml.org/sax/features/validation", true);
        parser.setProperty(
             "http://apache.org/xml/properties/schema/external-noNamespaceSchemaLocation", 
             "memory.xsd");
        ErrorChecker errors = new ErrorChecker();
        parser.setErrorHandler(errors);
        parser.parse("memory.xml");
     } catch (Exception e) {
        System.out.print("Problem parsing the file.");
     }
  }
}

score 20 · Accepted Answer

我们使用 ant 构建项目，因此我们可以使用 schemavalidate 任务来检查我们的配置文件：

<schemavalidate> 
    <fileset dir="${configdir}" includes="**/*.xml" />
</schemavalidate>

现在顽皮的配置文件将使我们的构建失败！

http://ant.apache.org/manual/Tasks/schemavalidate.html

score 16 · Accepted Answer

由于这是一个流行的问题，我将指出 java 也可以针对“引用”xsd 进行验证，例如，如果 .xml 文件本身在标头中指定 XSD，则使用xsi:schemaLocationor xsi:noNamespaceSchemaLocation（或特定命名空间的 xsi）ex：

<document xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:noNamespaceSchemaLocation="http://www.example.com/document.xsd">
  ...

或 schemaLocation（总是命名空间到 xsd 映射的列表）

<document xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://www.example.com/my_namespace http://www.example.com/document.xsd">
  ...

其他答案在这里也有效，因为 .xsd 文件“映射”到 .xml 文件中声明的命名空间，因为它们声明了一个命名空间，并且如果与 .xml 文件中的命名空间匹配，那么你很好。但有时能够拥有一个自定义解析器很方便......

来自 javadocs：“如果您在未指定 URL、文件或源的情况下创建模式，那么 Java 语言会创建一个在被验证的文档中查找它应该使用的模式的模式。例如：”

SchemaFactory factory = SchemaFactory.newInstance("http://www.w3.org/2001/XMLSchema");
Schema schema = factory.newSchema();

这适用于多个命名空间等。这种方法的问题在于xmlsns:xsi它可能是一个网络位置，所以默认情况下，它会在每次验证时出去并访问网络，并不总是最优的。

下面是一个针对它引用的任何 XSD 验证 XML 文件的示例（即使它必须从网络中提取它们）：

  public static void verifyValidatesInternalXsd(String filename) throws Exception {
    InputStream xmlStream = new new FileInputStream(filename);
    DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
    factory.setValidating(true);
    factory.setNamespaceAware(true);
    factory.setAttribute("http://java.sun.com/xml/jaxp/properties/schemaLanguage",
                 "http://www.w3.org/2001/XMLSchema");
    DocumentBuilder builder = factory.newDocumentBuilder();
    builder.setErrorHandler(new RaiseOnErrorHandler());
    builder.parse(new InputSource(xmlStream));
    xmlStream.close();
  }

  public static class RaiseOnErrorHandler implements ErrorHandler {
    public void warning(SAXParseException e) throws SAXException {
      throw new RuntimeException(e);
    }
    public void error(SAXParseException e) throws SAXException {
      throw new RuntimeException(e);
    }
    public void fatalError(SAXParseException e) throws SAXException {
      throw new RuntimeException(e);
    }
  }

您可以通过手动指定 xsd（请参阅此处的其他答案）或使用“XML 目录”样式的解析器来避免从网络中提取引用的 XSD，即使 xml 文件引用了 url 。Spring 显然也可以拦截URL 请求以提供本地文件以进行验证。或者您可以通过setResourceResolver设置自己的，例如：

Source xmlFile = new StreamSource(xmlFileLocation);
SchemaFactory schemaFactory = SchemaFactory
                                .newInstance(XMLConstants.W3C_XML_SCHEMA_NS_URI);
Schema schema = schemaFactory.newSchema();
Validator validator = schema.newValidator();
validator.setResourceResolver(new LSResourceResolver() {
  @Override
  public LSInput resolveResource(String type, String namespaceURI,
                                 String publicId, String systemId, String baseURI) {
    InputSource is = new InputSource(
                           getClass().getResourceAsStream(
                          "some_local_file_in_the_jar.xsd"));
                          // or lookup by URI, etc...
    return new Input(is); // for class Input see 
                          // https://stackoverflow.com/a/2342859/32453
  }
});
validator.validate(xmlFile);

另请参阅此处以获取另一个教程。

我相信默认是使用 DOM 解析，您也可以使用正在验证的 SAX 解析器执行类似的操作 saxReader.setEntityResolver(your_resolver_here);

score 6 · Accepted Answer

使用 Java 7，您可以按照包描述中提供的文档进行操作。

// create a SchemaFactory capable of understanding WXS schemas
SchemaFactory factory = SchemaFactory.newInstance(XMLConstants.W3C_XML_SCHEMA_NS_URI);

// load a WXS schema, represented by a Schema instance
Source schemaFile = new StreamSource(new File("mySchema.xsd"));
Schema schema = factory.newSchema(schemaFile);

// create a Validator instance, which can be used to validate an instance document
Validator validator = schema.newValidator();

// validate the DOM tree
try {
    validator.validate(new StreamSource(new File("instance.xml"));
} catch (SAXException e) {
    // instance document is invalid!
}

score 3 · Accepted Answer

另一个答案：既然您说您需要验证正在生成（写入）的文件，您可能希望在写入时验证内容，而不是先写入，然后再读取以进行验证。如果您使用基于 SAX 的编写器，您可能可以使用 JDK API 进行 Xml 验证：如果是这样，只需通过调用 'Validator.validate(source, result)' 链接验证器，其中源来自您的编写器，结果是输出需要去哪里。

或者，如果您使用 Stax 编写内容（或使用或可以使用 stax 的库），Woodstox也可以在使用 XMLStreamWriter 时直接支持验证。这是一个博客条目，展示了这是如何完成的：

score 3 · Accepted Answer

如果你有一台 Linux 机器，你可以使用免费的命令行工具 SAXCount。我发现这非常有用。

SAXCount -f -s -n my.xml

它针对 dtd 和 xsd 进行验证。50MB 文件需要 5 秒。

在 debian 挤压中，它位于包“libxerces-c-samples”中。

dtd 和 xsd 的定义必须在 xml 中！您不能单独配置它们。

score 2 · Accepted Answer

如果您以编程方式生成 XML 文件，您可能需要查看XMLBeans库。使用命令行工具，XMLBeans 将自动生成并打包一组基于 XSD 的 Java 对象。然后，您可以使用这些对象来构建基于此模式的 XML 文档。

它具有对模式验证的内置支持，并且可以将 Java 对象转换为 XML 文档，反之亦然。

Castor和JAXB是与 XMLBeans 具有相似用途的其他 Java 库。

score 2 · Accepted Answer

使用 JAXB，您可以使用以下代码：

    @Test
public void testCheckXmlIsValidAgainstSchema() {
    logger.info("Validating an XML file against the latest schema...");

    MyValidationEventCollector vec = new MyValidationEventCollector();

    validateXmlAgainstSchema(vec, inputXmlFileName, inputXmlSchemaName, inputXmlRootClass);

    assertThat(vec.getValidationErrors().isEmpty(), is(expectedValidationResult));
}

private void validateXmlAgainstSchema(final MyValidationEventCollector vec, final String xmlFileName, final String xsdSchemaName, final Class<?> rootClass) {
    try (InputStream xmlFileIs = Thread.currentThread().getContextClassLoader().getResourceAsStream(xmlFileName);) {
        final JAXBContext jContext = JAXBContext.newInstance(rootClass);
        // Unmarshal the data from InputStream
        final Unmarshaller unmarshaller = jContext.createUnmarshaller();

        final SchemaFactory sf = SchemaFactory.newInstance(XMLConstants.W3C_XML_SCHEMA_NS_URI);
        final InputStream schemaAsStream = Thread.currentThread().getContextClassLoader().getResourceAsStream(xsdSchemaName);
        unmarshaller.setSchema(sf.newSchema(new StreamSource(schemaAsStream)));

        unmarshaller.setEventHandler(vec);

        unmarshaller.unmarshal(new StreamSource(xmlFileIs), rootClass).getValue(); // The Document class is the root object in the XML file you want to validate

        for (String validationError : vec.getValidationErrors()) {
            logger.trace(validationError);
        }
    } catch (final Exception e) {
        logger.error("The validation of the XML file " + xmlFileName + " failed: ", e);
    }
}

class MyValidationEventCollector implements ValidationEventHandler {
    private final List<String> validationErrors;

    public MyValidationEventCollector() {
        validationErrors = new ArrayList<>();
    }

    public List<String> getValidationErrors() {
        return Collections.unmodifiableList(validationErrors);
    }

    @Override
    public boolean handleEvent(final ValidationEvent event) {
        String pattern = "line {0}, column {1}, error message {2}";
        String errorMessage = MessageFormat.format(pattern, event.getLocator().getLineNumber(), event.getLocator().getColumnNumber(),
                event.getMessage());
        if (event.getSeverity() == ValidationEvent.FATAL_ERROR) {
            validationErrors.add(errorMessage);
        }
        return true; // you collect the validation errors in a List and handle them later
    }
}

score 1 · Accepted Answer

使用Woodstox配置 StAX 解析器以根据您的架构进行验证并解析 XML。

如果捕获到异常，则 XML 无效，否则有效：

// create the XSD schema from your schema file
XMLValidationSchemaFactory schemaFactory = XMLValidationSchemaFactory.newInstance(XMLValidationSchema.SCHEMA_ID_W3C_SCHEMA);
XMLValidationSchema validationSchema = schemaFactory.createSchema(schemaInputStream);

// create the XML reader for your XML file
WstxInputFactory inputFactory = new WstxInputFactory();
XMLStreamReader2 xmlReader = (XMLStreamReader2) inputFactory.createXMLStreamReader(xmlInputStream);

try {
    // configure the reader to validate against the schema
    xmlReader.validateAgainst(validationSchema);

    // parse the XML
    while (xmlReader.hasNext()) {
        xmlReader.next();
    }

    // no exceptions, the XML is valid

} catch (XMLStreamException e) {

    // exceptions, the XML is not valid

} finally {
    xmlReader.close();
}

注意：如果您需要验证多个文件，您应该尝试重用您的XMLInputFactoryandXMLValidationSchema以最大限度地提高性能。

score 0 · Accepted Answer

您在寻找工具还是库？

就库而言，事实上的标准几乎是Xerces2，它同时具有C++和Java版本。

但请注意，这是一个重量级的解决方案。但话又说回来，针对 XSD 文件验证 XML 是一个相当沉重的问题。

至于为您执行此操作的工具，XMLFox似乎是一个不错的免费软件解决方案，但没有亲自使用过，我不能肯定地说。

score 0 · Accepted Answer

针对在线模式进行验证

Source xmlFile = new StreamSource(Thread.currentThread().getContextClassLoader().getResourceAsStream("your.xml"));
SchemaFactory factory = SchemaFactory.newInstance(XMLConstants.W3C_XML_SCHEMA_NS_URI);
Schema schema = factory.newSchema(Thread.currentThread().getContextClassLoader().getResource("your.xsd"));
Validator validator = schema.newValidator();
validator.validate(xmlFile);

针对本地模式进行验证

使用 Java 进行离线 XML 验证

score -3 · Accepted Answer

我只需要针对 XSD 验证 XML 一次，所以我尝试了 XMLFox。我发现它非常混乱和奇怪。帮助说明似乎与界面不匹配。

我最终使用了 LiquidXML Studio 2008 (v6)，它更易于使用且更加熟悉（UI 与我经常使用的 Visual Basic 2008 Express 非常相似）。缺点：免费版没有验证能力，所以只能试用30天。

java - 如何根据 XSD 文件验证 XML 文件？

13 回答 13

Related

Reference