refresh() 方法简析

最新推荐文章于 2022-10-26 17:29:34 发布

墨家先生

最新推荐文章于 2022-10-26 17:29:34 发布

阅读量2.6k

点赞数 3

分类专栏： Spring Framework 文章标签： spring

原文链接：https://blog.csdn.net/xuan_lu/article/details/108249324?spm=1001.2101.3001.6650.7&utm_medium=distribute.pc_relevant.none-task-blog-2%7Edefault%7EBlogCommendFromBaidu%7ERate-7.pc_relevant_paycolumn_v3&depth_1-utm_source=distribute.pc_relevant.none-task-blo

版权

Spring Framework 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

IOC 控制反转_牦牛先生的博客-CSDN博客_ioc控制反转和依赖注入Spring Framework 概述https://blog.csdn.net/centrl/article/details/115519480通过前面的学习，我们至少已经知道 IOC，下面我们就来说说 IOC 是个什么东西。1.写在前面首先来想一件事，作为程序员，怎么开发程序才最巴适？我觉得最起码有两点：开发简单、升级简单。开发简单，就是我们只管写业务逻辑（培养只会写 if-else 的程序员）。升级简单，这里也包含两点：我们使用的技术（可理解为框架）出了什么问...https://blog.csdn.net/centrl/article/details/115523139通过前面的学习，我们只需要进行简单的pojo编写就能实现一个应用程序，剩下的工作都交由 Spring Framework 框架。

框架核心IOC 容器构建的方法是refresh()，我们看看具体都做了什么。

1.refresh() 概览

该方法是 Spring Bean 加载的核心，它是 ClassPathXmlApplicationContext 的父类 AbstractApplicationContext 的一个方法，用于刷新整个Spring 上下文信息，定义了整个 Spring 上下文加载的流程。

@Override
public void refresh() throws BeansException, IllegalStateException {
    synchronized (this.startupShutdownMonitor) {
    // 1.准备预处理：记录容器的启动时间startupDate, 标记容器为激活，初始化上下文环境如文件路径信息，验证必填属性是否填写 
    this.prepareRefresh();
    // **2.告诉子类去刷新bean工厂，此方法解析配置文件并将bean信息存储到beanDefinition中，注册到BeanFactory（但是未被初始化，仅将信息写到了beanDefination的map中）**重点方法，下面的操作都基于这个beanFactory进行的
    ConfigurableListableBeanFactory beanFactory = this.obtainFreshBeanFactory();
    // 3.设置beanFactory的基本属性：类加载器，添加多个beanPostProcesser
    this.prepareBeanFactory(beanFactory);
    try {
        // 4.空实现：允许子类上下文中对beanFactory做后期处理
        this.postProcessBeanFactory(beanFactory);
         /**************************以上是BeanFactory的创建及预准备工作  ****************/
        // 5.调用BeanFactoryPostProcessor各个实现类的方法
        this.invokeBeanFactoryPostProcessors(beanFactory);
        //6. 注册 BeanPostProcessor 的实现类，注意看和 BeanFactoryPostProcessor 的区别
         // 此接口两个方法: postProcessBeforeInitialization 和 postProcessAfterInitialization
         // 两个方法分别在 Bean 初始化之前和初始化之后得到执行。注意，到这里 Bean 还没初始化
        this.registerBeanPostProcessors(beanFactory);
        //7.初始化ApplicationContext的MessageSource组件(资源文件)，如国际化文件，消息解析，绑定等
        this.initMessageSource();
        //8.初始化ApplicationContext事件广播器
        this.initApplicationEventMulticaster();
        // 9.初始化子类特殊bean（钩子方法）
        this.onRefresh();
        // 10.获取所有的事件监听器，并将监听器注册到事件广播器
        this.registerListeners();
        //** 11.初始化所有singleton bean；**重点方法
        this.finishBeanFactoryInitialization(beanFactory);
        // 12.广播事件：ApplicationContext初始化完成
        this.finishRefresh();
} catch (BeansException ex) {
	if (logger.isWarnEnabled()) {
	logger.warn("Exception encountered during context initialization - " + "cancelling refresh attempt: " + ex);
	}
		// 销毁bean
		this.destroyBeans();
		// 重置 'active' 标志.
		this.cancelRefresh(ex);
		throw ex;
			}
		}

一共12个方法，按作用简单划分一下：

1 为准备环境
2 3 4 5 6 为准备 BeanFactory
7 8 9 10 12 为准备 ApplicationContext
11 为初始化 BeanFactory 中非延迟单例 bean

2.步骤明细

2.1.prepareRefresh

准备预处理：

记录spring容器的启动时间startupDate,
标记容器为激活，
初始化上下文环境如文件路径信息，
验证必填属性是否填写，
初始化保存事件的集合。

//刷新前的预处理;
protected void prepareRefresh() {
    this.startupDate = System.currentTimeMillis();
    this.closed.set(false);
    this.active.set(true);

    if (logger.isInfoEnabled()) {
        logger.info("Refreshing " + this);
    }
    // 初始化一些属性设置;子类自定义个性化的属性设置方法；
    initPropertySources();   
    // 校验配置文件的属性，合法性
    getEnvironment().validateRequiredProperties();
    // 初始化保存事件的集合
    this.earlyApplicationEvents = new LinkedHashSet<ApplicationEvent>();
}

2.2.obtainFreshBeanFactory

获取BeanFactory，解析配置文件，生成beanDefinition;

protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
    // 创建了一个this.beanFactory = new DefaultListableBeanFactory();
    // 设置了序列化的ID
    // 自定义此上下文使用的内部beanFactory
    // 加载beanDefinitions
    refreshBeanFactory();
    // 返回刚才创建的DefaultListableBeanFactory
    ConfigurableListableBeanFactory beanFactory = getBeanFactory();
    if (logger.isDebugEnabled()) {
        logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);
    }
    return beanFactory;
}

2.3.prepareBeanFactory

该方法主要负责对BeanFactory的预准备工作，配置beanFactory的基础属性，比如ClassLoader和一些PostProcessor等。

设置BeanFactory的类加载器、支持表达式解析器…
添加部分BeanPostProcessor【ApplicationContextAwareProcessor】
设置忽略的自动装配的接口EnvironmentAware、EmbeddedValueResolverAware、xxx；
注册可以解析的自动装配；我们能直接在任何组件中自动注入：BeanFactory、ResourceLoader、ApplicationEventPublisher、ApplicationContext
添加BeanPostProcessor【ApplicationListenerDetector】
添加编译时的AspectJ；
给BeanFactory中注册一些能用的组件；

protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
   	// Tell the internal bean factory to use the context's class loader etc.
     //设置类加载器
   	beanFactory.setBeanClassLoader(getClassLoader());
      //设置bean表达式解析器，详解见下文
   	beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver());
   	//资源编辑注册器
   	beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));

   	//添加一个BeanPostProcessor：ApplicationContextAwareProcessor，用于向实现类ApplitionContextAware中，调用setApplicationContext方法，并将ApplicationContext作为参数。
   	beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
   
   	//添加忽略自动装配的接口
   	beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
   	beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
   	beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
   	beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
   	beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
   	beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);
   

   	// 注册几个解析依赖项，意思是，当一个Bean需要注入对应的类时，使用下面注册的这些类
   //比如，如果@Autowire 一个BeanFactory，那么这个BeanFactory实际就是在此处注册的一个对象
   //这几项分别是：BeanFactory、ResourceLoader、ApplicationEventPublisher、ApplicationContext
   	beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
   	beanFactory.registerResolvableDependency(ResourceLoader.class, this);
   	beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
   	beanFactory.registerResolvableDependency(ApplicationContext.class, this);

   	// Detect a LoadTimeWeaver and prepare for weaving, if found.
   	//检查是否由LoadTimeWeaver，如果有loadTimeWeaver的bean，就放入一个BeanPostProcessor：LoadTimeWeaverAwareProcessor
   	if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
   		beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
   		// Set a temporary ClassLoader for type matching.
   		beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
   	}
   	
   	// 注册environment，注册成单例
   	if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
   		beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
   	}
   	 //注册systemProperties 成单例
   	if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
   		beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
   	}
      //注册 systemEnvironment 成单例
   	if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
   		beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
   	}
   }

这里涉及到几个点，BeanPostProcessor、XxxAware、XxxRegistrar，我们在另作讲解。

2.4.postProcessBeanFactory

主要负责在BeanFactory准备工作完成之后，beanFactory的后置处理工作；

protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
    }

这里使用了设计模式中的模板模式

2.5.invokeBeanFactoryPostProcessors

这一步会调用 beanFactory 后处理器。beanFactory 后处理器，充当 beanFactory 的扩展点，可以用来补充或修改 BeanDefinition。

常见的 beanFactory 后处理器有：

ConfigurationClassPostProcessor – 解析 @Configuration、@Bean、@Import、@PropertySource 等
PropertySourcesPlaceHolderConfigurer – 替换 BeanDefinition 中的 ${ }
MapperScannerConfigurer – 补充 Mapper 接口对应的 BeanDefinition

protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
    // Invoke BeanDefinitionRegistryPostProcessors first, if any.
    
    //用于存放已处理过的Bean
    Set<String> processedBeans = new HashSet<String>();
    
    //如果IOC容器是一个BeanDefinitionRegistry，有了注册BeanDefinition的能力，就可以执行BeanDefinitionRegistryPostProcessor的postProcessBeanDefinitionRegistry方法
    if (beanFactory instanceof BeanDefinitionRegistry) {
        
        BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
        
        //regularPostProcessors用于存放普通的BeanFactoryPostProcessor
        List<BeanFactoryPostProcessor> 
            regularPostProcessors = new LinkedList<BeanFactoryPostProcessor>();
        
        //registryPostProcessors用于存放 BeanDefinitionRegistryPostProcessor
        List<BeanDefinitionRegistryPostProcessor> 
            registryPostProcessors = new LinkedList<BeanDefinitionRegistryPostProcessor>();
        
        //查询通过addBeanFactoryPostProcessor等方法设置进来的的BeanFactoryPostProcessor（不是注册到IOC容器的中）
        for (BeanFactoryPostProcessor postProcessor : getBeanFactoryPostProcessors()) {
            
            //如果是 BeanDefinitionRegistryPostProcessor  ，
            //就先执行它的postProcessBeanDefinitionRegistry，用于向IOC中注册一些BeanDefinition，
            //然后添加到registryPostProcessors队列中
          if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
                BeanDefinitionRegistryPostProcessor registryPostProcessor =
                    (BeanDefinitionRegistryPostProcessor) postProcessor;
				  
            	registryPostProcessor.postProcessBeanDefinitionRegistry(registry);
                registryPostProcessors.add(registryPostProcessor);
            }
            else {
                //如果是普通的BeanFactoryPostProcessor，就添加到regularPostProcessors队列中
                regularPostProcessors.add(postProcessor);
            }
        }
        
        //获取IOC容器中注册的BeanDefinitionRegistryPostProcessor，
        //放入到registryPostProcessorBeans中，
        //并按照Order排序
        Map<String, BeanDefinitionRegistryPostProcessor> beanMap =
            beanFactory.getBeansOfType(BeanDefinitionRegistryPostProcessor.class, true, false);
        
        List<BeanDefinitionRegistryPostProcessor> registryPostProcessorBeans =
            new ArrayList<BeanDefinitionRegistryPostProcessor>(beanMap.values());
       
        OrderComparator.sort(registryPostProcessorBeans);
        
        //先调用registryPostProcessorBeans中的所有postProcessBeanDefinitionRegistry方法
        for (BeanDefinitionRegistryPostProcessor postProcessor : registryPostProcessorBeans) {
            postProcessor.postProcessBeanDefinitionRegistry(registry);
        }
        //先调用 registryPostProcessors中的postProcessBeanFactory方法
        //再调用 registryPostProcessorBeans中的postProcessBeanFactory方法
        //最后调用 regularPostProcessors中的postProcessBeanFactory方法
        invokeBeanFactoryPostProcessors(registryPostProcessors, beanFactory);
        invokeBeanFactoryPostProcessors(registryPostProcessorBeans, beanFactory);
        invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
        
        //对于IOC容器中注册的BeanDefinitionRegistryPostProcessor来说，还要放置到processedBeans中，放置重复调用
        processedBeans.addAll(beanMap.keySet());
    }
    else {
        //如果IOC就是一个普通的BeanFacotry，就直接从context中取出所有的BeanFactoryPostProcessor，并调用他们的postProcessBeanFactory方法
        // Invoke factory processors registered with the context instance.
        invokeBeanFactoryPostProcessors(getBeanFactoryPostProcessors(), beanFactory);
    }
	
    // Do not initialize FactoryBeans here: We need to leave all regular beans
    // 查询IOC容器中所有的BeanFactoryPostProcessor，有可能上面的BeanDefinitionRegistryPostProcessor刚刚向IOC容器中注册了一些BeanFactoryPostProcessor，所以要在此处全部查出来。
    String[] postProcessorNames =
        beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);

    // 按照 这些BeanFactoryPostProcessor实现的排序接口（ PriorityOrdered 和 Ordered）分成3组
    //第一组 实现了PriorityOrdered  --- priorityOrderedPostProcessors
    //第二组 实现了Ordered          --- orderedPostProcessorNames
    //第三组 没有实现排序接口         --- nonOrderedPostProcessorNames
    List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<BeanFactoryPostProcessor>();
    List<String> orderedPostProcessorNames = new ArrayList<String>();
    List<String> nonOrderedPostProcessorNames = new ArrayList<String>();
    
    for (String ppName : postProcessorNames) {
        //如果已经处理了，就跳过
        if (processedBeans.contains(ppName)) {
            // skip - already processed in first phase above
        }
         //实现PriorityOrdered 接口的
        else if (isTypeMatch(ppName, PriorityOrdered.class)) {
           
            priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
        }
        // 实现Ordered 接口的
        else if (isTypeMatch(ppName, Ordered.class)) {
            orderedPostProcessorNames.add(ppName);
        }
        //普通的
        else {
            nonOrderedPostProcessorNames.add(ppName);
        }
    }
      //然后先执行priorityOrderedPostProcessors中的，再执行orderedPostProcessorNames的，最后执行nonOrderedPostProcessorNames
	
    //排序并执行priorityOrderedPostProcessors的
    OrderComparator.sort(priorityOrderedPostProcessors);
    invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);

    // 排序并执行orderedPostProcessors的
    List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<BeanFactoryPostProcessor>();
    for (String postProcessorName : orderedPostProcessorNames) {
        orderedPostProcessors.add(getBean(postProcessorName, BeanFactoryPostProcessor.class));
    }
    OrderComparator.sort(orderedPostProcessors);
    invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);

    // 最后执行普通的BeanFactoryPostProcessor的
    List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<BeanFactoryPostProcessor>();
    for (String postProcessorName : nonOrderedPostProcessorNames) {
        nonOrderedPostProcessors.add(getBean(postProcessorName, BeanFactoryPostProcessor.class));
    }
    invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);
}

2.6.registerBeanPost Processors

这一步是继续从 beanFactory 中找出 bean 后处理器，添加至 beanPostProcessors 集合

bean 后处理器，充当 bean 的扩展点，可以工作在 bean 的实例化、依赖注入、初始化阶段，常见的有：

AutowiredAnnotationBeanPostProcessor 功能有：解析 @Autowired，@Value 注解
CommonAnnotationBeanPostProcessor 功能有：解析 @Resource，@PostConstruct，@PreDestroy
AnnotationAwareAspectJAutoProxyCreator 功能有：为符合切点的目标 bean 自动创建代理

protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {
    // 获取IOC中注册的 BeanPostProcessor
    String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);

    // BeanPostProcessorChecker 也是一个 BeanPostProcessor，用于检查一个Bean应该经过的BeanPostProcessor和
    
    int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
    beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));

    //按照排序接口分类。
    //这里需要注意的是，priorityOrderedPostProcessors里面装的是BeanPostProcessor
    //而orderedPostProcessorNames和nonOrderedPostProcessorNames里面装的是BeanPostProcessor的name
    //原因是：实例化BeanPostProcessor实现类的时候，也需要调用IOC中已有的BeanPostProcessor，所以Spring这里没有提前实例化Orderd接口和普通的BeanPostProcessor。
    //因此，这里有一个有趣的现象，示例化Orderd接口的BeanProcessor的时候，会使用PriorityOrdered的BeanPostProcessor进行处理
    //实例化普通的BeanProcessor时，会先后经过PriorityOrdered和Orderd接口的BeanPostProcessor的处理
    
    List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<BeanPostProcessor>();
    List<BeanPostProcessor> internalPostProcessors = new ArrayList<BeanPostProcessor>();
    
    List<String> orderedPostProcessorNames = new ArrayList<String>();
    List<String> nonOrderedPostProcessorNames = new ArrayList<String>();
    
    //分类
    for (String ppName : postProcessorNames) {
        //PriorityOrdered接口的，先行实例化，并把MergedBeanDefinitionPostProcessor放入到internalPostProcessors中
        if (isTypeMatch(ppName, PriorityOrdered.class)) {
            BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
            priorityOrderedPostProcessors.add(pp);
            //
            if (pp instanceof MergedBeanDefinitionPostProcessor) {
                internalPostProcessors.add(pp);
            }
        }
        //Ordered接口的，这里只是把name记录下来。
        else if (isTypeMatch(ppName, Ordered.class)) {
            //
            orderedPostProcessorNames.add(ppName);
        }
        //普通的，这里只是把name记录下来。
        else {
            nonOrderedPostProcessorNames.add(ppName);
        }
    }

    //排序并注册PriorityOrdered接口的BeanPostProcessor
    OrderComparator.sort(priorityOrderedPostProcessors);
    registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);

    //排序并注册Ordered接口的BeanPostProcessor
    List<BeanPostProcessor> orderedPostProcessors = new ArrayList<BeanPostProcessor>();
    for (String ppName : orderedPostProcessorNames) {
        //这里才进行实例化，所以会使用实现了PriorityOrdered接口的BeanPostProcessor进行处理
        BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
        orderedPostProcessors.add(pp);
        //把MergedBeanDefinitionPostProcessor放入到internalPostProcessors中
        if (pp instanceof MergedBeanDefinitionPostProcessor) {
            internalPostProcessors.add(pp);
        }
    }
    OrderComparator.sort(orderedPostProcessors);
    registerBeanPostProcessors(beanFactory, orderedPostProcessors);

    // 注册普通的BeanPostProcessor
    List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<BeanPostProcessor>();
    for (String ppName : nonOrderedPostProcessorNames) {
       //这里才进行实例化，所以会使用实现了PriorityOrdered接口或Orderd的BeanPostProcessor进行处理
        BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
        nonOrderedPostProcessors.add(pp);
         //把 MergedBeanDefinitionPostProcessor 放入到internalPostProcessors中
        //同时注意到，即使在internalPostProcessors中
        //BeanPostProcessor的顺序也是按照 PriorityOrderd > Orderd > 普通 的顺序进入的。
        if (pp instanceof MergedBeanDefinitionPostProcessor) {
            internalPostProcessors.add(pp);
        }
    }
    registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);

    //注册所有的MergedBeanDefinitionPostProcessor
    OrderComparator.sort(internalPostProcessors);
    registerBeanPostProcessors(beanFactory, internalPostProcessors);
	
    //最后，在末尾添加一个ApplicationListenerDetector
    beanFactory.addBeanPostProcessor(new ApplicationListenerDetector());
}

2.7.initMessageSource

初始化MessageSource组件（做国际化功能；消息绑定，消息解析）；
MessageSource：取出国际化配置文件中的某个key的值；能按照区域信息获取。

protected void initMessageSource() {
    ConfigurableListableBeanFactory beanFactory = getBeanFactory();
    if (beanFactory.containsLocalBean(MESSAGE_SOURCE_BEAN_NAME)) {
        this.messageSource = beanFactory.getBean(MESSAGE_SOURCE_BEAN_NAME, MessageSource.class);
        // Make MessageSource aware of parent MessageSource.
        //如果已经注册了 messageSource && messageSource是HierarchicalMessageSource && messageSource没有parent && 此IOC有parent 
        if (this.parent != null && this.messageSource instanceof HierarchicalMessageSource) {
            HierarchicalMessageSource hms = (HierarchicalMessageSource) this.messageSource;
            if (hms.getParentMessageSource() == null) {
                // Only set parent context as parent MessageSource if no parent MessageSource
                // registered already.
                hms.setParentMessageSource(getInternalParentMessageSource());
            }
        }
        if (logger.isDebugEnabled()) {
            logger.debug("Using MessageSource [" + this.messageSource + "]");
        }
    }
    //如果没有注册messageSource，就创建一个DelegatingMessageSource,并注册到IOC中
    else {
        // Use empty MessageSource to be able to accept getMessage calls.
        DelegatingMessageSource dms = new DelegatingMessageSource();
        dms.setParentMessageSource(getInternalParentMessageSource());
        this.messageSource = dms;
        beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource);
        if (logger.isDebugEnabled()) {
            logger.debug("Unable to locate MessageSource with name '" + MESSAGE_SOURCE_BEAN_NAME +
                         "': using default [" + this.messageSource + "]");
        }
    }
}

2.8.initApplicationEventMulticaster

这一步为 ApplicationContext 添加事件广播器成员，即 applicationContextEventMulticaster

它的作用是发布事件给监听器。

protected void initApplicationEventMulticaster() {
    ConfigurableListableBeanFactory beanFactory = getBeanFactory();
    //如果有开发自定的applicationEventMulticaster实例bean，则设置IOC的事件广播器为该实例
    if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) {
        this.applicationEventMulticaster =
            beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class);
        if (logger.isDebugEnabled()) {
            logger.debug("Using ApplicationEventMulticaster [" + this.applicationEventMulticaster + "]");
        }
    }
    //如果没有applicationEventMulticaster，就设置一个SimpleApplicationEventMulticaster
    else {
        this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
        beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster);
        if (logger.isDebugEnabled()) {
            logger.debug("Unable to locate ApplicationEventMulticaster with name '" +
                         APPLICATION_EVENT_MULTICASTER_BEAN_NAME +
                         "': using default [" + this.applicationEventMulticaster + "]");
        }
    }
}

2.9.onRefresh

模板设计模式;该方法属于钩子方法；子类重写该方法并在容器刷新的时候自定义逻辑；

protected void onRefresh() throws BeansException {
		// For subclasses: do nothing by default.
}

2.10.registerListeners

注册监听器分为两部分:

向事件分发器注册硬编码设置的applicationListener
向事件分发器注册一个IOC中的事件监听器（并不实例化）

protected void registerListeners() {
    // 查出所有通过addApplicationListener方法添加的ApplicationListener，然后注册到事件广播器上
    for (ApplicationListener<?> listener : getApplicationListeners()) {
        getApplicationEventMulticaster().addApplicationListener(listener);
    }

    // 查出ioc容器中的所有ApplicationListener，只把他们注册到事件分发器的ApplicationListenerBean上，
    // 待使用时再进行实例化
    String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
    for (String listenerBeanName : listenerBeanNames) {
        getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
    }
}

2.11.finishBeanFactoryInitialization

finishBeanFactoryInitialization主要是负责初始化单实例的bean；该方法是重点方法，bean的生命周期基本调用getBean()方法完成。

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
    //如果IOC中有conversionService的话，就实例化并设置到IOC中
    //conversionService用于类型转换
    if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
        beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
        beanFactory.setConversionService(
            beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
    }
    // 如果有LoadTimeWeaverAware，就实例化
    String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
    for (String weaverAwareName : weaverAwareNames) {
        getBean(weaverAwareName);
    }
    // 清理临时的classLoader
    beanFactory.setTempClassLoader(null);
    // 缓存所有beanDefinition的name，以备不时之需
    beanFactory.freezeConfiguration();
    // 实例化所有非non-lazy-init的单例
    beanFactory.preInstantiateSingletons();
}

2.12.finishRefresh

完成bean创建和初始化过程，通知生命周期处理器 lifecycleProcessor 刷新过程，同时发出 ContextRefreshEvent 通知。

protected void finishRefresh() {
    // 实例化或初始化lifecycleProcessor
    initLifecycleProcessor();
    // 调用lifecycleProcessor的刷新方法
    getLifecycleProcessor().onRefresh();
    //发布一个ContextRefreshedEvent事件
    publishEvent(new ContextRefreshedEvent(this));
    // 注册MBean，用于JMX管理
    LiveBeansView.registerApplicationContext(this);
}

墨家先生

关注

3
点赞
踩
8

收藏

觉得还不错? 一键收藏
1
评论
refresh() 方法简析

IOC 控制反转_牦牛先生的博客-CSDN博客_ioc控制反转和依赖注入Spring Framework 概述https://blog.csdn.net/centrl/article/details/115519480通过前面的学习，我们至少已经知道 IOC，下面我们就来说说 IOC 是个什么东西。1.写在前面首先来想一件事，作为程序员，怎么开发程序才最巴适？我觉得最起码有两点：开发简单、升级简单。开发简单，就是我们只管写业务逻辑（培养只会写 if-else 的程序员）。升级简单，这里也包含两点：我们使用的
复制链接

扫一扫