|
package saxon;
|
|
import org.w3c.dom.TypeInfo;
|
|
import org.w3c.dom.ls.LSInput;
|
|
import org.w3c.dom.ls.LSResourceResolver;
|
|
import org.xml.sax.*;
|
|
import org.xml.sax.helpers.DefaultHandler;
|
|
|
|
import javax.xml.parsers.SAXParser;
|
|
import javax.xml.parsers.SAXParserFactory;
|
|
import javax.xml.validation.Schema;
|
|
import javax.xml.validation.SchemaFactory;
|
|
import javax.xml.validation.TypeInfoProvider;
|
|
import javax.xml.validation.ValidatorHandler;
|
|
import java.io.File;
|
|
|
|
/**
|
|
* SchemaValidatorHandlerExample demonstrates the use of jaxp validation apis.
|
|
*
|
|
* This version was modified by Michael Kay from the sample application named SchemaValidator
|
|
* issued with the JAXP 1.3 distribution. It has been changed to use a ValidatorHandler
|
|
* and to display the types of elements and attributes as reported.
|
|
*
|
|
* The original file contained no explicit terms and conditions or copyright statement,
|
|
* but it should be assumed that it is subject to the usual Apache rules.
|
|
*/
|
|
|
|
public class SchemaValidatorHandlerExample_MMArbeitsversion {
|
|
|
|
/**
|
|
* Main entry point. Expects two arguments: the schema document, and the source document.
|
|
* Allows "--" as the schema document, indicating that the schema is identified by xsi:schemaLocation
|
|
* @param args
|
|
*/
|
|
public static void main(String [] args) {
|
|
try {
|
|
// if(args.length != 2){
|
|
// printUsage();
|
|
// return;
|
|
// }
|
|
|
|
SchemaFactory schemaFactory;
|
|
|
|
// Set a system property to force selection of the Saxon SchemaFactory implementation
|
|
// This is commented out because it shouldn't be necessary if Saxon-EE is on the classpath;
|
|
// but in the event of configuration problems, try reinstating it.
|
|
|
|
// System.setProperty("javax.xml.validation.SchemaFactory:http://www.w3.org/2001/XMLSchema",
|
|
// "com.saxonica.ee.jaxp.SchemaFactoryImpl");
|
|
System.setProperty("javax.xml.validation.SchemaFactory:http://www.w3.org/XML/XMLSchema/v1.1",
|
|
"com.saxonica.ee.jaxp.SchemaFactoryImpl");
|
|
|
|
schemaFactory = SchemaFactory.newInstance("http://www.w3.org/2001/XMLSchema");
|
|
//Mario
|
|
System.out.println("Loaded schema validation provider " + schemaFactory.getClass().getName());
|
|
System.err.println("Loaded schema validation provider " + schemaFactory.getClass().getName());
|
|
|
|
LocalErrorHandler errorHandler = new LocalErrorHandler();
|
|
schemaFactory.setErrorHandler(errorHandler);
|
|
//create a grammar object.
|
|
Schema schemaGrammar;
|
|
|
|
// if (args[0].equals("--")) {
|
|
// // in this case, the schema must be identified using xsi:schemaLocation
|
|
// schemaGrammar = schemaFactory.newSchema();
|
|
// } else {
|
|
// schemaGrammar = schemaFactory.newSchema(new File(args[0]));
|
|
// System.err.println("Created Grammar object for schema : "+args[0]);
|
|
// }
|
|
|
|
schemaGrammar = schemaFactory.newSchema(new File("001_externalFiles/Mario_UTILMD_RD.xsd"));
|
|
if (schemaGrammar==null) {
|
|
System.out.println("schemaGrammar==null");
|
|
return;
|
|
}
|
|
|
|
String xmlName = "001_externalFiles/TestFile_WithAsserts.xml";
|
|
|
|
|
|
Resolver resolver = new Resolver();
|
|
|
|
//create a validator to validate against the schema.
|
|
ValidatorHandler schemaValidator = schemaGrammar.newValidatorHandler();
|
|
schemaValidator.setResourceResolver(resolver);
|
|
schemaValidator.setErrorHandler(errorHandler);
|
|
schemaValidator.setContentHandler(new LocalContentHandler(schemaValidator.getTypeInfoProvider()));
|
|
|
|
// System.err.println("Validating "+args[1] +" against grammar "+args[0]);
|
|
SAXParserFactory parserFactory = SAXParserFactory.newInstance();
|
|
parserFactory.setNamespaceAware(true);
|
|
SAXParser parser = parserFactory.newSAXParser();
|
|
XMLReader reader = parser.getXMLReader();
|
|
reader.setContentHandler(schemaValidator);
|
|
// reader.parse(new InputSource(new File(args[1]).toURI().toString()));
|
|
// File xmlFile = new File(args[1]);
|
|
File xmlFile = new File(xmlName);
|
|
if (xmlFile==null) {
|
|
System.out.println("xmlFile==null");
|
|
return;
|
|
}
|
|
// MM
|
|
String xmlFileToUri = xmlFile.toURI().toString();
|
|
System.out.println("Gelesenes File \t"+xmlFileToUri);
|
|
reader.parse(new InputSource(xmlFileToUri));
|
|
|
|
// Note: It appears Xerces exits normally if validation errors were found. Saxon throws an exception.
|
|
|
|
int errorCount = errorHandler.getErrorCount();
|
|
if (errorCount == 0) {
|
|
System.err.println("Validation successful");
|
|
} else {
|
|
System.err.println("Validation complete: found " + errorCount + " error" + (errorCount==1?"":"s"));
|
|
}
|
|
} catch (SAXException saxe) {
|
|
exit(1, "Error: " + saxe.getMessage());
|
|
} catch (Exception e) {
|
|
e.printStackTrace();
|
|
exit(2, "Fatal Error: " + e);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Class is never instantiated
|
|
*/
|
|
private SchemaValidatorHandlerExample_MMArbeitsversion() {}
|
|
|
|
/**
|
|
* A custom SAX error handler
|
|
*/
|
|
|
|
protected static class LocalErrorHandler implements ErrorHandler {
|
|
|
|
private int errorCount = 0;
|
|
|
|
/**
|
|
* Report a non-fatal error
|
|
* @param ex the error condition
|
|
*/
|
|
public void error(SAXParseException ex) {
|
|
System.err.println("At line " + ex.getLineNumber() + " of " + ex.getSystemId() + ':');
|
|
System.err.println(ex.getMessage());
|
|
errorCount++;
|
|
}
|
|
|
|
/**
|
|
* Report a fatal error
|
|
* @param ex the error condition
|
|
*/
|
|
|
|
public void fatalError(SAXParseException ex) {
|
|
System.err.println("At line " + ex.getLineNumber() + " of " + ex.getSystemId() + ':');
|
|
System.err.println(ex.getMessage());
|
|
errorCount++;
|
|
}
|
|
|
|
/**
|
|
* Report a warning
|
|
* @param ex the warning condition
|
|
*/
|
|
public void warning(SAXParseException ex) {
|
|
System.err.println("At line " + ex.getLineNumber() + " of " + ex.getSystemId() + ':');
|
|
System.err.println(ex.getMessage());
|
|
}
|
|
|
|
/**
|
|
* Get the error count
|
|
* @return the number of errors reported, that is, the number of calls on error() or fatalError()
|
|
*/
|
|
|
|
public int getErrorCount() {
|
|
return errorCount;
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
* Inner class to implement a resource resolver. This version always returns null, which
|
|
* has the same effect as not supplying a resource resolver at all. The LSResourceResolver
|
|
* is part of the DOM Level 3 load/save module.
|
|
*/
|
|
|
|
protected static class Resolver implements LSResourceResolver{
|
|
|
|
/**
|
|
* Resolve a reference to a resource
|
|
* @param type The type of resource, for example a schema, source XML document, or query
|
|
* @param namespace The target namespace (in the case of a schema document)
|
|
* @param publicId The public ID
|
|
* @param systemId The system identifier (as written, possibly a relative URI)
|
|
* @param baseURI The base URI against which the system identifier should be resolved
|
|
* @return an LSInput object typically containing the character stream or byte stream identified
|
|
* by the supplied parameters; or null if the reference cannot be resolved or if the resolver chooses
|
|
* not to resolve it.
|
|
*/
|
|
|
|
public LSInput resolveResource(String type, String namespace, String publicId, String systemId, String baseURI) {
|
|
return null;
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
* A ContentHandler to receive and display the results
|
|
*/
|
|
|
|
public static class LocalContentHandler extends DefaultHandler {
|
|
|
|
int indent = 0;
|
|
private TypeInfoProvider provider;
|
|
|
|
public LocalContentHandler(TypeInfoProvider provider) {
|
|
this.provider = provider;
|
|
}
|
|
|
|
/**
|
|
* Receive notification of the start of an element.
|
|
*/
|
|
public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {
|
|
TypeInfo etype = provider.getElementTypeInfo();
|
|
StringBuffer sb = new StringBuffer(100);
|
|
for (int i=0; i<indent; i++) {
|
|
sb.append(" ");
|
|
}
|
|
sb.append("Element " + qName);
|
|
sb.append(" of type {" + etype.getTypeNamespace() + '}' + etype.getTypeName());
|
|
System.out.println(sb.toString());
|
|
for (int a=0; a<attributes.getLength(); a++) {
|
|
TypeInfo atype = provider.getAttributeTypeInfo(a);
|
|
boolean spec = provider.isSpecified(a);
|
|
sb.setLength(0);
|
|
for (int i=0; i<indent+2; i++) {
|
|
sb.append(" ");
|
|
}
|
|
sb.append("Attribute " + attributes.getQName(a) + (spec ? " (specified)" : " (defaulted)"));
|
|
if (atype == null) {
|
|
sb.append(" of unknown type");
|
|
} else {
|
|
sb.append(" of type {" + atype.getTypeNamespace() + '}' + atype.getTypeName());
|
|
}
|
|
System.out.println(sb.toString());
|
|
}
|
|
indent++;
|
|
}
|
|
|
|
/**
|
|
* Receive notification of the end of an element.
|
|
*/
|
|
public void endElement(String uri, String localName, String qName) throws SAXException {
|
|
indent--;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
private static void exit(int errCode, String msg) {
|
|
System.err.println(msg);
|
|
System.exit(errCode);
|
|
}
|
|
|
|
public static void printUsage(){
|
|
System.err.println("Usage : java SchemaValidatorHandlerExample (<schemaFile>|--) <xmlFile>");
|
|
}
|
|
}
|
.