【spring 源码】IOC 之 ClassPathXmlApplicationContext

时间 2019-11-07

标签 spring 源码 ioc classpathxmlapplicationcontext 栏目 Spring 繁體版

原文原文链接

先看下启动 Spring 容器的一个例子：前端

public class App {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("classpath:application.xml");
        // 从 context 中取出咱们的 Bean
        MessageService messageService = context.getBean(MessageService.class);
        System.out.println(messageService.getMessage());
    }
}
复制代码

ClassPathXmlApplicationContext 的源码：

public class ClassPathXmlApplicationContext extends AbstractXmlApplicationContext {
  // 将配置文件做为资源都存放到这个数组中
  private Resource[] configResources;
 
 // 若是已经有 ApplicationContext并须要配置成父子关系，那么调用这个构造方法
  public ClassPathXmlApplicationContext(ApplicationContext parent) {
    super(parent);
  }
  ...
  public ClassPathXmlApplicationContext(String[] configLocations, boolean refresh, ApplicationContext parent) throws BeansException {
    super(parent);
    // 解析配置文件列表，放置到上面说的那个 configResources 数组中
    setConfigLocations(configLocations);
    if (refresh) {
      refresh(); // 核心方法 调用AbstractApplicationContext.refresh()
    }
  }
    ...
}
复制代码

// AbstractApplicationContext.java L509java

@Override
public void refresh() throws BeansException, IllegalStateException {
   synchronized (this.startupShutdownMonitor) {
       // 准备工做，记录下容器的启动时间、标记“已启动”状态、处理配置文件中的占位符
      prepareRefresh();
       // 这步比较关键，这步完成后，配置文件就会解析成一个个 Bean 定义，注册到 BeanFactory 中，这里的 Bean 尚未初始化，只是配置信息都提取出来了，
      // 注册也只是将这些信息都保存到了注册中心(说到底核心是一个 beanName-> beanDefinition 的 map)
      ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
 
      // 设置 BeanFactory 的类加载器，添加几个 BeanPostProcessor，手动注册几个特殊的 bean
      // 这块待会会展开说
      prepareBeanFactory(beanFactory);
 
      try {
         // 【这里须要知道 BeanFactoryPostProcessor 这个知识点，Bean 若是实现了此接口，那么在容器初始化之后，Spring 会负责调用里面的 postProcessBeanFactory 方法。】
 
         // 这里是提供给子类的扩展点，到这里的时候，全部的 Bean 都加载、注册完成了，可是都尚未初始化
         // 具体的子类能够在这步的时候添加一些特殊的BeanFactoryPostProcessor 的实现类或作点什么事
         postProcessBeanFactory(beanFactory);
         // 调用 BeanFactoryPostProcessor 各个实现类的 postProcessBeanFactory(factory) 方法
         invokeBeanFactoryPostProcessors(beanFactory);
 
         // 注册 BeanPostProcessor 的实现类，注意看和 BeanFactoryPostProcessor 的区别
         // 此接口两个方法: postProcessBeforeInitialization 和 postProcessAfterInitialization
         // 两个方法分别在 Bean 初始化以前和初始化以后获得执行。注意，到这里 Bean 还没初始化
         registerBeanPostProcessors(beanFactory);
 
         // 初始化当前 ApplicationContext 的 MessageSource（国际化相关信息），国际化这里就不展开说了
         initMessageSource();
          // 初始化当前 ApplicationContext 的事件广播器，这里也不展开了
         initApplicationEventMulticaster();
 
         // 从方法名就能够知道，典型的模板方法(钩子方法)，
         // 具体的子类能够在这里初始化一些特殊的 Bean（在初始化 singleton beans 以前）
         onRefresh();
 
         // 注册事件监听器，监听器须要实现 ApplicationListener 接口。这也不是咱们的重点，过
         registerListeners();
 
         // 重点，重点，重点
         // 初始化全部的 singleton beans
         //（lazy-init 的除外）
         finishBeanFactoryInitialization(beanFactory);
 
         // 最后，广播事件，ApplicationContext 初始化完成
         finishRefresh();
      } catch (BeansException ex) {
         
         // Destroy already created singletons to avoid dangling resources.
         // 销毁已经初始化的 singleton 的 Beans，以避免有些 bean 会一直占用资源
         destroyBeans();
          // Reset 'active' flag.
         cancelRefresh(ex);
          // 把异常往外抛
         throw ex;
      }finally {
         // Reset common introspection caches in Spring's core, since we // might not ever need metadata for singleton beans anymore... resetCommonCaches(); } } } 复制代码

接下来对refresh（）方法进行分析：web

1-0.prepareRefresh() 建立 Bean 容器前的准备工做

AbstractApplicationContext.java L557spring

protected void prepareRefresh() {
   // 将 active 属性设置为 true，closed 属性设置为 false，它们都是 AtomicBoolean 类型
   this.closed.set(false);
   this.active.set(true);
    // Initialize any placeholder property sources in the context environment
   initPropertySources();
    // 校验 xml 配置文件
   getEnvironment().validateRequiredProperties();
    this.earlyApplicationEvents = new LinkedHashSet<ApplicationEvent>();
}
复制代码

1-1.obtainFreshBeanFactory() 建立 Bean 容器，加载并注册 Bean

// AbstractApplicationContext.java L613后端

protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
   // 关闭旧的 BeanFactory (若是有)，建立新的 BeanFactory，加载 Bean 定义、注册 Bean 等等
   refreshBeanFactory();
   // 返回刚刚建立的 BeanFactory
   ConfigurableListableBeanFactory beanFactory = getBeanFactory();
   if (logger.isDebugEnabled()) {
      logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);
   }
   return beanFactory;
}
复制代码

refreshBeanFactory（）是建立bean的入口，并将bean实例放到bean工厂的入口（beanName为key，bean实例为value放入beanFactory里的map中），在《【spring 源码】IOC 之bean实例的建立》里详细介绍这个方法的实现。数组

1-2 prepareBeanFactory(beanFactory) 准备bean容器

AbstractApplicationContext.java L627bash

protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
		// 设置 BeanFactory 的类加载器，咱们知道 BeanFactory 须要加载类，也就须要类加载器，这里设置为当前线程的上下文类加载器
		beanFactory.setBeanClassLoader(getClassLoader());
		//设置spring 的Spel表达式相关解析器，不是主流程，不作拓展
		beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
		//设置PropertyEditorRegistrar,经过PropertyEditor将xml解析出来的bean属性（字符串）和相应的java类型作转换
		beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));

		// 添加一个 BeanPostProcessor，这个 processor 比较简单，
        // 实现了 Aware 接口的几个特殊的 beans 在初始化的时候，这个 processor 负责回调
		beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
		 // 下面几行的意思就是，若是某个 bean 依赖于如下几个接口的实现类，在自动装配的时候忽略它们，Spring 会经过其余方式来处理这些依赖。
		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 赋值，若是有 bean 依赖了如下几个，会注入这边相应的值，
            * 以前咱们说过，"当前 ApplicationContext 持有一个 BeanFactory"，这里解释了第一行
            * ApplicationContext 继承了 ResourceLoader、ApplicationEventPublisher、MessageSource
            * 因此对于这几个，能够赋值为 this，注意 this 是一个 ApplicationContext
            */
		beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
		beanFactory.registerResolvableDependency(ResourceLoader.class, this);
		beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
		beanFactory.registerResolvableDependency(ApplicationContext.class, this);

		// ，在 bean 实例化后，若是是 ApplicationListener 的子类，那么将其添加到 listener 列表中，能够理解成：注册事件监听器
		beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));

		// 这里涉及到特殊的 bean:loadTimeWeaver，织入的一种方式，此处这不是咱们的重点，忽略它
		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()));
		}

        /**
        * 从下面几行代码咱们能够知道，Spring 每每很 "智能" 就是由于它会帮咱们默认注册一些有用的 bean，
        * 咱们也能够选择覆盖
        */
		//注册一个默认的environment的bean
		if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
			beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
		}
		//注册一个systemProperties的bean
		if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
			beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
		}
		//注册一个systemEnvironment的bean
		if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
			beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
		}
	}
复制代码

至此，准备bean容器结束了，主要就是初始化bean工厂的一些环境、类加载器等session

1-3 postProcessBeanFactory(beanFactory)

主要做用是：承接前文中的prepareBeanFactory()方法后，供子类在标准的基础上再添加自定义的属性性质，主要是注册BeanPostProcessors //AbstractRefreshableWebApplicationContext.java L159mybatis

/**
	 * Register request/session scopes, a {@link ServletContextAwareProcessor}, etc.
	 */
	@Override
	protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
	    //注册ServletContextAwareProcessor
		beanFactory.addBeanPostProcessor(new ServletContextAwareProcessor(this.servletContext, this.servletConfig));
		beanFactory.ignoreDependencyInterface(ServletContextAware.class);
		beanFactory.ignoreDependencyInterface(ServletConfigAware.class);
        
        //注册web环境，包括request、session、golableSession、application
		WebApplicationContextUtils.registerWebApplicationScopes(beanFactory, this.servletContext);
		  //注册servletContext、contextParamters、contextAttributes、servletConfig单例bean
		WebApplicationContextUtils.registerEnvironmentBeans(beanFactory, this.servletContext, this.servletConfig);
	}
复制代码

1-4 invokeBeanFactoryPostProcessors(beanFactory)

主要是实例化和调用全部已注册的BeanFactoryPostProcessors的postProcessBeanFactory(factory) 方法 //AbstractApplicationContext.java L686app

/**
	 * Instantiate and invoke all registered BeanFactoryPostProcessor beans,
	 * respecting explicit order if given.
	 * <p>Must be called before singleton instantiation.
	 */
	protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
	    //经过一个委托类来处理实例化调用
		PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());

		// Detect a LoadTimeWeaver and prepare for weaving, if found in the meantime
		// (e.g. through an @Bean method registered by ConfigurationClassPostProcessor)
		if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
			beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
			beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
		}
	}
复制代码

1-4-0 invokeBeanFactoryPostProcessors(beanFactory,beanFactoryPostProcessors)

//PostProcessorRegistrationDelegate.java L52

public static void invokeBeanFactoryPostProcessors(
			ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {

		// Invoke BeanDefinitionRegistryPostProcessors first, if any.
		Set<String> processedBeans = new HashSet<String>();

		if (beanFactory instanceof BeanDefinitionRegistry) {
			BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
			List<BeanFactoryPostProcessor> regularPostProcessors = new LinkedList<BeanFactoryPostProcessor>();
			List<BeanDefinitionRegistryPostProcessor> registryProcessors = new LinkedList<BeanDefinitionRegistryPostProcessor>();
            //遍历BeanFactoryPostProcessors
			for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
				if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
				//BeanDefinitionRegistryPostProcessor这个类很重要，spring集成mybatis时会用到它。后面会有篇文章专门介绍它的做用
				//BeanDefinitionRegistryPostProcessor容许在正常的BeanFactoryPostProcessor检测开始以前注册更多的自定义bean。常常用来自定义注解
					BeanDefinitionRegistryPostProcessor registryProcessor =
							(BeanDefinitionRegistryPostProcessor) postProcessor;
					registryProcessor.postProcessBeanDefinitionRegistry(registry);
					registryProcessors.add(registryProcessor);
				}
				else {
					regularPostProcessors.add(postProcessor);
				}
			}

			// Do not initialize FactoryBeans here: We need to leave all regular beans
			// uninitialized to let the bean factory post-processors apply to them!
			// Separate between BeanDefinitionRegistryPostProcessors that implement
			// PriorityOrdered, Ordered, and the rest.
			List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<BeanDefinitionRegistryPostProcessor>();

			// First, invoke the BeanDefinitionRegistryPostProcessors that implement PriorityOrdered.
			String[] postProcessorNames =
					beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
			for (String ppName : postProcessorNames) {
				if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
					currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
					processedBeans.add(ppName);
				}
			}
			sortPostProcessors(currentRegistryProcessors, beanFactory);
			registryProcessors.addAll(currentRegistryProcessors);
			invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
			currentRegistryProcessors.clear();

			// Next, invoke the BeanDefinitionRegistryPostProcessors that implement Ordered.
			postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
			for (String ppName : postProcessorNames) {
				if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
					currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
					processedBeans.add(ppName);
				}
			}
			sortPostProcessors(currentRegistryProcessors, beanFactory);
			registryProcessors.addAll(currentRegistryProcessors);
			invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
			currentRegistryProcessors.clear();

			// Finally, invoke all other BeanDefinitionRegistryPostProcessors until no further ones appear.
			boolean reiterate = true;
			while (reiterate) {
				reiterate = false;
				postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
				for (String ppName : postProcessorNames) {
					if (!processedBeans.contains(ppName)) {
						currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
						processedBeans.add(ppName);
						reiterate = true;
					}
				}
				sortPostProcessors(currentRegistryProcessors, beanFactory);
				registryProcessors.addAll(currentRegistryProcessors);
				invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
				currentRegistryProcessors.clear();
			}

			// Now, invoke the postProcessBeanFactory callback of all processors handled so far.
			invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
			invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
		}

		else {
			// Invoke factory processors registered with the context instance.
			invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
		}

		// Do not initialize FactoryBeans here: We need to leave all regular beans
		// uninitialized to let the bean factory post-processors apply to them!
		String[] postProcessorNames =
				beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);

		// Separate between BeanFactoryPostProcessors that implement PriorityOrdered,
		// Ordered, and the rest.
		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
			}
			else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
				priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
			}
			else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
				orderedPostProcessorNames.add(ppName);
			}
			else {
				nonOrderedPostProcessorNames.add(ppName);
			}
		}

		// First, invoke the BeanFactoryPostProcessors that implement PriorityOrdered.
		sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
		invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);

		// Next, invoke the BeanFactoryPostProcessors that implement Ordered.
		List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<BeanFactoryPostProcessor>();
		for (String postProcessorName : orderedPostProcessorNames) {
			orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
		}
		sortPostProcessors(orderedPostProcessors, beanFactory);
		invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);

		// Finally, invoke all other BeanFactoryPostProcessors.
		List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<BeanFactoryPostProcessor>();
		for (String postProcessorName : nonOrderedPostProcessorNames) {
			nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
		}
		invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);

		// Clear cached merged bean definitions since the post-processors might have
		// modified the original metadata, e.g. replacing placeholders in values...
		beanFactory.clearMetadataCache();
	}
复制代码

咱们来总结一下，到目前为止，应该说 BeanFactory 已经建立完成，而且全部的实现了 BeanFactoryPostProcessor 接口的 Bean 都已经初始化而且其中的 postProcessBeanFactory(factory) 方法已经获得执行了。全部实现了 BeanPostProcessor 接口的 Bean 也都完成了初始化。

1-5 finishBeanFactoryInitialization（beanFactory）

初始化全部的 singleton beans

/**
	 * Finish the initialization of this context's bean factory, * initializing all remaining singleton beans. */ protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) { // 首先，初始化名字为 conversionService 的 Bean // 注意了，初始化的动做包装在 beanFactory.getBean(...) 中 //conversionService这个类相信用过的人不会陌生，它用来将前端传过来的参数和后端的 controller 方法上的参数进行绑定的时候用。像前端传过来的字符串、整数要转换为后端的 String、Integer 很容易，可是若是 controller 方法须要的是一个枚举值，或者是 Date 这些非基础类型（含基础类型包装类）值的时候，咱们就能够考虑采用 ConversionService 来进行转换 if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) && beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) { beanFactory.setConversionService( //beanFactory.getBean(),是bean真正初始化过程的关键入口 beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)); } // Register a default embedded value resolver if no bean post-processor // (such as a PropertyPlaceholderConfigurer bean) registered any before: // at this point, primarily for resolution in annotation attribute values. if (!beanFactory.hasEmbeddedValueResolver()) { beanFactory.addEmbeddedValueResolver(new StringValueResolver() { @Override public String resolveStringValue(String strVal) { return getEnvironment().resolvePlaceholders(strVal); } }); } // Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early. String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false); for (String weaverAwareName : weaverAwareNames) { getBean(weaverAwareName); } // Stop using the temporary ClassLoader for type matching. beanFactory.setTempClassLoader(null); // Allow for caching all bean definition metadata, not expecting further changes. beanFactory.freezeConfiguration(); // 开始初始化剩下的 beanFactory.preInstantiateSingletons(); } 复制代码

从上面最后一行往里看，咱们又回到 DefaultListableBeanFactory#preInstantiateSingletons了 //DefaultListableBeanFactory.java L728

public void preInstantiateSingletons() throws BeansException {
		...
		
		List<String> beanNames = new ArrayList<String>(this.beanDefinitionNames);

		for (String beanName : beanNames) {
		    //合并父bean中的配置   
			RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
			if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
				if (isFactoryBean(beanName)) {
    				// FactoryBean 的话，在 beanName 前面加上 ‘&’ 符号。再调用 getBean
					final FactoryBean<?> factory = (FactoryBean<?>) getBean(FACTORY_BEAN_PREFIX + beanName);
					boolean isEagerInit;
					// 判断当前 FactoryBean 是不是 SmartFactoryBean 的实现，此处忽略，直接跳过
					if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
						isEagerInit = AccessController.doPrivileged(new PrivilegedAction<Boolean>() {
							@Override
							public Boolean run() {
								return ((SmartFactoryBean<?>) factory).isEagerInit();
							}
						}, getAccessControlContext());
					}
					else {
						isEagerInit = (factory instanceof SmartFactoryBean &&
								((SmartFactoryBean<?>) factory).isEagerInit());
					}
					if (isEagerInit) {
						getBean(beanName);
					}
				}
				else {
				    // 对于普通的 Bean，只要调用 getBean(beanName) 这个方法就能够进行初始化了
					getBean(beanName);
				}
			}
		}

		// 到这里说明全部的非懒加载的 singleton beans 已经完成了初始化
       // 若是咱们定义的 bean 是实现了 SmartInitializingSingleton 接口的，那么在这里获得回调，忽略
		for (String beanName : beanNames) {
			Object singletonInstance = getSingleton(beanName);
			if (singletonInstance instanceof SmartInitializingSingleton) {
				final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
				if (System.getSecurityManager() != null) {
					AccessController.doPrivileged(new PrivilegedAction<Object>() {
						@Override
						public Object run() {
							smartSingleton.afterSingletonsInstantiated();
							return null;
						}
					}, getAccessControlContext());
				}
				else {
					smartSingleton.afterSingletonsInstantiated();
				}
			}
		}
	}
复制代码

上面代码里屡次出现getBean() 方法，这个方法咱们常常用来从 BeanFactory 中获取一个 Bean，而初始化的过程也封装到了这个方法里，详见【spring 源码】IOC 之 bean实例初始化。

（未完，待续）