Spring IOC（四）：相关特性

参考书籍：《Spring技术内幕》

Spring IOC（一）：概述

Spring IOC（二）：初始化

Spring IOC（三）：依赖注入

Spring IOC（四）：相关特性

下面对容器的一些其他相关特性的设计原理也进行简要的分析。这些特性都是在使用loC容器的时候会经常遇到的。

对于BeanFactory, 特别是ApplicationContext, 容器自身也有一个初始化和销毁关闭的过程。下面详细看看在这两个过程中，应用上下文完成了什么，可以让我们更多地理解应用上下文的工作，容器初始化和关闭过程可以简要地通过下图来表现。

从图中可以看到，对ApplicationContext启动的过程是在AbstractApplicationcontext中实现的，在使用应用上下文时需要做一些准备工作，这些准备工作在prepareBeanFactory()方法中实现。在这个方法中，为容器配置了ClassLoader, PropertyEditor和BeanPostProcessor等，从而为容器的启动做好了必要的准备工作。

//这个方法在refresh()函数中在创建容器之后调用
 
 protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
     // Tell the internal bean factory to use the context's class loader etc.
     beanFactory.setBeanClassLoader(getClassLoader());
     if (!shouldIgnoreSpel) {
         beanFactory.setBeanexpressionResolver(new StandardBeanexpressionResolver(beanFactory.getBeanClassLoader()));
     }
     beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));
 
     // Configure the bean factory with context callbacks.
     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);
     beanFactory.ignoreDependencyInterface(ApplicationStartupAware.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);
 
     // Register early post-processor for detecting inner beans as ApplicationListeners.
     beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));
 
     // Detect a LoadTimeWeaver and prepare for weaving, if found.
     if (!NativeDetector.inNativeImage() && 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());
     }
     if (!beanFactory.containsLocalBean(APPLICATION_STARTUP_BEAN_NAME)) {
         beanFactory.registerSingleton(APPLICATION_STARTUP_BEAN_NAME, getApplicationStartup());
     }
 }

同样，在容器要关闭时，也需要完成一系列的工作，这些工作在doClose()方法中完成。在这个方法中，先发出容器关闭的信号，然后将Bean逐个关闭，最后关闭容器自身。

@SuppressWarnings("deprecation")
 protected void doClose() {
     // Check whether an actual close attempt is necessary...
     if (this.active.get() && this.closed.compareAndSet(false, true)) {
         if (logger.isDebugEnabled()) {
             logger.debug("Closing " + this);
         }
 
         if (!NativeDetector.inNativeImage()) {
             LiveBeansView.unregisterApplicationContext(this);
         }
 
         try {
             // Publish shutdown event.
             publishEvent(new ContextClosedEvent(this));
         }
         catch (Throwable ex) {
             logger.warn("Exception thrown from ApplicationListener handling ContextClosedEvent", ex);
         }
 
         // Stop all Lifecycle beans, to avoid delays during individual destruction.
         if (this.lifecycleProcessor != null) {
             try {
                 this.lifecycleProcessor.onClose();
             }
             catch (Throwable ex) {
                 logger.warn("Exception thrown from LifecycleProcessor on context close", ex);
             }
         }
 
         // Destroy all cached singletons in the context's BeanFactory.
         destroyBeans();
 
         // Close the state of this context itself.
         closeBeanFactory();
 
         // Let subclasses do some final clean-up if they wish...
         onClose();
 
         // Reset local application listeners to pre-refresh state.
         if (this.earlyApplicationListeners != null) {
             this.applicationListeners.clear();
             this.applicationListeners.addAll(this.earlyApplicationListeners);
         }
 
         // Switch to inactive.
         this.active.set(false);
     }
 }

以上是容器的初始化和销毁的设计与实现。

在应用开发中，常常需要执行一些特定的初始化工作，这些工作都是相对比较固定的，比如建立数据库连接，打开网络连接等，同时，在结束服务时，也有一些相对固定的销毁工作需要执行。为了便于这些工作的设计，Spring IoC容器提供了相关的功能，可以让应用定制Bean的初始化和销毁过程。

容器的实现是通过IoC管理Bean的生命周期来实现的。Spring IoC容器在对Bean的生命周期进行管理时提供了Bean生命周期各个时间点的回调，在分析Bean初始化和销毁过程的设计之前，介绍一下loC容器中的Bean生命周期。

• Bean实例的创建
• 为Bean实例设置属性
• 初始化回调
• 应用可以通过IOC容器使用Bean
• 销毁回调

Bean的初始化方法调用是在doCreateBean()中调用的，具体初始化内容的逻辑实现是在initializeBean()方法中实现的：

//AbstractAutowireCapableBeanFactory类中: 在doCreateBean()方法中被调用，Bean实例创建后并且为Bean实例设置属性之后被调用
 protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
     if (System.getSecurityManager() != null) {
         AccessController.doPrivileged((PrivilegedAction