美文网首页
Spring IOC容器初始化过程

Spring IOC容器初始化过程

作者: Xr丶_c967 | 来源:发表于2019-08-15 16:27 被阅读0次

    应用场景

    spring IOC 提供了一个基本JavaBean容器,通过IOC模式管理依赖关系,并通过依赖注入和AOP切面增强了为JavaBean这样的POJO对象赋予了事务管理,生命周期管理等基本功能

    控制反转

    对象的依赖关系的管理被反转了,转到了IOC容器中,对象之间的依赖关系由IOC容器进行管理,并由IOC容器完成对象的注入。

    IOC 容器系列实现与设计

    一个是实现BeanFactory接口简单容器系列,一个是ApplicationContext应用上下文,作为容器的高级形态存在

    BeanFactory

    如果把IOC容器比作一个水桶,那么BeanFactory就定义了这个水桶的基本功能,例如:能装水,有提手,容器里面装的水,则是BeanDefinition(依赖反转功能都是围绕BeanDefinition)

    • BenaFactory 容器设计原理

    我们以XmlBeanactory的实现为例来说明简单IOC容器的设计原理,其实XmlBeanFactory的功是建立在DefaultListableBeanFactory这个基础上

    
    public class XmlBeanFactory extends DefaultListableBeanFactory {
        private final XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(this);   
        public XmlBeanFactory(Resource resource) throws BeansException {
            //调用构造方法  
            this(resource, null);
        }
        public XmlBeanFactory(Resource resource, BeanFactory parentBeanFactory) throws BeansException {
            super(parentBeanFactory);
            //这段代码是真正的资源加载
            this.reader.loadBeanDefinitions(resource);
        }
     
    }
    
    • 使用IOC容器的步骤:
      1. 创建配置文件,里面包含了BeanDefinition的定义信息。
      2. 创建一个BeanFactory,使用是DefaultListableBeanFactory(纯粹是一个IOC容器)。
      3. 创建一个载入BeanDefinition的读取器,使用XmlBeanDefinitionReader来读取XML文件形式的BeanDefinition,通过回调配置给BeanFactory。
      4. 完成整个载入和注册Bean之后,需要IOC容器就建立起来了。就可以直接使用IOC容器
    ClassPathResource res = new ClassPathResource ("beans.xml");
    DefaultListableBeanFactory factory = new DefaultListableBeanFactory();
    //创建XmlBeanDefinitionReader ,并通过回调设置到BenFactory中
    XmlBeanDefinitionReader reder = new XmlBeanDefinitionReader(factory);
    reder.loadBeanDefinitions(res);
    
    ApplicationContext

    我们以FileSystemXmlApplicationContext的实现为例来说明ApplicationContext容器的设计原理,其主要功能已经在FileSystemXmlApplicationContext的基类AbstractXmlApplicationContext中实现。通过refresh()启动IOC容器

    • 初始化IOC容器过程
    1. Resource定位,指BeanDefinition的资源定位,它由ResourceLoader 通过统一的Resource接口完成。
    2. BeanDefinition的载入,把定义好的Bean表示成IOC容器内部的数据结构
    3. IOC容器注册BeanDefinition,这个过程是通过BeanDefinitionRegistry接口实现完成的,在IOC容器内部将BeanDefinition注入到一个hasmap中,IOC容器通过这个Hashmap来持有这些BeanDefinition数据机构

    PS: Bean定义的载入和依赖注入是两个独立过程,依赖注入一般发生在应用第一次通过getBean容器索取Bean的时候,如果Bean定义了lazyinit属性,那么这个Bean依赖注入在IOC容器初始化时就预先完成了。

    BeanDefinition的Resurce定位丶载入丶注册

    • 定位
      FileSystemXmlApplicationContext 继承了 abstractApplicationContext具备了ResourceLoader读入以Resource定义BeanDefinition 的能力,AbstractApplicationContext的基类是DefaultResourceLoader,所以关于IOC容器功能相关实现都是在FileSystemXmlApplicationContext中完成的。
    • 载入
      BeanDefinition载入分为两个部分,首先通过调用XML的解析器获取到document对象,但是这个对象没有按照spring bean 规则进行解析,是在documentReader中实现解析的,处理结果有BeanDefinitionHolder对象持有,BeanDefinitionHolder除了持有BeanDefinition对象外,还持有其他与BeanDefinition的使用相关信息,比如Bean名字,别名等。

    AbstractApplicationContext.refresh()标志着IoC容器的正式启动

    public void refresh() throws BeansException, IllegalStateException {
        synchronized (this.startupShutdownMonitor) {
            // Prepare this context for refreshing.
            //准备启动spring容器,设置容器的启动日期和活动标志 
            prepareRefresh();
    
            // Tell the subclass to refresh the internal bean factory.
            //获得容器ApplicationContext的子类BeanFactory。步骤如下:
            //1.如果已经有了BeanFactory就销毁它里面的单例Bean并关闭这个BeanFactory。
            //2.创建一个新的BeanFactory。
            //3.对这个BeanFactory进行定制(customize),如allowBeanDefinitionOverriding等参数
            //4.转载BeanDefinitions(读取配置文件,将xml转换成对应得BeanDefinition)
            //5.检查是否同时启动了两个BeanFactory。  
            ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
    
            // Prepare the bean factory for use in this context.
            //配置BeanFactory(就是将ApplicationContext的一些属性配置到BeanFactory上吧)
         //如重要的如设置classLoader;将BeanPostProcess注册到BeanFactory里  
            prepareBeanFactory(beanFactory);
    
            try {
            // Allows post-processing of the bean factory in context subclasses.
            //允许上下文的子类去执行postProcessor  
            postProcessBeanFactory(beanFactory);
    
            // Invoke factory processors registered as beans in the context.
            // 执行注册到该上下文的BeanFactoryPostProcessors
            invokeBeanFactoryPostProcessors(beanFactory);
    
            // Register bean processors that intercept bean creation.
            // 开始注册BeanPostProcessor来拦截其他的bean的初始化过程
            registerBeanPostProcessors(beanFactory);
    
            // Initialize message source for this context.
            // 初始化消息源
            initMessageSource();
    
            // Initialize event multicaster for this context.
            //注册上下文事件的广播集  
            initApplicationEventMulticaster();
    
            // Initialize other special beans in specific context subclasses.
            //初始化一些特殊的bean
            onRefresh();
    
            // Check for listener beans and register them.
            //查询并校验监听器并注册
            registerListeners();
    
            // Instantiate all remaining (non-lazy-init) singletons.
            /// 实例化所有非懒加载的所有bean
            finishBeanFactoryInitialization(beanFactory);
    
            // Last step: publish corresponding event.
            //最后一步发布所有的运用
            finishRefresh();
            }
    
            catch (BeansException ex) {
                if (logger.isWarnEnabled()) {
                    logger.warn("Exception encountered during context initialization - " +
                    "cancelling refresh attempt: " + ex);
                }
    
                // Destroy already created singletons to avoid dangling resources.
                destroyBeans();
    
                // Reset 'active' flag.
                cancelRefresh(ex);
    
                // Propagate exception to caller.
                throw ex;
            }
    
            finally {
                // Reset common introspection caches in Spring's core, since we
                // might not ever need metadata for singleton beans anymore...
                resetCommonCaches();
            }
        }
    }
    

    obtainFreshBeanFactory方法如下:

    protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
         
                refreshBeanFactory();
            ConfigurableListableBeanFactory beanFactory = getBeanFactory();
            if (logger.isDebugEnabled()) {
                logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);
            }
            return beanFactory;
        }
    

    在AbstractRefreshableApplicationContext的refreshBeanFactory()方法中创建BeanFactory,在创建前,如果容器已经存在,那么需要把已有的容器销毁与关闭,保证refresh之后使用的是新建立起来的IOC容器。

    protected final void refreshBeanFactory() throws BeansException {
            if (hasBeanFactory()) {
                destroyBeans();
                closeBeanFactory();
            }
            try {
                DefaultListableBeanFactory beanFactory = createBeanFactory();
                beanFactory.setSerializationId(getId());
                customizeBeanFactory(beanFactory);
                //第二步BeanDefinition的载入,第三步对载入的BeanDefinition在Ioc上注册
                loadBeanDefinitions(beanFactory);
                synchronized (this.beanFactoryMonitor) {
                    this.beanFactory = beanFactory;
                }
            }
            catch (IOException ex) {
                throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
            }
        }
    

    obtainFreshBeanFactory准备容器,refreshBeanFactory产生DefaultListableBeanFactoryro容器,getBeanFactory是对产生的容器校验,避免失败.可以看出其实真正使用的IoC容器是DefaultListableBeanFactory.

    • 注册
      DefaultListableBeanFactory实现了BeanDefinitionRegistry的接口,这个接口实现BeanDefinition向容器的注册。

    相关文章

      网友评论

          本文标题:Spring IOC容器初始化过程

          本文链接:https://www.haomeiwen.com/subject/mungjctx.html