commons-discovery-0.5/ 0000755 0001750 0001750 00000000000 11643422202 014726 5 ustar drazzib drazzib commons-discovery-0.5/build.properties.sample 0000644 0001750 0001750 00000002745 11550346276 021450 0 ustar drazzib drazzib # 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.
##########################################################################
# Sample Ant build.properties file
#
# This setup assumes dependent jars are in a local maven 2 repository.
# However the jars are located, the properties ending in ".jar" need
# expand to full paths to the jars.
##########################################################################
# Repository base path - unnecessary if full jar paths are provided below
repository=${user.home}/.m2/repository
# JUnit
junit.home=${repository}/junit/junit/4.8.2
junit.jar=${junit.home}/junit-4.8.2.jar
# Commons logging
logger.home=${repository}/commons-logging/commons-logging/1.1.1
logger.jar=${logger.home}/commons-logging-1.1.1.jar commons-discovery-0.5/pom.xml 0000644 0001750 0001750 00000017715 11556060015 016261 0 ustar drazzib drazzib
org.apache.commonscommons-parent204.0.0commons-discoverycommons-discovery0.5Commons Discovery2002The Apache Commons Discovery component is about discovering, or finding,
implementations for pluggable interfaces.http://commons.apache.org/discovery/jirahttp://issues.apache.org/jira/browse/DISCOVERYscm:svn:http://svn.apache.org/repos/asf/commons/proper/discovery/tags/DISCOVERY_0_5_RC2scm:svn:https://svn.apache.org/repos/asf/commons/proper/discovery/tags/DISCOVERY_0_5_RC2http://svn.apache.org/viewvc/commons/proper/discovery/tags/DISCOVERY_0_5_RC2Richard SitzersitzeCraig R. McClanahancraigmccCostin ManolachecostinJames Strachanjstrachanjstrachan@apache.orgSpiritSoft, Inc.Matthew Hawthornematthmatth@apache.orgDavanum Srinivasdimsdims@apache.orgRory Winstonrwinstonrwinston@eircom.netRobert Burrell Donkinrdonkinrdonkin@apache.orgSimone Tripodisimonetripodisimonetripodi@apache.orgcommons-loggingcommons-logging1.1.1junitjunit4.8.2testdiscovery0.5(minium JDK 1.5)RC2DISCOVERY123104721.51.5apache.websiteApache Commons Site${commons.deployment.protocol}://people.apache.org/www/commons.apache.org/discoverysrc/javasrc/test${basedir}/src/test**/*.properties**/testResourceMETA-INF/**org.apache.maven.pluginsmaven-surefire-plugin**/TestAll.java${basedir}/src/testAlt1${basedir}/src/testAlt2maven-assembly-pluginpackagesinglesrc/assembly/bin.xmlsrc/assembly/src.xmlgnuorg.apache.maven.pluginsmaven-changes-plugin2.3${basedir}/src/changes/changes.xml%URL%/%ISSUE%changes-reportorg.apache.maven.pluginsmaven-checkstyle-plugin2.1${basedir}/checkstyle.xmlfalseorg.codehaus.mojofindbugs-maven-plugin2.3.1NormalDefault${basedir}/findbugs-exclude-filter.xmlrcapache.websiteApache Commons Release Candidate Staging Site${commons.deployment.protocol}://people.apache.org/www/people.apache.org/builds/commons/${commons.componentid}/${commons.release.version}/${commons.rc.version}/site
commons-discovery-0.5/doap_discovery.rdf 0000644 0001750 0001750 00000004437 11546071675 020465 0 ustar drazzib drazzib
Apache Commons DiscoveryJavaCommons DiscoveryCommons Discoverycommons-discovery2003-04-150.2
commons-discovery-0.5/STATUS.html 0000644 0001750 0001750 00000007505 10653533705 016661 0 ustar drazzib drazzib
Status File for Apache Commons "Discovery" Component
The commons-discovery package provides best-practice algorithms for
discovering (locating) implementations of Java interfaces.
It includes support for locating/loading properties files,
caching-by-classloaders, and attempts using various classloaders.
commons-discovery was heavily influenced by code originally
integrated into commons-logging, which was likely to have been based
on experience/projects related to the committers of that component.
Goals:
Portable across JDK 1.1.8 or above
Represent Best-Practices for locating & loading Classes and Resources in non-trivial environments (non-trivial classloader hierarchies).
Functional in standalone Java runtime environments
Functional within a J2EE environment.
Non-goals:
Replacing J2EE container managed services. This means: middleware solutions
(commons-logging, axis, etc) that need to discover interface implementations
are encouraged to use this as they must remain independent of J2EE,
yet it is expected that these may be packaged as part of a
Web Application (WAR/EAR/JAR).
Applications/solutions developed for a J2EE managed environment should
NOT use commons-discovery.
2. DEPENDENCIES
The Discovery component is dependent upon the following external
components for compilation:
The user must ensure that any service that they wish
to discover (use) are 'discoverable' by the application environments classloaders
(in the classpath, war/ear/jar file, etc) when they use this component.
3. RELEASE INFO
Current Release: 0.2, CVS Repository Only
Planned Next Release: RC1
4. COMMITTERS
The following individuals are the primary developers and maintainers of this
component. Developers who plan to use Discovery in their own
projects are encouraged to collaborate on the future development of this
component to ensure that it continues to meet a variety of needs.
Richard A. Sitze
Costin Manoloche
Craig R. McClanahan
Matthew Hawthorne
5. ACTION ITEMS
TO DO List: see also TODO file
Action Item
Volunteer
commons-discovery-0.5/PROPOSAL.html 0000644 0001750 0001750 00000010301 10653172436 017061 0 ustar drazzib drazzib
Proposal for Service Discovery
Proposal for Service Discovery Package
(0) Rationale
The Discovery Component is about discovering, or finding,
implementations for pluggable interfaces.
It provides facilities intantiating classes in general,
and for lifecycle management of singleton (factory) classes.
Fundamentally, Discovery locates classes that implement a given Java interface.
The discovery pattern, though not necessarily this package,
is used in many projects including JAXP (SaxParserFactory and others)
and commons-logging (LogFactory).
By extracting this pattern, other projects can (re)use it
and take advantage of improvements to the pattern as Discovery evolves.
Discovery improves over previous implementations
by establishing facilities for working within managed environments.
These allow configuration and property overrides without appealing
to the global System properties (which are scoped across an entire JVM).
(1) Scope of the Package
This is not indended to be a replacement to be used strictly by the user, but rather
a replacement to be used directly by projects. Use by the user is also reasonable,
but limited due to 'keeping this simple'. In particular, there is no configuration
for this discovery service, it relies soley on usage patterns.
Given a java.lang.Class parameter 'package.Class' that represents a
fundamental service as either an interface, an abstract class
(or even a regular class), find an implementation of that class:
Look for system property named 'package.Class', the value of which is the
name of an implementation.
Look for a 'local' property named 'package.Class'...
Attempt JDK 1.3+ style discovery
Attempt to load a default implementation
In all cases, verify that the discovered implementation implements
'package.Class'.
The package should :
Have an API which should be as simple to use as possible
Be based on usage patterns, not specific configuration file
Be reasonably portable across JDK levels (1.1.8+?)
(1.5) Interaction With Other Packages
Services relies on:
Java Development Kit (Version 1.1 or later)
[by design] Nothing Else, particularly anything that would be classified as a 'service'.
(2) Required Jakarta-Commons Resources
CVS Repository - New directory discovery in the
jakarta-commons-sandbox CVS repository.
Initial Committers - The list is provided below.
Mailing List - Discussions will take place on the general
dev@commons.apache.org mailing list. To help list
subscribers identify messages of interest, it is suggested that the
message subject of messages about this component be prefixed with
[discovery].
Bugzilla - New component "discovery" under the "Commons" product
category, with appropriate version identifiers as needed.
Jyve FAQ - New category "discovery" (when available).
(4) Initial Committers
The initial committers on the Service Discovery component shall be:
The Discovery Component is about discovering, or finding,
implementations for pluggable interfaces.
It provides facilities intantiating classes in general,
and for lifecycle management of singleton (factory) classes.
Fundamentally, Discovery locates classes that implement a given Java interface.
The discovery pattern, though not necessarily this package,
is used in many projects including JAXP (SaxParserFactory and others)
and commons-logging (LogFactory).
By extracting this pattern, other projects can (re)use it
and take advantage of improvements to the pattern as Discovery evolves.
Discovery improves over previous implementations
by establishing facilities for working within managed environments.
These allow configuration and property overrides without appealing
to the global System properties (which are scoped across an entire JVM).
This is not indended to be a replacement to be used strictly by the user, but rather
a replacement to be used directly by projects. Use by the user is also reasonable,
but limited due to 'keeping this simple'. In particular, there is no configuration
for this discovery service, it relies soley on usage patterns.
Given a java.lang.Class parameter 'package.Class' that represents a
fundamental service as either an interface, an abstract class
(or even a regular class), find an implementation of that class:
Look for system property named 'package.Class', the value of which is the
name of an implementation.
Look for a 'local' property named 'package.Class'...
Attempt JDK 1.3+ style discovery
Attempt to load a default implementation
In all cases, verify that the discovered implementation implements
'package.Class'.
The package should :
Have an API which should be as simple to use as possible
Be based on usage patterns, not specific configuration file
Be reasonably portable across JDK levels (1.1.8+?)
Services relies on:
Java Development Kit (Version 1.1 or later)
[by design] Nothing Else, particularly anything that would be classified as a 'service'.
CVS Repository - New directory discovery in the
jakarta-commons-sandbox CVS repository.
Initial Committers - The list is provided below.
Mailing List - Discussions will take place on the general
dev@commons.apache.org mailing list. To help list
subscribers identify messages of interest, it is suggested that the
message subject of messages about this component be prefixed with
[discovery].
Bugzilla - New component "discovery" under the "Commons" product
category, with appropriate version identifiers as needed.
Jyve FAQ - New category "discovery" (when available).
The initial committers on the Service Discovery component shall be:
Best-practices are discussed.
See the javadoc, starting with DiscoverySingleton and DiscoverClass,
for detail on the API:
where service implementations are looked for,
the order in which those places are checked,
which classloaders are used,
and the order in which they are used.
3.1. CALLING DIRECTLY
3.1.1. Finding Singleton Instances (Factories)
DiscoverSingleton finds, loads, and manages the lifecycle of a class implementing
a given interface. It only supports classes with default (zero-argument) constructors.
DiscoverSingleton can pass a set of properties to the class
(see [Service Life Cycle Management]).
Use of the term singleton should be applied loosely:
DiscoverSingleton will instantiate separate instances of a class if called with
different:
thread context class loaders
(for example, within different web applications in a J2EE managed environment)
group contexts
(maintain separation between different subsystems, if desired)
DiscoverSingleton looks for the value of the system property
org.apache.commons.logging.LogFactory
for the name of a class that implements the LogFactory (abstract) class.
Failing that, it uses JDK1.3-style service discovery.
DiscoverSingleton also allows a java.util.Properties
parameter to be used for query for service implementation class name,
as well as a default implementation class name:
This last form is equivalent in function
to the original LogFactory.getFactory()
method.
There are a variety of find methods
provided by DiscoverSingleton, review the javadoc for
other forms and options available.
3.1.2. Finding Classes
DiscoverClass finds and loads a class implementing a given interface.
DiscoverClass can pass a set of properties to the class if it implements
the Service interface (which doesn't support full-lifecycle
management as does the SingletonService interface).
DiscoverClass provides API's that instantiate a class, though it currently
supports only classes with default (zero-argument) constructors.
Unlike DiscoverySingleton, class instances are not cached,
so each call will result in a new object instance.
DiscoverClass is more oriented toward calling multiple times within similar contexts,
so it's use is slightly different than DiscoverSingleton: where as DiscoverSingleton provides
a set of static methods (no state), DiscoverClass must be instantiated before it is
used and maintains internal state.
To find a class directly from user-code:
[NEED BETTER EXAMPLE]
In this case, DiscoverClass looks for the value of the system property
org.apache.commons.logging.LogFactory
for the name of a class that implements the LogFactory (abstract) class.
Failing that, it uses JDK1.3-style service discovery.
To find all the SPI implementation classes from user-code, use DiscoverClasses instead:
import org.apache.commons.discovery.ResourceClassIterator;
import org.apache.commons.discovery.ResourceClass:
import org.apache.commons.discovery.resource.classes.DiscoverClasses;
import org.apache.commons.logging.LogFactory;
...
DiscoverClasses<LogFactory> discovery = new DiscoverClasses<TestInterface2>(loaders);
ResourceClassIterator<LogFactory> iter = discovery.findResourceClasses(name);
while (iter.hasNext()) {
ResourceClass<LogFactory> resource = iter.nextResourceClass();
try {
Class<? extends LogFactory> implClass = resource.loadClass();
if (implClass != null) {
// TODO do something
}
} catch (Exception e) {
// TODO handle exception
}
}
}
To instantiate a class directly from user-code:
[NEED BETTER EXAMPLE]
As with DiscoverSingleton, DiscoverClass provides methods that
use java.util.Properties and a default implementation class name
to help determine the name of the class.
3.2 INTEGRATING INTO FACTORIES : WRAPPING
In this example, a factory (such as is used in commons-logging)
internalizes the discovery mechanism, passing appropriate defaults
for a default properties file and a default implementation.
In this case, the factory plays double duty as both the service
to be discovered (abstract class), and the discovery mechanism.
import java.util.Properties;
import org.apache.commons.discovery.DiscoverSingleton;
import org.apache.commons.discovery.DiscoveryException;
public abstract class LogFactory
{
protected static final String FACTORY_DEFAULT =
org.apache.commons.logging.impl.DefaultLogFactory.class.getName();
protected static final String FACTORY_PROPERTIES =
"commons-logging.properties";
/**
* Protected constructor that is not available for public use.
*/
protected LogFactory() { }
public static LogFactory getFactory() throws ServiceException
{
return DiscoverSingleton.find(LogFactory.class,
LogFactory.class,
FACTORY_PROPERTIES,
FACTORY_DEFAULT);
}
public static LogFactory getFactory(Properties properties)
throws ServiceException
{
return DiscoverSingleton.find(LogFactory.class,
LogFactory.class,
properties,
FACTORY_DEFAULT);
}
...
}
Note the addition of one extra parameter to the find
method call.
The first parameter is a root wrapper class,
which delegates to the discovery mechanism.
This is necessary to all Discovery
to determine the correct class loaders to be used
in loading an implementation class.
The second parameter is the service interface/class
for which Discovery will be looking for an implementation.
In this example, they are the same class, as the LogFactory
is providing helper methods that 'wrap' Discovery.
3.3 INTEGRATING INTO DI FRAMEWORKS : GOOGLE GUICE
Sometimes, a DiscoverSingleton/Factory approach like the one exposed above,
is not enough, because you may require injecting dependencies in your discovered SPI.
In this example is shown how DiscoverClass can be useful inside DI framework such
Google Guice:
In this way, ServiceInterface discovery is delegated to Commons Discovery,
but concrete class implementation creation and dependencies injection, to Google Guice.
Commons Discovery shares mailing lists with all the other
Commons Components.
To make it easier for people to only read messages related to components they are interested in,
the convention in Commons is to prefix the subject line of messages with the component's name,
for example:
[discovery] Problem with the ...
Questions related to the usage of Commons Discovery should be posted to the
User List.
The Developer List
is for questions and discussion related to the development of Commons Discovery.
Please do not cross-post; developers are also subscribed to the user list.
Note: please don't send patches or attachments to any of the mailing lists.
Patches are best handled via the Issue Tracking system.
Otherwise, please upload the file to a public server and include the URL in the mail.
Please prefix the subject line of any messages for Commons Discovery
with [discovery] - thanks!
To build a jar file and the javadocs, change into Discovery's root directory
and run ant dist.
The result will be in the "dist" subdirectory.
Nightly Builds
are built once a day from the current SVN HEAD. These are provided purely for test purposes and are NOT
official releases of the Apache Software Foundation - Released versions of Commons Discovery are
available here.
The Discovery component is about discovering, or finding,
implementations for pluggable interfaces.
It provides facilities for instantiating classes in general,
and for lifecycle management of singleton (factory) classes.
Fundamentally, Discovery locates classes that implement a given Java interface.
The discovery pattern, though not necessarily this package,
is used in many projects including JAXP (SaxParserFactory and others)
and commons-logging (LogFactory).
By extracting this pattern, other projects can (re)use it
and take advantage of improvements to the pattern as Discovery evolves.
Discovery improves over previous implementations
by establishing facilities for working within managed environments.
These allow configuration and property overrides without appealing
to the global System properties (which are scoped across an entire JVM).
This is not indended to be a replacement to be used strictly by the user, but rather
a replacement to be used directly by projects. Use by the user is also reasonable,
but limited due to 'keeping this simple'. In particular, there is no configuration
for this discovery service, it relies only on usage patterns.
Given a java.lang.Class parameter 'package.Class' that represents a
fundamental service as either an interface, an abstract class
(or even a regular class), find an implementation of that class:
Look for system property named 'package.Class', the value of which is the
name of an implementation.
Look for a 'local' property named 'package.Class'...
Attempt JDK 1.3+ style discovery
Attempt to load a default implementation
In all cases, verify that the discovered implementation implements
'package.Class'.
The package aims to :
Have an API which should be as simple to use as possible
Be based on usage patterns, not specific configuration file
We recommend you use a mirror to download our release
builds, but you must verify the integrity of
the downloaded files using signatures downloaded from our main
distribution directories. Recent releases (48 hours) may not yet
be available from the mirrors.
You are currently using [preferred]. If you
encounter a problem with this mirror, please select another
mirror. If all mirrors are failing, there are backup
mirrors (at the end of the mirrors list) that should be
available.
[if-any logo][end]
The KEYS
link links to the code signing keys used to sign the product.
The PGP link downloads the OpenPGP compatible signature from our main site.
The MD5 link downloads the checksum from the main site.
To use JIRA you may need to create an account
(if you have previously created/updated Commons issues using Bugzilla an account will have been automatically
created and you can use the Forgot Password
page to get a new password).
If you would like to report a bug, or raise an enhancement request with
Commons Discovery please do the following:
Search existing open bugs.
If you find your issue listed then please add a comment with your details.
commons-discovery-0.5/src/java/ 0000755 0001750 0001750 00000000000 11643422200 016434 5 ustar drazzib drazzib commons-discovery-0.5/src/java/org/ 0000755 0001750 0001750 00000000000 11643422200 017223 5 ustar drazzib drazzib commons-discovery-0.5/src/java/org/apache/ 0000755 0001750 0001750 00000000000 11643422200 020444 5 ustar drazzib drazzib commons-discovery-0.5/src/java/org/apache/commons/ 0000755 0001750 0001750 00000000000 11643422200 022117 5 ustar drazzib drazzib commons-discovery-0.5/src/java/org/apache/commons/discovery/ 0000755 0001750 0001750 00000000000 11643422201 024127 5 ustar drazzib drazzib commons-discovery-0.5/src/java/org/apache/commons/discovery/log/ 0000755 0001750 0001750 00000000000 11643422201 024710 5 ustar drazzib drazzib commons-discovery-0.5/src/java/org/apache/commons/discovery/log/package-info.java 0000644 0001750 0001750 00000001571 11546710126 030113 0 ustar drazzib drazzib /*
* 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.
*/
/**
* Apache Commons-Logging wrapper.
*/
package org.apache.commons.discovery.log;
commons-discovery-0.5/src/java/org/apache/commons/discovery/log/DiscoveryLogFactory.java 0000644 0001750 0001750 00000012752 11546707311 031535 0 ustar drazzib drazzib /*
* 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 org.apache.commons.discovery.log;
import java.lang.reflect.Method;
import java.util.Hashtable;
import java.util.Map;
import org.apache.commons.discovery.DiscoveryException;
import org.apache.commons.discovery.tools.ClassUtils;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
/**
*
Simple implementation of Log that sends all enabled log messages,
* for all defined loggers, to System.err.
*
*
*
Hacked from commons-logging SimpleLog for use in discovery.
* This is intended to be enough of a Log implementation to bootstrap
* Discovery.
*
*
*
One property: org.apache.commons.discovery.log.level.
* valid values: all, trace, debug, info, warn, error, fatal, off.
*
*
* @deprecated Starting from commons-discovery-05, Log is totally delegated to commons-logging
* @version $Id: DiscoveryLogFactory.java 1089255 2011-04-05 21:51:05Z simonetripodi $
*/
@Deprecated
public class DiscoveryLogFactory {
private static LogFactory logFactory = null;
private static final Map, Class> classRegistry = new Hashtable, Class>();
private static final Class[] setLogParamClasses = new Class[] { Log.class };
/**
* Above fields must be initialied before this one..
*/
private static Log log = DiscoveryLogFactory._newLog(DiscoveryLogFactory.class);
/**
* Creates a new {@code Log} instance for the input class.
*
* @param clazz The class the log has to be created for
* @return The input class logger
*/
public static Log newLog(Class clazz) {
/**
* Required to implement 'public static void setLog(Log)'
*/
try {
Method setLog = ClassUtils.findPublicStaticMethod(clazz,
void.class,
"setLog",
setLogParamClasses);
if (setLog == null) {
String msg = "Internal Error: "
+ clazz.getName()
+ " required to implement 'public static void setLog(Log)'";
log.fatal(msg);
throw new DiscoveryException(msg);
}
} catch (SecurityException se) {
String msg = "Required Security Permissions not present";
log.fatal(msg, se);
throw new DiscoveryException(msg, se);
}
if (log.isDebugEnabled()) {
log.debug("Class meets requirements: " + clazz.getName());
}
return _newLog(clazz);
}
/**
* This method MUST not invoke any logging..
*
* @param clazz The class the log has to be created for
* @return The input class logger
*/
public static Log _newLog(Class clazz) {
classRegistry.put(clazz, clazz);
return (logFactory == null)
? new SimpleLog(clazz.getName())
: logFactory.getInstance(clazz.getName());
}
/**
* Sets the {@code Log} for this class.
*
* @param _log This class {@code Log}
*/
public static void setLog(Log _log) {
log = _log;
}
/**
* Set logFactory, works ONLY on first call.
*
* @param factory The log factory
*/
public static void setFactory(LogFactory factory) {
if (logFactory == null) {
// for future generations.. if any
logFactory = factory;
// now, go back and reset loggers for all current classes..
for (Class clazz : classRegistry.values()) {
if (log.isDebugEnabled()) {
log.debug("Reset Log for: " + clazz.getName());
}
Method setLog = null;
// invoke 'setLog(Log)'.. we already know it's 'public static',
// have verified parameters, and return type..
try {
setLog = clazz.getMethod("setLog", setLogParamClasses);
} catch(Exception e) {
String msg = "Internal Error: pre-check for " + clazz.getName() + " failed?!";
log.fatal(msg, e);
throw new DiscoveryException(msg, e);
}
Object[] setLogParam = new Object[] { factory.getInstance(clazz.getName()) };
try {
setLog.invoke(null, setLogParam);
} catch(Exception e) {
String msg = "Internal Error: setLog failed for " + clazz.getName();
log.fatal(msg, e);
throw new DiscoveryException(msg, e);
}
}
}
}
}
commons-discovery-0.5/src/java/org/apache/commons/discovery/log/SimpleLog.java 0000644 0001750 0001750 00000034636 11547102270 027466 0 ustar drazzib drazzib /*
* 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 org.apache.commons.discovery.log;
import java.io.PrintStream;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
import org.apache.commons.logging.Log;
/**
*
Simple implementation of Log that sends all enabled log messages,
* for all defined loggers, to System.err.
*
*
*
Hacked from commons-logging SimpleLog for use in discovery.
* This is intended to be enough of a Log implementation to bootstrap
* Discovery.
*
*
*
One property: org.apache.commons.discovery.log.level.
* valid values: all, trace, debug, info, warn, error, fatal, off.
*
*
* @deprecated Starting from commons-discovery-05, Log is totally delegated to commons-logging
* @version $Id: SimpleLog.java 1089489 2011-04-06 15:20:24Z sebb $
*/
@Deprecated
public class SimpleLog implements Log {
// ---------------------------------------------------- Log Level Constants
/** "Trace" level logging. */
public static final int LOG_LEVEL_TRACE = 1;
/** "Debug" level logging. */
public static final int LOG_LEVEL_DEBUG = 2;
/** "Info" level logging. */
public static final int LOG_LEVEL_INFO = 3;
/** "Warn" level logging. */
public static final int LOG_LEVEL_WARN = 4;
/** "Error" level logging. */
public static final int LOG_LEVEL_ERROR = 5;
/** "Fatal" level logging. */
public static final int LOG_LEVEL_FATAL = 6;
/** Enable all logging levels */
public static final int LOG_LEVEL_ALL = (LOG_LEVEL_TRACE - 1);
/** Enable no logging levels */
public static final int LOG_LEVEL_OFF = (LOG_LEVEL_FATAL + 1);
// ------------------------------------------------------- Class Attributes
static protected final String PROP_LEVEL =
"org.apache.commons.discovery.log.level";
/** Include the instance name in the log message? */
static protected boolean showLogName = false;
/** Include the short name ( last component ) of the logger in the log
message. Default to true - otherwise we'll be lost in a flood of
messages without knowing who sends them.
*/
static protected boolean showShortName = true;
/** Include the current time in the log message */
static protected boolean showDateTime = false;
/** Used to format times */
static protected DateFormat dateFormatter = null;
/** The current log level */
static protected int logLevel = LOG_LEVEL_INFO;
/**
* Use 'out' instead of 'err' for logging
* to keep in-sync with test messages.
*/
static private PrintStream out = System.out;
// ------------------------------------------------------------ Initializer
// initialize class attributes
static {
if(showDateTime) {
dateFormatter = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss:SSS zzz");
}
try {
// set log level from properties
String lvl = System.getProperty(PROP_LEVEL);
if("all".equalsIgnoreCase(lvl)) {
setLevel(SimpleLog.LOG_LEVEL_ALL);
} else if("trace".equalsIgnoreCase(lvl)) {
setLevel(SimpleLog.LOG_LEVEL_TRACE);
} else if("debug".equalsIgnoreCase(lvl)) {
setLevel(SimpleLog.LOG_LEVEL_DEBUG);
} else if("info".equalsIgnoreCase(lvl)) {
setLevel(SimpleLog.LOG_LEVEL_INFO);
} else if("warn".equalsIgnoreCase(lvl)) {
setLevel(SimpleLog.LOG_LEVEL_WARN);
} else if("error".equalsIgnoreCase(lvl)) {
setLevel(SimpleLog.LOG_LEVEL_ERROR);
} else if("fatal".equalsIgnoreCase(lvl)) {
setLevel(SimpleLog.LOG_LEVEL_FATAL);
} else if("off".equalsIgnoreCase(lvl)) {
setLevel(SimpleLog.LOG_LEVEL_OFF);
}
} catch (SecurityException ignored) {
//do nothing. We get here if running discovery
//under a servlet with restricted security rights, and
//cannot read the system property.
//In which case, the default is what you get to keep.
}
}
// -------------------------------------------------------- Properties
/**
*
Set logging level.
*
* @param currentLogLevel new logging level
*/
public static void setLevel(int currentLogLevel) {
logLevel = currentLogLevel;
}
/**
* Get logging level.
*
* @return The logging level
*/
public static int getLevel() {
return logLevel;
}
/**
* Is the given log level currently enabled?
*
* @param level is this level enabled?
* @return true, if the input level is enabled, false otherwise
*/
protected static boolean isLevelEnabled(int level) {
// log level are numerically ordered so can use simple numeric
// comparison
return (level >= getLevel());
}
// ------------------------------------------------------------- Attributes
/** The name of this simple log instance */
protected String logName = null;
private String prefix=null;
// ------------------------------------------------------------ Constructor
/**
* Construct a simple log with given name.
*
* @param name log name
*/
public SimpleLog(String name) {
logName = name;
}
// -------------------------------------------------------- Logging Methods
/**
* Do the actual logging.
*
* This method assembles the message and then prints to {@code System.err}.
*
* @param type The logging level
* @param message The message to log
* @param t The error cause, if any
*/
protected void log(int type, Object message, Throwable t) {
// use a string buffer for better performance
StringBuffer buf = new StringBuffer();
// append date-time if so configured
if(showDateTime) {
buf.append(dateFormatter.format(new Date()));
buf.append(" ");
}
// append a readable representation of the log leve
switch(type) {
case SimpleLog.LOG_LEVEL_TRACE: buf.append("[TRACE] "); break;
case SimpleLog.LOG_LEVEL_DEBUG: buf.append("[DEBUG] "); break;
case SimpleLog.LOG_LEVEL_INFO: buf.append("[INFO ] "); break;
case SimpleLog.LOG_LEVEL_WARN: buf.append("[WARN ] "); break;
case SimpleLog.LOG_LEVEL_ERROR: buf.append("[ERROR] "); break;
case SimpleLog.LOG_LEVEL_FATAL: buf.append("[FATAL] "); break;
}
// append the name of the log instance if so configured
if( showShortName) {
if( prefix==null ) {
// cut all but the last component of the name for both styles
prefix = logName.substring( logName.lastIndexOf(".") +1) + " - ";
prefix = prefix.substring( prefix.lastIndexOf("/") +1) + "-";
}
buf.append( prefix );
} else if(showLogName) {
buf.append(String.valueOf(logName)).append(" - ");
}
// append the message
buf.append(String.valueOf(message));
// append stack trace if not null
if(t != null) {
buf.append(" <");
buf.append(t.toString());
buf.append(">");
}
// print to System.err
out.println(buf.toString());
if (t != null) {
t.printStackTrace(System.err);
}
}
// -------------------------------------------------------- Log Implementation
/**
* Log a message with debug log level.
*
* @param message The message to log
*/
public final void debug(Object message) {
if (isLevelEnabled(SimpleLog.LOG_LEVEL_DEBUG)) {
log(SimpleLog.LOG_LEVEL_DEBUG, message, null);
}
}
/**
* Log an error with debug log level.
*
* @param message The message to log
* @param t The error cause, if any
*/
public final void debug(Object message, Throwable t) {
if (isLevelEnabled(SimpleLog.LOG_LEVEL_DEBUG)) {
log(SimpleLog.LOG_LEVEL_DEBUG, message, t);
}
}
/**
* Log a message with debug log level.
*
* @param message The message to log
*/
public final void trace(Object message) {
if (isLevelEnabled(SimpleLog.LOG_LEVEL_TRACE)) {
log(SimpleLog.LOG_LEVEL_TRACE, message, null);
}
}
/**
* Log an error with debug log level.
*
* @param message The message to log
* @param t The error cause, if any
*/
public final void trace(Object message, Throwable t) {
if (isLevelEnabled(SimpleLog.LOG_LEVEL_TRACE)) {
log(SimpleLog.LOG_LEVEL_TRACE, message, t);
}
}
/**
* Log a message with info log level.
*
* @param message The message to log
*/
public final void info(Object message) {
if (isLevelEnabled(SimpleLog.LOG_LEVEL_INFO)) {
log(SimpleLog.LOG_LEVEL_INFO,message,null);
}
}
/**
* Log an error with info log level.
*
* @param message The message to log
* @param t The error cause, if any
*/
public final void info(Object message, Throwable t) {
if (isLevelEnabled(SimpleLog.LOG_LEVEL_INFO)) {
log(SimpleLog.LOG_LEVEL_INFO, message, t);
}
}
/**
* Log a message with warn log level.
*
* @param message The message to log
*/
public final void warn(Object message) {
if (isLevelEnabled(SimpleLog.LOG_LEVEL_WARN)) {
log(SimpleLog.LOG_LEVEL_WARN, message, null);
}
}
/**
* Log an error with warn log level.
*
* @param message The message to log
* @param t The error cause, if any
*/
public final void warn(Object message, Throwable t) {
if (isLevelEnabled(SimpleLog.LOG_LEVEL_WARN)) {
log(SimpleLog.LOG_LEVEL_WARN, message, t);
}
}
/**
* Log a message with error log level.
*
* @param message The message to log
*/
public final void error(Object message) {
if (isLevelEnabled(SimpleLog.LOG_LEVEL_ERROR)) {
log(SimpleLog.LOG_LEVEL_ERROR, message, null);
}
}
/**
* Log an error with error log level.
*
* @param message The message to log
* @param t The error cause, if any
*/
public final void error(Object message, Throwable t) {
if (isLevelEnabled(SimpleLog.LOG_LEVEL_ERROR)) {
log(SimpleLog.LOG_LEVEL_ERROR, message, t);
}
}
/**
* Log a message with fatal log level.
*
* @param message The message to log
*/
public final void fatal(Object message) {
if (isLevelEnabled(SimpleLog.LOG_LEVEL_FATAL)) {
log(SimpleLog.LOG_LEVEL_FATAL, message, null);
}
}
/**
* Log an error with fatal log level.
*
* @param message The message to log
* @param t The error cause, if any
*/
public final void fatal(Object message, Throwable t) {
if (isLevelEnabled(SimpleLog.LOG_LEVEL_FATAL)) {
log(SimpleLog.LOG_LEVEL_FATAL, message, t);
}
}
/**
*
Are debug messages currently enabled?
*
*
This allows expensive operations such as String
* concatenation to be avoided when the message will be ignored by the
* logger.
*
* @return true, if the {@link SimpleLog#LOG_LEVEL_DEBUG} is enabled, false otherwise
*/
public final boolean isDebugEnabled() {
return isLevelEnabled(SimpleLog.LOG_LEVEL_DEBUG);
}
/**
*
Are error messages currently enabled?
*
*
This allows expensive operations such as String
* concatenation to be avoided when the message will be ignored by the
* logger.
*
* @return true, if the {@link SimpleLog#LOG_LEVEL_ERROR} is enabled, false otherwise
*/
public final boolean isErrorEnabled() {
return isLevelEnabled(SimpleLog.LOG_LEVEL_ERROR);
}
/**
*
Are fatal messages currently enabled?
*
*
This allows expensive operations such as String
* concatenation to be avoided when the message will be ignored by the
* logger.
*
* @return true, if the {@link SimpleLog#LOG_LEVEL_FATAL} is enabled, false otherwise
*/
public final boolean isFatalEnabled() {
return isLevelEnabled(SimpleLog.LOG_LEVEL_FATAL);
}
/**
*
Are info messages currently enabled?
*
*
This allows expensive operations such as String
* concatenation to be avoided when the message will be ignored by the
* logger.
*
* @return true, if the {@link SimpleLog#LOG_LEVEL_INFO} is enabled, false otherwise
*/
public final boolean isInfoEnabled() {
return isLevelEnabled(SimpleLog.LOG_LEVEL_INFO);
}
/**
*
Are trace messages currently enabled?
*
*
This allows expensive operations such as String
* concatenation to be avoided when the message will be ignored by the
* logger.
*
* @return true, if the {@link SimpleLog#LOG_LEVEL_TRACE} is enabled, false otherwise
*/
public final boolean isTraceEnabled() {
return isLevelEnabled(SimpleLog.LOG_LEVEL_TRACE);
}
/**
*
Are warn messages currently enabled?
*
*
This allows expensive operations such as String
* concatenation to be avoided when the message will be ignored by the
* logger.
*
* @return true, if the {@link SimpleLog#LOG_LEVEL_WARN} is enabled, false otherwise
*/
public final boolean isWarnEnabled() {
return isLevelEnabled(SimpleLog.LOG_LEVEL_WARN);
}
}
commons-discovery-0.5/src/java/org/apache/commons/discovery/package-info.java 0000644 0001750 0001750 00000001774 11545717577 027357 0 ustar drazzib drazzib /*
* 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.
*/
/**
* Highlights:
*
*
JDK 1.3 Service discovery
*
Discovery supports JDK 1.1.8 and up (see org.apache.commons.discover.jdk.JDKHooks).
*
*
*/
package org.apache.commons.discovery;
commons-discovery-0.5/src/java/org/apache/commons/discovery/ResourceNameDiscover.java 0000644 0001750 0001750 00000003035 11546563027 031100 0 ustar drazzib drazzib /*
* 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 org.apache.commons.discovery;
/**
* Interface representing a mapping
* from a set of source resource names
* to a resultant set of resource names.
*/
public interface ResourceNameDiscover {
/**
* Locate names of resources that are bound to {@code resourceName}.
*
* @param resourceName The resource has to be located
* @return The bound resources name iterator
*/
ResourceNameIterator findResourceNames(String resourceName);
/**
* Locate names of resources that are bound to {@code resourceNames}.
*
* @param resourceNames The resources has to be located
* @return The bound resources name iterator
*/
ResourceNameIterator findResourceNames(ResourceNameIterator resourceNames);
}
commons-discovery-0.5/src/java/org/apache/commons/discovery/ResourceClass.java 0000644 0001750 0001750 00000010635 11547556500 027571 0 ustar drazzib drazzib /*
* 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 org.apache.commons.discovery;
import java.net.URL;
import java.security.AccessController;
import java.security.PrivilegedAction;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
/**
* 'Resource' located by discovery.
* Naming of methods becomes a real pain ('getClass()')
* so I've patterned this after ClassLoader...
*
* I think it works well as it will give users a point-of-reference.
*
* @param The SPI type
*/
public class ResourceClass extends Resource {
private static Log log = LogFactory.getLog(ResourceClass.class);
/**
* Sets the {@code Log} for this class.
*
* @param _log This class {@code Log}
* @deprecated This method is not thread-safe
*/
@Deprecated
public static void setLog(Log _log) {
log = _log;
}
protected Class resourceClass;
/**
* Create a new {@code Resource} class located by discovery.
*
* @param Any type extends T
* @param resourceClass The resource class has to be located
* @param resource The resource URL has to be located
*/
public ResourceClass(Class resourceClass, URL resource) {
super(resourceClass.getName(), resource, resourceClass.getClassLoader());
this.resourceClass = resourceClass;
}
/**
* Create a new {@code Resource} class located by discovery.
*
* @param resourceName The resource class name has to be located
* @param resource The resource URL has to be located
* @param loader The class loaders holder
*/
public ResourceClass(String resourceName, URL resource, ClassLoader loader) {
super(resourceName, resource, loader);
}
/**
* Get the value of resourceClass.
* Loading the class does NOT guarentee that the class can be
* instantiated. Go figure.
* The class can be instantiated when the class is linked/resolved,
* and all dependencies are resolved.
* Various JDKs do this at different times, so beware:
* java.lang.NoClassDefFoundError when
* calling Class.getDeclaredMethod() (JDK14),
* java.lang.reflect.InvocationTargetException
* (wrapping java.lang.NoClassDefFoundError) when calling
* java.lang.newInstance (JDK13),
* and who knows what else..
*
* @param Any type extends T
*
* @return value of resourceClass.
*/
public Class loadClass() {
if (resourceClass == null && getClassLoader() != null) {
if (log.isDebugEnabled()) {
log.debug("loadClass: Loading class '" + getName() + "' with " + getClassLoader());
}
resourceClass = AccessController.doPrivileged(
new PrivilegedAction>() {
public Class run() {
try {
@SuppressWarnings("unchecked") // this can raise a ClassCastException at runtime
Class returned = (Class) getClassLoader().loadClass(getName());
return returned;
} catch (ClassNotFoundException e) {
return null;
}
}
});
}
@SuppressWarnings("unchecked") // this is assumed by default, see the ctor
Class returned = (Class) resourceClass;
return returned;
}
/**
* {@inheritDoc}
*/
@Override
public String toString() {
return "ResourceClass[" + getName() + ", " + getResource() + ", " + getClassLoader() + "]";
}
}
commons-discovery-0.5/src/java/org/apache/commons/discovery/tools/ 0000755 0001750 0001750 00000000000 11643422201 025267 5 ustar drazzib drazzib commons-discovery-0.5/src/java/org/apache/commons/discovery/tools/package-info.java 0000644 0001750 0001750 00000001574 11546710126 030475 0 ustar drazzib drazzib /*
* 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.
*/
/**
* Discovery tools implementations.
*/
package org.apache.commons.discovery.tools;
commons-discovery-0.5/src/java/org/apache/commons/discovery/tools/DiscoverSingleton.java 0000644 0001750 0001750 00000046437 11546705241 031623 0 ustar drazzib drazzib /*
* 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 org.apache.commons.discovery.tools;
import java.util.HashMap;
import java.util.Map;
import java.util.Properties;
import org.apache.commons.discovery.DiscoveryException;
import org.apache.commons.discovery.jdk.JDKHooks;
import org.apache.commons.discovery.resource.ClassLoaders;
/**
*
Discover singleton service providers.
* This
*
*
*
DiscoverSingleton instances are cached by the Discovery service,
* keyed by a combination of
*
*
thread context class loader,
*
groupContext, and
*
SPI.
*
* This DOES allow multiple instances of a given singleton class
* to exist for different class loaders and different group contexts.
*
*
*
In the context of this package, a service interface is defined by a
* Service Provider Interface (SPI). The SPI is expressed as a Java interface,
* abstract class, or (base) class that defines an expected programming
* interface.
*
*
*
DiscoverSingleton provides the find methods for locating and
* instantiating a singleton instance of an implementation of a service (SPI).
* Each form of find varies slightly, but they all perform the
* same basic function.
*
* The simplest find methods are intended for direct use by
* components looking for a service. If you are not sure which finder(s)
* to use, you can narrow your search to one of these:
*
*
static <T> T find(Class<T> spi);
*
static <T> T find(Class<T> spi, Properties properties);
*
static <T> T find(Class<T> spi, String defaultImpl);
*
static <T> T find(Class<T> spi,
* Properties properties, String defaultImpl);
*
static <T> T find(Class<T> spi,
* String propertiesFileName, String defaultImpl);
*
* The DiscoverSingleton.find methods proceed as follows:
*
*
*
* Examine an internal cache to determine if the desired service was
* previously identified and instantiated. If found in cache, return it.
*
*
* Get the name of an implementation class. The name is the first
* non-null value obtained from the following resources:
*
*
* The value of the (scoped) system property whose name is the same as
* the SPI's fully qualified class name (as given by SPI.class.getName()).
* The ScopedProperties class provides a way to bind
* properties by classloader, in a secure hierarchy similar in concept
* to the way classloader find class and resource files.
* See ScopedProperties for more details.
*
If the ScopedProperties are not set by users, then behaviour
* is equivalent to System.getProperty().
*
*
*
* The value of a Properties properties property, if provided
* as a parameter, whose name is the same as the SPI's fully qualifed class
* name (as given by SPI.class.getName()).
*
*
* The value obtained using the JDK1.3+ 'Service Provider' specification
* (http://java.sun.com/j2se/1.3/docs/guide/jar/jar.html) to locate a
* service named SPI.class.getName(). This is implemented
* internally, so there is not a dependency on JDK 1.3+.
*
*
*
*
* If the name of the implementation class is non-null, load that class.
* The class loaded is the first class loaded by the following sequence
* of class loaders:
*
*
Thread Context Class Loader
*
DiscoverSingleton's Caller's Class Loader
*
SPI's Class Loader
*
DiscoverSingleton's (this class or wrapper) Class Loader
*
System Class Loader
*
* An exception is thrown if the class cannot be loaded.
*
*
* If the name of the implementation class is null, AND the default
* implementation class (defaultImpl) is null,
* then an exception is thrown.
*
*
* If the name of the implementation class is null, AND the default
* implementation class (defaultImpl) is non-null,
* then load the default implementation class. The class loaded is the
* first class loaded by the following sequence of class loaders:
*
*
SPI's Class Loader
*
DiscoverSingleton's (this class or wrapper) Class Loader
*
System Class Loader
*
*
* This limits the scope in which the default class loader can be found
* to the SPI, DiscoverSingleton, and System class loaders. The assumption
* here is that the default implementation is closely associated with the SPI
* or system, and is not defined in the user's application space.
*
*
* An exception is thrown if the class cannot be loaded.
*
*
*
* Verify that the loaded class implements the SPI: an exception is thrown
* if the loaded class does not implement the SPI.
*
*
* Create an instance of the class.
*
*
*
*
* Variances for various forms of the find
* methods are discussed with each such method.
* Variances include the following concepts:
*
*
rootFinderClass - a wrapper encapsulating a finder method
* (factory or other helper class). The root finder class is used to
* determine the 'real' caller, and hence the caller's class loader -
* thereby preserving knowledge that is relevant to finding the
* correct/expected implementation class.
*
*
propertiesFileName - Properties may be specified
* directly, or by property file name. A property file is loaded using the
* same sequence of class loaders used to load the SPI implementation:
*
*
Thread Context Class Loader
*
DiscoverSingleton's Caller's Class Loader
*
SPI's Class Loader
*
DiscoverSingleton's (this class) Class Loader
*
System Class Loader
*
*
*
groupContext - differentiates service providers for different
* logical groups of service users, that might otherwise be forced to share
* a common service and, more importantly, a common configuration of that
* service.
*
The groupContext is used to qualify the name of the property file
* name: groupContext + '.' + propertiesFileName. If that
* file is not found, then the unqualified propertyFileName is used.
*
*
In addition, groupContext is used to qualify the name of the system
* property used to find the service implementation by prepending the value
* of groupContext to the property name:
* groupContext> + '.' + SPI.class.getName().
* Again, if a system property cannot be found by that name, then the
* unqualified property name is used.
*
*
*
*
*
*
IMPLEMENTATION NOTE - This implementation is modelled
* after the SAXParserFactory and DocumentBuilderFactory implementations
* (corresponding to the JAXP pluggability APIs) found in Apache Xerces.
*
*
* @version $Revision: 1089242 $ $Date: 2011-04-05 23:33:21 +0200 (mar. 05 avril 2011) $
*/
public class DiscoverSingleton {
/********************** (RELATIVELY) SIMPLE FINDERS **********************
*
* These finders are suitable for direct use in components looking for a
* service. If you are not sure which finder(s) to use, you can narrow
* your search to one of these.
*/
/**
* Find implementation of SPI.
*
* @param Service Provider Interface type.
* @param spiClass Service Provider Interface Class.
*
* @return Instance of a class implementing the SPI.
*
* @exception DiscoveryException Thrown if the name of a class implementing
* the SPI cannot be found, if the class cannot be loaded and
* instantiated, or if the resulting class does not implement
* (or extend) the SPI.
*/
public static T find(Class spiClass) throws DiscoveryException {
return find(null,
new SPInterface(spiClass),
DiscoverClass.nullProperties,
(DefaultClassHolder) null);
}
/**
* Find implementation of SPI.
*
* @param Service Provider Interface type
*
* @param spiClass Service Provider Interface Class.
*
* @param properties Used to determine name of SPI implementation,
* and passed to implementation.init() method if
* implementation implements Service interface.
*
* @return Instance of a class implementing the SPI.
*
* @exception DiscoveryException Thrown if the name of a class implementing
* the SPI cannot be found, if the class cannot be loaded and
* instantiated, or if the resulting class does not implement
* (or extend) the SPI.
*/
public static T find(Class spiClass, Properties properties) throws DiscoveryException {
return find(null,
new SPInterface(spiClass),
new PropertiesHolder(properties),
(DefaultClassHolder) null);
}
/**
* Find implementation of SPI.
*
* @param Service Provider Interface type
*
* @param spiClass Service Provider Interface Class.
*
* @param defaultImpl Default implementation.
*
* @return Instance of a class implementing the SPI.
*
* @exception DiscoveryException Thrown if the name of a class implementing
* the SPI cannot be found, if the class cannot be loaded and
* instantiated, or if the resulting class does not implement
* (or extend) the SPI.
*/
public static T find(Class spiClass, String defaultImpl) throws DiscoveryException {
return find(null,
new SPInterface(spiClass),
DiscoverClass.nullProperties,
new DefaultClassHolder(defaultImpl));
}
/**
* Find implementation of SPI.
*
* @param Service Provider Interface type
*
* @param spiClass Service Provider Interface Class.
*
* @param properties Used to determine name of SPI implementation,
* and passed to implementation.init() method if
* implementation implements Service interface.
*
* @param defaultImpl Default implementation.
*
* @return Instance of a class implementing the SPI.
*
* @exception DiscoveryException Thrown if the name of a class implementing
* the SPI cannot be found, if the class cannot be loaded and
* instantiated, or if the resulting class does not implement
* (or extend) the SPI.
*/
public static T find(Class spiClass,
Properties properties,
String defaultImpl) throws DiscoveryException {
return find(null,
new SPInterface(spiClass),
new PropertiesHolder(properties),
new DefaultClassHolder(defaultImpl));
}
/**
* Find implementation of SPI.
*
* @param Service Provider Interface type
*
* @param spiClass Service Provider Interface Class.
*
* @param propertiesFileName Used to determine name of SPI implementation,
* and passed to implementation.init() method if
* implementation implements Service interface.
*
* @param defaultImpl Default implementation.
*
* @return Instance of a class implementing the SPI.
*
* @exception DiscoveryException Thrown if the name of a class implementing
* the SPI cannot be found, if the class cannot be loaded and
* instantiated, or if the resulting class does not implement
* (or extend) the SPI.
*/
public static T find(Class spiClass,
String propertiesFileName,
String defaultImpl) throws DiscoveryException {
return find(null,
new SPInterface(spiClass),
new PropertiesHolder(propertiesFileName),
new DefaultClassHolder(defaultImpl));
}
/*************** FINDERS FOR USE IN FACTORY/HELPER METHODS ***************
*/
/**
* Find implementation of SPI.
*
* @param Service Provider Interface type
*
* @param loaders The {@code ClassLoader} holder
*
* @param spi Service Provider Interface Class.
*
* @param properties Used to determine name of SPI implementation,
* and passed to implementation.init() method if
* implementation implements Service interface.
*
* @param defaultImpl Default implementation.
*
* @return Instance of a class implementing the SPI.
*
* @exception DiscoveryException Thrown if the name of a class implementing
* the SPI cannot be found, if the class cannot be loaded and
* instantiated, or if the resulting class does not implement
* (or extend) the SPI.
*/
public static T find(ClassLoaders loaders,
SPInterface spi,
PropertiesHolder properties,
DefaultClassHolder defaultImpl) throws DiscoveryException {
ClassLoader contextLoader = JDKHooks.getJDKHooks().getThreadContextClassLoader();
@SuppressWarnings("unchecked") // spiName is assignable from stored object class
T obj = (T) get(contextLoader, spi.getSPName());
if (obj == null) {
try {
obj = DiscoverClass.newInstance(loaders, spi, properties, defaultImpl);
if (obj != null) {
put(contextLoader, spi.getSPName(), obj);
}
} catch (DiscoveryException de) {
throw de;
} catch (Exception e) {
throw new DiscoveryException("Unable to instantiate implementation class for " + spi.getSPName(), e);
}
}
return obj;
}
/********************** CACHE-MANAGEMENT SUPPORT **********************/
/**
* Release all internal references to previously created service
* instances associated with the current thread context class loader.
* The release() method is called for service instances that
* implement the Service interface.
*
* This is useful in environments like servlet containers,
* which implement application reloading by throwing away a ClassLoader.
* Dangling references to objects in that class loader would prevent
* garbage collection.
*/
public static synchronized void release() {
EnvironmentCache.release();
}
/**
* Release any internal references to a previously created service
* instance associated with the current thread context class loader.
* If the SPI instance implements Service, then call
* release().
*
* @param spiClass The previously created service
*/
public static synchronized void release(Class spiClass) {
Map spis = EnvironmentCache.get(JDKHooks.getJDKHooks().getThreadContextClassLoader());
if (spis != null) {
spis.remove(spiClass.getName());
}
}
/************************* SPI CACHE SUPPORT *************************
*
* Cache services by a 'key' unique to the requesting class/environment:
*
* When we 'release', it is expected that the caller of the 'release'
* have the same thread context class loader... as that will be used
* to identify all cached entries to be released.
*
* We will manage synchronization directly, so all caches are implemented
* as HashMap (unsynchronized).
*
* - ClassLoader::groupContext::SPI::Instance Cache
* Cache : HashMap
* Key : Thread Context Class Loader (ClassLoader).
* Value : groupContext::SPI Cache (HashMap).
*
* - groupContext::SPI::Instance Cache
* Cache : HashMap
* Key : groupContext (String).
* Value : SPI Cache (HashMap).
*
* - SPI::Instance Cache
* Cache : HashMap
* Key : SPI Class Name (String).
* Value : SPI Instance/Implementation (Object.
*/
/**
* Implements first two levels of the cache (loader & groupContext).
* Allows null keys, important as default groupContext is null.
*/
/**
* Get service keyed by spi & classLoader.
*
* @param classLoader The class loader as key to retrieve the related cache
* @param spiName The SPI class name
* @return The object instance associated to the given class loader/SPI name
*/
private static synchronized Object get(ClassLoader classLoader,
String spiName) {
Map spis = EnvironmentCache.get(classLoader);
if (spis != null) {
return spis.get(spiName);
}
return null;
}
/**
* Put service keyed by spi & classLoader.
*
* @param classLoader The {@link EnvironmentCache} key
* @param spiName The SPI class name
* @param service The SPI object reference
*/
private static synchronized void put(ClassLoader classLoader,
String spiName,
Object service) {
if (service != null) {
Map spis = EnvironmentCache.get(classLoader);
if (spis == null) {
spis = new HashMap(EnvironmentCache.smallHashSize);
EnvironmentCache.put(classLoader, spis);
}
spis.put(spiName, service);
}
}
}
commons-discovery-0.5/src/java/org/apache/commons/discovery/tools/DefaultClassHolder.java 0000644 0001750 0001750 00000006622 11546667004 031666 0 ustar drazzib drazzib /*
* 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 org.apache.commons.discovery.tools;
import org.apache.commons.discovery.ResourceClass;
import org.apache.commons.discovery.ResourceClassIterator;
import org.apache.commons.discovery.resource.classes.DiscoverClasses;
import org.apache.commons.discovery.resource.ClassLoaders;
/**
* Holder for a default class.
*
* Class may be specified by name (String) or class (Class).
* Using the holder complicates the users job, but minimized # of API's.
*/
public class DefaultClassHolder {
private Class defaultClass;
private final String defaultName;
/**
* Creates a new holder implementation given
* the input SPI implementation/extension class.
*
* @param Any type extends the SPI type
* @param defaultClass The hold class
*/
public DefaultClassHolder(Class defaultClass) {
this.defaultClass = defaultClass;
this.defaultName = defaultClass.getName();
}
/**
* Creates a new holder implementation given
* the input SPI implementation/extension class name.
*
* @param defaultName The hold class name
*/
public DefaultClassHolder(String defaultName) {
this.defaultClass = null;
this.defaultName = defaultName;
}
/**
* Returns the default class, loading it if necessary
* and verifying that it implements the SPI
* (this forces the check, no way out..).
*
* @param Any type extends the SPI type
* @param spi non-null SPI
* @param loaders Used only if class needs to be loaded.
* @return The default Class.
*/
public Class getDefaultClass(SPInterface spi, ClassLoaders loaders) {
if (defaultClass == null) {
DiscoverClasses classDiscovery = new DiscoverClasses(loaders);
ResourceClassIterator classes = classDiscovery.findResourceClasses(getDefaultName());
if (classes.hasNext()) {
ResourceClass info = classes.nextResourceClass();
try {
defaultClass = info.loadClass();
} catch (Exception e) {
// ignore
}
}
}
if (defaultClass != null) {
spi.verifyAncestory(defaultClass);
}
@SuppressWarnings("unchecked") // the SPInterface.verifyAncestory already asserted
Class returned = (Class) defaultClass;
return returned;
}
/**
* Returns the hold class name.
*
* @return The hold class name
*/
public String getDefaultName() {
return defaultName;
}
}
commons-discovery-0.5/src/java/org/apache/commons/discovery/tools/DiscoverClass.java 0000644 0001750 0001750 00000062112 11547423466 030721 0 ustar drazzib drazzib /*
* 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 org.apache.commons.discovery.tools;
import java.lang.reflect.InvocationTargetException;
import java.util.LinkedList;
import java.util.List;
import java.util.Properties;
import org.apache.commons.discovery.DiscoveryException;
import org.apache.commons.discovery.ResourceClass;
import org.apache.commons.discovery.ResourceClassIterator;
import org.apache.commons.discovery.ResourceNameIterator;
import org.apache.commons.discovery.resource.ClassLoaders;
import org.apache.commons.discovery.resource.classes.DiscoverClasses;
import org.apache.commons.discovery.resource.names.DiscoverServiceNames;
/**
*
Discover class that implements a given service interface,
* with discovery and configuration features similar to that employed
* by standard Java APIs such as JAXP.
*
*
*
In the context of this package, a service interface is defined by a
* Service Provider Interface (SPI). The SPI is expressed as a Java interface,
* abstract class, or (base) class that defines an expected programming
* interface.
*
*
*
DiscoverClass provides the find methods for locating a
* class that implements a service interface (SPI). Each form of
* find varies slightly, but they all perform the same basic
* function.
*
* The DiscoverClass.find methods proceed as follows:
*
*
*
* Get the name of an implementation class. The name is the first
* non-null value obtained from the following resources:
*
*
* The value of the (scoped) system property whose name is the same as
* the SPI's fully qualified class name (as given by SPI.class.getName()).
* The ScopedProperties class provides a way to bind
* properties by classloader, in a secure hierarchy similar in concept
* to the way classloader find class and resource files.
* See ScopedProperties for more details.
*
If the ScopedProperties are not set by users, then behaviour
* is equivalent to System.getProperty().
*
*
*
* The value of a Properties properties property, if provided
* as a parameter, whose name is the same as the SPI's fully qualifed class
* name (as given by SPI.class.getName()).
*
*
* The value obtained using the JDK1.3+ 'Service Provider' specification
* (http://java.sun.com/j2se/1.3/docs/guide/jar/jar.html) to locate a
* service named SPI.class.getName(). This is implemented
* internally, so there is not a dependency on JDK 1.3+.
*
*
*
*
* If the name of the implementation class is non-null, load that class.
* The class loaded is the first class loaded by the following sequence
* of class loaders:
*
*
Thread Context Class Loader
*
DiscoverSingleton's Caller's Class Loader
*
SPI's Class Loader
*
DiscoverSingleton's (this class or wrapper) Class Loader
*
System Class Loader
*
* An exception is thrown if the class cannot be loaded.
*
*
* If the name of the implementation class is null, AND the default
* implementation class name (defaultImpl) is null,
* then an exception is thrown.
*
*
* If the name of the implementation class is null, AND the default
* implementation class (defaultImpl) is non-null,
* then load the default implementation class. The class loaded is the
* first class loaded by the following sequence of class loaders:
*
*
SPI's Class Loader
*
DiscoverSingleton's (this class or wrapper) Class Loader
*
System Class Loader
*
*
* This limits the scope in which the default class loader can be found
* to the SPI, DiscoverSingleton, and System class loaders. The assumption here
* is that the default implementation is closely associated with the SPI
* or system, and is not defined in the user's application space.
*
*
* An exception is thrown if the class cannot be loaded.
*
*
*
* Verify that the loaded class implements the SPI: an exception is thrown
* if the loaded class does not implement the SPI.
*
*
*
*
*
IMPLEMENTATION NOTE - This implementation is modelled
* after the SAXParserFactory and DocumentBuilderFactory implementations
* (corresponding to the JAXP pluggability APIs) found in Apache Xerces.
*
*
* @version $Revision: 1090010 $ $Date: 2011-04-07 23:05:58 +0200 (jeu. 07 avril 2011) $
*/
public class DiscoverClass {
/**
* Readable placeholder for a null value.
*/
public static final PropertiesHolder nullProperties = null;
/**
* The class loaders holder.
*/
private final ClassLoaders classLoaders;
/**
* Create a class instance with dynamic environment
* (thread context class loader is determined on each call).
*
* Dynamically construct class loaders on each call.
*/
public DiscoverClass() {
this(null);
}
/**
* Create a class instance with dynamic environment
* (thread context class loader is determined on each call).
*
* Cache static list of class loaders for each call.
*
* @param classLoaders The class loaders holder
*/
public DiscoverClass(ClassLoaders classLoaders) {
this.classLoaders = classLoaders;
}
/**
* Return the class loaders holder for the given SPI.
*
* @param spiClass The SPI type
* @return The class loaders holder for the given SPI
*/
public ClassLoaders getClassLoaders(@SuppressWarnings("unused") Class spiClass) {
return classLoaders;
}
/**
* Find class implementing SPI.
*
* @param The SPI type
* @param Any class extending T
* @param spiClass Service Provider Interface Class.
* @return Class implementing the SPI.
* @exception DiscoveryException Thrown if the name of a class implementing
* the SPI cannot be found, if the class cannot be loaded, or if
* the resulting class does not implement (or extend) the SPI.
*/
public Class find(Class spiClass) throws DiscoveryException {
return find(getClassLoaders(spiClass),
new SPInterface(spiClass),
nullProperties,
(DefaultClassHolder) null);
}
/**
* Find class implementing SPI.
*
* @param The SPI type
* @param Any class extending T
* @param spiClass Service Provider Interface Class.
* @param properties Used to determine name of SPI implementation.
* @return Class implementing the SPI.
* @exception DiscoveryException Thrown if the name of a class implementing
* the SPI cannot be found, if the class cannot be loaded, or if
* the resulting class does not implement (or extend) the SPI.
*/
public Class find(Class spiClass, Properties properties) throws DiscoveryException {
return find(getClassLoaders(spiClass),
new SPInterface(spiClass),
new PropertiesHolder(properties),
(DefaultClassHolder) null);
}
/**
* Find class implementing SPI.
*
* @param The SPI type
* @param Any class extending T
* @param spiClass Service Provider Interface Class.
* @param defaultImpl Default implementation name.
* @return Class implementing the SPI.
* @exception DiscoveryException Thrown if the name of a class implementing
* the SPI cannot be found, if the class cannot be loaded, or if
* the resulting class does not implement (or extend) the SPI.
*/
public Class find(Class spiClass, String defaultImpl) throws DiscoveryException {
return find(getClassLoaders(spiClass),
new SPInterface(spiClass),
nullProperties,
new DefaultClassHolder(defaultImpl));
}
/**
* Find class implementing SPI.
*
* @param The SPI type
* @param Any class extending T
* @param spiClass Service Provider Interface Class.
* @param properties Used to determine name of SPI implementation,.
* @param defaultImpl Default implementation class.
* @return Class implementing the SPI.
* @exception DiscoveryException Thrown if the name of a class implementing
* the SPI cannot be found, if the class cannot be loaded, or if
* the resulting class does not implement (or extend) the SPI.
*/
public Class find(Class spiClass, Properties properties, String defaultImpl)
throws DiscoveryException {
return find(getClassLoaders(spiClass),
new SPInterface(spiClass),
new PropertiesHolder(properties),
new DefaultClassHolder(defaultImpl));
}
/**
* Find class implementing SPI.
*
* @param The SPI type
* @param Any class extending T
* @param spiClass Service Provider Interface Class.
* @param propertiesFileName Used to determine name of SPI implementation,.
* @param defaultImpl Default implementation class.
* @return Class implementing the SPI.
* @exception DiscoveryException Thrown if the name of a class implementing
* the SPI cannot be found, if the class cannot be loaded, or if
* the resulting class does not implement (or extend) the SPI.
*/
public Class find(Class spiClass, String propertiesFileName, String defaultImpl)
throws DiscoveryException {
return find(getClassLoaders(spiClass),
new SPInterface(spiClass),
new PropertiesHolder(propertiesFileName),
new DefaultClassHolder(defaultImpl));
}
/**
* Find class implementing SPI.
*
* @param The SPI type
* @param Any class extending T
* @param loaders The class loaders holder
* @param spi Service Provider Interface Class.
* @param properties Used to determine name of SPI implementation,.
* @param defaultImpl Default implementation class.
* @return Class implementing the SPI.
* @exception DiscoveryException Thrown if the name of a class implementing
* the SPI cannot be found, if the class cannot be loaded, or if
* the resulting class does not implement (or extend) the SPI.
*/
public static Class find(ClassLoaders loaders,
SPInterface spi,
PropertiesHolder properties,
DefaultClassHolder defaultImpl) throws DiscoveryException {
if (loaders == null) {
loaders = ClassLoaders.getLibLoaders(spi.getSPClass(),
DiscoverClass.class,
true);
}
Properties props = (properties == null)
? null
: properties.getProperties(spi, loaders);
String[] classNames = discoverClassNames(spi, props);
Exception error = null;
if (classNames.length > 0) {
DiscoverClasses classDiscovery = new DiscoverClasses(loaders);
for (String className : classNames) {
ResourceClassIterator classes =
classDiscovery.findResourceClasses(className);
// If it's set as a property.. it had better be there!
if (classes.hasNext()) {
ResourceClass info = classes.nextResourceClass();
try {
return info.loadClass();
} catch (Exception e) {
error = e;
}
}
}
} else {
ResourceNameIterator classIter =
(new DiscoverServiceNames(loaders)).findResourceNames(spi.getSPName());
ResourceClassIterator classes =
(new DiscoverClasses(loaders)).findResourceClasses(classIter);
if (!classes.hasNext() && defaultImpl != null) {
return defaultImpl.getDefaultClass(spi, loaders);
}
// Services we iterate through until we find one that loads..
while (classes.hasNext()) {
ResourceClass info = classes.nextResourceClass();
try {
return info.loadClass();
} catch (Exception e) {
error = e;
}
}
}
throw new DiscoveryException("No implementation defined for " + spi.getSPName(), error);
// return null;
}
/**
* Create new instance of class implementing SPI.
*
* @param The SPI type
* @param spiClass Service Provider Interface Class.
* @return Instance of a class implementing the SPI.
* @exception DiscoveryException Thrown if the name of a class implementing
* the SPI cannot be found, if the class cannot be loaded and
* instantiated, or if the resulting class does not implement
* (or extend) the SPI.
* @throws InstantiationException see {@link Class#newInstance()}
* @throws IllegalAccessException see {@link Class#newInstance()}
* @throws NoSuchMethodException see {@link Class#newInstance()}
* @throws InvocationTargetException see {@link Class#newInstance()}
*/
public T newInstance(Class spiClass)
throws DiscoveryException,
InstantiationException,
IllegalAccessException,
NoSuchMethodException,
InvocationTargetException {
return newInstance(getClassLoaders(spiClass),
new SPInterface(spiClass),
nullProperties,
(DefaultClassHolder) null);
}
/**
* Create new instance of class implementing SPI.
*
* @param The SPI type
* @param spiClass Service Provider Interface Class.
* @param properties Used to determine name of SPI implementation,
* and passed to implementation.init() method if
* implementation implements Service interface.
* @return Instance of a class implementing the SPI.
* @exception DiscoveryException Thrown if the name of a class implementing
* the SPI cannot be found, if the class cannot be loaded and
* instantiated, or if the resulting class does not implement
* (or extend) the SPI.
* @throws InstantiationException see {@link Class#newInstance()}
* @throws IllegalAccessException see {@link Class#newInstance()}
* @throws NoSuchMethodException see {@link Class#newInstance()}
* @throws InvocationTargetException see {@link Class#newInstance()}
*/
public T newInstance(Class spiClass, Properties properties) throws DiscoveryException,
InstantiationException,
IllegalAccessException,
NoSuchMethodException,
InvocationTargetException {
return newInstance(getClassLoaders(spiClass),
new SPInterface(spiClass),
new PropertiesHolder(properties),
(DefaultClassHolder) null);
}
/**
* Create new instance of class implementing SPI.
*
* @param The SPI type
* @param spiClass Service Provider Interface Class.
* @param defaultImpl Default implementation.
* @return Instance of a class implementing the SPI.
* @exception DiscoveryException Thrown if the name of a class implementing
* the SPI cannot be found, if the class cannot be loaded and
* instantiated, or if the resulting class does not implement
* (or extend) the SPI.
* @throws InstantiationException see {@link Class#newInstance()}
* @throws IllegalAccessException see {@link Class#newInstance()}
* @throws NoSuchMethodException see {@link Class#newInstance()}
* @throws InvocationTargetException see {@link Class#newInstance()}
*/
public T newInstance(Class spiClass, String defaultImpl) throws DiscoveryException,
InstantiationException,
IllegalAccessException,
NoSuchMethodException,
InvocationTargetException {
return newInstance(getClassLoaders(spiClass),
new SPInterface(spiClass),
nullProperties,
new DefaultClassHolder(defaultImpl));
}
/**
* Create new instance of class implementing SPI.
*
* @param The SPI type
* @param spiClass Service Provider Interface Class.
* @param properties Used to determine name of SPI implementation,
* and passed to implementation.init() method if
* implementation implements Service interface.
* @param defaultImpl Default implementation.
* @return Instance of a class implementing the SPI.
* @exception DiscoveryException Thrown if the name of a class implementing
* the SPI cannot be found, if the class cannot be loaded and
* instantiated, or if the resulting class does not implement
* (or extend) the SPI.
* @throws InstantiationException see {@link Class#newInstance()}
* @throws IllegalAccessException see {@link Class#newInstance()}
* @throws NoSuchMethodException see {@link Class#newInstance()}
* @throws InvocationTargetException see {@link Class#newInstance()}
*/
public T newInstance(Class spiClass, Properties properties, String defaultImpl) throws DiscoveryException,
InstantiationException,
IllegalAccessException,
NoSuchMethodException,
InvocationTargetException {
return newInstance(getClassLoaders(spiClass),
new SPInterface(spiClass),
new PropertiesHolder(properties),
new DefaultClassHolder(defaultImpl));
}
/**
* Create new instance of class implementing SPI.
*
* @param The SPI type
* @param spiClass Service Provider Interface Class.
* @param propertiesFileName Used to determine name of SPI implementation,
* and passed to implementation.init() method if
* implementation implements Service interface.
* @param defaultImpl Default implementation.
* @return Instance of a class implementing the SPI.
* @exception DiscoveryException Thrown if the name of a class implementing
* the SPI cannot be found, if the class cannot be loaded and
* instantiated, or if the resulting class does not implement
* (or extend) the SPI.
* @throws InstantiationException see {@link Class#newInstance()}
* @throws IllegalAccessException see {@link Class#newInstance()}
* @throws NoSuchMethodException see {@link Class#newInstance()}
* @throws InvocationTargetException see {@link Class#newInstance()}
*/
public T newInstance(Class spiClass, String propertiesFileName, String defaultImpl)
throws DiscoveryException,
InstantiationException,
IllegalAccessException,
NoSuchMethodException,
InvocationTargetException {
return newInstance(getClassLoaders(spiClass),
new SPInterface(spiClass),
new PropertiesHolder(propertiesFileName),
new DefaultClassHolder(defaultImpl));
}
/**
* Create new instance of class implementing SPI.
*
* @param The SPI type
* @param loaders The class loaders holder
* @param spi Service Provider Interface Class.
* @param properties Used to determine name of SPI implementation,
* and passed to implementation.init() method if
* implementation implements Service interface.
* @param defaultImpl Default implementation.
* @return Instance of a class implementing the SPI.
* @exception DiscoveryException Thrown if the name of a class implementing
* the SPI cannot be found, if the class cannot be loaded and
* instantiated, or if the resulting class does not implement
* (or extend) the SPI.
* @throws InstantiationException see {@link Class#newInstance()}
* @throws IllegalAccessException see {@link Class#newInstance()}
* @throws NoSuchMethodException see {@link Class#newInstance()}
* @throws InvocationTargetException see {@link Class#newInstance()}
*/
public static T newInstance(ClassLoaders loaders,
SPInterface spi,
PropertiesHolder properties,
DefaultClassHolder defaultImpl) throws DiscoveryException,
InstantiationException,
IllegalAccessException,
NoSuchMethodException,
InvocationTargetException {
return spi.newInstance(find(loaders, spi, properties, defaultImpl));
}
/**
*
Discover names of SPI implementation Classes from properties.
* The names are the non-null values, in order, obtained from the following
* resources:
*
*
ManagedProperty.getProperty(SPI.class.getName());
*
properties.getProperty(SPI.class.getName());
*
*
* @param The SPI type
* @param spi The SPI representation
* @param properties Properties that may define the implementation
* class name(s).
* @return String[] Name of classes implementing the SPI.
* @exception DiscoveryException Thrown if the name of a class implementing
* the SPI cannot be found.
*/
public static String[] discoverClassNames(SPInterface spi,
Properties properties) {
List names = new LinkedList();
String spiName = spi.getSPName();
String propertyName = spi.getPropertyName();
boolean includeAltProperty = !spiName.equals(propertyName);
// Try the (managed) system property spiName
String className = getManagedProperty(spiName);
if (className != null) {
names.add(className);
}
if (includeAltProperty) {
// Try the (managed) system property propertyName
className = getManagedProperty(propertyName);
if (className != null) {
names.add(className);
}
}
if (properties != null) {
// Try the properties parameter spiName
className = properties.getProperty(spiName);
if (className != null) {
names.add(className);
}
if (includeAltProperty) {
// Try the properties parameter propertyName
className = properties.getProperty(propertyName);
if (className != null) {
names.add(className);
}
}
}
String[] results = new String[names.size()];
names.toArray(results);
return results;
}
/**
* Load the class whose name is given by the value of a (Managed)
* System Property.
*
* @param propertyName the name of the system property whose value is
* the name of the class to load.
* @return The managed property value
* @see ManagedProperties
*/
public static String getManagedProperty(String propertyName) {
String value;
try {
value = ManagedProperties.getProperty(propertyName);
} catch (SecurityException e) {
value = null;
}
return value;
}
}
commons-discovery-0.5/src/java/org/apache/commons/discovery/tools/ManagedProperties.java 0000644 0001750 0001750 00000033703 11547002043 031552 0 ustar drazzib drazzib /*
* 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 org.apache.commons.discovery.tools;
import java.security.AccessController;
import java.security.PrivilegedAction;
import java.util.Collections;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.Map;
import java.util.Properties;
import org.apache.commons.discovery.jdk.JDKHooks;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
/**
*
This class may disappear in the future, or be moved to another project..
*
*
*
Extend the concept of System properties to a hierarchical scheme
* based around class loaders. System properties are global in nature,
* so using them easily violates sound architectural and design principles
* for maintaining separation between components and runtime environments.
* Nevertheless, there is a need for properties broader in scope than
* class or class instance scope.
*
*
*
This class is one solution.
*
*
*
Manage properties according to a secure
* scheme similar to that used by classloaders:
*
*
ClassLoaders are organized in a tree hierarchy.
*
each ClassLoader has a reference
* to a parent ClassLoader.
*
the root of the tree is the bootstrap ClassLoaderer.
*
the youngest decendent is the thread context class loader.
*
properties are bound to a ClassLoader instance
*
*
non-default properties bound to a parent ClassLoader
* instance take precedence over all properties of the same name bound
* to any decendent.
* Just to confuse the issue, this is the default case.
*
default properties bound to a parent ClassLoader
* instance may be overriden by (default or non-default) properties of
* the same name bound to any decendent.
*
*
*
*
System properties take precedence over all other properties
*
*
*
*
This is not a perfect solution, as it is possible that
* different ClassLoaders load different instances of
* ScopedProperties. The 'higher' this class is loaded
* within the ClassLoader hierarchy, the more usefull
* it will be.
*
*/
public class ManagedProperties {
private static Log log = LogFactory.getLog(ManagedProperties.class);
/**
* Sets the {@code Log} for this class.
*
* @param _log This class {@code Log}
* @deprecated This method is not thread-safe
*/
@Deprecated
public static void setLog(Log _log) {
log = _log;
}
/**
* Cache of Properties, keyed by (thread-context) class loaders.
* Use HashMap because it allows 'null' keys, which
* allows us to account for the (null) bootstrap classloader.
*/
private static final Map> propertiesCache =
new HashMap>();
/**
* Get value for property bound to the current thread context class loader.
*
* @param propertyName property name.
* @return property value if found, otherwise default.
*/
public static String getProperty(String propertyName) {
return getProperty(getThreadContextClassLoader(), propertyName);
}
/**
* Get value for property bound to the current thread context class loader.
* If not found, then return default.
*
* @param propertyName property name.
* @param dephault default value.
* @return property value if found, otherwise default.
*/
public static String getProperty(String propertyName, String dephault) {
return getProperty(getThreadContextClassLoader(), propertyName, dephault);
}
/**
* Get value for property bound to the class loader.
*
* @param classLoader The classloader used to load resources.
* @param propertyName property name.
* @return property value if found, otherwise default.
*/
public static String getProperty(ClassLoader classLoader, String propertyName) {
String value = JDKHooks.getJDKHooks().getSystemProperty(propertyName);
if (value == null) {
Value val = getValueProperty(classLoader, propertyName);
if (val != null) {
value = val.value;
}
} else if (log.isDebugEnabled()) {
log.debug("found System property '" + propertyName + "'" +
" with value '" + value + "'.");
}
return value;
}
/**
* Get value for property bound to the class loader.
* If not found, then return default.
*
* @param classLoader The classloader used to load resources.
* @param propertyName property name.
* @param dephault default value.
* @return property value if found, otherwise default.
*/
public static String getProperty(ClassLoader classLoader, String propertyName, String dephault) {
String value = getProperty(classLoader, propertyName);
return (value == null) ? dephault : value;
}
/**
* Set value for property bound to the current thread context class loader.
* @param propertyName property name
* @param value property value (non-default) If null, remove the property.
*/
public static void setProperty(String propertyName, String value) {
setProperty(propertyName, value, false);
}
/**
* Set value for property bound to the current thread context class loader.
* @param propertyName property name
* @param value property value. If null, remove the property.
* @param isDefault determines if property is default or not.
* A non-default property cannot be overriden.
* A default property can be overriden by a property
* (default or non-default) of the same name bound to
* a decendent class loader.
*/
public static void setProperty(String propertyName, String value, boolean isDefault) {
if (propertyName != null) {
synchronized (propertiesCache) {
ClassLoader classLoader = getThreadContextClassLoader();
Map properties = propertiesCache.get(classLoader);
if (value == null) {
if (properties != null) {
properties.remove(propertyName);
}
} else {
if (properties == null) {
properties = new HashMap();
propertiesCache.put(classLoader, properties);
}
properties.put(propertyName, new Value(value, isDefault));
}
}
}
}
/**
* Set property values for Properties bound to the
* current thread context class loader.
*
* @param newProperties name/value pairs to be bound
*/
public static void setProperties(Map newProperties) {
setProperties(newProperties, false);
}
/**
* Set property values for Properties bound to the
* current thread context class loader.
*
* @param newProperties name/value pairs to be bound
* @param isDefault determines if properties are default or not.
* A non-default property cannot be overriden.
* A default property can be overriden by a property
* (default or non-default) of the same name bound to
* a decendent class loader.
*/
public static void setProperties(Map newProperties, boolean isDefault) {
/**
* Each entry must be mapped to a Property.
* 'setProperty' does this for us.
*/
for (Map.Entry entry : newProperties.entrySet()) {
setProperty( String.valueOf(entry.getKey()),
String.valueOf(entry.getValue()),
isDefault);
}
}
/**
* Return list of all property names. This is an expensive
* operation: ON EACH CALL it walks through all property lists
* associated with the current context class loader upto
* and including the bootstrap class loader.
*
* @return The list of all property names
*/
public static Enumeration propertyNames() {
Map allProps = new Hashtable();
ClassLoader classLoader = getThreadContextClassLoader();
/**
* Order doesn't matter, we are only going to use
* the set of all keys...
*/
while (true) {
Map properties = null;
synchronized (propertiesCache) {
properties = propertiesCache.get(classLoader);
}
if (properties != null) {
allProps.putAll(properties);
}
if (classLoader == null) {
break;
}
classLoader = getParent(classLoader);
}
return Collections.enumeration(allProps.keySet());
}
/**
* This is an expensive operation.
* ON EACH CALL it walks through all property lists
* associated with the current context class loader upto
* and including the bootstrap class loader.
*
* @return Returns a java.util.Properties instance
* that is equivalent to the current state of the scoped
* properties, in that getProperty() will return the same value.
* However, this is a copy, so setProperty on the
* returned value will not effect the scoped properties.
*/
public static Properties getProperties() {
Properties p = new Properties();
Enumeration names = propertyNames();
while (names.hasMoreElements()) {
String name = names.nextElement();
p.put(name, getProperty(name));
}
return p;
}
/***************** INTERNAL IMPLEMENTATION *****************/
private static class Value {
final String value;
final boolean isDefault;
/**
* Creates a new Value instance with string value and
* the flag to mark is default value or not.
*
* @param value String representation of this value
* @param isDefault The default flag
*/
Value(String value, boolean isDefault) {
this.value = value;
this.isDefault = isDefault;
}
}
/**
* Get value for properties bound to the class loader.
* Explore up the tree first, as higher-level class
* loaders take precedence over lower-level class loaders.
*
*
* @param classLoader The class loader as key
* @param propertyName The property name to lookup
* @return The Value associated to the input class loader and property name
*/
private static final Value getValueProperty(ClassLoader classLoader, String propertyName) {
Value value = null;
if (propertyName != null) {
/**
* If classLoader isn't bootstrap loader (==null),
* then get up-tree value.
*/
if (classLoader != null) {
value = getValueProperty(getParent(classLoader), propertyName);
}
if (value == null || value.isDefault) {
synchronized (propertiesCache) {
Map properties = propertiesCache.get(classLoader);
if (properties != null) {
Value altValue = properties.get(propertyName);
// set value only if override exists..
// otherwise pass default (or null) on..
if (altValue != null) {
value = altValue;
if (log.isDebugEnabled()) {
log.debug("found Managed property '" + propertyName + "'" +
" with value '" + value + "'" +
" bound to classloader " + classLoader + ".");
}
}
}
}
}
}
return value;
}
/**
* Returns the thread context class loader.
*
* @return The thread context class loader
*/
private static final ClassLoader getThreadContextClassLoader() {
return JDKHooks.getJDKHooks().getThreadContextClassLoader();
}
/**
* Return the parent class loader of the given class loader.
*
* @param classLoader The class loader from wich the parent has to be extracted
* @return The parent class loader of the given class loader
*/
private static final ClassLoader getParent(final ClassLoader classLoader) {
return AccessController.doPrivileged(new PrivilegedAction() {
public ClassLoader run() {
try {
return classLoader.getParent();
} catch (SecurityException se){
return null;
}
}
});
}
}
commons-discovery-0.5/src/java/org/apache/commons/discovery/tools/PropertiesHolder.java 0000644 0001750 0001750 00000005316 11546615411 031442 0 ustar drazzib drazzib /*
* 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 org.apache.commons.discovery.tools;
import java.util.Properties;
import org.apache.commons.discovery.resource.ClassLoaders;
/**
* Holder for a default class.
*
* Class may be specified by name (String) or class (Class).
* Using the holder complicates the users job, but minimized # of API's.
*/
public class PropertiesHolder {
private Properties properties;
private final String propertiesFileName;
/**
* Creates a new {@code PropertiesHolder} instance given an
* already load {@code Properties} set.
*
* @param properties The already load {@code Properties} set
*/
public PropertiesHolder(Properties properties) {
this.properties = properties;
this.propertiesFileName = null;
}
/**
* Creates a new {@code PropertiesHolder} instance given a
* property file name.
*
* @param propertiesFileName The property file name
*/
public PropertiesHolder(String propertiesFileName) {
this.properties = null;
this.propertiesFileName = propertiesFileName;
}
/**
* Returns the {@code Properties} instance, loaded if necessary from {@code propertiesFileName}.
*
* @param spi Optional SPI (may be null).
* If provided, an attempt is made to load the
* property file as-per Class.getResource().
*
* @param loaders Used only if properties need to be loaded.
*
* @return The {@code Properties}, loaded if necessary.
*/
public Properties getProperties(SPInterface spi, ClassLoaders loaders) {
if (properties == null) {
properties = ResourceUtils.loadProperties(spi.getSPClass(), getPropertiesFileName(), loaders);
}
return properties;
}
/**
* Returns the property file name
*
* @return The property file name
*/
public String getPropertiesFileName() {
return propertiesFileName;
}
}
commons-discovery-0.5/src/java/org/apache/commons/discovery/tools/EnvironmentCache.java 0000644 0001750 0001750 00000010611 11546617175 031403 0 ustar drazzib drazzib /*
* 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 org.apache.commons.discovery.tools;
import java.util.HashMap;
import java.util.Map;
import org.apache.commons.discovery.jdk.JDKHooks;
/**
* Cache by a 'key' unique to the environment:
*
* - ClassLoader::groupContext::Object Cache
* Cache : HashMap
* Key : Thread Context Class Loader (ClassLoader)
* Value : groupContext::SPI Cache (HashMap)
*
* //- groupContext::Object Cache
* // Cache : HashMap
* // Key : groupContext (String)
* // Value : Object
*
* When we 'release', it is expected that the caller of the 'release'
* have the same thread context class loader... as that will be used
* to identify cached entries to be released.
*/
public class EnvironmentCache {
/**
* Allows null key, important as default groupContext is null.
*
* We will manage synchronization directly, so all caches are implemented
* as HashMap (unsynchronized).
*/
private static final Map> root_cache =
new HashMap>();
/**
* Initial hash size for SPI's, default just seem TO big today..
*/
public static final int smallHashSize = 13;
/**
* Get object keyed by classLoader.
*
* @param classLoader The class loader key
* @return The SPI name/instance cache
*/
public static synchronized Map get(ClassLoader classLoader) {
/*
* 'null' (bootstrap/system class loader) thread context class loader
* is ok... Until we learn otherwise.
*/
return root_cache.get(classLoader);
}
/**
* Put service keyed by spi & classLoader.
*
* @param classLoader The class loader key
* @param spis The SPI name/instance cache
*/
public static synchronized void put(ClassLoader classLoader, Map spis) {
/*
* 'null' (bootstrap/system class loader) thread context class loader
* is ok... Until we learn otherwise.
*/
if (spis != null) {
root_cache.put(classLoader, spis);
}
}
/********************** CACHE-MANAGEMENT SUPPORT **********************/
/**
* Release all internal references to previously created service
* instances associated with the current thread context class loader.
* The release() method is called for service instances that
* implement the Service interface.
*
* This is useful in environments like servlet containers,
* which implement application reloading by throwing away a ClassLoader.
* Dangling references to objects in that class loader would prevent
* garbage collection.
*/
public static synchronized void release() {
/*
* 'null' (bootstrap/system class loader) thread context class loader
* is ok... Until we learn otherwise.
*/
root_cache.remove(JDKHooks.getJDKHooks().getThreadContextClassLoader());
}
/**
* Release any internal references to a previously created service
* instance associated with the current thread context class loader.
* If the SPI instance implements Service, then call
* release().
*
* @param classLoader The class loader key
*/
public static synchronized void release(ClassLoader classLoader) {
/*
* 'null' (bootstrap/system class loader) thread context class loader
* is ok... Until we learn otherwise.
*/
root_cache.remove(classLoader);
}
}
commons-discovery-0.5/src/java/org/apache/commons/discovery/tools/SPInterface.java 0000644 0001750 0001750 00000021470 11550133124 030301 0 ustar drazzib drazzib /*
* 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 org.apache.commons.discovery.tools;
import java.lang.reflect.InvocationTargetException;
import org.apache.commons.discovery.DiscoveryException;
/**
* Represents a Service Programming Interface (spi).
* - SPI's name
* - SPI's (provider) class
* - SPI's (alternate) override property name
*
* In addition, while there are many cases where this is NOT
* usefull, for those in which it is:
*
* - expected constructor argument types and parameters values.
*
* @param The SPI type
*/
public class SPInterface {
/**
* Construct object representing Class {@code provider}.
*
* @param The SPI type
* @param provider The SPI class
* @return A new object representing Class {@code provider}
* @since 0.5
*/
public static SPInterface newSPInterface(Class provider) {
return newSPInterface(provider, provider.getName());
}
/**
* Construct object representing Class {@code provider}.
*
* @param The SPI type
* @param provider The SPI class
* @param propertyName when looking for the name of a class implementing
* the provider class, a discovery strategy may involve looking for
* (system or other) properties having either the name of the class
* (provider) or the propertyName.
* @return A new object representing Class {@code provider}
* @since 0.5
*/
public static SPInterface newSPInterface(Class provider, String propertyName) {
return new SPInterface(provider, propertyName);
}
/**
* Construct object representing Class {@code provider}.
*
* @param The SPI type
* @param provider The SPI class
* @param constructorParamClasses classes representing the
* constructor argument types
* @param constructorParams objects representing the
* constructor arguments
* @return A new object representing Class {@code provider}
* @since 0.5
*/
public static SPInterface newSPInterface(Class provider,
Class constructorParamClasses[],
Object constructorParams[]) {
return newSPInterface(provider, provider.getName(), constructorParamClasses, constructorParams);
}
/**
* Construct object representing Class {@code provider}.
*
* @param The SPI type
* @param provider The SPI class
* @param propertyName when looking for the name of a class implementing
* the provider class, a discovery strategy may involve looking for
* (system or other) properties having either the name of the class
* (provider) or the propertyName.
* @param constructorParamClasses classes representing the
* constructor argument types
* @param constructorParams objects representing the
* constructor arguments
* @return A new object representing Class {@code provider}
* @since 0.5
*/
public static SPInterface newSPInterface(Class provider,
String propertyName,
Class constructorParamClasses[],
Object constructorParams[]) {
return new SPInterface(provider, propertyName, constructorParamClasses, constructorParams);
}
/**
* The service programming interface: intended to be
* an interface or abstract class, but not limited
* to those two.
*/
private final Class spi;
/**
* The property name to be used for finding the name of
* the SPI implementation class.
*/
private final String propertyName;
private final Class paramClasses[];
private final Object params[];
/**
* Construct object representing Class provider.
*
* @param provider The SPI class
*/
public SPInterface(Class provider) {
this(provider, provider.getName());
}
/**
* Construct object representing Class provider.
*
* @param spi The SPI class
*
* @param propertyName when looking for the name of a class implementing
* the provider class, a discovery strategy may involve looking for
* (system or other) properties having either the name of the class
* (provider) or the propertyName.
*/
public SPInterface(Class spi, String propertyName) {
this.spi = spi;
this.propertyName = propertyName;
this.paramClasses = null;
this.params = null;
}
/**
* Construct object representing Class provider.
*
* @param provider The SPI class
*
* @param constructorParamClasses classes representing the
* constructor argument types.
*
* @param constructorParams objects representing the
* constructor arguments.
*/
public SPInterface(Class provider,
Class constructorParamClasses[],
Object constructorParams[]) {
this(provider,
provider.getName(),
constructorParamClasses,
constructorParams);
}
/**
* Construct object representing Class provider.
*
* @param spi The SPI class
*
* @param propertyName when looking for the name of a class implementing
* the provider class, a discovery strategy may involve looking for
* (system or other) properties having either the name of the class
* (provider) or the propertyName.
*
* @param constructorParamClasses classes representing the
* constructor argument types.
*
* @param constructorParams objects representing the
* constructor arguments.
*/
public SPInterface(Class spi,
String propertyName,
Class constructorParamClasses[],
Object constructorParams[]) {
this.spi = spi;
this.propertyName = propertyName;
this.paramClasses = constructorParamClasses;
this.params = constructorParams;
}
/**
* Returns the SPI class name.
*
* @return The SPI class name
*/
public String getSPName() {
return spi.getName();
}
/**
* Returns the SPI class.
*
* @return The SPI class
*/
public Class getSPClass() {
return spi;
}
/**
* Returns the property name to be used for finding
* the name of the SPI implementation class.
*
* @return The property name to be used for finding
* the name of the SPI implementation class
*/
public String getPropertyName() {
return propertyName;
}
/**
* Creates a new instance of the given SPI class.
*
* @param Any type extends T
* @param impl The SPI class has to be instantiated
* @return A new instance of the given SPI class
* @throws DiscoveryException if the class implementing
* the SPI cannot be found, cannot be loaded and
* instantiated, or if the resulting class does not implement
* (or extend) the SPI
* @throws InstantiationException see {@link Class#newInstance()}
* @throws IllegalAccessException see {@link Class#newInstance()}
* @throws NoSuchMethodException see {@link Class#newInstance()}
* @throws InvocationTargetException see {@link Class#newInstance()}
*/
public S newInstance(Class impl)
throws DiscoveryException,
InstantiationException,
IllegalAccessException,
NoSuchMethodException,
InvocationTargetException {
verifyAncestory(impl);
return ClassUtils.newInstance(impl, paramClasses, params);
}
/**
* Verifies the given SPI implementation is a SPI specialization.
*
* @param Any type extends T
* @param impl The SPI instantance
*/
public void verifyAncestory(Class impl) {
ClassUtils.verifyAncestory(spi, impl);
}
}
commons-discovery-0.5/src/java/org/apache/commons/discovery/tools/Service.java 0000644 0001750 0001750 00000011021 11550164115 027531 0 ustar drazzib drazzib /*
* 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 org.apache.commons.discovery.tools;
import java.util.Enumeration;
import java.util.NoSuchElementException;
import org.apache.commons.discovery.ResourceClass;
import org.apache.commons.discovery.ResourceClassIterator;
import org.apache.commons.discovery.ResourceNameIterator;
import org.apache.commons.discovery.resource.ClassLoaders;
import org.apache.commons.discovery.resource.classes.DiscoverClasses;
import org.apache.commons.discovery.resource.names.DiscoverServiceNames;
/**
* [this was ServiceDiscovery12... the 1.1 versus 1.2 issue
* has been abstracted to org.apache.commons.discover.jdk.JDKHooks]
*
*
*
* This class supports any VM, including JDK1.1, via
* org.apache.commons.discover.jdk.JDKHooks.
*
* The caller will first configure the discoverer by adding ( in the desired
* order ) all the places to look for the META-INF/services. Currently
* we support loaders.
*
* The findResources() method will check every loader.
*/
public class Service {
/**
* Construct a new service discoverer
*/
protected Service() {
}
/**
* as described in
* sun/jdk1.3.1/docs/guide/jar/jar.html#Service Provider,
* Except this uses Enumeration
* instead of Interator.
*
* @param Service Provider Interface type
* @param Any type extends the SPI type
* @param spiClass Service Provider Interface Class
* @return Enumeration of class instances ({@code S})
*/
public static Enumeration providers(Class spiClass) {
return providers(new SPInterface(spiClass), null);
}
/**
* This version lets you specify constructor arguments..
*
* @param Service Provider Interface type
* @param Any type extends the SPI type
* @param spi SPI to look for and load.
* @param loaders loaders to use in search.
* If null then use ClassLoaders.getAppLoaders().
* @return Enumeration of class instances ({@code S})
*/
public static Enumeration providers(final SPInterface spi,
ClassLoaders loaders) {
if (loaders == null) {
loaders = ClassLoaders.getAppLoaders(spi.getSPClass(),
Service.class,
true);
}
ResourceNameIterator servicesIter =
(new DiscoverServiceNames(loaders)).findResourceNames(spi.getSPName());
final ResourceClassIterator services =
(new DiscoverClasses(loaders)).findResourceClasses(servicesIter);
return new Enumeration() {
private S object = getNextClassInstance();
public boolean hasMoreElements() {
return object != null;
}
public S nextElement() {
if (object == null) {
throw new NoSuchElementException();
}
S obj = object;
object = getNextClassInstance();
return obj;
}
private S getNextClassInstance() {
while (services.hasNext()) {
ResourceClass info = services.nextResourceClass();
try {
return spi.newInstance(info.loadClass());
} catch (Exception e) {
// ignore
} catch (LinkageError le) {
// ignore
}
}
return null;
}
};
}
}
commons-discovery-0.5/src/java/org/apache/commons/discovery/tools/ClassUtils.java 0000644 0001750 0001750 00000016160 11547423466 030245 0 ustar drazzib drazzib /*
* 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 org.apache.commons.discovery.tools;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import org.apache.commons.discovery.DiscoveryException;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
/**
* Various utilities to interact with {@code Class} types.
*/
public class ClassUtils {
private static Log log = LogFactory.getLog(ClassUtils.class);
/**
* Sets the {@code Log} for this class.
*
* @param _log This class {@code Log}
* @deprecated This method is not thread-safe
*/
@Deprecated
public static void setLog(Log _log) {
log = _log;
}
/**
* Get package name.
* Not all class loaders 'keep' package information,
* in which case Class.getPackage() returns null.
* This means that calling Class.getPackage().getName()
* is unreliable at best.
*
* @param clazz The class from which the package has to be extracted
* @return The string representation of the input class package
*/
public static String getPackageName(Class clazz) {
Package clazzPackage = clazz.getPackage();
String packageName;
if (clazzPackage != null) {
packageName = clazzPackage.getName();
} else {
String clazzName = clazz.getName();
packageName = clazzName.substring(0, clazzName.lastIndexOf('.'));
}
return packageName;
}
/**
* Looks for {@code public static returnType methodName(paramTypes)}.
*
* @param clazz The class where looking for the method
* @param returnType The method return type
* @param methodName The method name
* @param paramTypes The method arguments types
* @return Method {@code public static returnType methodName(paramTypes)},
* if found to be directly implemented by clazz.
*/
public static Method findPublicStaticMethod(Class clazz,
Class returnType,
String methodName,
Class[] paramTypes) {
boolean problem = false;
Method method = null;
// verify '()' is directly in class.
try {
method = clazz.getDeclaredMethod(methodName, paramTypes);
} catch(NoSuchMethodException e) {
problem = true;
log.debug("Class " + clazz.getName() + ": missing method '" + methodName + "(...)", e);
}
// verify 'public static '
if (!problem &&
!(Modifier.isPublic(method.getModifiers()) &&
Modifier.isStatic(method.getModifiers()) &&
method.getReturnType() == returnType)) {
if (log.isDebugEnabled()) {
if (!Modifier.isPublic(method.getModifiers())) {
log.debug(methodName + "() is not public");
}
if (!Modifier.isStatic(method.getModifiers())) {
log.debug(methodName + "() is not static");
}
if (method.getReturnType() != returnType) {
log.debug("Method returns: "
+ method.getReturnType().getName()
+ "@@"
+ method.getReturnType().getClassLoader());
log.debug("Should return: "
+ returnType.getName()
+ "@@"
+ returnType.getClassLoader());
}
}
problem = true;
method = null;
}
return method;
}
/**
* Creates a new instance of the input class using the following policy:
*
*
*
if paramClasses or params is null,
* the default constructor will be used;
*
the public constructor with paramClasses arguments type,
* with params as arguments value, will be used.
*
*
* @param The class type has to be instantiated
* @param impl The class has to be instantiated
* @param paramClasses The constructor arguments types (can be {@code null})
* @param params The constructor arguments values (can be {@code null})
* @return A new class instance
* @throws DiscoveryException if the class implementing
* the SPI cannot be found, cannot be loaded and
* instantiated, or if the resulting class does not implement
* (or extend) the SPI
* @throws InstantiationException see {@link Class#newInstance()}
* @throws IllegalAccessException see {@link Class#newInstance()}
* @throws NoSuchMethodException see {@link Class#newInstance()}
* @throws InvocationTargetException see {@link Class#newInstance()}
*/
public static T newInstance(Class impl, Class paramClasses[], Object params[]) throws DiscoveryException,
InstantiationException,
IllegalAccessException,
NoSuchMethodException,
InvocationTargetException {
if (paramClasses == null || params == null) {
return impl.newInstance();
}
Constructor constructor = impl.getConstructor(paramClasses);
return constructor.newInstance(params);
}
/**
* Throws exception if {@code impl} does not
* implement or extend the SPI.
*
* @param spi The SPI type
* @param impl The class has to be verified is a SPI implementation/extension
* @throws DiscoveryException if the input implementation class is not an SPI implementation
*/
public static void verifyAncestory(Class spi, Class impl) throws DiscoveryException {
if (spi == null) {
throw new DiscoveryException("No interface defined!");
}
if (impl == null) {
throw new DiscoveryException("No implementation defined for " + spi.getName());
}
if (!spi.isAssignableFrom(impl)) {
throw new DiscoveryException("Class "
+ impl.getName()
+ " does not implement "
+ spi.getName());
}
}
}
commons-discovery-0.5/src/java/org/apache/commons/discovery/tools/ResourceUtils.java 0000644 0001750 0001750 00000013652 11547423466 030772 0 ustar drazzib drazzib /*
* 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 org.apache.commons.discovery.tools;
import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;
import org.apache.commons.discovery.DiscoveryException;
import org.apache.commons.discovery.Resource;
import org.apache.commons.discovery.ResourceIterator;
import org.apache.commons.discovery.resource.ClassLoaders;
import org.apache.commons.discovery.resource.DiscoverResources;
/**
* Mechanisms to locate and load a class.
*
* The load methods locate a class only.
* The find methods locate a class and verify that the
* class implements an given interface or extends a given class.
*/
public class ResourceUtils {
/**
* Get package name.
*
* Not all class loaders 'keep' package information,
* in which case Class.getPackage() returns null.
* This means that calling Class.getPackage().getName()
* is unreliable at best.
*
* @param clazz The class from which the package has to be extracted
* @return The string representation of the input class package
*/
public static String getPackageName(Class clazz) {
Package clazzPackage = clazz.getPackage();
String packageName;
if (clazzPackage != null) {
packageName = clazzPackage.getName();
} else {
String clazzName = clazz.getName();
packageName = new String(clazzName.toCharArray(), 0, clazzName.lastIndexOf('.'));
}
return packageName;
}
/**
* Load the resource resourceName.
*
* Try each classloader in succession,
* until first succeeds, or all fail.
* If all fail and resouceName is not absolute
* (doesn't start with '/' character), then retry with
* packageName/resourceName after changing all
* '.' to '/'.
*
* @param spi The SPI type
* @param resourceName The name of the resource to load.
* @param loaders the class loaders holder
* @return The discovered {@link Resource} instance
* @throws DiscoveryException if the class implementing
* the SPI cannot be found, cannot be loaded and
* instantiated, or if the resulting class does not implement
* (or extend) the SPI
*/
public static Resource getResource(Class spi,
String resourceName,
ClassLoaders loaders) throws DiscoveryException {
DiscoverResources explorer = new DiscoverResources(loaders);
ResourceIterator resources = explorer.findResources(resourceName);
if (spi != null &&
!resources.hasNext() &&
resourceName.charAt(0) != '/') {
/**
* If we didn't find the resource, and if the resourceName
* isn't an 'absolute' path name, then qualify with
* package name of the spi.
*/
resourceName = getPackageName(spi).replace('.','/') + "/" + resourceName;
resources = explorer.findResources(resourceName);
}
return resources.hasNext()
? resources.nextResource()
: null;
}
/**
* Load named property file, optionally qualified by spi's package name
* as per Class.getResource.
*
* A property file is loaded using the following sequence of class loaders:
*
*
Thread Context Class Loader
*
DiscoverSingleton's Caller's Class Loader
*
SPI's Class Loader
*
DiscoverSingleton's (this class) Class Loader
*
System Class Loader
*
*
* @param spi The SPI type
* @param propertiesFileName The property file name.
* @param classLoaders The class loaders holder
* @return The loaded named property file, in {@code Properties} format
* @throws DiscoveryException Thrown if the name of a class implementing
* the SPI cannot be found, if the class cannot be loaded and
* instantiated, or if the resulting class does not implement
* (or extend) the SPI.
*/
public static Properties loadProperties(Class spi,
String propertiesFileName,
ClassLoaders classLoaders) throws DiscoveryException {
Properties properties = null;
if (propertiesFileName != null) {
try {
Resource resource = getResource(spi, propertiesFileName, classLoaders);
if (resource != null) {
InputStream stream = resource.getResourceAsStream();
if (stream != null) {
properties = new Properties();
try {
properties.load(stream);
} finally {
stream.close();
}
}
}
} catch (IOException e) {
// ignore
} catch (SecurityException e) {
// ignore
}
}
return properties;
}
}
commons-discovery-0.5/src/java/org/apache/commons/discovery/ResourceIterator.java 0000644 0001750 0001750 00000002533 11546563027 030314 0 ustar drazzib drazzib /*
* 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 org.apache.commons.discovery;
/**
* Iterator over discovered {@link Resource}.
*/
public abstract class ResourceIterator implements ResourceNameIterator {
/**
* Returns the next {@link Resource} in the iteration.
*
* @return The next resource in the iteration
*/
public abstract Resource nextResource();
/**
* Returns the next resource name in the iteration.
*
* @return The next resource name in the iteration
*/
public String nextResourceName() {
return nextResource().getName();
}
}
commons-discovery-0.5/src/java/org/apache/commons/discovery/ResourceClassDiscover.java 0000644 0001750 0001750 00000002772 11546563027 031274 0 ustar drazzib drazzib /*
* 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 org.apache.commons.discovery;
/**
* SPI Discovery.
*
* @param The SPI type
*/
public interface ResourceClassDiscover extends ResourceDiscover {
/**
* Locate class resources that are bound to {@code className}.
*
* @param className The class name has to be located
* @return The iterator over the located classes
*/
ResourceClassIterator findResourceClasses(String className);
/**
* Locate class resources that are bound to {@code resourceNames}.
*
* @param classNames The classes name has to be located
* @return The iterator over the located classes
*/
ResourceClassIterator findResourceClasses(ResourceNameIterator classNames);
}
commons-discovery-0.5/src/java/org/apache/commons/discovery/jdk/ 0000755 0001750 0001750 00000000000 11643422201 024677 5 ustar drazzib drazzib commons-discovery-0.5/src/java/org/apache/commons/discovery/jdk/package-info.java 0000644 0001750 0001750 00000001605 11546710126 030100 0 ustar drazzib drazzib /*
* 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.
*/
/**
* Different JDK hookers style implementation.
*/
package org.apache.commons.discovery.jdk;
commons-discovery-0.5/src/java/org/apache/commons/discovery/jdk/JDK11Hooks.java 0000644 0001750 0001750 00000010671 11546640301 027332 0 ustar drazzib drazzib /*
* 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 org.apache.commons.discovery.jdk;
import java.io.IOException;
import java.net.URL;
import java.util.Enumeration;
/**
* JDK 1.1 Style Hooks implementation.
*/
public class JDK11Hooks extends JDKHooks {
private static final ClassLoader systemClassLoader = new PsuedoSystemClassLoader();
/**
* {@inheritDoc}
*/
@Override
public String getSystemProperty(final String propName) {
return System.getProperty(propName);
}
/**
* {@inheritDoc}
*/
@Override
public ClassLoader getThreadContextClassLoader() {
return null;
}
/**
* {@inheritDoc}
*/
@Override
public ClassLoader getSystemClassLoader() {
return systemClassLoader;
}
/**
* {@inheritDoc}
*/
@Override
public Enumeration getResources(ClassLoader loader, String resourceName) throws IOException {
/*
* The simple answer is/was:
* return loader.getResources(resourceName);
*
* However, some classloaders overload the behavior of getResource
* (loadClass, etc) such that the order of returned results changes
* from normally expected behavior.
*
* Example: locate classes/resources from child ClassLoaders first,
* parents last (in some J2EE environs).
*
* The resource returned by getResource() should be the same as the
* first resource returned by getResources(). Unfortunately, this
* is not, and cannot be: getResources() is 'final' in the current
* JDK's (1.2, 1.3, 1.4).
*
* To address this, the implementation of this method will
* return an Enumeration such that the first element is the
* results of getResource, and all trailing elements are
* from getResources. On each iteration, we check so see
* if the resource (from getResources) matches the first resource,
* and eliminate the redundent element.
*/
final URL first = loader.getResource(resourceName);
final Enumeration rest = loader.getResources(resourceName);
return new Enumeration() {
private boolean firstDone = (first == null);
private URL next = getNext();
public URL nextElement() {
URL o = next;
next = getNext();
return o;
}
public boolean hasMoreElements() {
return next != null;
}
private URL getNext() {
URL n;
if (!firstDone) {
/*
* First time through, use results of getReference()
* if they were non-null.
*/
firstDone = true;
n = first;
} else {
/*
* Subsequent times through,
* use results of getReferences()
* but take out anything that matches 'first'.
*
* Iterate through list until we find one that
* doesn't match 'first'.
*/
n = null;
while (rest.hasMoreElements() && n == null) {
n = rest.nextElement();
if (first != null &&
n != null &&
n.equals(first))
{
n = null;
}
}
}
return n;
}
};
}
}
commons-discovery-0.5/src/java/org/apache/commons/discovery/jdk/PsuedoSystemClassLoader.java 0000644 0001750 0001750 00000003164 11546635274 032351 0 ustar drazzib drazzib /*
* 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 org.apache.commons.discovery.jdk;
import java.io.InputStream;
import java.net.URL;
/**
* JDK 1.1.x compatible?
* There is no direct way to get the system class loader
* in 1.1.x, but this should be a good work around...
*/
class PsuedoSystemClassLoader extends ClassLoader {
/**
* {@inheritDoc}
*/
@Override
protected Class loadClass(String className, @SuppressWarnings("unused") boolean resolve)
throws ClassNotFoundException {
return findSystemClass(className);
}
/**
* {@inheritDoc}
*/
@Override
public URL getResource(String resName) {
return getSystemResource(resName);
}
/**
* {@inheritDoc}
*/
@Override
public InputStream getResourceAsStream(String resName) {
return getSystemResourceAsStream(resName);
}
}
commons-discovery-0.5/src/java/org/apache/commons/discovery/jdk/JDK12Hooks.java 0000644 0001750 0001750 00000017761 11547002043 027336 0 ustar drazzib drazzib /*
* 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 org.apache.commons.discovery.jdk;
import java.io.IOException;
import java.net.URL;
import java.security.AccessController;
import java.security.PrivilegedAction;
import java.util.Collections;
import java.util.Enumeration;
import java.util.List;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
/**
* JDK 1.2 Style Hooks implementation.
*/
public class JDK12Hooks extends JDKHooks {
/**
* Logger
*/
private static Log log = LogFactory.getLog(JDK12Hooks.class);
private static final ClassLoader systemClassLoader = findSystemClassLoader();
/**
* Sets the {@code Log} for this class.
*
* @param _log This class {@code Log}
* @deprecated This method is not thread-safe
*/
@Deprecated
public static void setLog(Log _log) {
log = _log;
}
/**
* {@inheritDoc}
*/
@Override
public String getSystemProperty(final String propName) {
return AccessController.doPrivileged(new PrivilegedAction() {
public String run() {
try {
return System.getProperty(propName);
} catch (SecurityException se){
return null;
}
}
});
}
/**
* {@inheritDoc}
*/
@Override
public ClassLoader getThreadContextClassLoader() {
ClassLoader classLoader;
try {
classLoader = Thread.currentThread().getContextClassLoader();
} catch (SecurityException e) {
/*
* SecurityException is thrown when
* a) the context class loader isn't an ancestor of the
* calling class's class loader, or
* b) if security permissions are restricted.
*
* For (a), ignore and keep going. We cannot help but also
* ignore (b) with the logic below, but other calls elsewhere
* (to obtain a class loader) will re-trigger this exception
* where we can make a distinction.
*/
classLoader = null; // ignore
}
// Return the selected class loader
return classLoader;
}
/**
* {@inheritDoc}
*/
@Override
public ClassLoader getSystemClassLoader() {
return systemClassLoader;
}
/**
* {@inheritDoc}
*/
@Override
public Enumeration getResources(ClassLoader loader, String resourceName) throws IOException {
/*
* The simple answer is/was:
* return loader.getResources(resourceName);
*
* However, some classloaders overload the behavior of getResource
* (loadClass, etc) such that the order of returned results changes
* from normally expected behavior.
*
* Example: locate classes/resources from child ClassLoaders first,
* parents last (in some J2EE environs).
*
* The resource returned by getResource() should be the same as the
* first resource returned by getResources(). Unfortunately, this
* is not, and cannot be: getResources() is 'final' in the current
* JDK's (1.2, 1.3, 1.4).
*
* To address this, the implementation of this method will
* return an Enumeration such that the first element is the
* results of getResource, and all trailing elements are
* from getResources. On each iteration, we check so see
* if the resource (from getResources) matches the first resource,
* and eliminate the redundent element.
*/
final URL first = loader.getResource(resourceName);
// XXX: Trying to avoid JBoss UnifiedClassLoader problem
Enumeration