SpringFactoriesLoader as the simplest possible mechanism for BeanInfoFactory loading

Author: jhoeller

spring-beans/src/main/java/org/springframework/beans/CachedIntrospectionResults.java

@@ -62,6 +62,10 @@ public class CachedIntrospectionResults {
 
 	private static final Log logger = LogFactory.getLog(CachedIntrospectionResults.class);
 
+	/** Stores the BeanInfoFactory instances */
+	private static List<BeanInfoFactory> beanInfoFactories =
+			SpringFactoriesLoader.loadFactories(BeanInfoFactory.class, CachedIntrospectionResults.class.getClassLoader());
+
 	/**
 	 * Set of ClassLoaders that this CachedIntrospectionResults class will always
 	 * accept classes from, even if the classes do not qualify as cache-safe.
@@ -75,11 +79,6 @@ public class CachedIntrospectionResults {
 	 */
 	static final Map<Class, Object> classCache = Collections.synchronizedMap(new WeakHashMap<Class, Object>());
 
-	/** Stores the BeanInfoFactory instances */
-	private static List<BeanInfoFactory> beanInfoFactories;
-
-	private static final Object beanInfoFactoriesMutex = new Object();
-
 
 	/**
 	 * Accept the given ClassLoader as cache-safe, even if its classes would
@@ -230,7 +229,6 @@ private CachedIntrospectionResults(Class beanClass, boolean cacheFullMetadata) t
 			}
 
 			BeanInfo beanInfo = null;
-			List<BeanInfoFactory> beanInfoFactories = getBeanInfoFactories(beanClass.getClassLoader());
 			for (BeanInfoFactory beanInfoFactory : beanInfoFactories) {
 				beanInfo = beanInfoFactory.getBeanInfo(beanClass);
 				if (beanInfo != null) {
@@ -325,16 +323,4 @@ private PropertyDescriptor buildGenericTypeAwarePropertyDescriptor(Class beanCla
 		}
 	}
 
-	private static List<BeanInfoFactory> getBeanInfoFactories(ClassLoader classLoader) {
-		if (beanInfoFactories == null) {
-			synchronized (beanInfoFactoriesMutex) {
-				if (beanInfoFactories == null) {
-					beanInfoFactories = Collections.synchronizedList(SpringFactoriesLoader
-							.loadFactories(BeanInfoFactory.class, classLoader));
-				}
-			}
-		}
-		return beanInfoFactories;
-	}
-
 }

spring-core/src/main/java/org/springframework/core/io/support/SpringFactoriesLoader.java

@@ -20,179 +20,100 @@
 import java.net.URL;
 import java.util.ArrayList;
 import java.util.Arrays;
-import java.util.Collections;
 import java.util.Enumeration;
 import java.util.List;
 import java.util.Properties;
 
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
 
-import org.springframework.core.annotation.AnnotationAwareOrderComparator;
+import org.springframework.core.OrderComparator;
 import org.springframework.core.io.UrlResource;
 import org.springframework.util.Assert;
 import org.springframework.util.ClassUtils;
 import org.springframework.util.StringUtils;
 
 /**
- * General purpose factory loading mechanism.
+ * General purpose factory loading mechanism for internal use within the framework.
  *
  * <p>The {@code SpringFactoriesLoader} loads and instantiates factories of a given type
- * from a given file location. If a location is not given, the {@linkplain
- * #DEFAULT_FACTORIES_LOCATION default location} is used.
- *
- * <p>The file should be in {@link Properties} format, where the key is the fully
- * qualified interface or abstract class name, and the value is a comma separated list of
- * implementations. For instance:
+ * from "META-INF/spring.factories" files. The file should be in {@link Properties} format,
+ * where the key is the fully qualified interface or abstract class name, and the value
+ * is a comma-separated list of implementation class names. For instance:
  *
  * <pre class="code">example.MyService=example.MyServiceImpl1,example.MyServiceImpl2</pre>
  *
  * where {@code MyService} is the name of the interface, and {@code MyServiceImpl1} and
  * {@code MyServiceImpl2} are the two implementations.
  *
  * @author Arjen Poutsma
+ * @author Juergen Hoeller
  * @since 3.2
  */
 public abstract class SpringFactoriesLoader {
 
-	private static final Log logger = LogFactory.getLog(SpringFactoriesLoader.class);
-
 	/** The location to look for the factories. Can be present in multiple JAR files. */
-	public static final String DEFAULT_FACTORIES_LOCATION = "META-INF/spring.factories";
+	private static final String FACTORIES_RESOURCE_LOCATION = "META-INF/spring.factories";
+
+	private static final Log logger = LogFactory.getLog(SpringFactoriesLoader.class);
 
-	/**
-	 * Loads the factory implementations of the given type from the default location.
-	 *
-	 * <p>The returned factories are ordered in accordance with the {@link
-	 * AnnotationAwareOrderComparator}.
-	 *
-	 * @param factoryClass the interface or abstract class representing the factory
-	 * @throws IllegalArgumentException in case of errors
-	 */
-	public static <T> List<T> loadFactories(Class<T> factoryClass) {
-		return loadFactories(factoryClass, null, null);
-	}
 
 	/**
 	 * Loads the factory implementations of the given type from the default location, using
 	 * the given class loader.
-	 *
-	 * <p>The returned factories are ordered in accordance with the {@link
-	 * AnnotationAwareOrderComparator}.
-	 *
-	 * @param factoryClass the interface or abstract class representing the factory
-	 * @param classLoader the ClassLoader to use for loading, can be {@code null} to use the
-	 * default
-	 * @throws IllegalArgumentException in case of errors
-	 */
-	public static <T> List<T> loadFactories(Class<T> factoryClass,
-			ClassLoader classLoader) {
-		return loadFactories(factoryClass, classLoader, null);
-	}
-
-	/**
-	 * Loads the factory implementations of the given type from the given location, using the
-	 * given class loader.
-	 *
-	 * <p>The returned factories are ordered in accordance with the {@link
-	 * AnnotationAwareOrderComparator}.
-	 *
+	 * <p>The returned factories are ordered in accordance with the {@link OrderComparator}.
 	 * @param factoryClass the interface or abstract class representing the factory
-	 * @param classLoader the ClassLoader to use for loading, can be {@code null} to use the
-	 * default
-	 * @param factoriesLocation the factories file location, can be {@code null} to use the
-	 * {@linkplain #DEFAULT_FACTORIES_LOCATION default}
-	 * @throws IllegalArgumentException in case of errors
+	 * @param classLoader the ClassLoader to use for loading (can be {@code null} to use the default)
 	 */
-	public static <T> List<T> loadFactories(Class<T> factoryClass,
-			ClassLoader classLoader, String factoriesLocation) {
+	public static <T> List<T> loadFactories(Class<T> factoryClass, ClassLoader classLoader) {
 		Assert.notNull(factoryClass, "'factoryClass' must not be null");
-
 		if (classLoader == null) {
-			classLoader = ClassUtils.getDefaultClassLoader();
-		}
-		if (factoriesLocation == null) {
-			factoriesLocation = DEFAULT_FACTORIES_LOCATION;
+			classLoader = SpringFactoriesLoader.class.getClassLoader();
 		}
-
-		List<String> factoryNames =
-				loadFactoryNames(factoryClass, classLoader, factoriesLocation);
-
+		List<String> factoryNames = loadFactoryNames(factoryClass, classLoader);
 		if (logger.isTraceEnabled()) {
-			logger.trace(
-					"Loaded [" + factoryClass.getName() + "] names: " + factoryNames);
+			logger.trace("Loaded [" + factoryClass.getName() + "] names: " + factoryNames);
 		}
-
 		List<T> result = new ArrayList<T>(factoryNames.size());
 		for (String factoryName : factoryNames) {
 			result.add(instantiateFactory(factoryName, factoryClass, classLoader));
 		}
-
-		Collections.sort(result, new AnnotationAwareOrderComparator());
-
+		OrderComparator.sort(result);
 		return result;
 	}
 
-	private static List<String> loadFactoryNames(Class<?> factoryClass,
-			ClassLoader classLoader, String factoriesLocation) {
-
+	private static List<String> loadFactoryNames(Class<?> factoryClass, ClassLoader classLoader) {
 		String factoryClassName = factoryClass.getName();
-
 		try {
 			List<String> result = new ArrayList<String>();
-			Enumeration<URL> urls = classLoader.getResources(factoriesLocation);
+			Enumeration<URL> urls = classLoader.getResources(FACTORIES_RESOURCE_LOCATION);
 			while (urls.hasMoreElements()) {
 				URL url = urls.nextElement();
-				Properties properties =
-						PropertiesLoaderUtils.loadProperties(new UrlResource(url));
+				Properties properties = PropertiesLoaderUtils.loadProperties(new UrlResource(url));
 				String factoryClassNames = properties.getProperty(factoryClassName);
-				result.addAll(Arrays.asList(
-						StringUtils.commaDelimitedListToStringArray(factoryClassNames)));
+				result.addAll(Arrays.asList(StringUtils.commaDelimitedListToStringArray(factoryClassNames)));
 			}
 			return result;
 		}
 		catch (IOException ex) {
-			throw new IllegalArgumentException(
-					"Unable to load [" + factoryClass.getName() +
-							"] factories from location [" +
-							factoriesLocation + "]", ex);
+			throw new IllegalArgumentException("Unable to load [" + factoryClass.getName() +
+					"] factories from location [" + FACTORIES_RESOURCE_LOCATION + "]", ex);
 		}
-
-
 	}
 
 	@SuppressWarnings("unchecked")
-	private static <T> T instantiateFactory(String instanceClassName,
-			Class<T> factoryClass, ClassLoader classLoader) {
+	private static <T> T instantiateFactory(String instanceClassName, Class<T> factoryClass, ClassLoader classLoader) {
 		try {
 			Class<?> instanceClass = ClassUtils.forName(instanceClassName, classLoader);
 			if (!factoryClass.isAssignableFrom(instanceClass)) {
 				throw new IllegalArgumentException(
-						"Class [" + instanceClassName + "] is not assignable to [" +
-								factoryClass.getName() + "]");
+						"Class [" + instanceClassName + "] is not assignable to [" + factoryClass.getName() + "]");
 			}
 			return (T) instanceClass.newInstance();
 		}
-		catch (ClassNotFoundException ex) {
-			throw new IllegalArgumentException(
-					factoryClass.getName() + " class [" + instanceClassName +
-							"] not found", ex);
-		}
-		catch (LinkageError err) {
-			throw new IllegalArgumentException(
-					"Invalid " + factoryClass.getName() + " class [" + instanceClassName +
-							"]: problem with handler class file or dependent class", err);
-		}
-		catch (InstantiationException ex) {
-			throw new IllegalArgumentException(
-					"Could not instantiate bean class [" + instanceClassName +
-							"]: Is it an abstract class?", ex);
-		}
-		catch (IllegalAccessException ex) {
-			throw new IllegalArgumentException(
-					"Could not instantiate bean class [" + instanceClassName +
-							"Is the constructor accessible?", ex);
+		catch (Throwable ex) {
+			throw new IllegalArgumentException("Cannot instantiate factory class: " + factoryClass.getName(), ex);
 		}
 	}
 
-}
+}