Was ist der beste Weg, um eine XML-Datei gegen eine XSD-Datei zu validieren?

Die Java-Laufzeit-Bibliothek unterstützt die Validierung. Letztes mal habe ich überprüft, das war der Apache Xerces-parser unter der Decke. Sie sollten wahrscheinlich ein javax.xml.die Validierung.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) {}

Schema Fabrik "Konstante" ist die Zeichenfolge http://www.w3.org/2001/XMLSchema definiert XSDs. Der obige code prüft ein KRIEG deployment-descriptor gegen die URL http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd aber Sie könnten genauso leicht validieren gegen eine lokale Datei.

Sollten Sie nicht verwenden die DOMParser, um ein Dokument prüfen (es sei denn, Ihr Ziel ist, erstellen Sie ein Dokument-Objekt-Modell jedenfalls). Dies wird starten Sie die Erstellung von DOM-Objekten, wie es analysiert das Dokument - verschwenderisch, wenn Sie nicht gehen, um Sie zu benutzen.

InformationsquelleAutor der Antwort McDowell

Bauen wir unser Projekt mit Hilfe von ant, so können wir die schemavalidate Aufgabe, zu prüfen, unsere config-Dateien:

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

Nun frech config-Dateien werden nicht unser bauen!

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

InformationsquelleAutor der Antwort chickeninabiscuit

Da dies ist eine beliebte Frage, ich möchte auch darauf hinweisen, dass java überprüfen kann, gegen ein "bezeichnet" xsd, zum Beispiel wenn die .xml-Datei selbst gibt ein XSD, mit xsi:SchemaLocation oder xsi:noNamespaceSchemaLocation (oder xsi für bestimmte namespaces) wie angegeben hier:

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

oder SchemaLocation (immer eine Liste von namespace xsd-mappings)

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

"Wenn Sie ein schema erstellen, ohne Angabe einer URL, Datei oder Quelle, dann der Java-Sprache erstellt, sieht in dem Dokument, das validiert wird, zu finden, das schema zu verwenden. Zum Beispiel:"

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

und das funktioniert für mehrere namespaces, etc.
Das problem bei diesem Ansatz ist, dass die xmlsns:xsi ist wahrscheinlich ein Speicherort im Netzwerk, so dass es dann gehen und traf das Netzwerk mit jedem Validierung, nicht immer optimal.

Hier ist ein Beispiel, validiert eine XML-Datei gegen jede XSD-s Referenzen (auch wenn es, ziehen Sie Sie aus dem Netzwerk):

  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);
    }
  }

Können Sie vermeiden, ziehen referenzierten XSD ' s aus dem Netz, obwohl die xml-Dateien, die Referenz-url, indem Sie die xsd-manuell (siehe einige andere Antworten hier) oder ein "XML-Katalog" Stil resolver. Der Frühling scheinbar auch abfangen kann die URL-Anfragen zu servieren lokale Dateien-Validierungen. Oder Sie können Ihre eigenen über setResourceResolverex:

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);

Siehe auch hier für ein anderes tutorial.

InformationsquelleAutor der Antwort rogerdpack

Eine weitere Antwort: da Sie sagten, Sie brauchen, um zu überprüfen Dateien, die Sie generieren (schriftlich), möchten Sie vielleicht zu überprüfen Inhalte, während Sie schreiben, anstatt zuerst das schreiben, dann das Lesen wieder für die Validierung. Sie können sich wahrscheinlich machen, dass mit dem JDK-API für Xml-Validierung, wenn Sie SAX-basierte writer: wenn ja, nur link im validator durch Aufruf von 'Validator.validate(source, result)', wo die Quelle stammt von Ihrem Autor, und das Ergebnis ist wo Ausgabe gehen muss.

Alternativ, wenn Sie verwenden Stax für das schreiben von content (oder eine Bibliothek, die verwendet oder verwenden kann, stax), Woodstox kann auch direkt Unterstützung von Validierung, wenn mit XMLStreamWriter. Hier ist ein Blogeintragdie zeigen, wie das geschehen ist:

InformationsquelleAutor der Antwort StaxMan

Wenn Sie eine Linux-Maschine, können Sie das Kostenlose Kommandozeilen-tool SAXCount. Ich fand dies sehr nützlich.

SAXCount -f -s -n my.xml

Überprüft er gegen dtd-und xsd.
5s für eine 50MB-Datei.

In debian squeeze es befindet sich im package "libxerces-c-Proben".

Die definition der dtd und xsd in xml! Kann man nicht config Ihnen getrennt.

InformationsquelleAutor der Antwort jens

Mit JAXB, könnten Sie folgenden code verwenden:

    @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
    }
}

InformationsquelleAutor der Antwort razvanone