Java Code Examples for javax.xml.validation.Schema#newValidator()

protected void validateGood(File file) throws IOException, SAXException,
		AdeException {
	System.out.println("Starting");

	String fileName_Flowlayout_xsd = Ade.getAde().getConfigProperties()
			.getXsltDir()
			+ FLOW_LAYOUT_XSD_File_Name;
	Source schemaFile = new StreamSource(fileName_Flowlayout_xsd);
	SchemaFactory sf = SchemaFactory
			.newInstance(XMLConstants.W3C_XML_SCHEMA_NS_URI);
	Schema mSchema = sf.newSchema(schemaFile);

	System.out.println("Validating " + file.getPath());
	Validator val = mSchema.newValidator();
	FileInputStream fis = new FileInputStream(file);
	StreamSource streamSource = new StreamSource(fis);

	try {
		val.validate(streamSource);
	} catch (SAXParseException e) {
		System.out.println(e);
		throw e;
	}
	System.out.println("SUCCESS!");
}
 

private void validate(final String xsdFile, final Source src, final Result result) throws Exception {
    try {
        SchemaFactory sf = SchemaFactory.newInstance(XMLConstants.W3C_XML_SCHEMA_NS_URI);
        Schema schema = sf.newSchema(new File(ValidatorTest.class.getResource(xsdFile).toURI()));

        // Get a Validator which can be used to validate instance document
        // against this grammar.
        Validator validator = schema.newValidator();
        ErrorHandler eh = new ErrorHandlerImpl();
        validator.setErrorHandler(eh);

        // Validate this instance document against the
        // Instance document supplied
        validator.validate(src, result);
    } catch (Exception ex) {
        throw ex;
    }
}
 

/**
 * Helper method that returns a validator for our XSD, or null if the current Java
 * implementation can't process XSD schemas.
 *
 * @param version The version of the XML Schema.
 *        See {@link SdkStatsConstants#getXsdStream(int)}
 */
private Validator getValidator(int version) throws SAXException {
    InputStream xsdStream = SdkStatsConstants.getXsdStream(version);
    try {
        SchemaFactory factory = SchemaFactory.newInstance(XMLConstants.W3C_XML_SCHEMA_NS_URI);

        if (factory == null) {
            return null;
        }

        // This may throw a SAX Exception if the schema itself is not a valid XSD
        Schema schema = factory.newSchema(new StreamSource(xsdStream));

        Validator validator = schema == null ? null : schema.newValidator();

        return validator;
    } finally {
        if (xsdStream != null) {
            try {
                xsdStream.close();
            } catch (IOException ignore) {}
        }
    }
}
 

/**
 * Validate the configuration file with the XSD schema.
 *
 * @param document XML Document.
 * @param xsd      File representing the XSD schema.
 * @throws SAXException If configuration file is not valid.
 * @throws IOException  If schema is not found.
 */
private void validate(Document document, File xsd)
    throws SAXException, IOException
{
  SchemaFactory factory =
      SchemaFactory.newInstance(XMLConstants.W3C_XML_SCHEMA_NS_URI);
  Source schemaFile = new StreamSource(xsd);
  Schema schema = factory.newSchema(schemaFile);
  Validator validator = schema.newValidator();
  validator.validate(new DOMSource(document));
}
 

@Test
public void validate() throws Exception {
  GraphMl graphMl = creategraphml();
  JAXBContext jc = new GraphMlContext().getJaxbContext();
  JAXBSource source = new JAXBSource(jc, graphMl);

  SchemaFactory sf = SchemaFactory.newInstance(XMLConstants.W3C_XML_SCHEMA_NS_URI);
  Schema schema = sf.newSchema(new URL("http://graphml.graphdrawing.org/xmlns/1.0/graphml.xsd"));

  Validator validator = schema.newValidator();
  validator.setErrorHandler(new GraphErrorHandler());
  validator.validate(source);
}
 

/**
 * Validates the given document against the given schema.
 */
private void validateDocument(Document document, Schema schema) throws SAXException, IOException {
    if (schema != null) {
        Validator validator = schema.newValidator();
        validator.validate(new DOMSource(document));
        LOG.info("Incoming capture request was successfully validated against the EPCISDocument schema");
    } else {
        LOG.warn("Schema validator unavailable. Unable to validate EPCIS capture event against schema!");
    }
}
 

private static Validator getValidator() throws IOException, SAXException {
	if (validator == null) {
		SchemaFactory xmlSchemaFactory = SchemaFactory.newInstance(XMLConstants.W3C_XML_SCHEMA_NS_URI);
		File schemafile = new File(schemaFilePathName);
		int idx = schemaFilePathName.lastIndexOf(schemafile.getName());
		String path = schemaFilePathName.substring(0, idx);
		xmlSchemaFactory.setResourceResolver(new XMLUtils().new ResourceResolver(path));
		Reader reader = new StringReader(convertSchemaToString(schemaFilePathName));
		Schema schema = xmlSchemaFactory.newSchema(new StreamSource(reader));
		validator = schema.newValidator();
	}
	return validator;
}
 

public void validar(ErrorHandler handler) throws Exception {
    SchemaFactory sf = SchemaFactory.newInstance(XMLConstants.W3C_XML_SCHEMA_NS_URI);
    Schema schema = sf.newSchema(getClass().getResource(XSD));
    Validator validator = schema.newValidator();
    if (handler != null) {
        validator.setErrorHandler(handler);
    }
    validator.validate(new JAXBSource(CONTEXT, tfd));
}
 

private void validateXmlSchema(final URL schemaUrl, final InputStream data) throws IOException, SAXException {
    final SchemaFactory schemaFactory = SchemaFactory.newInstance(XMLConstants.W3C_XML_SCHEMA_NS_URI);
    schemaFactory.setErrorHandler(ERROR_HANDLER);

    final Schema schema = schemaFactory.newSchema(schemaUrl);
    final Validator validator = schema.newValidator();
    validator.validate(new StreamSource(data));
}
 

private boolean validateXML(Schema schema, String xml){    
    try {
        Validator validator = schema.newValidator();
        validator.validate(new StreamSource(new StringReader(xml)));
    } catch (IOException | SAXException e) {
        System.out.println("Exception: " + e.getMessage());
        return false;
    }
    return true;
}
 

public static Validator validator() throws SAXException, IOException {
    SystemPropertiesUtil.ensure();

    if (validator == null) {
        Schema schema = getSchema();
        if (schema == null)
            throw logger.nullValueError("schema");

        validator = schema.newValidator();
        validator.setErrorHandler(new CustomErrorHandler());
    }
    return validator;
}
 

void doOneTestIteration() throws Exception {
    Source src = new StreamSource(new StringReader(xml));
    SchemaFactory schemaFactory = SchemaFactory.newInstance(XMLConstants.W3C_XML_SCHEMA_NS_URI);
    SAXSource xsdSource = new SAXSource(new InputSource(new ByteArrayInputStream(xsd.getBytes())));
    Schema schema = schemaFactory.newSchema(xsdSource);
    Validator v = schema.newValidator();
    v.validate(src);
}
 

private void validateXmlSchema(final File file) throws SAXException, IOException {
    final URL schemaFile = this.getClass().getClassLoader().getResource("Log4j-events.xsd");
    final Source xmlFile = new StreamSource(file);
    final SchemaFactory schemaFactory = SchemaFactory.newInstance(XMLConstants.W3C_XML_SCHEMA_NS_URI);
    final Schema schema = schemaFactory.newSchema(schemaFile);
    final Validator validator = schema.newValidator();
    validator.validate(xmlFile);
}
 

private Document validateSchema(ErrorListener errorHandler)
    throws ParserConfigurationException, SAXException, IOException {
  // parse an XML document into a DOM tree
  final DocumentBuilderFactory parserFactory = DocumentBuilderFactory.newInstance();
  parserFactory.setNamespaceAware(true);
  parserFactory.setXIncludeAware(true);
  final DocumentBuilder parser = parserFactory.newDocumentBuilder();
  final Document document = parser.parse(inputStream);

  // create a SchemaFactory capable of understanding WXS schemas
  final SchemaFactory factory = SchemaFactory.newInstance(XMLConstants.W3C_XML_SCHEMA_NS_URI);
  final ResourceResolver resourceResolver = new ResourceResolver();
  factory.setResourceResolver(resourceResolver);

  // load a WXS schema, represented by a Schema instance
  final URL resourceUrl = this.getClass().getClassLoader().getResource("xsd/repository.xsd");
  final String path = resourceUrl.getPath();
  final String parentPath = path.substring(0, path.lastIndexOf('/'));
  final URL baseUrl = new URL(resourceUrl.getProtocol(), null, parentPath);
  resourceResolver.setBaseUrl(baseUrl);

  final Source schemaFile = new StreamSource(resourceUrl.openStream());
  final Schema schema = factory.newSchema(schemaFile);

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

  validator.setErrorHandler(errorHandler);

  // validate the DOM tree
  validator.validate(new DOMSource(document));
  return document;
}
 

void doOneTestIteration() throws Exception {
    Source src = new StreamSource(new StringReader(xml));
    SchemaFactory schemaFactory = SchemaFactory.newInstance(XMLConstants.W3C_XML_SCHEMA_NS_URI);
    SAXSource xsdSource = new SAXSource(new InputSource(new ByteArrayInputStream(xsd.getBytes())));
    Schema schema = schemaFactory.newSchema(xsdSource);
    Validator v = schema.newValidator();
    v.validate(src);
}
 

/**
 * Test of validateXML method, of class ValueModel.
 */
@Test
public void test_ValidateXML() {
    //Test to see if the XML DOM tree is validated
    System.out.println("Testing ValueModel's validateXML(String xmlURI)");
    String xmlURI= System.getProperty("user.dir");
    xmlURI=xmlURI.concat(File.separator);
    xmlURI=xmlURI.concat("test_ValidateXML");
    ValueModel instance = new ValueModel();
    boolean expResult = false;
    boolean result = instance.validateXML(xmlURI);
    try {
        // parse an XML document into a DOM tree
        DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance();
        dbFactory.setNamespaceAware(true);
        DocumentBuilder parser = dbFactory.newDocumentBuilder();
        Document document = parser.parse(xmlURI);
        // create a SchemaFactory capable of understanding WXS schemas
        SchemaFactory schemaFactory =
                SchemaFactory.newInstance(
                XMLConstants.W3C_XML_SCHEMA_NS_URI);
        // load a WXS schema, represented by a Schema instance
        Source schemaFile = new StreamSource(
                new URL(instance.getValueModelXMLSchemaURL()).openStream());
        Schema schema = schemaFactory.newSchema(schemaFile);
        // create a Validator instance, which can be used to validate an instance document
        Validator validator = schema.newValidator();
        // validate the DOM tree
        validator.validate(new DOMSource(document));
       }
        catch (ParserConfigurationException | SAXException | IOException ex) {
        result = ex instanceof UnknownHostException;
                                                                             }               
    assertEquals(expResult, result);
}
 

public void validate(InputStream inputStream) throws Exception {
   XMLStreamReader reader = XMLInputFactory.newInstance().createXMLStreamReader(inputStream);
   SchemaFactory factory = SchemaFactory.newInstance(XMLConstants.W3C_XML_SCHEMA_NS_URI);
   Schema schema = factory.newSchema(XmlDataImporter.findResource("schema/artemis-import-export.xsd"));

   Validator validator = schema.newValidator();
   validator.validate(new StAXSource(reader));
   reader.close();
}
 

public static boolean validate(URL schemaURL, Source input)  {
	try {
		Schema schema = getSchemaFromResource(schemaURL);
		Validator validator = schema.newValidator();
		validator.setErrorHandler(getValidationErrorHandler("sax "));
		validator.validate(input);
		return true;
	} catch (Exception e) {
		//System.out.println("("+e.getClass().getName()+"): "+e.getMessage());
		return false;
	}
}
 

public boolean validate(InputSource wsdlsource, String[] schemas) throws ToolException {
    boolean isValid = false;
    Schema schema;
    try {
        SAXParserFactory saxFactory = SAXParserFactory.newInstance();
        saxFactory.setFeature("http://xml.org/sax/features/namespaces", true);
        saxFactory.setFeature(XMLConstants.FEATURE_SECURE_PROCESSING, Boolean.TRUE);
        saxFactory.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true);
        saxParser = saxFactory.newSAXParser();

        if (defaultSchemas != null) {
            schemas = addSchemas(defaultSchemas, schemas);
            schema = createSchema(schemas);
        } else {
            schema = createSchema(schemaFromJar, schemas);
        }


        Validator validator = schema.newValidator();

        NewStackTraceErrorHandler errHandler = new NewStackTraceErrorHandler();
        validator.setErrorHandler(errHandler);
        SAXSource saxSource = new SAXSource(saxParser.getXMLReader(), wsdlsource);
        validator.validate(saxSource);


        if (!errHandler.isValid()) {
            throw new ToolException(errHandler.getErrorMessages());
        }

        isValid = true;

    } catch (IOException ioe) {
        throw new ToolException("Cannot get the wsdl " + wsdlsource.getSystemId(), ioe);
    } catch (SAXException saxEx) {
        throw new ToolException(saxEx);
    } catch (ParserConfigurationException e) {
        throw new ToolException(e);
    }
    return isValid;
}
 

private XSDValidator(Schema schema) {
   this.validator = schema.newValidator();
   this.validator.setErrorHandler(new XSDErrorHandler());
}