java - online - xs schema

¿Cuál es la mejor manera de validar un archivo XML contra un archivo XSD?

Question

Estoy generando algunos archivos xml que deben ajustarse a un archivo xsd que se me entregó. ¿Cuál es la mejor manera de verificar que cumplan?

Answer 1

¿Estás buscando una herramienta o una biblioteca?

En cuanto a las bibliotecas, prácticamente el estándar de facto es Xerces2, que tiene versiones C++ y Xerces2 .

Antes de ser advertido, es una solución de peso pesado. Pero nuevamente, validar XML contra archivos XSD es un problema bastante pesado.

En cuanto a una herramienta para hacer esto por usted, XMLFox parece ser una solución de software libre decente, pero no haberlo utilizado personalmente, no puedo asegurarlo.

Answer 2

Con JAXB, podrías usar el siguiente código:

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

Answer 3

Construimos nuestro proyecto usando ant, por lo que podemos usar la tarea schemavalidate para verificar nuestros archivos de configuración:

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

Ahora los archivos de configuración traviesos fallarán nuestra compilación!

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

Answer 4

Encontré este sitio para ser útil, también.

http://www.ibm.com/developerworks/xml/library/x-javaxmlvalidapi.html

Es el que realmente trabajó para mí con un mínimo de alboroto.

Answer 5

He aquí cómo hacerlo usando Xerces2 . Un tutorial para esto, here (req. Registro).

Atribución original: copiado descaradamente de here :

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

Answer 6

La biblioteca de tiempo de ejecución de Java admite la validación. La última vez que verifiqué esto fue el analizador de Apache Xerces debajo de las portadas. Probablemente debería usar un 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) {}

La constante de fábrica de esquema es la cadena http://www.w3.org/2001/XMLSchema que define los XSD. El código anterior valida un descriptor de implementación WAR en la URL http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd pero puede validar fácilmente con un archivo local.

No debe usar el DOMParser para validar un documento (a menos que su objetivo sea crear un modelo de objeto de documento de todos modos). Esto comenzará a crear objetos DOM a medida que analiza el documento, un desperdicio si no los va a usar.

Answer 7

Si está generando archivos XML de manera programática, es posible que desee consultar la biblioteca XMLBeans . Usando una herramienta de línea de comandos, XMLBeans generará y empaquetará automáticamente un conjunto de objetos Java basados ​​en un XSD. Luego puede usar estos objetos para construir un documento XML basado en este esquema.

Tiene soporte incorporado para la validación de esquemas y puede convertir objetos Java a un documento XML y viceversa.

Castor y JAXB son otras bibliotecas de Java que tienen un propósito similar a XMLBeans.

Answer 8

Si tiene una máquina Linux, puede usar la herramienta gratuita de línea de comandos SAXCount. Encontré esto muy útil.

SAXCount -f -s -n my.xml

Valida contra dtd y xsd. 5s para un archivo de 50MB.

En debian squeeze se encuentra en el paquete "libxerces-c-samples".

La definición de dtd y xsd tiene que estar en el xml! No puedes configurarlos por separado.

Answer 9

Tuve que validar un XML contra XSD solo una vez, así que probé XMLFox. Me pareció muy confuso y extraño. Las instrucciones de ayuda no parecían coincidir con la interfaz.

Terminé usando LiquidXML Studio 2008 (v6), que era mucho más fácil de usar y más familiar de inmediato (la interfaz de usuario es muy similar a Visual Basic 2008 Express, que uso con frecuencia). El inconveniente: la capacidad de validación no está en la versión gratuita, así que tuve que usar la versión de prueba de 30 días.

Answer 10

Una respuesta más: ya que dijo que necesita validar los archivos que está generando (escribiendo), es posible que desee validar el contenido mientras escribe, en lugar de escribir primero, y luego volver a leer para la validación. Probablemente pueda hacer eso con JDK API para la validación de Xml, si usa un escritor basado en SAX: si es así, simplemente haga un enlace en el validador llamando a ''Validator.validate (fuente, resultado)'', donde la fuente proviene de su escritor, y el resultado es donde la salida tiene que ir

Alternativamente, si usa Stax para escribir contenido (o una biblioteca que usa o puede usar stax), Woodstox también puede respaldar directamente la validación cuando usa XMLStreamWriter. Aquí hay una entrada de blog que muestra cómo se hace eso:

Answer 11

Usando Java 7 puede seguir la documentación proporcionada en la descripción del paquete .

// parse an XML document into a DOM tree
DocumentBuilder parser = DocumentBuilderFactory.newInstance().newDocumentBuilder();
Document document = parser.parse(new File("instance.xml"));

// 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 DOMSource(document));
} catch (SAXException e) {
    // instance document is invalid!
}

Answer 12

Ya que esta es una pregunta popular, también me gustaría señalar que Java puede validar contra un xsd "referido", por ejemplo, si el propio archivo .xml especifica un XSD, usando xsi:SchemaLocation o xsi:noNamespaceSchemaLocation (o xsi para espacios de nombres particulares) como se indica here :

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

o SchemaLocation (siempre una lista de espacio de nombres para mapeos xsd)

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

"Si crea un esquema sin especificar una URL, un archivo o una fuente, entonces el lenguaje Java crea uno que busca en el documento que se está validando para encontrar el esquema que debería usar. Por ejemplo:"

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

y esto funciona para múltiples espacios de nombres, etc. El problema con este enfoque es que xmlsns:xsi es probablemente una ubicación de red, por lo que saldrá y llegará a la red con todas y cada una de las validaciones, no siempre es óptima.

Aquí hay un ejemplo que valida un archivo XML contra cualquier referencia de XSD (incluso si tiene que extraerlos de la red):

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

Puede evitar extraer los XSD de la red a los que se hace referencia, aunque los archivos xml hagan referencia a las direcciones URL, especificando el xsd manualmente (consulte otras respuestas aquí) o utilizando un sistema de resolución de estilo "catálogo XML". Aparentemente, Spring también puede interceptar las solicitudes de URL para servir archivos locales para validaciones. O puede configurar su propio a través de setResourceResolver , por ejemplo:

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://.com/a/2342859/32453
  }
});
validator.validate(xmlFile);

Véase también here para otro tutorial.

Answer 13

Validar contra esquemas en línea

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

Validar contra esquemas locales

Validación XML fuera de línea con Java