FileDocCategorySizeDatePackage
SchemaFactoryFinder.javaAPI DocJava SE 5 API13586Fri Aug 26 14:58:24 BST 2005javax.xml.validation

SchemaFactoryFinder

public class SchemaFactoryFinder extends Object
Implementation of {@link SchemaFactory#newInstance(String)}.
author
Kohsuke Kawaguchi
version
$Revision: 1.14 $, $Date: 2004/11/24 23:32:37 $
since
1.5

Fields Summary
private static boolean
debug
debug support code.
private static SecuritySupport
ss

Take care of restrictions imposed by java security model

private static Properties
cacheProps

Cache properties for performance.

private static boolean
firstTime

First time requires initialization overhead.

private final ClassLoader
classLoader

ClassLoader to use to find SchemaFactory.

private static final Class
SERVICE_CLASS
private static final String
SERVICE_ID
Constructors Summary
public SchemaFactoryFinder(ClassLoader loader)

Constructor that specifies ClassLoader to use to find SchemaFactory.

param
loader to be used to load resource, {@link SchemaFactory}, and {@link SchemaFactoryLoader} implementations during the resolution process. If this parameter is null, the default system class loader will be used.

        this.classLoader = loader;
        if( debug ) {
            debugDisplayClassLoader();
        }
Methods Summary
private javax.xml.validation.SchemaFactory_newFactory(java.lang.String schemaLanguage)

Lookup a SchemaFactory for the given schemaLanguage.

param
schemaLanguage Schema language to lookup SchemaFactory for.
return
SchemaFactory for the given schemaLanguage.

        SchemaFactory sf;
        
        String propertyName = SERVICE_CLASS.getName() + ":" + schemaLanguage;
        
        // system property look up
        try {
            debugPrintln("Looking up system property '"+propertyName+"'" );
            String r = ss.getSystemProperty(propertyName);
            if(r!=null) {
                debugPrintln("The value is '"+r+"'");
                sf = createInstance(r);
                if(sf!=null)    return sf;
            } else
                debugPrintln("The property is undefined.");
        } catch( Throwable t ) {
            if( debug ) {
                debugPrintln("failed to look up system property '"+propertyName+"'" );
                t.printStackTrace();
            }
        }

        String javah = ss.getSystemProperty( "java.home" );
        String configFile = javah + File.separator +
        "lib" + File.separator + "jaxp.properties";

        String factoryClassName = null ;

        // try to read from $java.home/lib/jaxp.properties
        try {
            if(firstTime){
                synchronized(cacheProps){
                    if(firstTime){
                        File f=new File( configFile );
                        firstTime = false;
                        if(ss.doesFileExist(f)){
                            debugPrintln("Read properties file " + f);                                
                            cacheProps.load(ss.getFileInputStream(f));
                        }
                    }
                }
            }
            factoryClassName = cacheProps.getProperty(propertyName);            
            debugPrintln("found " + factoryClassName + " in $java.home/jaxp.properties"); 

            if (factoryClassName != null) {
                sf = createInstance(factoryClassName);
                if(sf != null){
                    return sf;
                }
            }
        } catch (Exception ex) {
            if (debug) {
                ex.printStackTrace();
            } 
        }

        /**
        // try to read from $java.home/lib/jaxp.properties
        try {
            String javah = ss.getSystemProperty( "java.home" );
            String configFile = javah + File.separator +
            "lib" + File.separator + "jaxp.properties";
            File f = new File( configFile );
            if( ss.doesFileExist(f)) {
                sf = loadFromProperty(
                        propertyName,f.getAbsolutePath(), new FileInputStream(f));
                if(sf!=null)    return sf;
            } else {
                debugPrintln("Tried to read "+ f.getAbsolutePath()+", but it doesn't exist.");
            }
        } catch(Throwable e) {
            if( debug ) {
                debugPrintln("failed to read $java.home/lib/jaxp.properties");
                e.printStackTrace();
            }
        }
         */
        
        // try META-INF/services files
        Iterator sitr = createServiceFileIterator();
        while(sitr.hasNext()) {
            URL resource = (URL)sitr.next();
            debugPrintln("looking into " + resource);
            try {
                //sf = loadFromProperty(schemaLanguage,resource.toExternalForm(),resource.openStream());
                sf = loadFromProperty(schemaLanguage,resource.toExternalForm(),ss.getURLInputStream(resource));
                if(sf!=null)    return sf;
            } catch(IOException e) {
                if( debug ) {
                    debugPrintln("failed to read "+resource);
                    e.printStackTrace();
                }
            }
        }
        
        // platform default
        if(schemaLanguage.equals("http://www.w3.org/2001/XMLSchema")) {
            debugPrintln("attempting to use the platform default XML Schema validator");
            return createInstance("com.sun.org.apache.xerces.internal.jaxp.validation.xs.SchemaFactoryImpl");
        }
        
        debugPrintln("all things were tried, but none was found. bailing out.");
        return null;
private javax.xml.validation.SchemaFactorycreateInstance(java.lang.String className)

Creates an instance of the specified and returns it.

param
className fully qualified class name to be instanciated.
return
null if it fails. Error messages will be printed by this method.

        try {
            debugPrintln("instanciating "+className);
            Class clazz;
            if( classLoader!=null )
                clazz = classLoader.loadClass(className);
            else
                clazz = Class.forName(className);
            if(debug)       debugPrintln("loaded it from "+which(clazz));
            Object o = clazz.newInstance();
            
            if( o instanceof SchemaFactory )
                return (SchemaFactory)o;
            
            debugPrintln(className+" is not assignable to "+SERVICE_CLASS.getName());
        } catch( Throwable t ) {
            debugPrintln("failed to instanciate "+className);
            if(debug)   t.printStackTrace();
        }
        return null;
private java.util.IteratorcreateServiceFileIterator()
Returns an {@link Iterator} that enumerates all the META-INF/services files that we care.

        if (classLoader == null) {
            return new SingleIterator() {
                protected Object value() {
                    ClassLoader classLoader = SchemaFactoryFinder.class.getClassLoader();
                    //return (ClassLoader.getSystemResource( SERVICE_ID ));
                    return ss.getResourceAsURL(classLoader, SERVICE_ID);
                }
            };
        } else {
            try {
                //final Enumeration e = classLoader.getResources(SERVICE_ID);
                final Enumeration e = ss.getResources(classLoader, SERVICE_ID);
                if(!e.hasMoreElements()) {
                    debugPrintln("no "+SERVICE_ID+" file was found");
                }
                
                // wrap it into an Iterator.
                return new Iterator() {
                    public void remove() {
                        throw new UnsupportedOperationException();
                    }

                    public boolean hasNext() {
                        return e.hasMoreElements();
                    }

                    public Object next() {
                        return e.nextElement();
                    }
                };
            } catch (IOException e) {
                debugPrintln("failed to enumerate resources "+SERVICE_ID);
                if(debug)   e.printStackTrace();
                return new ArrayList().iterator();  // empty iterator
            }
        }
private voiddebugDisplayClassLoader()

        try {
            if( classLoader == ss.getContextClassLoader() ) {
                debugPrintln("using thread context class loader ("+classLoader+") for search");
                return;
            }
        } catch( Throwable _ ) {
            ; // getContextClassLoader() undefined in JDK1.1 
        }
        
        if( classLoader==ClassLoader.getSystemClassLoader() ) {
            debugPrintln("using system class loader ("+classLoader+") for search");
            return;
        }

        debugPrintln("using class loader ("+classLoader+") for search");
private static voiddebugPrintln(java.lang.String msg)

Conditional debug printing.

param
msg to print

    
     
        // Use try/catch block to support applets
        try {
            debug = ss.getSystemProperty("jaxp.debug") != null;
        } catch (Exception _) {
            debug = false;
        }
    
        if (debug) {
            System.err.println("JAXP: " + msg);
        }
private javax.xml.validation.SchemaFactoryloadFromProperty(java.lang.String keyName, java.lang.String resourceName, java.io.InputStream in)
Looks up a value in a property file while producing all sorts of debug messages.

return
null if there was an error.

        debugPrintln("Reading "+resourceName );
        
        Properties props=new Properties();
        props.load(in);
        in.close();
        String factoryClassName = props.getProperty(keyName);
        if(factoryClassName != null){
            debugPrintln("found "+keyName+" = " + factoryClassName);
            return createInstance(factoryClassName);
        } else {
            debugPrintln(keyName+" is not in the property file");
            return null;
        }
public javax.xml.validation.SchemaFactorynewFactory(java.lang.String schemaLanguage)

Creates a new {@link SchemaFactory} object for the specified schema language.

param
schemaLanguage See {@link SchemaFactory Schema Language} table in SchemaFactory for the list of available schema languages.
return
null if the callee fails to create one.
throws
NullPointerException If the schemaLanguage parameter is null.

        if(schemaLanguage==null)        throw new NullPointerException();
        SchemaFactory f = _newFactory(schemaLanguage);
        if (f != null) {
            debugPrintln("factory '" + f.getClass().getName() + "' was found for " + schemaLanguage);
        } else {
            debugPrintln("unable to find a factory for " + schemaLanguage);
        }
        return f;
private static java.lang.Stringwhich(java.lang.String classname, java.lang.ClassLoader loader)

Search the specified classloader for the given classname.

param
classname the fully qualified name of the class to search for
param
loader the classloader to search
return
the source location of the resource, or null if it wasn't found


        String classnameAsResource = classname.replace('.", '/") + ".class";
        
        if( loader==null )  loader = ClassLoader.getSystemClassLoader();
        
        //URL it = loader.getResource(classnameAsResource);
        URL it = ss.getResourceAsURL(loader, classnameAsResource);
        if (it != null) {
            return it.toString();
        } else {
            return null;
        }
private static java.lang.Stringwhich(java.lang.Class clazz)

    
    
    
           
        return which( clazz.getName(), clazz.getClassLoader() );