ObjectFactorypublic class ObjectFactory extends Object | This class is duplicated for each JAXP subpackage so keep it in sync.
It is package private and therefore is not exposed as part of the JAXP
API.
This code is designed to implement the JAXP 1.1 spec pluggability
feature and is designed to run on JDK version 1.1 and
later, and to compile on JDK 1.2 and onward.
The code also runs both as part of an unbundled jar file and
when bundled as part of the JDK.
This class was moved from the javax.xml.parsers.ObjectFactory
class and modified to be used as a general utility for creating objects
dynamically. |
| Fields Summary |
|---|
| private static final String | DEFAULT_PROPERTIES_FILENAME | | private static final String | SERVICES_PATH | | private static final boolean | DEBUGSet to true for debugging | | private static Properties | fXalanPropertiescache the contents of the xalan.properties file.
Until an attempt has been made to read this file, this will
be null; if the file does not exist or we encounter some other error
during the read, this will be empty. | | private static long | fLastModifiedCache the time stamp of the xalan.properties file so
that we know if it's been modified and can invalidate
the cache when necessary. |
| Methods Summary |
|---|
| static java.lang.Object | createObject(java.lang.String factoryId, java.lang.String fallbackClassName)Finds the implementation Class object in the specified order. The
specified order is the following:
- query the system property using
System.getProperty
- read
META-INF/services/factoryId file
- use fallback classname
//
// Public static methods
//
return createObject(factoryId, null, fallbackClassName);
| | static java.lang.Object | createObject(java.lang.String factoryId, java.lang.String propertiesFilename, java.lang.String fallbackClassName)Finds the implementation Class object in the specified order. The
specified order is the following:
- query the system property using
System.getProperty
- read
$java.home/lib/propertiesFilename file
- read
META-INF/services/factoryId file
- use fallback classname
Class factoryClass = lookUpFactoryClass(factoryId,
propertiesFilename,
fallbackClassName);
if (factoryClass == null) {
throw new ConfigurationError(
"Provider for " + factoryId + " cannot be found", null);
}
try{
Object instance = factoryClass.newInstance();
debugPrintln("created new instance of factory " + factoryId);
return instance;
} catch (Exception x) {
throw new ConfigurationError(
"Provider for factory " + factoryId
+ " could not be instantiated: " + x, x);
}
| | private static void | debugPrintln(java.lang.String msg)Prints a message to standard error if debugging is enabled.
if (DEBUG) {
System.err.println("JAXP: " + msg);
}
| | static java.lang.ClassLoader | findClassLoader()Figure out which ClassLoader to use. For JDK 1.2 and later use
the context ClassLoader.
SecuritySupport ss = SecuritySupport.getInstance();
// Figure out which ClassLoader to use for loading the provider
// class. If there is a Context ClassLoader then use it.
ClassLoader context = ss.getContextClassLoader();
ClassLoader system = ss.getSystemClassLoader();
ClassLoader chain = system;
while (true) {
if (context == chain) {
// Assert: we are on JDK 1.1 or we have no Context ClassLoader
// or any Context ClassLoader in chain of system classloader
// (including extension ClassLoader) so extend to widest
// ClassLoader (always look in system ClassLoader if Xalan
// is in boot/extension/system classpath and in current
// ClassLoader otherwise); normal classloaders delegate
// back to system ClassLoader first so this widening doesn't
// change the fact that context ClassLoader will be consulted
ClassLoader current = ObjectFactory.class.getClassLoader();
chain = system;
while (true) {
if (current == chain) {
// Assert: Current ClassLoader in chain of
// boot/extension/system ClassLoaders
return system;
}
if (chain == null) {
break;
}
chain = ss.getParentClassLoader(chain);
}
// Assert: Current ClassLoader not in chain of
// boot/extension/system ClassLoaders
return current;
}
if (chain == null) {
// boot ClassLoader reached
break;
}
// Check for any extension ClassLoaders in chain up to
// boot ClassLoader
chain = ss.getParentClassLoader(chain);
};
// Assert: Context ClassLoader not in chain of
// boot/extension/system ClassLoaders
return context;
| | private static java.lang.String | findJarServiceProviderName(java.lang.String factoryId)Find the name of service provider using Jar Service Provider Mechanism
SecuritySupport ss = SecuritySupport.getInstance();
String serviceId = SERVICES_PATH + factoryId;
InputStream is = null;
// First try the Context ClassLoader
ClassLoader cl = findClassLoader();
is = ss.getResourceAsStream(cl, serviceId);
// If no provider found then try the current ClassLoader
if (is == null) {
ClassLoader current = ObjectFactory.class.getClassLoader();
if (cl != current) {
cl = current;
is = ss.getResourceAsStream(cl, serviceId);
}
}
if (is == null) {
// No provider found
return null;
}
debugPrintln("found jar resource=" + serviceId +
" using ClassLoader: " + cl);
// Read the service provider name in UTF-8 as specified in
// the jar spec. Unfortunately this fails in Microsoft
// VJ++, which does not implement the UTF-8
// encoding. Theoretically, we should simply let it fail in
// that case, since the JVM is obviously broken if it
// doesn't support such a basic standard. But since there
// are still some users attempting to use VJ++ for
// development, we have dropped in a fallback which makes a
// second attempt using the platform's default encoding. In
// VJ++ this is apparently ASCII, which is a subset of
// UTF-8... and since the strings we'll be reading here are
// also primarily limited to the 7-bit ASCII range (at
// least, in English versions), this should work well
// enough to keep us on the air until we're ready to
// officially decommit from VJ++. [Edited comment from
// jkesselm]
BufferedReader rd;
try {
rd = new BufferedReader(new InputStreamReader(is, "UTF-8"));
} catch (java.io.UnsupportedEncodingException e) {
rd = new BufferedReader(new InputStreamReader(is));
}
String factoryClassName = null;
try {
// XXX Does not handle all possible input as specified by the
// Jar Service Provider specification
factoryClassName = rd.readLine();
rd.close();
} catch (IOException x) {
// No provider found
return null;
}
if (factoryClassName != null &&
! "".equals(factoryClassName)) {
debugPrintln("found in resource, value="
+ factoryClassName);
// Note: here we do not want to fall back to the current
// ClassLoader because we want to avoid the case where the
// resource file was found using one ClassLoader and the
// provider class was instantiated using a different one.
return factoryClassName;
}
// No provider found
return null;
| | static java.lang.Class | findProviderClass(java.lang.String className, java.lang.ClassLoader cl, boolean doFallback)Find a Class using the specified ClassLoader
//throw security exception if the calling thread is not allowed to access the
//class. Restrict the access to the package classes as specified in java.security policy.
SecurityManager security = System.getSecurityManager();
if (security != null){
final int lastDot = className.lastIndexOf(".");
String packageName = className;
if (lastDot != -1)
packageName = className.substring(0, lastDot);
security.checkPackageAccess(packageName);
}
Class providerClass;
if (cl == null) {
// XXX Use the bootstrap ClassLoader. There is no way to
// load a class using the bootstrap ClassLoader that works
// in both JDK 1.1 and Java 2. However, this should still
// work b/c the following should be true:
//
// (cl == null) iff current ClassLoader == null
//
// Thus Class.forName(String) will use the current
// ClassLoader which will be the bootstrap ClassLoader.
providerClass = Class.forName(className);
} else {
try {
providerClass = cl.loadClass(className);
} catch (ClassNotFoundException x) {
if (doFallback) {
// Fall back to current classloader
ClassLoader current = ObjectFactory.class.getClassLoader();
if (current == null) {
providerClass = Class.forName(className);
} else if (cl != current) {
cl = current;
providerClass = cl.loadClass(className);
} else {
throw x;
}
} else {
throw x;
}
}
}
return providerClass;
| | static java.lang.Class | lookUpFactoryClass(java.lang.String factoryId)Finds the implementation Class object in the specified order. The
specified order is the following:
- query the system property using
System.getProperty
- read
$java.home/lib/propertiesFilename file
- read
META-INF/services/factoryId file
- use fallback classname
return lookUpFactoryClass(factoryId, null, null);
| | static java.lang.Class | lookUpFactoryClass(java.lang.String factoryId, java.lang.String propertiesFilename, java.lang.String fallbackClassName)Finds the implementation Class object in the specified order. The
specified order is the following:
- query the system property using
System.getProperty
- read
$java.home/lib/propertiesFilename file
- read
META-INF/services/factoryId file
- use fallback classname
String factoryClassName = lookUpFactoryClassName(factoryId,
propertiesFilename,
fallbackClassName);
ClassLoader cl = findClassLoader();
if (factoryClassName == null) {
factoryClassName = fallbackClassName;
}
// assert(className != null);
try{
Class providerClass = findProviderClass(factoryClassName,
cl,
true);
debugPrintln("created new instance of " + providerClass +
" using ClassLoader: " + cl);
return providerClass;
} catch (ClassNotFoundException x) {
throw new ConfigurationError(
"Provider " + factoryClassName + " not found", x);
} catch (Exception x) {
throw new ConfigurationError(
"Provider "+factoryClassName+" could not be instantiated: "+x,
x);
}
| | static java.lang.String | lookUpFactoryClassName(java.lang.String factoryId, java.lang.String propertiesFilename, java.lang.String fallbackClassName)Finds the name of the required implementation class in the specified
order. The specified order is the following:
- query the system property using
System.getProperty
- read
$java.home/lib/propertiesFilename file
- read
META-INF/services/factoryId file
- use fallback classname
SecuritySupport ss = SecuritySupport.getInstance();
// Use the system property first
try {
String systemProp = ss.getSystemProperty(factoryId);
if (systemProp != null) {
debugPrintln("found system property, value=" + systemProp);
return systemProp;
}
} catch (SecurityException se) {
// Ignore and continue w/ next location
}
// Try to read from propertiesFilename, or
// $java.home/lib/xalan.properties
String factoryClassName = null;
// no properties file name specified; use
// $JAVA_HOME/lib/xalan.properties:
if (propertiesFilename == null) {
File propertiesFile = null;
boolean propertiesFileExists = false;
try {
String javah = ss.getSystemProperty("java.home");
propertiesFilename = javah + File.separator +
"lib" + File.separator + DEFAULT_PROPERTIES_FILENAME;
propertiesFile = new File(propertiesFilename);
propertiesFileExists = ss.getFileExists(propertiesFile);
} catch (SecurityException e) {
// try again...
fLastModified = -1;
fXalanProperties = null;
}
synchronized (ObjectFactory.class) {
boolean loadProperties = false;
try {
// file existed last time
if(fLastModified >= 0) {
if(propertiesFileExists &&
(fLastModified < (fLastModified = ss.getLastModified(propertiesFile)))) {
loadProperties = true;
} else {
// file has stopped existing...
if(!propertiesFileExists) {
fLastModified = -1;
fXalanProperties = null;
} // else, file wasn't modified!
}
} else {
// file has started to exist:
if(propertiesFileExists) {
loadProperties = true;
fLastModified = ss.getLastModified(propertiesFile);
} // else, nothing's changed
}
if(loadProperties) {
// must never have attempted to read xalan.properties
// before (or it's outdeated)
fXalanProperties = new Properties();
FileInputStream fis =
ss.getFileInputStream(propertiesFile);
fXalanProperties.load(fis);
fis.close();
}
} catch (Exception x) {
fXalanProperties = null;
fLastModified = -1;
// assert(x instanceof FileNotFoundException
// || x instanceof SecurityException)
// In both cases, ignore and continue w/ next location
}
}
if(fXalanProperties != null) {
factoryClassName = fXalanProperties.getProperty(factoryId);
}
} else {
try {
FileInputStream fis =
ss.getFileInputStream(new File(propertiesFilename));
Properties props = new Properties();
props.load(fis);
fis.close();
factoryClassName = props.getProperty(factoryId);
} catch (Exception x) {
// assert(x instanceof FileNotFoundException
// || x instanceof SecurityException)
// In both cases, ignore and continue w/ next location
}
}
if (factoryClassName != null) {
debugPrintln("found in " + propertiesFilename + ", value="
+ factoryClassName);
return factoryClassName;
}
// Try Jar Service Provider Mechanism
return findJarServiceProviderName(factoryId);
| | static java.lang.Object | newInstance(java.lang.String className, java.lang.ClassLoader cl, boolean doFallback)Create an instance of a class using the specified ClassLoader
// assert(className != null);
try{
Class providerClass = findProviderClass(className, cl, doFallback);
Object instance = providerClass.newInstance();
debugPrintln("created new instance of " + providerClass +
" using ClassLoader: " + cl);
return instance;
} catch (ClassNotFoundException x) {
throw new ConfigurationError(
"Provider " + className + " not found", x);
} catch (Exception x) {
throw new ConfigurationError(
"Provider " + className + " could not be instantiated: " + x,
x);
}
|
|
