乐趣区

关于java:二BeanFactory源码分析

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

BeanFactory

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

public interface BeanFactory {

    // 这里能够临时不必管
    String FACTORY_BEAN_PREFIX = "&";

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

FACTORY_BEAN_PREFIX 是用于与 BeanFactory 类似类~~~~FactoryBean 的相干应用,后续会在 Aop 讲。

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,就容器方面而言性能曾经健全了。

退出移动版