Spring IOC源码 BeanFactory

在Spring IOC的过程中BeanFactory发挥了相当大的作用。而BeanFactory的具体实现类DefaultListableBeanFactory才是Spring IOC的最大功臣。首先我们来看一看它的类的关系图。

注:圆点代表是接口.

其它的东西我们不说最主要的是说一下里面的接口还有就是这个类了:

1、BeanFactory

访问Spring Bean容器的root接口，它是一个Bean容器的基本客户端视图.主要用于获取Bean实例，也就是转换为POJO。下面这个这接口的主要方法.

public interface BeanFactory {

    String FACTORY_BEAN_PREFIX = "&";

    Object getBean(String name) throws BeansException;

     T getBean(String name, Class requiredType) throws BeansException;

     T getBean(Class requiredType) throws BeansException;

    Object getBean(String name, Object... args) throws BeansException;

     T getBean(Class requiredType, Object... args) throws BeansException;

    boolean containsBean(String name);

    boolean isSingleton(String name) throws NoSuchBeanDefinitionException;

    boolean isPrototype(String name) throws NoSuchBeanDefinitionException;

    boolean isTypeMatch(String name, ResolvableType typeToMatch) throws NoSuchBeanDefinitionException;

    boolean isTypeMatch(String name, Class typeToMatch) throws NoSuchBeanDefinitionException;

    Class getType(String name) throws NoSuchBeanDefinitionException;

    String[] getAliases(String name);

}

注意：看getBean(),getType(),getAliases()使用了典型的抽象工厂方法。

2、ListableBeanFactory

继承自BeanFactory接口，可以枚举BeanFactory中所有的bean实例，而不是让client依次去查询。BeanFactory的实现会预加载所有的bean的定义(such as XML-base factories)需要实现这个接口。这个接口的方法如下:

public interface ListableBeanFactory extends BeanFactory {

    boolean containsBeanDefinition(String beanName);

    int getBeanDefinitionCount();

    String[] getBeanDefinitionNames();

    String[] getBeanNamesForType(ResolvableType type);

    String[] getBeanNamesForType(Class type);

    String[] getBeanNamesForType(Class type, boolean includeNonSingletons, boolean allowEagerInit);

    <T> Map<String, T> getBeansOfType(Class<T> type) throws BeansException;

    <T> Map<String, T> getBeansOfType(Class<T> type, boolean includeNonSingletons, boolean allowEagerInit)
            throws BeansException;

    String[] getBeanNamesForAnnotation(Classextends Annotation> annotationType);

    Map<String, Object> getBeansWithAnnotation(Classextends Annotation> annotationType) throws BeansException;

    <A extends Annotation> A findAnnotationOnBean(String beanName, Class<A> annotationType)
            throws NoSuchBeanDefinitionException;

}

注意：如果它是一个HierarchicalBeanFactory，返回值不会获取到它的上层BeanFactory储存的实例，只能关联当前层的Factory定义的bean。但是你可以使用BeanFactoryUtils这个帮助类来获取它的上层factory.

3、ConfigurableBeanFactory

大多数的BeanFactory都需要实现这个Configuration接口。除了org.springframework.beans.factory.BeanFactory接口的client方法之外,它还提供工具来配置一个bean factory.

public interface ConfigurableBeanFactory extends HierarchicalBeanFactory, SingletonBeanRegistry {

    String SCOPE_SINGLETON = "singleton";

    String SCOPE_PROTOTYPE = "prototype";

    void setParentBeanFactory(BeanFactory parentBeanFactory) throws IllegalStateException;

    void setBeanClassLoader(ClassLoader beanClassLoader);

    ClassLoader getBeanClassLoader();

    void setTempClassLoader(ClassLoader tempClassLoader);

    ClassLoader getTempClassLoader();

    void setCacheBeanMetadata(boolean cacheBeanMetadata);

    boolean isCacheBeanMetadata();

    void setBeanExpressionResolver(BeanExpressionResolver resolver);

    BeanExpressionResolver getBeanExpressionResolver();

    void setConversionService(ConversionService conversionService);

    ConversionService getConversionService();

    void addPropertyEditorRegistrar(PropertyEditorRegistrar registrar);

    void registerCustomEditor(Class requiredType, Class propertyEditorClass);

    void copyRegisteredEditorsTo(PropertyEditorRegistry registry);

    void setTypeConverter(TypeConverter typeConverter);

    TypeConverter getTypeConverter();

    void addEmbeddedValueResolver(StringValueResolver valueResolver);

    String resolveEmbeddedValue(String value);

    void addBeanPostProcessor(BeanPostProcessor beanPostProcessor);

    int getBeanPostProcessorCount();

    void registerScope(String scopeName, Scope scope);

    String[] getRegisteredScopeNames();

    Scope getRegisteredScope(String scopeName);

    AccessControlContext getAccessControlContext();

    void copyConfigurationFrom(ConfigurableBeanFactory otherFactory);

    void registerAlias(String beanName, String alias) throws BeanDefinitionStoreException;

    void resolveAliases(StringValueResolver valueResolver);

    BeanDefinition getMergedBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;

    boolean isFactoryBean(String name) throws NoSuchBeanDefinitionException;

    void setCurrentlyInCreation(String beanName, boolean inCreation);

    boolean isCurrentlyInCreation(String beanName);

    void registerDependentBean(String beanName, String dependentBeanName);

    String[] getDependentBeans(String beanName);

    String[] getDependenciesForBean(String beanName);

    void destroyBean(String beanName, Object beanInstance);

    void destroyScopedBean(String beanName);

    void destroySingletons();

}

注意：这个bean factory接口不是命中注定被普通应用代码使用的.与BeanFactory或者ListableBeanFactory一起提供典型的使用。这个扩展接口仅仅是用来Spring框架内部插件使用并且是为了使用bean factory的配置配置方法。

下面举这个接口应用典型的例子:
1. setTypeConverter()
设置一个自定义类型的的转换器，这个BeanFactory会使用这个转换器来转换bean的property值，构造器参数值等等。
2. registerScope()
我们都知道bean的作用域有singleton和prototype。但是Spring还有其它范围的作用域，而且我们还可以定义自己的作用域。都是通过这个接口来实现的。
3. registerAlias()
给一个bean的名称创建一个别名。我们使用这个方法来支持在XML配置中不能配置ids.也就是只有一个名字这个缺陷。等等…

4、HierarchicalBeanFactory

bean factories实现的子接口，可以提供获取父容器。最典型的应用就是我们的web项目。

public interface HierarchicalBeanFactory extends BeanFactory {

    BeanFactory getParentBeanFactory();

    boolean containsLocalBean(String name);

}

5、AutowireCapableBeanFactory

BeanFactory接口的扩展,实现这个接口的bean factories具有自动装配的能力，提供给它们想要暴露这个功能给目前的bean实例。

public interface AutowireCapableBeanFactory extends BeanFactory {

    //-------------------------------------------------------------------------
    // Typical methods for creating and populating external bean instances
    //-------------------------------------------------------------------------

     T createBean(Class beanClass) throws BeansException;

    void autowireBean(Object existingBean) throws BeansException;

    Object configureBean(Object existingBean, String beanName) throws BeansException;

    //-------------------------------------------------------------------------
    // Specialized methods for fine-grained control over the bean lifecycle
    //-------------------------------------------------------------------------

    Object createBean(Class beanClass, int autowireMode, boolean dependencyCheck) throws BeansException;

    Object autowire(Class beanClass, int autowireMode, boolean dependencyCheck) throws BeansException;

    void autowireBeanProperties(Object existingBean, int autowireMode, boolean dependencyCheck)
            throws BeansException;

    void applyBeanPropertyValues(Object existingBean, String beanName) throws BeansException;

    Object initializeBean(Object existingBean, String beanName) throws BeansException;

    Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
            throws BeansException;

    Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
            throws BeansException;

    void destroyBean(Object existingBean);

    //-------------------------------------------------------------------------
    // Delegate methods for resolving injection points
    //-------------------------------------------------------------------------

    Object resolveDependency(DependencyDescriptor descriptor, String requestingBeanName) throws BeansException;

    Object resolveDependency(DependencyDescriptor descriptor, String requestingBeanName,
            Set autowiredBeanNames, TypeConverter typeConverter) throws BeansException;

}

6、ConfigurableListableBeanFactory

被大多数listable的bean factories实现的配置接口。除了ConfigurableBeanFactory之外，它还提供了分析和修改bean definitions.并且预实例化singletons.

public interface ConfigurableListableBeanFactory
        extends ListableBeanFactory, AutowireCapableBeanFactory, ConfigurableBeanFactory {

    void ignoreDependencyType(Class type);

    void ignoreDependencyInterface(Class ifc);

    void registerResolvableDependency(Class dependencyType, Object autowiredValue);

    boolean isAutowireCandidate(String beanName, DependencyDescriptor descriptor)
            throws NoSuchBeanDefinitionException;

    BeanDefinition getBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;

    Iterator getBeanNamesIterator();

    void clearMetadataCache();

    void freezeConfiguration();

    boolean isConfigurationFrozen();

    void preInstantiateSingletons() throws BeansException;

}

7、BeanDefinitionRegistry

注册并且保存bean definition的接口，例如RootBeanDefinition和ChildBeanDefinition实例。BeanFactory的典型实现使用AbstractBeanDefinition的等级的内部工作。

public interface BeanDefinitionRegistry extends AliasRegistry {

    void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
            throws BeanDefinitionStoreException;

    void removeBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;

    BeanDefinition getBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;

    boolean containsBeanDefinition(String beanName);

    String[] getBeanDefinitionNames();

    int getBeanDefinitionCount();

    boolean isBeanNameInUse(String beanName);

}

上面说了很多BeanDefinition这个对象，其实它就是Spring对于XML解析后的对象，然后把它储存在Spring容器中。然后当调用getBean()操作的时候就会触发依赖注入。也就是下面的3个过程:
1. createBeanInstance()。创建bean实例。
2. populateBean().装载bean属性。
3. initializeBean()。初始化bean.
然后就能够得到我们想到的POJO对象了。

8、SingletonBeanRegistry

顾名思义，这个接口是用来用Singletion作用域进行操作的。这个接口是对Singletion作用域的Bean的一个统一的方式。其中包含对它的注册,获取等等一系列的操作。

public interface SingletonBeanRegistry {

    void registerSingleton(String beanName, Object singletonObject);

    Object getSingleton(String beanName);

    boolean containsSingleton(String beanName);

    String[] getSingletonNames();

    int getSingletonCount();

    Object getSingletonMutex();

}

9、AliasRegistry

其实这个接口是对Spring bean别名的管理。主要是服务于BeanDefinitionRegistry这个接口。

public interface AliasRegistry {

    void registerAlias(String name, String alias);

    void removeAlias(String alias);

    boolean isAlias(String name);

    String[] getAliases(String name);

}

10、DefaultListableBeanFactory

把上面的接口都讲了，其实上面的接口的实现类就是DefaultListableBeanFactory，它包含了上面接口的所有的功能。DefaultListableBeanFactory为Spring IOC的整个过程服务的，包括把XML解析后成Spring的内部对象BeanDefinition注册到Spring里面.然后通过调用getBean()方法实现Spring对于POJO对象的依赖注入。这里分析了Spring IOC中BeanFactory对于Spring IOC的作用。只能算是了解了Spring IOC的基本过程。我将会在后面的补充一篇ApplicationContext的分享来讲Spring IOC对于资源的加载，然后就是容器更多的高级用法。