二、BeanFactory源码分析

BeanFactory提供最基本的Ioc容器的功能,BeanFactory只是一个接口类,并没有给出容器的具体实现,它通过不同的实现类,来定义或者扩充某个功能。从名字上也很好理解,生产管理bean的工厂(容器),它负责生产和管理各个bean实例。BeanFactory接口相关的主要继承结构如下:

BeanFactory

BeanFactory是顶级接口,定义了Ioc容器最基本的形式。

public interface BeanFactory {

    //这里可以暂时不用管
    String FACTORY_BEAN_PREFIX = "&";

    Object getBean(String name) throws BeansException;
    ... //省略其它方法
}

BeanFactory接口直系亲属

ListableBeanFactory

通过名字,这定义的是一个可列举(迭代)的BeanFactory,通过这个BeanFactory可以查找特定的Bean,相比顶级的BeanFactory,其查询更加多样化,牵涉到BeanDefinition,BeanName,注解等。

public interface ListableBeanFactory extends BeanFactory {

    // 对于给定的名字是否含有BeanDefinition
    boolean containsBeanDefinition(String beanName);

    // 返回工厂的BeanDefinition总数
    int getBeanDefinitionCount();
    
    // 返回工厂中所有Bean的名字
    String[] getBeanDefinitionNames();

    // 返回对于指定类型 获取bean的名字
    String[] getBeanNamesForType(ResolvableType type);
    
    // 获取包含某个注解 bean的名字
    String[] getBeanNamesForAnnotation(Class<? extends Annotation> annotationType);

    // 根据指定Bean名和注解类型查找指定的Bean
    <A extends Annotation> A findAnnotationOnBean(String beanName, Class<A> annotationType)
            throws NoSuchBeanDefinitionException;

}

HierarchicalBeanFactory

分层式的BeanFactory,这个工厂接口非常简单,实现了Bean工厂的分层。相对于BeanFactory接口,它只扩展了一个重要的功能————工厂分层,可以指定父工厂(容器),同时查找Bean的时候,可以只查看本容器,忽略父容器。

public interface HierarchicalBeanFactory extends BeanFactory {

    BeanFactory getParentBeanFactory();

    /**
     * 返回本地bean工厂是否包含给定名称的bean,
     * 忽略父容器上下文中定义的bean。
     * <p>这是{@code containsBean}的替代方法,
     * 忽略bean来自一个父容器工厂的名字。
     */
    boolean containsLocalBean(String name);

}

AutowireCapableBeanFactory

AutowireCapableBeanFactory目前还没有深入的研究,这个Beanfactory增加了注解功能,可以通过注解进行装配(操作)的工厂(容器)。

public interface AutowireCapableBeanFactory extends BeanFactory {

    // 这个常量表明工厂没有自动装配的Bean
    int AUTOWIRE_NO = 0;

    // 表明根据名称自动装配
    int AUTOWIRE_BY_NAME = 1;

    // 表明根据类型自动装配
    int AUTOWIRE_BY_TYPE = 2;

    // 表明根据构造方法装配
    int AUTOWIRE_CONSTRUCTOR = 3;

    // 被废弃了
    @Deprecated
    int AUTOWIRE_AUTODETECT = 4;

    <T> T createBean(Class<T> beanClass) throws BeansException;

    // 给定对象,根据注释、后处理器等,进行自动装配
    void autowireBean(Object existingBean) throws BeansException;

    ...//省略后续方法
}

BeanFactory高级接口

SingletonBeanRegistry

SingletoBeanRegistry接口主要实现了单例类注册的功能。

public interface SingletonBeanRegistry {

    //注册一个单例类  
    void registerSingleton(String beanName, Object singletonObject);


    Object getSingleton(String beanName);


    boolean containsSingleton(String beanName);


    String[] getSingletonNames();
    
    int getSingletonCount();

    //不清楚
    Object getSingletonMutex();
}

ConfigurableBeanFactory

ConfigurableBeanFactory同时继承了HierarchicalBeanFactory和SingletonBeanRegistry这两个接口,即同时继承了分层和单例类注册的功能。

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 setBeanExpressionResolver(@Nullable BeanExpressionResolver resolver);
    
    BeanExpressionResolver getBeanExpressionResolver();

    /*
     * 设置 转换服务
     */
    void setConversionService(ConversionService conversionService);

    ConversionService getConversionService();

    void addPropertyEditorRegistrar(PropertyEditorRegistrar registrar);

    /*
     * 注册属性编辑器
     */
    void registerCustomEditor(Class<?> requiredType, Class<? extends PropertyEditor> propertyEditorClass);
    
    void copyRegisteredEditorsTo(PropertyEditorRegistry registry);
    
    void setTypeConverter(TypeConverter typeConverter);
    
    TypeConverter getTypeConverter();

    //设置一个Bean后处理器
    void addBeanPostProcessor(BeanPostProcessor beanPostProcessor);
    
    int getBeanPostProcessorCount();
    
    void registerScope(String scopeName, Scope scope);
    
    String[] getRegisteredScopeNames();
    
    Scope getRegisteredScope(String scopeName);
    
    void copyConfigurationFrom(ConfigurableBeanFactory otherFactory);
    /*
     * 给指定的Bean注册别名
     */
    void registerAlias(String beanName, String alias) throws BeanDefinitionStoreException;
    
    BeanDefinition getMergedBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;
    
    //判断指定Bean是否为一个工厂Bean
    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();
    
    ...//省略部分方法
}

ConfigurableListableBeanFactory

工厂接口ConfigrableListableBeanFactory同时继承了3个接口,ListableBeanFactory、AutowireCapableBeanfactory,ConfigurableBeanFactory,功能已经很全面了。

public interface ConfigurableListableBeanFactory
        extends ListableBeanFactory, AutowireCapableBeanFactory, ConfigurableBeanFactory {

    //忽略自动装配的依赖类型
    void ignoreDependencyType(Class<?> type);
    
    //忽略自动装配的接口
    void ignoreDependencyInterface(Class<?> ifc);

    //返回注册的Bean定义
    BeanDefinition getBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;


    Iterator<String> getBeanNamesIterator();

    ...//忽略部分方法
}

BeanDefinitionRegistry

BeanDefinitionRegistry用于对BeanDefinition的操作

public interface BeanDefinitionRegistry extends AliasRegistry {

    //给定bean名称,注册一个新的bean定义
    void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
            throws BeanDefinitionStoreException;

    //根据指定Bean名移除对应的Bean定义
    void removeBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;

    根据指定bean名得到对应的Bean定义
    BeanDefinition getBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;

    查找,指定的Bean名是否包含Bean定义
    boolean containsBeanDefinition(String beanName);

    //返回本容器内所有注册的Bean定义名称
    String[] getBeanDefinitionNames();

    //指定Bean名是否被注册过。
    int getBeanDefinitionCount();

   //指定Bean名是否被注册过。
    boolean isBeanNameInUse(String beanName);
}

BeanDefinition

Bean的定义主要由BeanDefinition来描述,作为Spring中用于包装Bean的数据结构。

// 标准单例作用域 标识符:“singleton”。
String SCOPE_SINGLETON = ConfigurableBeanFactory.SCOPE_SINGLETON;

// 标准原型作用域的范围标识符:“prototype”。
String SCOPE_PROTOTYPE = ConfigurableBeanFactory.SCOPE_PROTOTYPE;

// 表示BeanDefinition是应用程序主要部分的角色提示。 通常对应于用户定义的bean。
int ROLE_APPLICATION = 0;

// 表示BeanDefinition是某些大型配置的支持部分的角色提示,通常是一个外部ComponentDefinition。
// 当查看某个特定的ComponentDefinition时,认为bean非常重要,
// 以便在查看应用程序的整体配置时能够意识到这一点。

int ROLE_SUPPORT = 1;

// 角色提示表明一个BeanDefinition是提供一个完全背景的角色,并且与最终用户没有关系。
int ROLE_INFRASTRUCTURE = 2;

上面是BeanDifinition的一些基本属性信息,一个就是标识当前Bean的作用域,另外就是标识一下这个Bean是内部的还是外部的。

总结

ListableBeanFactory(可列举的容器(多花样查询)),HierarchicalBeanFactory(分层次容器,可有父容器),AutowireCapableBeanFactory(自动装配容器),这三个容器定义了BeanFactory的基本面貌,在这个三个直系亲属下面又派生了两个复杂的容器:ConfigurableBeanFactory,ConfigurableListableBeanFactory,可配置的(可操作)的容器,通过这两个BeanFactory 可有修改容器中的bean,功能又更加高级了,集成了单例bean 服务,以及BeanDefinition 注册服务,那么对于 DefaultListableBeanFactory 来说,此时它就是一个可注册,可配置,可获取的BeanFactory ,就容器方面而言功能已经健全了。

评论

暂无评论