Spring源码阅读：IOC容器之BeanFactory

/**

 * Static {@link org.springframework.beans.factory.BeanFactory} implementation

 * which allows to register existing singleton instances programmatically.

 * Does not have support for prototype beans or aliases.

 *

 * <p>Serves as example for a simple implementation of the

 * {@link org.springframework.beans.factory.ListableBeanFactory} interface,

 * managing existing bean instances rather than creating new ones based on bean

 * definitions, and not implementing any extended SPI interfaces (such as

 * {@link org.springframework.beans.factory.config.ConfigurableBeanFactory}).

 *

 * <p>For a full-fledged factory based on bean definitions, have a look

 * at {@link DefaultListableBeanFactory}.

 */

public class StaticListableBeanFactory implements ListableBeanFactory {

 

   /** Map from bean name to bean instance */

   private final Map<String, Object> beans = new HashMap<String, Object>();

 

 

   /**

    * Add a new singleton bean.

    * Will overwrite any existing instance for the given name.

    * @param name the name of the bean

    * @param bean the bean instance

    */

   public void addBean(String name, Object bean) {

      this.beans.put(name, bean);

   }

 

/**

 * The root interface for accessing a Spring bean container.

 * This is the basic client view of a bean container;

 * further interfaces such as {@link ListableBeanFactory} and

 * {@link org.springframework.beans.factory.config.ConfigurableBeanFactory}

 * are available for specific purposes.

 *

 * <p>This interface is implemented by objects that hold a number of bean definitions,

 * each uniquely identified by a String name. Depending on the bean definition,

 * the factory will return either an independent instance of a contained object

 * (the Prototype design pattern), or a single shared instance (a superior

 * alternative to the Singleton design pattern, in which the instance is a

 * singleton in the scope of the factory). Which type of instance will be returned

 * depends on the bean factory configuration: the API is the same. Since Spring

 * 2.0, further scopes are available depending on the concrete application

 * context (e.g. "request" and "session" scopes in a web environment).

 *

 * <p>The point of this approach is that the BeanFactory is a central registry

 * of application components, and centralizes configuration of application

 * components (no more do individual objects need to read properties files,

 * for example). See chapters 4 and 11 of "Expert One-on-One J2EE Design and

 * Development" for a discussion of the benefits of this approach.

 *

 * <p>Note that it is generally better to rely on Dependency Injection

 * ("push" configuration) to configure application objects through setters

 * or constructors, rather than use any form of "pull" configuration like a

 * BeanFactory lookup. Spring‘s Dependency Injection functionality is

 * implemented using this BeanFactory interface and its subinterfaces.

 *

 * <p>Normally a BeanFactory will load bean definitions stored in a configuration

 * source (such as an XML document), and use the <code>org.springframework.beans</code>

 * package to configure the beans. However, an implementation could simply return

 * Java objects it creates as necessary directly in Java code. There are no

 * constraints on how the definitions could be stored: LDAP, RDBMS, XML,

 * properties file, etc. Implementations are encouraged to support references

 * amongst beans (Dependency Injection).

 *

 * <p>In contrast to the methods in {@link ListableBeanFactory}, all of the

 * operations in this interface will also check parent factories if this is a

 * {@link HierarchicalBeanFactory}. If a bean is not found in this factory instance,

 * the immediate parent factory will be asked. Beans in this factory instance

 * are supposed to override beans of the same name in any parent factory.

 *

 * <p>Bean factory implementations should support the standard bean lifecycle interfaces

 * as far as possible. The full set of initialization methods and their standard order is:<br>

 * 1. BeanNameAware‘s <code>setBeanName</code><br>

 * 2. BeanClassLoaderAware‘s <code>setBeanClassLoader</code><br>

 * 3. BeanFactoryAware‘s <code>setBeanFactory</code><br>

 * 4. ResourceLoaderAware‘s <code>setResourceLoader</code>

 * (only applicable when running in an application context)<br>

 * 5. ApplicationEventPublisherAware‘s <code>setApplicationEventPublisher</code>

 * (only applicable when running in an application context)<br>

 * 6. MessageSourceAware‘s <code>setMessageSource</code>

 * (only applicable when running in an application context)<br>

 * 7. ApplicationContextAware‘s <code>setApplicationContext</code>

 * (only applicable when running in an application context)<br>

 * 8. ServletContextAware‘s <code>setServletContext</code>

 * (only applicable when running in a web application context)<br>

 * 9. <code>postProcessBeforeInitialization</code> methods of BeanPostProcessors<br>

 * 10. InitializingBean‘s <code>afterPropertiesSet</code><br>

 * 11. a custom init-method definition<br>

 * 12. <code>postProcessAfterInitialization</code> methods of BeanPostProcessors

 *

 * <p>On shutdown of a bean factory, the following lifecycle methods apply:<br>

 * 1. DisposableBean‘s <code>destroy</code><br>

 * 2. a custom destroy-method definition

*/

public abstract class AbstractBeanFactory extends FactoryBeanRegistrySupport implements ConfigurableBeanFactory {

 

   /** Parent bean factory, for bean inheritance support */

   private BeanFactory parentBeanFactory;

 

   /** ClassLoader to resolve bean class names with, if necessary */

   private ClassLoader beanClassLoader = ClassUtils.getDefaultClassLoader();

 

   /** ClassLoader to temporarily resolve bean class names with, if necessary */

   private ClassLoader tempClassLoader;

 

   /** Whether to cache bean metadata or rather reobtain it for every access */

   private boolean cacheBeanMetadata = true;

 

   /** Resolution strategy for expressions in bean definition values */

   private BeanExpressionResolver beanExpressionResolver;

 

   /** Spring 3.0 ConversionService to use instead of PropertyEditors */

   private ConversionService conversionService;

 

   /** Custom PropertyEditorRegistrars to apply to the beans of this factory */

   private final Set<PropertyEditorRegistrar> propertyEditorRegistrars =

        new LinkedHashSet<PropertyEditorRegistrar>(4);

 

   /** A custom TypeConverter to use, overriding the default PropertyEditor mechanism */

   private TypeConverter typeConverter;

 

   /** Custom PropertyEditors to apply to the beans of this factory */

   private final Map<Class, Class<? extends PropertyEditor>> customEditors =

        new HashMap<Class, Class<? extends PropertyEditor>>(4);

 

   /** String resolvers to apply e.g. to annotation attribute values */

   private final List<StringValueResolver> embeddedValueResolvers = new LinkedList<StringValueResolver>();

 

   /** BeanPostProcessors to apply in createBean */

   private final List<BeanPostProcessor> beanPostProcessors = new ArrayList<BeanPostProcessor>();

 

   /** Indicates whether any InstantiationAwareBeanPostProcessors have been registered */

   private boolean hasInstantiationAwareBeanPostProcessors;

 

   /** Indicates whether any DestructionAwareBeanPostProcessors have been registered */

   private boolean hasDestructionAwareBeanPostProcessors;

 

   /** Map from scope identifier String to corresponding Scope */

   private final Map<String, Scope> scopes = new HashMap<String, Scope>();

 

   /** Security context used when running with a SecurityManager */

   private SecurityContextProvider securityContextProvider;

 

   /** Map from bean name to merged RootBeanDefinition */

   private final Map<String, RootBeanDefinition> mergedBeanDefinitions =

        new ConcurrentHashMap<String, RootBeanDefinition>();

 

   /** Names of beans that have already been created at least once */

   private final Set<String> alreadyCreated = Collections.synchronizedSet(new HashSet<String>());

 

   /** Names of beans that are currently in creation */

   private final ThreadLocal<Object> prototypesCurrentlyInCreation =

        new NamedThreadLocal<Object>("Prototype beans currently in creation");

}

 

public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFactory

      implements ConfigurableListableBeanFactory, BeanDefinitionRegistry, Serializable {

 

   private static Class javaxInjectProviderClass = null;

 

   static {

      ClassLoader cl = DefaultListableBeanFactory.class.getClassLoader();

      try {

        javaxInjectProviderClass = cl.loadClass("javax.inject.Provider");

      }

      catch (ClassNotFoundException ex) {

        // JSR-330 API not available - Provider interface simply not supported then.

      }

   }

 

 

   /** Map from serialized id to factory instance */

   private static final Map<String, Reference<DefaultListableBeanFactory>> serializableFactories =

        new ConcurrentHashMap<String, Reference<DefaultListableBeanFactory>>();

 

   /** Optional id for this factory, for serialization purposes */

   private String serializationId;

 

   /** Whether to allow re-registration of a different definition with the same name */

   private boolean allowBeanDefinitionOverriding = true;

 

   /** Whether to allow eager class loading even for lazy-init beans */

   private boolean allowEagerClassLoading = true;

 

   /** Resolver to use for checking if a bean definition is an autowire candidate */

   private AutowireCandidateResolver autowireCandidateResolver = new SimpleAutowireCandidateResolver();

 

   /** Map from dependency type to corresponding autowired value */

   private final Map<Class, Object> resolvableDependencies = new HashMap<Class, Object>();

 

   /** Map of bean definition objects, keyed by bean name */

   private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<String, BeanDefinition>();

 

   /** List of bean definition names, in registration order */

   private final List<String> beanDefinitionNames = new ArrayList<String>();

 

   /** Whether bean definition metadata may be cached for all beans */

   private boolean configurationFrozen = false;

 

   /** Cached array of bean definition names in case of frozen configuration */

   private String[] frozenBeanDefinitionNames;

}

 

/**

 * Convenience extension of {@link DefaultListableBeanFactory} that reads bean definitions

 * from an XML document. Delegates to {@link XmlBeanDefinitionReader} underneath; effectively

 * equivalent to using an XmlBeanDefinitionReader with a DefaultListableBeanFactory.

 *

 * <p>The structure, element and attribute names of the required XML document

 * are hard-coded in this class. (Of course a transform could be run if necessary

 * to produce this format). "beans" doesn‘t need to be the root element of the XML

 * document: This class will parse all bean definition elements in the XML file.

 *

 * <p>This class registers each bean definition with the {@link DefaultListableBeanFactory}

 * superclass, and relies on the latter‘s implementation of the {@link BeanFactory} interface.

 * It supports singletons, prototypes, and references to either of these kinds of bean.

 * See "spring-beans-2.0.dtd" for details on options and configuration style.

 *

 * <p><b>For advanced needs, consider using a {@link DefaultListableBeanFactory} with

 * an {@link XmlBeanDefinitionReader}.</b> The latter allows for reading from multiple XML

 * resources and is highly configurable in its actual XML parsing behavior.

 *
*/

public class XmlBeanFactory extends DefaultListableBeanFactory {

 

   private final XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(this);

 

public XmlBeanFactory(Resource resource) throws BeansException {

      this(resource, null);

   }

public XmlBeanFactory(Resource resource, BeanFactory parentBeanFactory) throws BeansException {

      super(parentBeanFactory);

      this.reader.loadBeanDefinitions(resource);

   }

 

}