Spring（四）IOC容器的高级特性

• • 一、IOC 高级特性
  • • 1.1 延迟加载
    • • 1.1.1 延迟加载的使用
      • 1.1.2 延迟加载流程
    • 1.2 FactoryBean和BeanFactory
    • 1.3 自动装配
    • 1.4 两种后置处理器
  • 二、Bean生命周期的相关问题
  • • 2.1 Spring框架中Bean的生命周期
    • • 2.1.1 简述
      • 2.1.2 详述
      • 2.1.3 相关生命周期方法的使用
    • 2.2 用xml配置的方式重写init和destroy方法

本系列文章：
  Spring（一）IOC、DI、@Autowired、@Resource、作用域
  Spring（二）IOC容器的初始化流程
  Spring（三）IOC容器的依赖注入流程
  Spring（四）IOC容器的高级特性
  Spring（五）AOP、事务
  Spring（六）Spring MVC
  Spring（七）SpringBoot
  Spring（八）Spring Cloud

  通过前面章节中对Spring IOC容器的源码分析，我们已经基本上了解了Spring IOC容器对Bean定义资源的定位、载入和注册过程，同时也清楚了当用户通过 getBean()方法向IOC容器获取被管理的Bean时，IOC 容器对 Bean 进行的初始化和依赖注入过程，这些是 Spring IOC 容器的基本功能特性。
  Spring IOC容器还有一些高级特性，如使用lazy-init属性对Bean预初始化、FactoryBean产生或者修饰Bean对象的生成、IOC容器初始化Bean过程中使用BeanPostProcessor后置处理器对Bean声明周期事件管理和IOC容器的autowiring自动装配功能等。

   IOC 容器的初始化过程就是对 Bean定义资源的定位、载入和注册，此时容器对 Bean 的依赖注入并没有发生，依赖注入主要是在应用程序第一次向容器索取 Bean 时，通过 getBean()方法的调用完成。
  当 Bean 定义资源的元素中配置了lazy-init=false属性时，容器将会在初始化的时候对所配置的 Bean 进行预实例化，Bean的依赖注入在容器初始化的时候就已经完成。这样，当应用程序第一次向容器索取被管理的Bean时，就不用再初始化和对Bean进行依赖注入了，直接从容器中获取已经完成依赖注入的现成Bean，可以提高应用第一次向容器获取Bean的性能。

  ApplicationContext容器默认在启动服务器时将所有单例Bean提前进行实例化。提前实例化意味着作为初始化过程的一部分，ApplicationContext实例会创建并配置所有的单例Bean。
  比如：

  lazy-init="false"，立即加载，表示在spring启动时，立刻进行实例化。
  如果不想让个单例Bean在ApplicationContext实现初始化时被提前实例化，那么可以将Bean
设置为延迟实例化。示例：

  设置lazy-init为true的Bean将不会在ApplicationContext启动时提前被实例化，而是第一次向容器通过getBean索取Bean时实例化的。
  如果一个设置了立即加载的bean1，引用了一个延迟加载的bean2，那么bean1在容器启动时被实例化，而bean2由于被bean1引用，所以也被实例化，这种情况也符合延时加载的Bean在第一次调用时才被实例化的规则。
  如果一个bean的scope属性为scope=“pototype” 时，即使设置了lazy-init="false"，容器启动时也不会实例化Bean，而是调用getBean方法实例化的。

• 延迟加载场景
    1）开启延迟加载一定程度提高容器启动和运转性能。
    2）对于不常使用的Bean设置延迟加载，这样偶尔使用的时候再加载，不必要从一开始就让该Bean占用资源。

• 1、refresh()方法
    先从IOC 容器的初始化过程开始，我们知道IOC容器读入已经定位的 Bean 定义资源是从 refresh()方法开始的，我们首先从 AbstractApplicationContext 类的 refresh()方法入手分析：

	//refresh方法主要为IOC容器Bean的生命周期管理提供条件，在获取了BeanFactory之后都是在向该容器
	//注册信息源和生命周期事件。在创建IOC容器前，如果已经有容器存在，需要把已有的容器销毁和关闭，
	//以保证在refresh()方法之后使用的是新创建的IOC容器。
	@Override
	public void refresh() throws BeansException, IllegalStateException {
		synchronized (this.startupShutdownMonitor) {
			// 调用容器准备刷新的方法，获取容器的当前时间，同时给容器设置同步标识
			prepareRefresh();

			// 获得beanFactory
			ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

			// beanFactory的预准备工作，对beanfactory配置容器特性，例如类加载器、事件处理器等
			prepareBeanFactory(beanFactory);

			try {
				//beanFactory准备工作完成之后要进行的后置处理(BeanPost事件处理)工作，留给子类扩展使用
				postProcessBeanFactory(beanFactory);

				//调用所有注册的BeanFactoryPostProcessor的Bean
				invokeBeanFactoryPostProcessors(beanFactory);

				//为BeanFactory注册BeanPost事件处理器
				//BeanPostProcessors是Bean后置处理器，用于监听容器触发的事件
				registerBeanPostProcessors(beanFactory);

				//初始化MessageSource信息源，即国际化处理、消息绑定、消息解析
				initMessageSource();

				//初始化容器事件传播器
				initApplicationEventMulticaster();

				//留给子类来初始化其他的bean
				onRefresh();

				//在所有注册的bean中查找ApplicationListener，为事件广播器注册事件监听器
				registerListeners();

				//初始化所有剩下的单实例bean
				finishBeanFactoryInitialization(beanFactory);

				//完成刷新过程，初始化容器的生命周期事件处理器，并发布容器的生命周期事件
				finishRefresh();
			}

			catch (BeansException ex) {
				if (logger.isWarnEnabled()) {
					logger.warn("Exception encountered during context initialization - " +
							"cancelling refresh attempt: " + ex);
				}

				// 销毁已经创建的Bean
				destroyBeans();

				// 取消刷新操作，重置容器的同步标识
				cancelRefresh(ex);

				throw ex;
			}

			finally {
				// 重置公共缓存
				resetCommonCaches();
			}
		}
	}

  在 refresh()方法中ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();启动了 Bean 定义资源的载入、注册过程，而finishBeanFactoryInitialization方法是对注册后的 Bean定义中的预实例化(lazy-init=false，Spring 默认就是预实例化，即为 true)的 Bean 进行处理的地方。

• 2、finishBeanFactoryInitialization处理预实例化Bean
    当Bean定义资源被载入IOC容器之后，容器将Bean定义资源解析为容器内部的数据结构 BeanDefinition注册到容器中，AbstractApplicationContext 类中的 finishBeanFactoryInitialization()方法对配置了预实例化属性的 Bean 进行预初始化过程：

	//对配置了lazy-init属性的bean进行实例化处理
	protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
		//这是Spring3之后增加的代码，为容器准备一个转换服务，在对某些Bean属性进行转换时使用
		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));
		}

		if (!beanFactory.hasEmbeddedValueResolver()) {
			beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
		}

		String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
		for (String weaverAwareName : weaverAwareNames) {
			getBean(weaverAwareName);
		}

		//为了使类型匹配，停止使用临时的类加载器
		beanFactory.setTempClassLoader(null);

		//缓存容器中所有注册的BeanDefinition元数据，以防被修改
		beanFactory.freezeConfiguration();

		//对配置了lazy-init属性的单例模式的Bean进行预实例化处理
		beanFactory.preInstantiateSingletons();
	}

  ConfigurableListableBeanFactory是 一 个 接 口 ， 其preInstantiateSingletons()方法由其子类DefaultListableBeanFactory提供。

• 3、DefaultListableBeanFactory 对配置 lazy-init 属性单例Bean的预实例化

	@Override
	public void preInstantiateSingletons() throws BeansException {
		if (logger.isTraceEnabled()) {
			logger.trace("Pre-instantiating singletons in " + this);
		}

		//获取容器中的所有bean，依次进行初始化和创建对象
		List beanNames = new ArrayList<>(this.beanDefinitionNames);

		for (String beanName : beanNames) {
			//获取bean的定义信息
			RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
			//bean不是抽象的、是单实例的、是懒加载的
			if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
				//判断是否是FactoryBean，是否是实现FactoryBean接口的bean
				if (isFactoryBean(beanName)) {
					Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
					if (bean instanceof FactoryBean) {
						final FactoryBean factory = (FactoryBean) bean;
						//标识是否需要实例化
						boolean isEagerInit;
						if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
							isEagerInit = AccessController.doPrivileged((PrivilegedAction)
											((SmartFactoryBean) factory)::isEagerInit,
									getAccessControlContext());
						}
						else {
							isEagerInit = (factory instanceof SmartFactoryBean &&
									((SmartFactoryBean) factory).isEagerInit());
						}
						if (isEagerInit) {
							getBean(beanName);
						}
					}
				}
				else {
					//不是工厂Bean,利用getBean创建对象
					getBean(beanName);
				}
			}
		}

		for (String beanName : beanNames) {
			Object singletonInstance = getSingleton(beanName);
			if (singletonInstance instanceof SmartInitializingSingleton) {
				final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
				if (System.getSecurityManager() != null) {
					AccessController.doPrivileged((PrivilegedAction