• spring beans源码解读之--BeanFactory的注册


    beanFactory的继承关系如下图所示:

          (图片来源:http://www.myexception.cn/software-architecture-design/925888.html)

    在上节beanFactory的进化史,我们就讲到了上图的左边部分,这次我们来分析一下图的右边部分。AliasRegistry 是一个用于别名管理的通用接口,BeanDefinitionRegistry继承了该接口。

    SimpleAliasRegistry作为一个基类,实现了AliasRegistry接口。

    SingletonBeanRegistry是spring 提供的一个共享bean的注册接口。实现该接口可以方便对单例进行管理。

    public interface SingletonBeanRegistry {
    
        /**
         * Register the given existing object as singleton in the bean registry,
         * under the given bean name.
         * <p>The given instance is supposed to be fully initialized; the registry
         * will not perform any initialization callbacks (in particular, it won't
         * call InitializingBean's {@code afterPropertiesSet} method).
         * The given instance will not receive any destruction callbacks
         * (like DisposableBean's {@code destroy} method) either.
         * <p>When running within a full BeanFactory: <b>Register a bean definition
         * instead of an existing instance if your bean is supposed to receive
         * initialization and/or destruction callbacks.</b>
         * <p>Typically invoked during registry configuration, but can also be used
         * for runtime registration of singletons. As a consequence, a registry
         * implementation should synchronize singleton access; it will have to do
         * this anyway if it supports a BeanFactory's lazy initialization of singletons.
         * @param beanName the name of the bean
         * @param singletonObject the existing singleton object
         * @see org.springframework.beans.factory.InitializingBean#afterPropertiesSet
         * @see org.springframework.beans.factory.DisposableBean#destroy
         * @see org.springframework.beans.factory.support.BeanDefinitionRegistry#registerBeanDefinition
         */
        void registerSingleton(String beanName, Object singletonObject);
    
        /**
         * Return the (raw) singleton object registered under the given name.
         * <p>Only checks already instantiated singletons; does not return an Object
         * for singleton bean definitions which have not been instantiated yet.
         * <p>The main purpose of this method is to access manually registered singletons
         * (see {@link #registerSingleton}). Can also be used to access a singleton
         * defined by a bean definition that already been created, in a raw fashion.
         * <p><b>NOTE:</b> This lookup method is not aware of FactoryBean prefixes or aliases.
         * You need to resolve the canonical bean name first before obtaining the singleton instance.
         * @param beanName the name of the bean to look for
         * @return the registered singleton object, or {@code null} if none found
         * @see ConfigurableListableBeanFactory#getBeanDefinition
         */
        Object getSingleton(String beanName);
    
        /**
         * Check if this registry contains a singleton instance with the given name.
         * <p>Only checks already instantiated singletons; does not return {@code true}
         * for singleton bean definitions which have not been instantiated yet.
         * <p>The main purpose of this method is to check manually registered singletons
         * (see {@link #registerSingleton}). Can also be used to check whether a
         * singleton defined by a bean definition has already been created.
         * <p>To check whether a bean factory contains a bean definition with a given name,
         * use ListableBeanFactory's {@code containsBeanDefinition}. Calling both
         * {@code containsBeanDefinition} and {@code containsSingleton} answers
         * whether a specific bean factory contains a local bean instance with the given name.
         * <p>Use BeanFactory's {@code containsBean} for general checks whether the
         * factory knows about a bean with a given name (whether manually registered singleton
         * instance or created by bean definition), also checking ancestor factories.
         * <p><b>NOTE:</b> This lookup method is not aware of FactoryBean prefixes or aliases.
         * You need to resolve the canonical bean name first before checking the singleton status.
         * @param beanName the name of the bean to look for
         * @return if this bean factory contains a singleton instance with the given name
         * @see #registerSingleton
         * @see org.springframework.beans.factory.ListableBeanFactory#containsBeanDefinition
         * @see org.springframework.beans.factory.BeanFactory#containsBean
         */
        boolean containsSingleton(String beanName);
    
        /**
         * Return the names of singleton beans registered in this registry.
         * <p>Only checks already instantiated singletons; does not return names
         * for singleton bean definitions which have not been instantiated yet.
         * <p>The main purpose of this method is to check manually registered singletons
         * (see {@link #registerSingleton}). Can also be used to check which singletons
         * defined by a bean definition have already been created.
         * @return the list of names as a String array (never {@code null})
         * @see #registerSingleton
         * @see org.springframework.beans.factory.support.BeanDefinitionRegistry#getBeanDefinitionNames
         * @see org.springframework.beans.factory.ListableBeanFactory#getBeanDefinitionNames
         */
        String[] getSingletonNames();
    
        /**
         * Return the number of singleton beans registered in this registry.
         * <p>Only checks already instantiated singletons; does not count
         * singleton bean definitions which have not been instantiated yet.
         * <p>The main purpose of this method is to check manually registered singletons
         * (see {@link #registerSingleton}). Can also be used to count the number of
         * singletons defined by a bean definition that have already been created.
         * @return the number of singleton beans
         * @see #registerSingleton
         * @see org.springframework.beans.factory.support.BeanDefinitionRegistry#getBeanDefinitionCount
         * @see org.springframework.beans.factory.ListableBeanFactory#getBeanDefinitionCount
         */
        int getSingletonCount();
    
    }

    注册接口的默认实现为:DefaultSingletonBeanRegistry,主要作用是提供能被所有调用者共享bean的注册,调用者可用通过bean 名称获取到该bean的实例。同时该类也提供了对注册bean的销毁方法。

    DefaultSingletonBeanRegistry也实现了AliasRegistry接口,增加了对别名的管理。

     FactoryBeanRegistrySupport 集成了DefaultSingletonBeanRegistry对bean的单例bean的管理功能,是一个基类,用来处理FactoryBean实例的单例bean的注册。

    我们重点介绍来研究一下AbstractBeanFactory的代码:

    public abstract class AbstractBeanFactory extends FactoryBeanRegistrySupport implements ConfigurableBeanFactory {
    // to do more
    }

    从继承关系上来讲,AbstractBeanFactory具备了ConfigurableBeanFactory 的完整功能,

  • 相关阅读:
    安卓开发_浅谈Android动画(三)
    安卓开发_浅谈Android动画(二)
    安卓开发_浅谈Android动画(一)
    Go语言获取系统性能数据gopsutil库
    Go语言标准库之log
    选项模式
    Go语言标准库之template
    Go语言基础之切片
    Go语言基础之反射
    Go语言基础之运算符
  • 原文地址:https://www.cnblogs.com/davidwang456/p/4153756.html
Copyright © 2020-2023  润新知