4:25 p.m.
Author: epbernard
Date: 2009-07-23 17:25:08 -0400 (Thu, 23 Jul 2009)
New Revision: 17199
Modified:
jpa-api/trunk/src/main/java/javax/persistence/spi/PersistenceProviderResolverHolder.java
Log:
EJB-454 implements the default PPR strategy
Modified:
jpa-api/trunk/src/main/java/javax/persistence/spi/PersistenceProviderResolverHolder.java
===================================================================
---
jpa-api/trunk/src/main/java/javax/persistence/spi/PersistenceProviderResolverHolder.java 2009-07-23
18:54:27 UTC (rev 17198)
+++
jpa-api/trunk/src/main/java/javax/persistence/spi/PersistenceProviderResolverHolder.java 2009-07-23
21:25:08 UTC (rev 17199)
@@ -2,23 +2,166 @@
// EJB3 Specification Copyright 2004-2009 Sun Microsystems, Inc.
package javax.persistence.spi;
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.lang.ref.WeakReference;
+import java.net.URL;
+import java.util.ArrayList;
+import java.util.Enumeration;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.WeakHashMap;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import javax.persistence.PersistenceException;
+
/**
* Holds the global PersistenceProviderResolver instance.
* If no PersistenceProviderResolver is set by the environment,
- * the default PersistenceProviderResolver is used. *
+ * the default PersistenceProviderResolver is used.
+ *
* Implementations must be thread-safe.
*/
public class PersistenceProviderResolverHolder {
+
+ private static volatile PersistenceProviderResolver resolver;
+
+ private static final PersistenceProviderResolver defaultResolver = new
PersistenceProviderResolverPerClassLoader();
+
/**
* Returns the current persistence provider resolver
*/
public static PersistenceProviderResolver getPersistenceProviderResolver() {
- return null;
+ return resolver == null ? defaultResolver : resolver;
}
/**
* Defines the persistence provider resolver used
*/
public static void setPersistenceProviderResolver(PersistenceProviderResolver resolver)
{
+ PersistenceProviderResolverHolder.resolver = resolver;
}
+
+ /**
+ * Cache PersistenceProviderResolver per classloader and use the current classloader as
a
+ * key.
+ * Use CachingPersistenceProviderResolver for each PersistenceProviderResolver
instance.
+ *
+ * @author Emmanuel Bernard
+ */
+ private static class PersistenceProviderResolverPerClassLoader implements
PersistenceProviderResolver {
+
+ //FIXME use a ConcurrentHashMap with weak entry
+ private final WeakHashMap<ClassLoader, PersistenceProviderResolver> resolvers =
+ new WeakHashMap<ClassLoader, PersistenceProviderResolver>();
+ private volatile short barrier = 1;
+
+
+ public List<PersistenceProvider> getPersistenceProviders() {
+ ClassLoader cl = Thread.currentThread().getContextClassLoader();
+ if ( cl == null ) {
+ cl = PersistenceProviderResolverPerClassLoader.class.getClassLoader();
+ }
+ if (barrier == 1) {} //read barrier syncs state with other threads
+ PersistenceProviderResolver currentResolver = resolvers.get( cl );
+ if (currentResolver == null) {
+ currentResolver = new CachingPersistenceProviderResolver(cl);
+ resolvers.put( cl, currentResolver );
+ barrier = 1;
+ }
+ return currentResolver.getPersistenceProviders();
+ }
+
+ /**
+ * Resolve the list of Persistence providers for a given classloader and cache the
results.
+ *
+ * Avoids to keep any reference from this class to the classloader being
+ * passed to the constructor.
+ *
+ * @author Emmanuel Bernard
+ */
+ private static class CachingPersistenceProviderResolver implements
PersistenceProviderResolver {
+ //this assumes that the class loader keeps the list of classes loaded
+ private final List<WeakReference<Class<? extends
PersistenceProvider>>> resolverClasses;
+
+ public CachingPersistenceProviderResolver(ClassLoader cl) {
+ //creates a hard reference to the cl :(
+ resolverClasses = new ArrayList<WeakReference<Class<? extends
PersistenceProvider>>>();
+ try {
+ Enumeration<URL> resources = cl.getResources( "META-INF/services/" +
PersistenceProvider.class.getName() );
+ Set<String> names = new HashSet<String>();
+ while ( resources.hasMoreElements() ) {
+ URL url = resources.nextElement();
+ InputStream is = url.openStream();
+ try {
+ names.addAll( providerNamesFromReader( new BufferedReader( new InputStreamReader(
is ) ) ) );
+ }
+ finally {
+ is.close();
+ }
+ }
+ for ( String s : names ) {
+ @SuppressWarnings( "unchecked" )
+ Class<? extends PersistenceProvider> providerClass = (Class<? extends
PersistenceProvider>) cl.loadClass( s );
+ WeakReference<Class<? extends PersistenceProvider>> reference
+ = new WeakReference<Class<? extends
PersistenceProvider>>(providerClass);
+ //keep Hibernate atop
+ if ( s.endsWith( "HibernatePersistence" ) &&
resolverClasses.size() > 0 ) {
+ WeakReference<Class<? extends PersistenceProvider>> movedReference =
resolverClasses.get( 0 );
+ resolverClasses.add( 0, reference );
+ resolverClasses.add( movedReference );
+ }
+ else {
+ resolverClasses.add( reference );
+ }
+ }
+ }
+ catch ( IOException e ) {
+ throw new PersistenceException( e );
+ }
+ catch ( ClassNotFoundException e ) {
+ throw new PersistenceException( e );
+ }
+ }
+
+ //TODO find a way to cache property instances
+ //problem #1: avoid hard ref with classloader (List<WR<PP>>?
+ //problem #2: avoid half GC lists
+ public List<PersistenceProvider> getPersistenceProviders() {
+ List<PersistenceProvider> providers = new ArrayList<PersistenceProvider>(
resolverClasses.size() );
+ try {
+ for ( WeakReference<Class<? extends PersistenceProvider>> providerClass
: resolverClasses ) {
+ providers.add( providerClass.get().newInstance() );
+ }
+ }
+ catch ( InstantiationException e ) {
+ throw new PersistenceException( e );
+ }
+ catch ( IllegalAccessException e ) {
+ throw new PersistenceException( e );
+ }
+ return providers;
+ }
+
+
+ private static final Pattern nonCommentPattern = Pattern.compile( "^([^#]+)"
);
+
+ private static Set<String> providerNamesFromReader(BufferedReader reader) throws
IOException {
+ Set<String> names = new HashSet<String>();
+ String line;
+ while ( ( line = reader.readLine() ) != null ) {
+ line = line.trim();
+ Matcher m = nonCommentPattern.matcher( line );
+ if ( m.find() ) {
+ names.add( m.group().trim() );
+ }
+ }
+ return names;
+ }
+ }
+ }
+
}