/** * Constructs a BootstrapServiceRegistryImpl. * * Do not use directly generally speaking. Use {@link org.hibernate.boot.registry.BootstrapServiceRegistryBuilder} * instead. * * @see org.hibernate.boot.registry.BootstrapServiceRegistryBuilder */ public BootstrapServiceRegistryImpl() { this( new ClassLoaderServiceImpl(), NO_INTEGRATORS ); } /**
public AggregatedClassLoader run() { return new AggregatedClassLoader( orderedClassLoaderSet, lookupPrecedence ); } } );
private Iterator<ClassLoader> newTcclNeverIterator() { final ClassLoader systemClassLoader = locateSystemClassLoader(); return new Iterator<ClassLoader>() { 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" ); } }; }
@Test public void testLookupAfterAvoided() { InternalClassLoader icl = new InternalClassLoader(); Thread.currentThread().setContextClassLoader( icl ); ClassLoaderServiceImpl csi = new ClassLoaderServiceImpl( null, TcclLookupPrecedence.AFTER ); Class<ClassLoaderServiceImplTest> clazz = csi.classForName( ClassLoaderServiceImplTest.class.getName() ); assertEquals( ClassLoaderServiceImplTest.class, clazz ); assertEquals( 0, icl.getAccessCount() ); csi.stop(); }
private Iterator<ClassLoader> 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 ); } }
@Override @SuppressWarnings("unchecked") public <T> T generateProxy(InvocationHandler handler, Class... interfaces) { return (T) Proxy.newProxyInstance( getAggregatedClassLoader(), interfaces, handler ); }
@Override public void stop() { super.stop(); osgiClassLoader.stop(); osgiServiceUtil.stop(); }
@Override protected URL findResource(String name) { final Iterator<ClassLoader> 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 ); }
/** * Generic method to parse a specified {@code persistence.xml} and return a Map of descriptors * for all discovered persistence-units keyed by the PU name. * * @param persistenceXmlUrl The URL of the {@code persistence.xml} to parse * @param transactionType The specific PersistenceUnitTransactionType to incorporate into the persistence-unit descriptor * @param integration The Map of integration settings * * @return Map of persistence-unit descriptors keyed by the PU name */ public static Map<String, ParsedPersistenceXmlDescriptor> parse( URL persistenceXmlUrl, PersistenceUnitTransactionType transactionType, Map integration) { PersistenceXmlParser parser = new PersistenceXmlParser( ClassLoaderServiceImpl.fromConfigSettings( integration ), transactionType ); parser.doResolve( integration ); return parser.persistenceUnits; }
@Override public <S> LinkedHashSet<S> loadJavaServices(Class<S> serviceContract) { Iterable<S> parentDiscoveredServices = super.loadJavaServices( serviceContract ); S[] serviceImpls = osgiServiceUtil.getServiceImpls(serviceContract); LinkedHashSet<S> composite = new LinkedHashSet<S>(); for ( S service : parentDiscoveredServices ) { composite.add( service ); } for ( S service : serviceImpls ) { composite.add( service ); } return composite; }
@Override public InputStream locateResourceStream(String name) { InputStreamWrapper stream = new InputStreamWrapper( super.locateResourceStream( name ) ); openedStreams.add( stream ); return stream; }
@Test public void testLookupBefore() { InternalClassLoader icl = new InternalClassLoader(); Thread.currentThread().setContextClassLoader( icl ); ClassLoaderServiceImpl csi = new ClassLoaderServiceImpl( null, TcclLookupPrecedence.BEFORE ); Class<ClassLoaderServiceImplTest> clazz = csi.classForName( ClassLoaderServiceImplTest.class.getName() ); assertEquals( ClassLoaderServiceImplTest.class, clazz ); assertEquals( 1, icl.getAccessCount() ); csi.stop(); }
@Override public <T> T workWithClassLoader(Work<T> work) { return work.doWork( getAggregatedClassLoader() ); }
private Iterator<ClassLoader> newTcclAfterIterator(final ClassLoader threadContextClassLoader) { final ClassLoader systemClassLoader = locateSystemClassLoader(); return new Iterator<ClassLoader>() { private int currentIndex = 0;
@Override public void stop() { for ( InputStreamWrapper openedStream : openedStreams ) { if ( !openedStream.wasClosed ) { try { openedStream.close(); } catch (IOException ignore) { } } } openedStreams.clear(); stopped = true; super.stop(); } }
@Test public void testLookupAfter() { InternalClassLoader icl = new InternalClassLoader(); Thread.currentThread().setContextClassLoader( icl ); ClassLoaderServiceImpl csi = new ClassLoaderServiceImpl( null, TcclLookupPrecedence.AFTER ); try { csi.classForName( "test.class.name" ); assertTrue( false ); } catch ( Exception e ) { } assertEquals( 0, icl.getAccessCount() ); csi.stop(); }
@Override @SuppressWarnings({"unchecked"}) public <T> Class<T> classForName(String className) { try { return (Class<T>) 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 ); } }
private Iterator<ClassLoader> newTcclBeforeIterator(final ClassLoader threadContextClassLoader) { final ClassLoader systemClassLoader = locateSystemClassLoader(); return new Iterator<ClassLoader>() { private int currentIndex = 0;
@Test public void testLookupAfterNotFound() { InternalClassLoader icl = new InternalClassLoader(); Thread.currentThread().setContextClassLoader( icl ); ClassLoaderServiceImpl csi = new ClassLoaderServiceImpl( null, TcclLookupPrecedence.BEFORE ); try { csi.classForName( "test.class.not.found" ); assertTrue( false ); } catch ( Exception e ) { } assertEquals( 0, icl.getAccessCount() ); csi.stop(); }
@Test public void testLookupNever() { InternalClassLoader icl = new InternalClassLoader(); Thread.currentThread().setContextClassLoader( icl ); ClassLoaderServiceImpl csi = new ClassLoaderServiceImpl( null, TcclLookupPrecedence.NEVER ); try { csi.classForName( "test.class.name" ); assertTrue( false ); } catch ( Exception e ) { } assertEquals( 0, icl.getAccessCount() ); csi.stop(); }