spring-refresh方法

 public void refresh() throws BeansException, IllegalStateException {
//startupShutdownMonitor:refresh方法和destory方法公用的一个监视器，避免两个方法同时执行
        synchronized(this.startupShutdownMonitor) {
//刷新前预处理
            this.prepareRefresh();
            ConfigurableListableBeanFactory beanFactory = this.obtainFreshBeanFactory();
            this.prepareBeanFactory(beanFactory);

            try {
                this.postProcessBeanFactory(beanFactory);
                this.invokeBeanFactoryPostProcessors(beanFactory);
                this.registerBeanPostProcessors(beanFactory);
                this.initMessageSource();
                this.initApplicationEventMulticaster();
                this.onRefresh();
                this.registerListeners();
                this.finishBeanFactoryInitialization(beanFactory);
                this.finishRefresh();
            } catch (BeansException var9) {
                if (this.logger.isWarnEnabled()) {
                    this.logger.warn("Exception encountered during context initialization - cancelling refresh attempt: " + var9);
                }

                this.destroyBeans();
                this.cancelRefresh(var9);
                throw var9;
            } finally {
                this.resetCommonCaches();
            }

        }
    }

 

prepareRefresh方法

 

//刷新前的预处理    
protected void prepareRefresh() {
        this.startupDate = System.currentTimeMillis();
        this.closed.set(false);
        this.active.set(true);
        if (this.logger.isInfoEnabled()) {
            this.logger.info("Refreshing " + this);
        }
//初始化属性设置（未实现）
        this.initPropertySources();
//检验配置文件
        this.getEnvironment().validateRequiredProperties();
//保存当前容器里的事件
        this.earlyApplicationEvents = new LinkedHashSet();
    }

 

obtainFreshBeanFactory():销毁旧beanFactory，创建新beanFactory

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

 refresh方法之perpareBeanFactory方法：

	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.getBeanClassLoader()));
//内部属性编辑器；将xml里声明的变量转换成实际所需要的变量
		beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));

		// Configure the bean factory with context callbacks.
//实现内部aware接口，添加后置处理器
		beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
//忽略已在ApplicationContextAwareProcessor注入的属性
		beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
		beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
		beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
		beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);
		beanFactory.ignoreDependencyInterface(EnvironmentAware.class);

		// BeanFactory interface not registered as resolvable type in a plain factory.
		// MessageSource registered (and found for autowiring) as a bean.
//注册自动装配相关的类和实例
		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.
		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()));
		}

		// Register default environment beans.
		if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
			beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
		}
		if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
			beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
		}
		if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
			beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
		}
	}

postProcessBeanFactory：

 spring中并没有具体去实现postProcessBeanFactory方法，留给三方框架或者自己配置，作用是允许对beanFoctory进行扩展处理

 

invokeBeanFactoryPostProcessors

调用bean工厂的后置处理器。

Bean工厂的后置处理器：BeanFactoryPostProcessor（触发时机：bean定义注册之后bean实例化之前）和BeanDefinitionRegistryPostProcessor（触发时机：bean定义注册之前），所以可以在Bean工厂的后置处理器中修改Bean的定义信息，比如是否延迟加载、加入一些新的Bean的定义信息等。

（另起一篇）

registerBeanPostProcessors

注册BeanPostProcessor（bean的后置处理器）

（另起一篇）

initMessageSource

国际化

（另起一篇）

initApplicationEventMulticaster：

初始化广播器

（另起一篇）

onRefresh（）

registerListeners()

注册监听器

（另起一篇）

finishBeanFactoryInitialization(beanFactory);

实例化所有剩余的（非懒加载）单例

（另起一篇）

finishRefresh();

清除上下文资源缓存（如扫描中的ASM元数据）
初始化上下文的生命周期处理器，并刷新（找出Spring容器中实现了Lifecycle接口的bean并执行start()方法）。
发布ContextRefreshedEvent事件告知对应的ApplicationListener进行响应的操作

（另起一篇）

 

 

 

总结：

bean对象的实例化过程：

1.将xml配置文件配置信息，映射为BeanDefinition，并将其注册到相应的BeanDefinitionRegistry。（容器启动阶段）

在refresh方法中invokeBeanFactoryPostProcessors之前准备都是这一工作，既在spring容器加载了bean的定义文件之后，在bean实例化之前执行的spring容器创建。

2.注册BeanPostProcessor

3.实例化bean

 

bean的生命周期：

Spring Bean的完整生命周期从创建Spring容器开始，直到最终Spring容器销毁Bean

即三个过程：

实例化bean

执行bean业务功能

销毁bean

完整的实例化过程：

完整的实例化过程应该分为两步：

第一步：创建beanFactory

a.创建标准的beanFactory.

b.添加beanFactory的后置处理器

c.实例化并调用所有注册的beanFactory后置处理器

第二步：

实例化并初始化bean：

a.注册bean的后置处理器

b.调用构造函数创建对象

c.给创建的bean进行赋值

d.对bean进行初始化调用xxAware接口

e.调用bean的后置处理器

f.调用自定义的初始化方法

g.把创建好的bean放入缓存