org.hibernate.boot.registry.classloading.internal.ClassLoaderServiceImpl Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of hibernate-core Show documentation
Show all versions of hibernate-core Show documentation
The core O/RM functionality as provided by Hibernate
The newest version!
/*
* Hibernate, Relational Persistence for Idiomatic Java
*
* License: GNU Lesser General Public License (LGPL), version 2.1 or later.
* See the lgpl.txt file in the root directory or .
*/
package org.hibernate.boot.registry.classloading.internal;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
import java.net.URL;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Enumeration;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.ServiceLoader;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import org.hibernate.boot.registry.classloading.spi.ClassLoaderService;
import org.hibernate.boot.registry.classloading.spi.ClassLoadingException;
import org.hibernate.cfg.AvailableSettings;
import org.hibernate.internal.CoreLogging;
import org.hibernate.internal.CoreMessageLogger;
/**
* Standard implementation of the service for interacting with class loaders
*
* @author Steve Ebersole
* @author Sanne Grinovero
*/
public class ClassLoaderServiceImpl implements ClassLoaderService {
private static final CoreMessageLogger log = CoreLogging.messageLogger( ClassLoaderServiceImpl.class );
private final ConcurrentMap serviceLoaders = new ConcurrentHashMap();
private volatile AggregatedClassLoader aggregatedClassLoader;
/**
* Constructs a ClassLoaderServiceImpl with standard set-up
*/
public ClassLoaderServiceImpl() {
this( ClassLoaderServiceImpl.class.getClassLoader() );
}
/**
* Constructs a ClassLoaderServiceImpl with the given ClassLoader
*
* @param classLoader The ClassLoader to use
*/
public ClassLoaderServiceImpl(ClassLoader classLoader) {
this( Collections.singletonList( classLoader ),TcclLookupPrecedence.AFTER );
}
/**
* Constructs a ClassLoaderServiceImpl with the given ClassLoader instances
*
* @param providedClassLoaders The ClassLoader instances to use
* @param lookupPrecedence The lookup precedence of the thread context {@code ClassLoader}
*/
public ClassLoaderServiceImpl(Collection providedClassLoaders, TcclLookupPrecedence lookupPrecedence) {
final LinkedHashSet orderedClassLoaderSet = new LinkedHashSet();
// first, add all provided class loaders, if any
if ( providedClassLoaders != null ) {
for ( ClassLoader classLoader : providedClassLoaders ) {
if ( classLoader != null ) {
orderedClassLoaderSet.add( classLoader );
}
}
}
// normalize adding known class-loaders...
// then the Hibernate class loader
orderedClassLoaderSet.add( ClassLoaderServiceImpl.class.getClassLoader() );
// now build the aggregated class loader...
this.aggregatedClassLoader = new AggregatedClassLoader( orderedClassLoaderSet,lookupPrecedence );
}
/**
* No longer used/supported!
*
* @param configValues The config values
*
* @return The built service
*
* @deprecated No longer used/supported!
*/
@Deprecated
@SuppressWarnings({"UnusedDeclaration", "unchecked", "deprecation"})
public static ClassLoaderServiceImpl fromConfigSettings(Map configValues) {
final List providedClassLoaders = new ArrayList();
final Collection classLoaders = (Collection) configValues.get( AvailableSettings.CLASSLOADERS );
if ( classLoaders != null ) {
for ( ClassLoader classLoader : classLoaders ) {
providedClassLoaders.add( classLoader );
}
}
addIfSet( providedClassLoaders, AvailableSettings.APP_CLASSLOADER, configValues );
addIfSet( providedClassLoaders, AvailableSettings.RESOURCES_CLASSLOADER, configValues );
addIfSet( providedClassLoaders, AvailableSettings.HIBERNATE_CLASSLOADER, configValues );
addIfSet( providedClassLoaders, AvailableSettings.ENVIRONMENT_CLASSLOADER, configValues );
return new ClassLoaderServiceImpl( providedClassLoaders,TcclLookupPrecedence.AFTER );
}
private static void addIfSet(List providedClassLoaders, String name, Map configVales) {
final ClassLoader providedClassLoader = (ClassLoader) configVales.get( name );
if ( providedClassLoader != null ) {
providedClassLoaders.add( providedClassLoader );
}
}
private static ClassLoader locateSystemClassLoader() {
try {
return ClassLoader.getSystemClassLoader();
}
catch (Exception e) {
return null;
}
}
private static ClassLoader locateTCCL() {
try {
return Thread.currentThread().getContextClassLoader();
}
catch (Exception e) {
return null;
}
}
private static class AggregatedClassLoader extends ClassLoader {
private final ClassLoader[] individualClassLoaders;
private final TcclLookupPrecedence tcclLookupPrecedence;
private AggregatedClassLoader(final LinkedHashSet orderedClassLoaderSet, TcclLookupPrecedence precedence) {
super( null );
individualClassLoaders = orderedClassLoaderSet.toArray( new ClassLoader[orderedClassLoaderSet.size()] );
tcclLookupPrecedence = precedence;
}
private Iterator newClassLoaderIterator() {
final ClassLoader threadClassLoader = locateTCCL();
if ( tcclLookupPrecedence == TcclLookupPrecedence.NEVER || threadClassLoader == null ) {
return newTcclNeverIterator();
}
else if ( tcclLookupPrecedence == TcclLookupPrecedence.AFTER ) {
return newTcclAfterIterator(threadClassLoader);
}
else if ( tcclLookupPrecedence == TcclLookupPrecedence.BEFORE ) {
return newTcclBeforeIterator(threadClassLoader);
}
else {
throw new RuntimeException( "Unknown precedence: "+tcclLookupPrecedence );
}
}
private Iterator newTcclBeforeIterator(final ClassLoader threadContextClassLoader) {
final ClassLoader systemClassLoader = locateSystemClassLoader();
return new Iterator() {
private int currentIndex = 0;
private boolean tcCLReturned = false;
private boolean sysCLReturned = false;
@Override
public boolean hasNext() {
if ( !tcCLReturned ) {
return true;
}
else if ( currentIndex < individualClassLoaders.length ) {
return true;
}
else if ( !sysCLReturned && systemClassLoader != null ) {
return true;
}
return false;
}
@Override
public ClassLoader next() {
if ( !tcCLReturned ) {
tcCLReturned = true;
return threadContextClassLoader;
}
else if ( currentIndex < individualClassLoaders.length ) {
currentIndex += 1;
return individualClassLoaders[ currentIndex - 1 ];
}
else if ( !sysCLReturned && systemClassLoader != null ) {
sysCLReturned = true;
return systemClassLoader;
}
throw new IllegalStateException( "No more item" );
}
};
}
private Iterator newTcclAfterIterator(final ClassLoader threadContextClassLoader) {
final ClassLoader systemClassLoader = locateSystemClassLoader();
return new Iterator() {
private int currentIndex = 0;
private boolean tcCLReturned = false;
private boolean sysCLReturned = false;
@Override
public boolean hasNext() {
if ( currentIndex < individualClassLoaders.length ) {
return true;
}
else if ( !tcCLReturned ) {
return true;
}
else if ( !sysCLReturned && systemClassLoader != null ) {
return true;
}
return false;
}
@Override
public ClassLoader next() {
if ( currentIndex < individualClassLoaders.length ) {
currentIndex += 1;
return individualClassLoaders[ currentIndex - 1 ];
}
else if ( !tcCLReturned ) {
tcCLReturned = true;
return threadContextClassLoader;
}
else if ( !sysCLReturned && systemClassLoader != null ) {
sysCLReturned = true;
return systemClassLoader;
}
throw new IllegalStateException( "No more item" );
}
};
}
private Iterator newTcclNeverIterator() {
final ClassLoader systemClassLoader = locateSystemClassLoader();
return new Iterator() {
private int currentIndex = 0;
private boolean sysCLReturned = false;
@Override
public boolean hasNext() {
if ( currentIndex < individualClassLoaders.length ) {
return true;
}
else if ( !sysCLReturned && systemClassLoader != null ) {
return true;
}
return false;
}
@Override
public ClassLoader next() {
if ( currentIndex < individualClassLoaders.length ) {
currentIndex += 1;
return individualClassLoaders[ currentIndex - 1 ];
}
else if ( !sysCLReturned && systemClassLoader != null ) {
sysCLReturned = true;
return systemClassLoader;
}
throw new IllegalStateException( "No more item" );
}
};
}
@Override
public Enumeration getResources(String name) throws IOException {
final LinkedHashSet resourceUrls = new LinkedHashSet();
final Iterator clIterator = newClassLoaderIterator();
while ( clIterator.hasNext() ) {
final ClassLoader classLoader = clIterator.next();
final Enumeration urls = classLoader.getResources( name );
while ( urls.hasMoreElements() ) {
resourceUrls.add( urls.nextElement() );
}
}
return new Enumeration() {
final Iterator resourceUrlIterator = resourceUrls.iterator();
@Override
public boolean hasMoreElements() {
return resourceUrlIterator.hasNext();
}
@Override
public URL nextElement() {
return resourceUrlIterator.next();
}
};
}
@Override
protected URL findResource(String name) {
final Iterator clIterator = newClassLoaderIterator();
while ( clIterator.hasNext() ) {
final ClassLoader classLoader = clIterator.next();
final URL resource = classLoader.getResource( name );
if ( resource != null ) {
return resource;
}
}
return super.findResource( name );
}
@Override
protected Class findClass(String name) throws ClassNotFoundException {
final Iterator clIterator = newClassLoaderIterator();
while ( clIterator.hasNext() ) {
final ClassLoader classLoader = clIterator.next();
try {
return classLoader.loadClass( name );
}
catch (Exception ignore) {
}
catch (LinkageError ignore) {
}
}
throw new ClassNotFoundException( "Could not load requested class : " + name );
}
}
@Override
@SuppressWarnings({"unchecked"})
public Class classForName(String className) {
try {
return (Class) Class.forName( className, true, getAggregatedClassLoader() );
}
catch (Exception e) {
throw new ClassLoadingException( "Unable to load class [" + className + "]", e );
}
catch (LinkageError e) {
throw new ClassLoadingException( "Unable to load class [" + className + "]", e );
}
}
@Override
public URL locateResource(String name) {
// first we try name as a URL
try {
return new URL( name );
}
catch (Exception ignore) {
}
try {
final URL url = getAggregatedClassLoader().getResource( name );
if ( url != null ) {
return url;
}
}
catch (Exception ignore) {
}
if ( name.startsWith( "/" ) ) {
name = name.substring( 1 );
try {
final URL url = getAggregatedClassLoader().getResource( name );
if ( url != null ) {
return url;
}
}
catch (Exception ignore) {
}
}
return null;
}
@Override
public InputStream locateResourceStream(String name) {
// first we try name as a URL
try {
log.tracef( "trying via [new URL(\"%s\")]", name );
return new URL( name ).openStream();
}
catch (Exception ignore) {
}
try {
log.tracef( "trying via [ClassLoader.getResourceAsStream(\"%s\")]", name );
final InputStream stream = getAggregatedClassLoader().getResourceAsStream( name );
if ( stream != null ) {
return stream;
}
}
catch (Exception ignore) {
}
final String stripped = name.startsWith( "/" ) ? name.substring( 1 ) : null;
if ( stripped != null ) {
try {
log.tracef( "trying via [new URL(\"%s\")]", stripped );
return new URL( stripped ).openStream();
}
catch (Exception ignore) {
}
try {
log.tracef( "trying via [ClassLoader.getResourceAsStream(\"%s\")]", stripped );
final InputStream stream = getAggregatedClassLoader().getResourceAsStream( stripped );
if ( stream != null ) {
return stream;
}
}
catch (Exception ignore) {
}
}
return null;
}
@Override
public List locateResources(String name) {
final ArrayList urls = new ArrayList();
try {
final Enumeration urlEnumeration = getAggregatedClassLoader().getResources( name );
if ( urlEnumeration != null && urlEnumeration.hasMoreElements() ) {
while ( urlEnumeration.hasMoreElements() ) {
urls.add( urlEnumeration.nextElement() );
}
}
}
catch (Exception ignore) {
}
return urls;
}
@Override
@SuppressWarnings("unchecked")
public Collection loadJavaServices(Class serviceContract) {
ServiceLoader serviceLoader = serviceLoaders.get( serviceContract );
if ( serviceLoader == null ) {
serviceLoader = ServiceLoader.load( serviceContract, getAggregatedClassLoader() );
serviceLoaders.put( serviceContract, serviceLoader );
}
final LinkedHashSet services = new LinkedHashSet();
for ( S service : serviceLoader ) {
services.add( service );
}
return services;
}
@Override
@SuppressWarnings("unchecked")
public T generateProxy(InvocationHandler handler, Class... interfaces) {
return (T) Proxy.newProxyInstance(
getAggregatedClassLoader(),
interfaces,
handler
);
}
@Override
public T workWithClassLoader(Work work) {
return work.doWork( getAggregatedClassLoader() );
}
private ClassLoader getAggregatedClassLoader() {
final AggregatedClassLoader aggregated = this.aggregatedClassLoader;
if ( aggregated == null ) {
throw log.usingStoppedClassLoaderService();
}
return aggregated;
}
@Override
public void stop() {
for ( ServiceLoader serviceLoader : serviceLoaders.values() ) {
serviceLoader.reload(); // clear service loader providers
}
serviceLoaders.clear();
//Avoid ClassLoader leaks
this.aggregatedClassLoader = null;
}
}