xerces-2_12_0.samples.jaxp.InlineSchemaValidator Maven / Gradle / Ivy
Go to download
Xerces2 is the next generation of high performance, fully compliant XML parsers in the Apache Xerces family. This new version of Xerces introduces the Xerces Native Interface (XNI), a complete framework for building parser components and configurations that is extremely modular and easy to program.
The Apache Xerces2 parser is the reference implementation of XNI but other parser components, configurations, and parsers can be written using the Xerces Native Interface. For complete design and implementation documents, refer to the XNI Manual.
Xerces2 is a fully conforming XML Schema 1.0 processor. A partial experimental implementation of the XML Schema 1.1 Structures and Datatypes Working Drafts (December 2009) and an experimental implementation of the XML Schema Definition Language (XSD): Component Designators (SCD) Candidate Recommendation (January 2010) are provided for evaluation. For more information, refer to the XML Schema page.
Xerces2 also provides a complete implementation of the Document Object Model Level 3 Core and Load/Save W3C Recommendations and provides a complete implementation of the XML Inclusions (XInclude) W3C Recommendation. It also provides support for OASIS XML Catalogs v1.1.
Xerces2 is able to parse documents written according to the XML 1.1 Recommendation, except that it does not yet provide an option to enable normalization checking as described in section 2.13 of this specification. It also handles namespaces according to the XML Namespaces 1.1 Recommendation, and will correctly serialize XML 1.1 documents if the DOM level 3 load/save APIs are in use.
The newest version!
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package jaxp;
import java.io.PrintWriter;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.NoSuchElementException;
import java.util.Vector;
import javax.xml.XMLConstants;
import javax.xml.namespace.NamespaceContext;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.transform.Source;
import javax.xml.transform.dom.DOMSource;
import javax.xml.validation.Schema;
import javax.xml.validation.SchemaFactory;
import javax.xml.validation.Validator;
import javax.xml.xpath.XPath;
import javax.xml.xpath.XPathConstants;
import javax.xml.xpath.XPathExpression;
import javax.xml.xpath.XPathFactory;
import org.w3c.dom.Document;
import org.w3c.dom.NodeList;
import org.xml.sax.ErrorHandler;
import org.xml.sax.SAXException;
import org.xml.sax.SAXNotRecognizedException;
import org.xml.sax.SAXNotSupportedException;
import org.xml.sax.SAXParseException;
/**
* A sample demonstrating how to use the JAXP 1.3 Validation API
* to create a validator and use the validator to validate input
* from a DOM which contains inline schemas and multiple validation
* roots. The output of this program shows the time spent executing
* the Validator.validate(Source) method.
*
* This class is useful as a "poor-man's" performance tester to
* compare the speed of various JAXP 1.3 validators with different
* input sources. However, it is important to note that the first
* validation time of a validator will include both VM class load time
* and validator initialization that would not be present in subsequent
* validations with the same document.
*
* Note: The results produced by this program
* should never be accepted as true performance measurements.
*
* @author Michael Glavassevich, IBM
*
* @version $Id$
*/
public class InlineSchemaValidator
implements ErrorHandler, NamespaceContext {
//
// Constants
//
// feature ids
/** Schema full checking feature id (http://apache.org/xml/features/validation/schema-full-checking). */
protected static final String SCHEMA_FULL_CHECKING_FEATURE_ID = "http://apache.org/xml/features/validation/schema-full-checking";
/** Honour all schema locations feature id (http://apache.org/xml/features/honour-all-schemaLocations). */
protected static final String HONOUR_ALL_SCHEMA_LOCATIONS_ID = "http://apache.org/xml/features/honour-all-schemaLocations";
/** Validate schema annotations feature id (http://apache.org/xml/features/validate-annotations) */
protected static final String VALIDATE_ANNOTATIONS_ID = "http://apache.org/xml/features/validate-annotations";
/** Generate synthetic schema annotations feature id (http://apache.org/xml/features/generate-synthetic-annotations). */
protected static final String GENERATE_SYNTHETIC_ANNOTATIONS_ID = "http://apache.org/xml/features/generate-synthetic-annotations";
// default settings
/** Default schema language (http://www.w3.org/2001/XMLSchema). */
protected static final String DEFAULT_SCHEMA_LANGUAGE = XMLConstants.W3C_XML_SCHEMA_NS_URI;
/** Default repetition (1). */
protected static final int DEFAULT_REPETITION = 1;
/** Default schema full checking support (false). */
protected static final boolean DEFAULT_SCHEMA_FULL_CHECKING = false;
/** Default honour all schema locations (false). */
protected static final boolean DEFAULT_HONOUR_ALL_SCHEMA_LOCATIONS = false;
/** Default validate schema annotations (false). */
protected static final boolean DEFAULT_VALIDATE_ANNOTATIONS = false;
/** Default generate synthetic schema annotations (false). */
protected static final boolean DEFAULT_GENERATE_SYNTHETIC_ANNOTATIONS = false;
/** Default memory usage report (false). */
protected static final boolean DEFAULT_MEMORY_USAGE = false;
//
// Data
//
/** Print writer. */
protected final PrintWriter fOut = new PrintWriter(System.out);
/** Prefix to URI mappings for the NamespaceContext. */
protected final HashMap fPrefixToURIMappings;
/** URI to prefix mappings for the NamespaceContext. */
protected final HashMap fURIToPrefixMappings;
//
// Constructors
//
public InlineSchemaValidator(HashMap prefixToURIMappings, HashMap uriToPrefixMappings) {
fPrefixToURIMappings = prefixToURIMappings;
fURIToPrefixMappings = uriToPrefixMappings;
} // (HashMap,HashMap)
//
// Public methods
//
public void validate(Validator validator,
Source source, String systemId,
int repetitions, boolean memoryUsage) {
try {
long timeBefore = System.currentTimeMillis();
long memoryBefore = Runtime.getRuntime().freeMemory();
for (int j = 0; j < repetitions; ++j) {
validator.validate(source);
}
long memoryAfter = Runtime.getRuntime().freeMemory();
long timeAfter = System.currentTimeMillis();
long time = timeAfter - timeBefore;
long memory = memoryUsage
? memoryBefore - memoryAfter : Long.MIN_VALUE;
printResults(fOut, systemId, time, memory, repetitions);
}
catch (SAXParseException e) {
// ignore
}
catch (Exception e) {
System.err.println("error: Parse error occurred - "+e.getMessage());
Exception se = e;
if (e instanceof SAXException) {
se = ((SAXException)e).getException();
}
if (se != null)
se.printStackTrace(System.err);
else
e.printStackTrace(System.err);
}
} // validate(Validator,Source,String,int,boolean)
/** Prints the results. */
public void printResults(PrintWriter out, String uri, long time,
long memory, int repetition) {
// filename.xml: 631 ms
out.print(uri);
out.print(": ");
if (repetition == 1) {
out.print(time);
}
else {
out.print(time);
out.print('/');
out.print(repetition);
out.print('=');
out.print(((float)time)/repetition);
}
out.print(" ms");
if (memory != Long.MIN_VALUE) {
out.print(", ");
out.print(memory);
out.print(" bytes");
}
out.println();
out.flush();
} // printResults(PrintWriter,String,long,long,int)
//
// ErrorHandler methods
//
/** Warning. */
public void warning(SAXParseException ex) throws SAXException {
printError("Warning", ex);
} // warning(SAXParseException)
/** Error. */
public void error(SAXParseException ex) throws SAXException {
printError("Error", ex);
} // error(SAXParseException)
/** Fatal error. */
public void fatalError(SAXParseException ex) throws SAXException {
printError("Fatal Error", ex);
throw ex;
} // fatalError(SAXParseException)
//
// NamespaceContext methods
//
public String getNamespaceURI(String prefix) {
if (prefix == null) {
throw new IllegalArgumentException("Prefix cannot be null.");
}
else if (XMLConstants.XML_NS_PREFIX.equals(prefix)) {
return XMLConstants.XML_NS_URI;
}
else if (XMLConstants.XMLNS_ATTRIBUTE.equals(prefix)) {
return XMLConstants.XMLNS_ATTRIBUTE_NS_URI;
}
else if (fPrefixToURIMappings != null) {
String uri = (String) fPrefixToURIMappings.get(prefix);
if (uri != null) {
return uri;
}
}
return XMLConstants.NULL_NS_URI;
} // getNamespaceURI(String)
public String getPrefix(String namespaceURI) {
if (namespaceURI == null) {
throw new IllegalArgumentException("Namespace URI cannot be null.");
}
else if (XMLConstants.XML_NS_URI.equals(namespaceURI)) {
return XMLConstants.XML_NS_PREFIX;
}
else if (XMLConstants.XMLNS_ATTRIBUTE_NS_URI.equals(namespaceURI)) {
return XMLConstants.XMLNS_ATTRIBUTE;
}
else if (fURIToPrefixMappings != null) {
HashSet prefixes = (HashSet) fURIToPrefixMappings.get(namespaceURI);
if (prefixes != null && prefixes.size() > 0) {
return (String) prefixes.iterator().next();
}
}
return null;
} // getPrefix(String)
public Iterator getPrefixes(String namespaceURI) {
if (namespaceURI == null) {
throw new IllegalArgumentException("Namespace URI cannot be null.");
}
else if (XMLConstants.XML_NS_URI.equals(namespaceURI)) {
return new Iterator() {
boolean more = true;
public boolean hasNext() {
return more;
}
public Object next() {
if (!hasNext()) {
throw new NoSuchElementException();
}
more = false;
return XMLConstants.XML_NS_PREFIX;
}
public void remove() {
throw new UnsupportedOperationException();
}
};
}
else if (XMLConstants.XMLNS_ATTRIBUTE_NS_URI.equals(namespaceURI)) {
return new Iterator() {
boolean more = true;
public boolean hasNext() {
return more;
}
public Object next() {
if (!hasNext()) {
throw new NoSuchElementException();
}
more = false;
return XMLConstants.XMLNS_ATTRIBUTE;
}
public void remove() {
throw new UnsupportedOperationException();
}
};
}
else if (fURIToPrefixMappings != null) {
HashSet prefixes = (HashSet) fURIToPrefixMappings.get(namespaceURI);
if (prefixes != null && prefixes.size() > 0) {
return prefixes.iterator();
}
}
return Collections.EMPTY_LIST.iterator();
} // getPrefixes(String)
//
// Protected methods
//
/** Prints the error message. */
protected void printError(String type, SAXParseException ex) {
System.err.print("[");
System.err.print(type);
System.err.print("] ");
String systemId = ex.getSystemId();
if (systemId != null) {
int index = systemId.lastIndexOf('/');
if (index != -1)
systemId = systemId.substring(index + 1);
System.err.print(systemId);
}
System.err.print(':');
System.err.print(ex.getLineNumber());
System.err.print(':');
System.err.print(ex.getColumnNumber());
System.err.print(": ");
System.err.print(ex.getMessage());
System.err.println();
System.err.flush();
} // printError(String,SAXParseException)
//
// MAIN
//
/** Main program entry point. */
public static void main (String [] argv) {
// is there anything to do?
if (argv.length == 0) {
printUsage();
System.exit(1);
}
// variables
Vector schemas = null;
Vector instances = null;
HashMap prefixMappings = null;
HashMap uriMappings = null;
String docURI = argv[argv.length - 1];
String schemaLanguage = DEFAULT_SCHEMA_LANGUAGE;
int repetition = DEFAULT_REPETITION;
boolean schemaFullChecking = DEFAULT_SCHEMA_FULL_CHECKING;
boolean honourAllSchemaLocations = DEFAULT_HONOUR_ALL_SCHEMA_LOCATIONS;
boolean validateAnnotations = DEFAULT_VALIDATE_ANNOTATIONS;
boolean generateSyntheticAnnotations = DEFAULT_GENERATE_SYNTHETIC_ANNOTATIONS;
boolean memoryUsage = DEFAULT_MEMORY_USAGE;
// process arguments
for (int i = 0; i < argv.length - 1; ++i) {
String arg = argv[i];
if (arg.startsWith("-")) {
String option = arg.substring(1);
if (option.equals("l")) {
// get schema language name
if (++i == argv.length) {
System.err.println("error: Missing argument to -l option.");
}
else {
schemaLanguage = argv[i];
}
continue;
}
if (option.equals("x")) {
if (++i == argv.length) {
System.err.println("error: Missing argument to -x option.");
continue;
}
String number = argv[i];
try {
int value = Integer.parseInt(number);
if (value < 1) {
System.err.println("error: Repetition must be at least 1.");
continue;
}
repetition = value;
}
catch (NumberFormatException e) {
System.err.println("error: invalid number ("+number+").");
}
continue;
}
if (arg.equals("-a")) {
// process -a: xpath expressions for schemas
if (schemas == null) {
schemas = new Vector();
}
while (i + 1 < argv.length - 1 && !(arg = argv[i + 1]).startsWith("-")) {
schemas.add(arg);
++i;
}
continue;
}
if (arg.equals("-i")) {
// process -i: xpath expressions for instance documents
if (instances == null) {
instances = new Vector();
}
while (i + 1 < argv.length - 1 && !(arg = argv[i + 1]).startsWith("-")) {
instances.add(arg);
++i;
}
continue;
}
if (arg.equals("-nm")) {
String prefix;
String uri;
while (i + 2 < argv.length - 1 && !(prefix = argv[i + 1]).startsWith("-") &&
!(uri = argv[i + 2]).startsWith("-")) {
if (prefixMappings == null) {
prefixMappings = new HashMap();
uriMappings = new HashMap();
}
prefixMappings.put(prefix, uri);
HashSet prefixes = (HashSet) uriMappings.get(uri);
if (prefixes == null) {
prefixes = new HashSet();
uriMappings.put(uri, prefixes);
}
prefixes.add(prefix);
i += 2;
}
continue;
}
if (option.equalsIgnoreCase("f")) {
schemaFullChecking = option.equals("f");
continue;
}
if (option.equalsIgnoreCase("hs")) {
honourAllSchemaLocations = option.equals("hs");
continue;
}
if (option.equalsIgnoreCase("va")) {
validateAnnotations = option.equals("va");
continue;
}
if (option.equalsIgnoreCase("ga")) {
generateSyntheticAnnotations = option.equals("ga");
continue;
}
if (option.equalsIgnoreCase("m")) {
memoryUsage = option.equals("m");
continue;
}
if (option.equals("h")) {
printUsage();
continue;
}
System.err.println("error: unknown option ("+option+").");
continue;
}
}
try {
// Create new instance of inline schema validator.
InlineSchemaValidator inlineSchemaValidator = new InlineSchemaValidator(prefixMappings, uriMappings);
// Parse document containing schemas and validation roots
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
dbf.setNamespaceAware(true);
DocumentBuilder db = dbf.newDocumentBuilder();
db.setErrorHandler(inlineSchemaValidator);
Document doc = db.parse(docURI);
// Create XPath factory for selecting schema and validation roots
XPathFactory xpf = XPathFactory.newInstance();
XPath xpath = xpf.newXPath();
xpath.setNamespaceContext(inlineSchemaValidator);
// Select schema roots from the DOM
NodeList [] schemaNodes = new NodeList[schemas != null ? schemas.size() : 0];
for (int i = 0; i < schemaNodes.length; ++i) {
XPathExpression xpathSchema = xpath.compile((String)schemas.elementAt(i));
schemaNodes[i] = (NodeList) xpathSchema.evaluate(doc, XPathConstants.NODESET);
}
// Select validation roots from the DOM
NodeList [] instanceNodes = new NodeList[instances != null ? instances.size() : 0];
for (int i = 0; i < instanceNodes.length; ++i) {
XPathExpression xpathInstance = xpath.compile((String)instances.elementAt(i));
instanceNodes[i] = (NodeList) xpathInstance.evaluate(doc, XPathConstants.NODESET);
}
// Create SchemaFactory and configure
SchemaFactory factory = SchemaFactory.newInstance(schemaLanguage);
factory.setErrorHandler(inlineSchemaValidator);
try {
factory.setFeature(SCHEMA_FULL_CHECKING_FEATURE_ID, schemaFullChecking);
}
catch (SAXNotRecognizedException e) {
System.err.println("warning: SchemaFactory does not recognize feature ("+SCHEMA_FULL_CHECKING_FEATURE_ID+")");
}
catch (SAXNotSupportedException e) {
System.err.println("warning: SchemaFactory does not support feature ("+SCHEMA_FULL_CHECKING_FEATURE_ID+")");
}
try {
factory.setFeature(HONOUR_ALL_SCHEMA_LOCATIONS_ID, honourAllSchemaLocations);
}
catch (SAXNotRecognizedException e) {
System.err.println("warning: SchemaFactory does not recognize feature ("+HONOUR_ALL_SCHEMA_LOCATIONS_ID+")");
}
catch (SAXNotSupportedException e) {
System.err.println("warning: SchemaFactory does not support feature ("+HONOUR_ALL_SCHEMA_LOCATIONS_ID+")");
}
try {
factory.setFeature(VALIDATE_ANNOTATIONS_ID, validateAnnotations);
}
catch (SAXNotRecognizedException e) {
System.err.println("warning: SchemaFactory does not recognize feature ("+VALIDATE_ANNOTATIONS_ID+")");
}
catch (SAXNotSupportedException e) {
System.err.println("warning: SchemaFactory does not support feature ("+VALIDATE_ANNOTATIONS_ID+")");
}
try {
factory.setFeature(GENERATE_SYNTHETIC_ANNOTATIONS_ID, generateSyntheticAnnotations);
}
catch (SAXNotRecognizedException e) {
System.err.println("warning: SchemaFactory does not recognize feature ("+GENERATE_SYNTHETIC_ANNOTATIONS_ID+")");
}
catch (SAXNotSupportedException e) {
System.err.println("warning: SchemaFactory does not support feature ("+GENERATE_SYNTHETIC_ANNOTATIONS_ID+")");
}
// Build Schema from sources
Schema schema;
{
DOMSource [] sources;
int size = 0;
for (int i = 0; i < schemaNodes.length; ++i) {
size += schemaNodes[i].getLength();
}
sources = new DOMSource[size];
if (size == 0) {
schema = factory.newSchema();
}
else {
int count = 0;
for (int i = 0; i < schemaNodes.length; ++i) {
NodeList nodeList = schemaNodes[i];
int nodeListLength = nodeList.getLength();
for (int j = 0; j < nodeListLength; ++j) {
sources[count++] = new DOMSource(nodeList.item(j));
}
}
schema = factory.newSchema(sources);
}
}
// Setup validator and input source.
Validator validator = schema.newValidator();
validator.setErrorHandler(inlineSchemaValidator);
try {
validator.setFeature(SCHEMA_FULL_CHECKING_FEATURE_ID, schemaFullChecking);
}
catch (SAXNotRecognizedException e) {
System.err.println("warning: Validator does not recognize feature ("+SCHEMA_FULL_CHECKING_FEATURE_ID+")");
}
catch (SAXNotSupportedException e) {
System.err.println("warning: Validator does not support feature ("+SCHEMA_FULL_CHECKING_FEATURE_ID+")");
}
try {
validator.setFeature(HONOUR_ALL_SCHEMA_LOCATIONS_ID, honourAllSchemaLocations);
}
catch (SAXNotRecognizedException e) {
System.err.println("warning: Validator does not recognize feature ("+HONOUR_ALL_SCHEMA_LOCATIONS_ID+")");
}
catch (SAXNotSupportedException e) {
System.err.println("warning: Validator does not support feature ("+HONOUR_ALL_SCHEMA_LOCATIONS_ID+")");
}
try {
validator.setFeature(VALIDATE_ANNOTATIONS_ID, validateAnnotations);
}
catch (SAXNotRecognizedException e) {
System.err.println("warning: Validator does not recognize feature ("+VALIDATE_ANNOTATIONS_ID+")");
}
catch (SAXNotSupportedException e) {
System.err.println("warning: Validator does not support feature ("+VALIDATE_ANNOTATIONS_ID+")");
}
try {
validator.setFeature(GENERATE_SYNTHETIC_ANNOTATIONS_ID, generateSyntheticAnnotations);
}
catch (SAXNotRecognizedException e) {
System.err.println("warning: Validator does not recognize feature ("+GENERATE_SYNTHETIC_ANNOTATIONS_ID+")");
}
catch (SAXNotSupportedException e) {
System.err.println("warning: Validator does not support feature ("+GENERATE_SYNTHETIC_ANNOTATIONS_ID+")");
}
// Validate instance documents
for (int i = 0; i < instanceNodes.length; ++i) {
NodeList nodeList = instanceNodes[i];
int nodeListLength = nodeList.getLength();
for (int j = 0; j < nodeListLength; ++j) {
DOMSource source = new DOMSource(nodeList.item(j));
source.setSystemId(docURI);
inlineSchemaValidator.validate(validator, source, docURI, repetition, memoryUsage);
}
}
}
catch (SAXParseException e) {
// ignore
}
catch (Exception e) {
System.err.println("error: Parse error occurred - "+e.getMessage());
if (e instanceof SAXException) {
Exception nested = ((SAXException)e).getException();
if (nested != null) {
e = nested;
}
}
e.printStackTrace(System.err);
}
} // main(String[])
//
// Private static methods
//
/** Prints the usage. */
private static void printUsage() {
System.err.println("usage: java jaxp.InlineSchemaValidator (options) uri ...");
System.err.println();
System.err.println("options:");
System.err.println(" -l name Select schema language by name.");
System.err.println(" -x number Select number of repetitions.");
System.err.println(" -a xpath ... Provide a list of XPath expressions for schema roots");
System.err.println(" -i xpath ... Provide a list of XPath expressions for validation roots");
System.err.println(" -nm pre uri ... Provide a list of prefix to namespace URI mappings for the XPath expressions.");
System.err.println(" -f | -F Turn on/off Schema full checking.");
System.err.println(" NOTE: Not supported by all schema factories and validators.");
System.err.println(" -hs | -HS Turn on/off honouring of all schema locations.");
System.err.println(" NOTE: Not supported by all schema factories and validators.");
System.err.println(" -va | -VA Turn on/off validation of schema annotations.");
System.err.println(" NOTE: Not supported by all schema factories and validators.");
System.err.println(" -ga | -GA Turn on/off generation of synthetic schema annotations.");
System.err.println(" NOTE: Not supported by all schema factories and validators.");
System.err.println(" -m | -M Turn on/off memory usage report");
System.err.println(" -h This help screen.");
System.err.println();
System.err.println("defaults:");
System.err.println(" Schema language: " + DEFAULT_SCHEMA_LANGUAGE);
System.err.println(" Repetition: " + DEFAULT_REPETITION);
System.err.print(" Schema full checking: ");
System.err.println(DEFAULT_SCHEMA_FULL_CHECKING ? "on" : "off");
System.err.print(" Honour all schema locations: ");
System.err.println(DEFAULT_HONOUR_ALL_SCHEMA_LOCATIONS ? "on" : "off");
System.err.print(" Validate annotations: ");
System.err.println(DEFAULT_VALIDATE_ANNOTATIONS ? "on" : "off");
System.err.print(" Generate synthetic annotations: ");
System.err.println(DEFAULT_GENERATE_SYNTHETIC_ANNOTATIONS ? "on" : "off");
System.err.print(" Memory: ");
System.err.println(DEFAULT_MEMORY_USAGE ? "on" : "off");
System.err.println();
System.err.println("notes:");
System.err.println(" The speed and memory results from this program should NOT be used as the");
System.err.println(" basis of parser performance comparison! Real analytical methods should be");
System.err.println(" used. For better results, perform multiple document validations within the");
System.err.println(" same virtual machine to remove class loading from parse time and memory usage.");
} // printUsage()
} // class InlineSchemaValidator
© 2015 - 2025 Weber Informatics LLC | Privacy Policy