• spring-BeanFactory源码解析


    BeanFactory继承体系

      1、BeanFactory作为一个主接口不继承任何接口,暂且称为一级接口

      2、有3个子接口继承了它,进行功能上的增强。这3个子接口称为二级接口

      3、ConfigurableBeanFactory可以被称为三级接口,对二级接口HierarchicalBeanFactory进行了再次增强,它还继承了另一个外来的接口SingletonBeanRegistry

      4、ConfigurableListableBeanFactory是一个更强大的接口,继承了上述的所有接口,无所不包,称为四级接口

      (这4级接口是BeanFactory的基本接口体系。继续,下面是继承关系的2个抽象类和2个实现类:)

      5、AbstractBeanFactory作为一个抽象类,实现了三级接口ConfigurableBeanFactory大部分功能。

      6、AbstractAutowireCapableBeanFactory同样是抽象类,继承自AbstractBeanFactory,并额外实现了二级接口AutowireCapableBeanFactory

      7、DefaultListableBeanFactory继承自AbstractAutowireCapableBeanFactory,实现了最强大的四级接口ConfigurableListableBeanFactory,并实现了一个外来接口BeanDefinitionRegistry,它并非抽象类。

      8、最后是最强大的XmlBeanFactory,继承自DefaultListableBeanFactory,重写了一些功能,使自己更强大。

    BeanFactory

    package org.springframework.beans.factory;
    
    public interface BeanFactory {
    
        //用来引用一个实例,或把它和工厂产生的Bean区分开
        //就是说,如果一个FactoryBean的名字为a,那么,&a会得到那个Factory
        String FACTORY_BEAN_PREFIX = "&";
    
        /*
         * 四个不同形式的getBean方法,获取实例
         */
        Object getBean(String name) throws BeansException;
        <T> T getBean(String name, Class<T> requiredType) throws BeansException;
        <T> T getBean(Class<T> requiredType) throws BeansException;
        Object getBean(String name, Object... args) throws BeansException;
        // 是否存在
        boolean containsBean(String name); 
        // 是否为单实例
        boolean isSingleton(String name) throws NoSuchBeanDefinitionException;
        // 是否为原型(多实例)
        boolean isPrototype(String name) throws NoSuchBeanDefinitionException;
        // 名称、类型是否匹配
        boolean isTypeMatch(String name, Class<?> targetType)
                throws NoSuchBeanDefinitionException;
        // 获取类型
        Class<?> getType(String name) throws NoSuchBeanDefinitionException; 
        // 根据实例的名字获取实例的别名
        String[] getAliases(String name);
    
    }

    ListableBeanFactory

    可将Bean逐一列出的工厂

    public interface ListableBeanFactory extends BeanFactory {
        // 对于给定的名字是否含有
        boolean containsBeanDefinition(String beanName); BeanDefinition
        // 返回工厂的BeanDefinition总数
        int getBeanDefinitionCount(); 
        // 返回工厂中所有Bean的名字
        String[] getBeanDefinitionNames(); 
        // 返回对于指定类型Bean(包括子类)的所有名字
        String[] getBeanNamesForType(Class<?> type); 
    
        /*
         * 返回指定类型的名字 
         *      includeNonSingletons为false表示只取单例Bean,true则不是
         *      allowEagerInit为true表示立刻加载,false表示延迟加载。 
         * 注意:FactoryBeans都是立刻加载的。
         */
        String[] getBeanNamesForType(Class<?> type, boolean includeNonSingletons,
                boolean allowEagerInit);
        // 根据类型(包括子类)返回指定Bean名和Bean的Map
        <T> Map<String, T> getBeansOfType(Class<T> type) throws BeansException; 
        <T> Map<String, T> getBeansOfType(Class<T> type,
                boolean includeNonSingletons, boolean allowEagerInit)
                throws BeansException;
    
        // 根据注解类型,查找所有有这个注解的Bean名和Bean的Map
        Map<String, Object> getBeansWithAnnotation(
                Class<? extends Annotation> annotationType) throws BeansException; 
    
        // 根据指定Bean名和注解类型查找指定的Bean
        <A extends Annotation> A findAnnotationOnBean(String beanName,
                Class<A> annotationType);
    
    }

    正如这个工厂接口的名字所示,这个工厂接口最大的特点就是可以列出工厂可以生产的所有实例。当然,工厂并没有直接提供返回所有实例的方法,也没这个必要。它可以返回指定类型的所有的实例。而且你可以通过getBeanDefinitionNames()得到工厂所有bean的名字,然后根据这些名字得到所有的Bean。这个工厂接口扩展了BeanFactory的功能,作为上文指出的BeanFactory二级接口,有9个独有的方法,扩展了跟BeanDefinition的功能,提供了BeanDefinition、BeanName、注解有关的各种操作。它可以根据条件返回Bean的集合,这就是它名字的由来——ListableBeanFactory。

    HierarchicalBeanFactory

    分层的Bean工厂

    public interface HierarchicalBeanFactory extends BeanFactory {
        //  返回本Bean工厂的父工厂
        BeanFactory getParentBeanFactory();    
        //  本地工厂是否包含这个Bean
        boolean containsLocalBean(String name);    
    }

    AutowireCapableBeanFactory

    自动装配的Bean工厂

    public interface AutowireCapableBeanFactory extends BeanFactory {
        // 这个常量表明工厂没有自动装配的Bean
        int AUTOWIRE_NO = 0;   
        // 表明根据名称自动装配
        int AUTOWIRE_BY_NAME = 1;  
        // 表明根据类型自动装配
        int AUTOWIRE_BY_TYPE = 2;  
        // 表明根据构造方法快速装配
        int AUTOWIRE_CONSTRUCTOR = 3;  
        //表明通过Bean的class的内部来自动装配(有没翻译错...)Spring3.0被弃用。
        @Deprecated
        int AUTOWIRE_AUTODETECT = 4;   
        //  根据指定Class创建一个全新的Bean实例
        <T> T createBean(Class<T> beanClass) throws BeansException;    
        //  给定对象,根据注释、后处理器等,进行自动装配
        void autowireBean(Object existingBean) throws BeansException;  
    
        // 根据Bean名的BeanDefinition装配这个未加工的Object,执行回调和各种后处理器。
        Object configureBean(Object existingBean, String beanName) throws BeansException;
    
        // 分解Bean在工厂中定义的这个指定的依赖descriptor
        Object resolveDependency(DependencyDescriptor descriptor, String beanName) throws BeansException;
    
        // 根据给定的类型和指定的装配策略,创建一个新的Bean实例
        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;
    
        /*
         * 初始化一个Bean...
         */
        Object initializeBean(Object existingBean, String beanName) throws BeansException;
    
        /*
         * 初始化之前执行BeanPostProcessors
         */
        Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
                throws BeansException;
        /*
         * 初始化之后执行BeanPostProcessors
         */
        Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
                throws BeansException;
    
        /*
         * 分解指定的依赖
         */
        Object resolveDependency(DependencyDescriptor descriptor, String beanName,
                Set<String> autowiredBeanNames, TypeConverter typeConverter) throws BeansException;
    
    }

    这个工厂接口继承自BeanFacotory,它扩展了自动装配的功能,根据类定义BeanDefinition装配Bean、执行前、后处理器等

     

    ConfigurableBeanFactory

    复杂的配置Bean工厂

    public interface ConfigurableBeanFactory extends HierarchicalBeanFactory, SingletonBeanRegistry {
    
        String SCOPE_SINGLETON = "singleton";  //  单例
    
        String SCOPE_PROTOTYPE = "prototype";  //  原型
    
        /*
         * 搭配HierarchicalBeanFactory接口的getParentBeanFactory方法
         */
        void setParentBeanFactory(BeanFactory parentBeanFactory) throws IllegalStateException;
    
        /*
         * 设置、返回工厂的类加载器
         */
        void setBeanClassLoader(ClassLoader beanClassLoader);
    
        ClassLoader getBeanClassLoader();
    
        /*
         * 设置、返回一个临时的类加载器
         */
        void setTempClassLoader(ClassLoader tempClassLoader);
    
        ClassLoader getTempClassLoader();
    
        /*
         * 设置、是否缓存元数据,如果false,那么每次请求实例,都会从类加载器重新加载(热加载)
    
         */
        void setCacheBeanMetadata(boolean cacheBeanMetadata);
        
        boolean isCacheBeanMetadata();//是否缓存元数据
    
        /*
         * Bean表达式分解器
         */
        void setBeanExpressionResolver(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();
    
        /*
         * 增加一个嵌入式的StringValueResolver
         */
        void addEmbeddedValueResolver(StringValueResolver valueResolver);
    
        String resolveEmbeddedValue(String value);//分解指定的嵌入式的值
    
        void addBeanPostProcessor(BeanPostProcessor beanPostProcessor);//设置一个Bean后处理器
    
        int getBeanPostProcessorCount();//返回Bean后处理器的数量
    
        void registerScope(String scopeName, Scope scope);//注册范围
    
        String[] getRegisteredScopeNames();//返回注册的范围名
    
        Scope getRegisteredScope(String scopeName);//返回指定的范围
    
        AccessControlContext getAccessControlContext();//返回本工厂的一个安全访问上下文
    
        void copyConfigurationFrom(ConfigurableBeanFactory otherFactory);//从其他的工厂复制相关的所有配置
    
        /*
         * 给指定的Bean注册别名
         */
        void registerAlias(String beanName, String alias) throws BeanDefinitionStoreException;
    
        void resolveAliases(StringValueResolver valueResolver);//根据指定的StringValueResolver移除所有的别名
    
        /*
         * 返回指定Bean合并后的Bean定义
         */
        BeanDefinition getMergedBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;
    
        boolean isFactoryBean(String name) throws NoSuchBeanDefinitionException;//判断指定Bean是否为一个工厂Bean
    
        void setCurrentlyInCreation(String beanName, boolean inCreation);//设置一个Bean是否正在创建
    
        boolean isCurrentlyInCreation(String beanName);//返回指定Bean是否已经成功创建
    
        void registerDependentBean(String beanName, String dependentBeanName);//注册一个依赖于指定bean的Bean
    
        String[] getDependentBeans(String beanName);//返回依赖于指定Bean的所欲Bean名
    
        String[] getDependenciesForBean(String beanName);//返回指定Bean依赖的所有Bean名
    
        void destroyBean(String beanName, Object beanInstance);//销毁指定的Bean
    
        void destroyScopedBean(String beanName);//销毁指定的范围Bean
    
        void destroySingletons();  //销毁所有的单例类

    ConfigurableListableBeanFactory

    BeanFactory的集大成者

    public interface ConfigurableListableBeanFactory
            extends ListableBeanFactory, AutowireCapableBeanFactory, ConfigurableBeanFactory {
    
        void ignoreDependencyType(Class<?> type);//忽略自动装配的依赖类型
    
        void ignoreDependencyInterface(Class<?> ifc);//忽略自动装配的接口
    
        /*
         * 注册一个可分解的依赖
         */
        void registerResolvableDependency(Class<?> dependencyType, Object autowiredValue);
    
        /*
         * 判断指定的Bean是否有资格作为自动装配的候选者
         */
        boolean isAutowireCandidate(String beanName, DependencyDescriptor descriptor)
                throws NoSuchBeanDefinitionException;
    
        // 返回注册的Bean定义
        BeanDefinition getBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;
        // 暂时冻结所有的Bean配置
        void freezeConfiguration();
        // 判断本工厂配置是否被冻结
        boolean isConfigurationFrozen();
        // 使所有的非延迟加载的单例类都实例化。
        void preInstantiateSingletons() throws BeansException;
    
    }

    工厂接口ConfigurableListableBeanFactory同时继承了3个接口,ListableBeanFactory、AutowireCapableBeanFactory 和 ConfigurableBeanFactory,扩展之后,加上自有的这8个方法,这个工厂接口总共有83个方法,实在是巨大到不行了。这个工厂接口的自有方法总体上只是对父类接口功能的补充,包含了BeanFactory体系目前的所有方法,可以说是接口的集大成者。

    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);
    
        String[] getBeanDefinitionNames();//返回本容器内所有注册的Bean定义名称
    
        int getBeanDefinitionCount();//返回本容器内注册的Bean定义数目
    
        boolean isBeanNameInUse(String beanName);//指定Bean名是否被注册过。
    
    }
     
  • 相关阅读:
    647. Palindromic Substrings
    151. Reverse Words in a String
    iOS UICollectionView(转一) XIB+纯代码创建:cell,头脚视图 cell间距
    iOS tableViewCell 在自定义高度方法中遇到的问题,cell高度为0,cell显示不出来,cell直接显示第几个而不是...cell显示个数不对
    iOS自定义文字高度添加行间距
    iOS 去掉小数点后边多余的0
    iOS 接收新消息通知调用系统声音 震动
    iOS 正则表达式使用(转)
    iOS实现类似QQ的好友列表,自由展开折叠(在原来TableView的基础上添加一个字典,一个Button)
    iOS 工程默认只允许竖屏,在单独界面进行横竖转换,屏幕旋转
  • 原文地址:https://www.cnblogs.com/yintingting/p/6186642.html
Copyright © 2020-2023  润新知