一、Bean的生命周期

1.1 相对完整的生命周期

Spring V2 - 图1

1.2.1 结合代码分析

1. 从容器创建入手

  1. public ClassPathXmlApplicationContext(String... configLocations) throws BeansException {
  2.     this(configLocations, true, null);
  3. }
  1. public ClassPathXmlApplicationContext(
  2.     String[] configLocations, boolean refresh, @Nullable ApplicationContext parent)
  3.     throws BeansException {
  5.     super(parent);
  6.     setConfigLocations(configLocations);
  7.     if (refresh) {
  8.         refresh();
  9.     }
  10. }

发现其中一个核心的方法：refresh()

  1.     @Override
  2.     public void refresh() throws BeansException, IllegalStateException {
  3.         synchronized (this.startupShutdownMonitor) {
  4.             StartupStep contextRefresh = this.applicationStartup.start("spring.context.refresh");
  6.             // Prepare this context for refreshing.
  7.             prepareRefresh();
  9.             // Tell the subclass to refresh the internal bean factory.
  10.             ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
  12.             // Prepare the bean factory for use in this context.
  13.             prepareBeanFactory(beanFactory);
  15.             try {
  16.                 // Allows post-processing of the bean factory in context subclasses.
  17.                 postProcessBeanFactory(beanFactory);
  19.                 StartupStep beanPostProcess = this.applicationStartup.start("spring.context.beans.post-process");
  20.                 // Invoke factory processors registered as beans in the context.
  21.                 invokeBeanFactoryPostProcessors(beanFactory);
  23.                 // Register bean processors that intercept bean creation.
  24.                 registerBeanPostProcessors(beanFactory);
  25.                 beanPostProcess.end();
  27.                 // Initialize message source for this context.
  28.                 initMessageSource();
  30.                 // Initialize event multicaster for this context.
  31.                 initApplicationEventMulticaster();
  33.                 // Initialize other special beans in specific context subclasses.
  34.                 onRefresh();
  36.                 // Check for listener beans and register them.
  37.                 registerListeners();
  39.                 // Instantiate all remaining (non-lazy-init) singletons.
  40.                 finishBeanFactoryInitialization(beanFactory);
  42.                 // Last step: publish corresponding event.
  43.                 finishRefresh();
  44.             }
  46.             catch (BeansException ex) {
  47.                 if (logger.isWarnEnabled()) {
  48.                     logger.warn("Exception encountered during context initialization - " +
  49.                             "cancelling refresh attempt: " + ex);
  50.                 }
  52.                 // Destroy already created singletons to avoid dangling resources.
  53.                 destroyBeans();
  55.                 // Reset 'active' flag.
  56.                 cancelRefresh(ex);
  58.                 // Propagate exception to caller.
  59.                 throw ex;
  60.             }
  62.             finally {
  63.                 // Reset common introspection caches in Spring's core, since we
  64.                 // might not ever need metadata for singleton beans anymore...
  65.                 resetCommonCaches();
  66.                 contextRefresh.end();
  67.             }
  68.         }
  69.     }

2. prepareRefresh()

此方法内部是刷新前的预期准备工作，包括启动时间的配置、容器状态的变更、属性资源的初始化、环境的验证以及一些集合的初始化工作。

  1. protected void prepareRefresh() {
  2.         // Switch to active.
  3.         this.startupDate = System.currentTimeMillis();
  4.         this.closed.set(false);
  5.         this.active.set(true);
  7.         if (logger.isDebugEnabled()) {
  8.             if (logger.isTraceEnabled()) {
  9.                 logger.trace("Refreshing " + this);
  10.             }
  11.             else {
  12.                 logger.debug("Refreshing " + getDisplayName());
  13.             }
  14.         }
  16.         // Initialize any placeholder property sources in the context environment.
  17.         initPropertySources();
  19.         // Validate that all properties marked as required are resolvable:
  20.         // see ConfigurablePropertyResolver#setRequiredProperties
  21.         getEnvironment().validateRequiredProperties();
  23.         // Store pre-refresh ApplicationListeners...
  24.         if (this.earlyApplicationListeners == null) {
  25.             this.earlyApplicationListeners = new LinkedHashSet<>(this.applicationListeners);
  26.         }
  27.         else {
  28.             // Reset local application listeners to pre-refresh state.
  29.             this.applicationListeners.clear();
  30.             this.applicationListeners.addAll(this.earlyApplicationListeners);
  31.         }
  33.         // Allow for the collection of early ApplicationEvents,
  34.         // to be published once the multicaster is available...
  35.         this.earlyApplicationEvents = new LinkedHashSet<>();
  36.     }

3. obtainFreshBeanFactory()

此方法主要是用来创建BeanFactory，并将Bean定义信息加载到BeanFactory中。

  1. protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
  2.     refreshBeanFactory();
  3.     return getBeanFactory();
  4. }
  1. @Override
  2. protected final void refreshBeanFactory() throws BeansException {
  3.     if (hasBeanFactory()) {        // 如果已经有BeanFactory，则销毁bean，关闭BeanFactory
  4.         destroyBeans();
  5.         closeBeanFactory();
  6.     }
  7.     try {
  8.         // 创建BeanFactory
  9.         DefaultListableBeanFactory beanFactory = createBeanFactory();
  10.         beanFactory.setSerializationId(getId());
  11.         // 自定义BeanFactory
  12.         customizeBeanFactory(beanFactory);
  13.         // 加载BeanDefinition到BeanFactory
  14.         loadBeanDefinitions(beanFactory);
  15.         this.beanFactory = beanFactory;
  16.     }
  17.     catch (IOException ex) {
  18.         throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
  19.     }
  20. }

4. prepareBeanFactory(beanFactory)

此一步骤，主要是为了给上步骤创建好的BeanFactory设置一些属性信息，完善其配置。

  1. protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
  2.     // Tell the internal bean factory to use the context's class loader etc.
  3.     beanFactory.setBeanClassLoader(getClassLoader());
  4.     if (!shouldIgnoreSpel) {
  5.         beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
  6.     }
  7.     beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));
  9.     // Configure the bean factory with context callbacks.
  10.     beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
  11.     beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
  12.     beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
  13.     beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
  14.     beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
  15.     beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
  16.     beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);
  17.     beanFactory.ignoreDependencyInterface(ApplicationStartupAware.class);
  19.     // BeanFactory interface not registered as resolvable type in a plain factory.
  20.     // MessageSource registered (and found for autowiring) as a bean.
  21.     beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
  22.     beanFactory.registerResolvableDependency(ResourceLoader.class, this);
  23.     beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
  24.     beanFactory.registerResolvableDependency(ApplicationContext.class, this);
  26.     // Register early post-processor for detecting inner beans as ApplicationListeners.
  27.     beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));
  29.     // Detect a LoadTimeWeaver and prepare for weaving, if found.
  30.     if (!NativeDetector.inNativeImage() && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
  31.         beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
  32.         // Set a temporary ClassLoader for type matching.
  33.         beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
  34.     }
  36.     // Register default environment beans.
  37.     if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
  38.         beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
  39.     }
  40.     if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
  41.         beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
  42.     }
  43.     if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
  44.         beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
  45.     }
  46.     if (!beanFactory.containsLocalBean(APPLICATION_STARTUP_BEAN_NAME)) {
  47.         beanFactory.registerSingleton(APPLICATION_STARTUP_BEAN_NAME, getApplicationStartup());
  48.     }
  49. }

5. postProcessBeanFactory(beanFactory)

此一步骤，是为了支持去注册一些特殊的BeanFactoryPostProcessor，为BeanFactory做增强操作。可以看到，此方法内部实现为空，是留给子类对扩展实现的。

  1. protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
  2. }

6. invokeBeanFactoryPostProcessors(beanFactory)

执行此步骤，是实例化并执行所有已经注册的BeanFactoryPostProcessor，实现对BeanFactory做增强操作。

  1. protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
  2.     PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());
  4.     // Detect a LoadTimeWeaver and prepare for weaving, if found in the meantime
  5.     // (e.g. through an @Bean method registered by ConfigurationClassPostProcessor)
  6.     if (!NativeDetector.inNativeImage() && beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
  7.         beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
  8.         beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
  9.     }
  10. }

7. registerBeanPostProcessors(beanFactory)

注册BeanPostProcessor。

  1. protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {
  2.         PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);
  3. }

8. initMessageSource()

初始化消息源，常用于国际化等。

  1. protected void initMessageSource() {
  2.     ConfigurableListableBeanFactory beanFactory = getBeanFactory();
  3.     if (beanFactory.containsLocalBean(MESSAGE_SOURCE_BEAN_NAME)) {
  4.         this.messageSource = beanFactory.getBean(MESSAGE_SOURCE_BEAN_NAME, MessageSource.class);
  5.         // Make MessageSource aware of parent MessageSource.
  6.         if (this.parent != null && this.messageSource instanceof HierarchicalMessageSource) {
  7.             HierarchicalMessageSource hms = (HierarchicalMessageSource) this.messageSource;
  8.             if (hms.getParentMessageSource() == null) {
  9.                 // Only set parent context as parent MessageSource if no parent MessageSource
  10.                 // registered already.
  11.                 hms.setParentMessageSource(getInternalParentMessageSource());
  12.             }
  13.         }
  14.         if (logger.isTraceEnabled()) {
  15.             logger.trace("Using MessageSource [" + this.messageSource + "]");
  16.         }
  17.     }
  18.     else {
  19.         // Use empty MessageSource to be able to accept getMessage calls.
  20.         DelegatingMessageSource dms = new DelegatingMessageSource();
  21.         dms.setParentMessageSource(getInternalParentMessageSource());
  22.         this.messageSource = dms;
  23.         beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource);
  24.         if (logger.isTraceEnabled()) {
  25.             logger.trace("No '" + MESSAGE_SOURCE_BEAN_NAME + "' bean, using [" + this.messageSource + "]");
  26.         }
  27.     }
  28. }

9. initApplicationEventMulticaster()

初始化应用程序中的事件多播器。

  1. protected void initApplicationEventMulticaster() {
  2.     ConfigurableListableBeanFactory beanFactory = getBeanFactory();
  3.     if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) {
  4.         this.applicationEventMulticaster =
  5.             beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class);
  6.         if (logger.isTraceEnabled()) {
  7.             logger.trace("Using ApplicationEventMulticaster [" + this.applicationEventMulticaster + "]");
  8.         }
  9.     }
  10.     else {
  11.         this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
  12.         beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster);
  13.         if (logger.isTraceEnabled()) {
  14.             logger.trace("No '" + APPLICATION_EVENT_MULTICASTER_BEAN_NAME + "' bean, using " +
  15.                          "[" + this.applicationEventMulticaster.getClass().getSimpleName() + "]");
  16.         }
  17.     }
  18. }

10. onRefresh()

初始化一些特殊子容器中的特殊bean，内部为空实现，由子类实现。

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

11. registerListeners()

注册监听器。

  1. protected void registerListeners() {
  2.     // Register statically specified listeners first.
  3.     for (ApplicationListener<?> listener : getApplicationListeners()) {
  4.         getApplicationEventMulticaster().addApplicationListener(listener);
  5.     }
  7.     // Do not initialize FactoryBeans here: We need to leave all regular beans
  8.     // uninitialized to let post-processors apply to them!
  9.     String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
  10.     for (String listenerBeanName : listenerBeanNames) {
  11.         getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
  12.     }
  14.     // Publish early application events now that we finally have a multicaster...
  15.     Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;
  16.     this.earlyApplicationEvents = null;
  17.     if (!CollectionUtils.isEmpty(earlyEventsToProcess)) {
  18.         for (ApplicationEvent earlyEvent : earlyEventsToProcess) {
  19.             getApplicationEventMulticaster().multicastEvent(earlyEvent);
  20.         }
  21.     }
  22. }

12. finishBeanFactoryInitialization(beanFactory)

a. Bean的实例化

实例化所有剩下的非懒加载的Bean。

  1.     protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
  2.         // Initialize conversion service for this context.
  3.         if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
  4.                 beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
  5.             beanFactory.setConversionService(
  6.                     beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
  7.         }
  9.         // Register a default embedded value resolver if no BeanFactoryPostProcessor
  10.         // (such as a PropertySourcesPlaceholderConfigurer bean) registered any before:
  11.         // at this point, primarily for resolution in annotation attribute values.
  12.         if (!beanFactory.hasEmbeddedValueResolver()) {
  13.             beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
  14.         }
  16.         // Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early.
  17.         String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
  18.         for (String weaverAwareName : weaverAwareNames) {
  19.             getBean(weaverAwareName);
  20.         }
  22.         // Stop using the temporary ClassLoader for type matching.
  23.         beanFactory.setTempClassLoader(null);
  25.         // Allow for caching all bean definition metadata, not expecting further changes.
  26.         beanFactory.freezeConfiguration();
  28.         // Instantiate all remaining (non-lazy-init) singletons.
  29.         // 此处是重点，预实例化单例Bean
  30.         beanFactory.preInstantiateSingletons();
  31.     }
  1.     @Override
  2.     public void preInstantiateSingletons() throws BeansException {
  3.         if (logger.isTraceEnabled()) {
  4.             logger.trace("Pre-instantiating singletons in " + this);
  5.         }
  7.         // Iterate over a copy to allow for init methods which in turn register new bean definitions.
  8.         // While this may not be part of the regular factory bootstrap, it does otherwise work fine.
  9.         List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
  11.         // Trigger initialization of all non-lazy singleton beans...
  12.         for (String beanName : beanNames) {
  13.             RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
  14.             if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
  15.                 if (isFactoryBean(beanName)) {
  16.                     Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
  17.                     if (bean instanceof FactoryBean) {
  18.                         FactoryBean<?> factory = (FactoryBean<?>) bean;
  19.                         boolean isEagerInit;
  20.                         if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
  21.                             isEagerInit = AccessController.doPrivileged(
  22.                                     (PrivilegedAction<Boolean>) ((SmartFactoryBean<?>) factory)::isEagerInit,
  23.                                     getAccessControlContext());
  24.                         }
  25.                         else {
  26.                             isEagerInit = (factory instanceof SmartFactoryBean &&
  27.                                     ((SmartFactoryBean<?>) factory).isEagerInit());
  28.                         }
  29.                         if (isEagerInit) {
  30.                             getBean(beanName);
  31.                         }
  32.                     }
  33.                 }
  34.                 else {
  35.                     // 此处是重点，获取Bean
  36.                     getBean(beanName);
  37.                 }
  38.             }
  39.         }
  1. @Override
  2. public Object getBean(String name) throws BeansException {
  3.     return doGetBean(name, null, null, false);
  4. }
  1. protected <T> T doGetBean(
  2.     String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)
  3.     throws BeansException {
  5.     String beanName = transformedBeanName(name);
  6.     Object beanInstance;
  8.     // Eagerly check singleton cache for manually registered singletons.
  9.     Object sharedInstance = getSingleton(beanName);
  10.     if (sharedInstance != null && args == null) {
  11.         if (logger.isTraceEnabled()) {
  12.             if (isSingletonCurrentlyInCreation(beanName)) {
  13.                 logger.trace("Returning eagerly cached instance of singleton bean '" + beanName +
  14.                              "' that is not fully initialized yet - a consequence of a circular reference");
  15.             }
  16.             else {
  17.                 logger.trace("Returning cached instance of singleton bean '" + beanName + "'");
  18.             }
  19.         }
  20.         beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, null);
  21.     }
  23.     else {
  24.         // Fail if we're already creating this bean instance:
  25.         // We're assumably within a circular reference.
  26.         if (isPrototypeCurrentlyInCreation(beanName)) {
  27.             throw new BeanCurrentlyInCreationException(beanName);
  28.         }
  30.         // Check if bean definition exists in this factory.
  31.         BeanFactory parentBeanFactory = getParentBeanFactory();
  32.         if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
  33.             // Not found -> check parent.
  34.             String nameToLookup = originalBeanName(name);
  35.             if (parentBeanFactory instanceof AbstractBeanFactory) {
  36.                 return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
  37.                     nameToLookup, requiredType, args, typeCheckOnly);
  38.             }
  39.             else if (args != null) {
  40.                 // Delegation to parent with explicit args.
  41.                 return (T) parentBeanFactory.getBean(nameToLookup, args);
  42.             }
  43.             else if (requiredType != null) {
  44.                 // No args -> delegate to standard getBean method.
  45.                 return parentBeanFactory.getBean(nameToLookup, requiredType);
  46.             }
  47.             else {
  48.                 return (T) parentBeanFactory.getBean(nameToLookup);
  49.             }
  50.         }
  52.         if (!typeCheckOnly) {
  53.             markBeanAsCreated(beanName);
  54.         }
  56.         StartupStep beanCreation = this.applicationStartup.start("spring.beans.instantiate")
  57.             .tag("beanName", name);
  58.         try {
  59.             if (requiredType != null) {
  60.                 beanCreation.tag("beanType", requiredType::toString);
  61.             }
  62.             RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
  63.             checkMergedBeanDefinition(mbd, beanName, args);
  65.             // Guarantee initialization of beans that the current bean depends on.
  66.             String[] dependsOn = mbd.getDependsOn();
  67.             if (dependsOn != null) {
  68.                 for (String dep : dependsOn) {
  69.                     if (isDependent(beanName, dep)) {
  70.                         throw new BeanCreationException(mbd.getResourceDescription(), beanName,
  71.                                                         "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
  72.                     }
  73.                     registerDependentBean(dep, beanName);
  74.                     try {
  75.                         getBean(dep);
  76.                     }
  77.                     catch (NoSuchBeanDefinitionException ex) {
  78.                         throw new BeanCreationException(mbd.getResourceDescription(), beanName,
  79.                                                         "'" + beanName + "' depends on missing bean '" + dep + "'", ex);
  80.                     }
  81.                 }
  82.             }
  84.             // Create bean instance.
  85.             if (mbd.isSingleton()) {
  86.                 sharedInstance = getSingleton(beanName, () -> {
  87.                     try {
  88.                         // 此处是重点，创建bean
  89.                         return createBean(beanName, mbd, args);
  90.                     }
  91.                     catch (BeansException ex) {
  92.                         // Explicitly remove instance from singleton cache: It might have been put there
  93.                         // eagerly by the creation process, to allow for circular reference resolution.
  94.                         // Also remove any beans that received a temporary reference to the bean.
  95.                         destroySingleton(beanName);
  96.                         throw ex;
  97.                     }
  98.                 });
  99.                 beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
  100.             }
  102.             else if (mbd.isPrototype()) {
  103.                 // It's a prototype -> create a new instance.
  104.                 Object prototypeInstance = null;
  105.                 try {
  106.                     beforePrototypeCreation(beanName);
  107.                     prototypeInstance = createBean(beanName, mbd, args);
  108.                 }
  109.                 finally {
  110.                     afterPrototypeCreation(beanName);
  111.                 }
  112.                 beanInstance = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
  113.             }
  115.             else {
  116.                 String scopeName = mbd.getScope();
  117.                 if (!StringUtils.hasLength(scopeName)) {
  118.                     throw new IllegalStateException("No scope name defined for bean '" + beanName + "'");
  119.                 }
  120.                 Scope scope = this.scopes.get(scopeName);
  121.                 if (scope == null) {
  122.                     throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
  123.                 }
  124.                 try {
  125.                     Object scopedInstance = scope.get(beanName, () -> {
  126.                         beforePrototypeCreation(beanName);
  127.                         try {
  128.                             return createBean(beanName, mbd, args);
  129.                         }
  130.                         finally {
  131.                             afterPrototypeCreation(beanName);
  132.                         }
  133.                     });
  134.                     beanInstance = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
  135.                 }
  136.                 catch (IllegalStateException ex) {
  137.                     throw new ScopeNotActiveException(beanName, scopeName, ex);
  138.                 }
  139.             }
  140.         }
  141.         catch (BeansException ex) {
  142.             beanCreation.tag("exception", ex.getClass().toString());
  143.             beanCreation.tag("message", String.valueOf(ex.getMessage()));
  144.             cleanupAfterBeanCreationFailure(beanName);
  145.             throw ex;
  146.         }
  147.         finally {
  148.             beanCreation.end();
  149.         }
  150.     }
  152.     return adaptBeanInstance(name, beanInstance, requiredType);
  153. }
  1. @Override
  2. protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
  3.     throws BeanCreationException {
  5.     if (logger.isTraceEnabled()) {
  6.         logger.trace("Creating instance of bean '" + beanName + "'");
  7.     }
  8.     RootBeanDefinition mbdToUse = mbd;
  10.     // Make sure bean class is actually resolved at this point, and
  11.     // clone the bean definition in case of a dynamically resolved Class
  12.     // which cannot be stored in the shared merged bean definition.
  13.     Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
  14.     if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
  15.         mbdToUse = new RootBeanDefinition(mbd);
  16.         mbdToUse.setBeanClass(resolvedClass);
  17.     }
  19.     // Prepare method overrides.
  20.     try {
  21.         mbdToUse.prepareMethodOverrides();
  22.     }
  23.     catch (BeanDefinitionValidationException ex) {
  24.         throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
  25.                                                beanName, "Validation of method overrides failed", ex);
  26.     }
  28.     try {
  29.         // Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
  30.         Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
  31.         if (bean != null) {
  32.             return bean;
  33.         }
  34.     }
  35.     catch (Throwable ex) {
  36.         throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
  37.                                         "BeanPostProcessor before instantiation of bean failed", ex);
  38.     }
  40.     try {
  41.         // 此处是重点，创建Bean
  42.         Object beanInstance = doCreateBean(beanName, mbdToUse, args);
  43.         if (logger.isTraceEnabled()) {
  44.             logger.trace("Finished creating instance of bean '" + beanName + "'");
  45.         }
  46.         return beanInstance;
  47.     }
  48.     catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
  49.         // A previously detected exception with proper bean creation context already,
  50.         // or illegal singleton state to be communicated up to DefaultSingletonBeanRegistry.
  51.         throw ex;
  52.     }
  53.     catch (Throwable ex) {
  54.         throw new BeanCreationException(
  55.             mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);
  56.     }
  57. }
  1.     protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
  2.             throws BeanCreationException {
  4.         // Instantiate the bean.
  5.         BeanWrapper instanceWrapper = null;
  6.         if (mbd.isSingleton()) {
  7.             instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
  8.         }
  9.         if (instanceWrapper == null) {
  10.             // 此处是重点，创建Bean实例
  11.             instanceWrapper = createBeanInstance(beanName, mbd, args);
  12.         }
  13.         Object bean = instanceWrapper.getWrappedInstance();
  14.         Class<?> beanType = instanceWrapper.getWrappedClass();
  15.         if (beanType != NullBean.class) {
  16.             mbd.resolvedTargetType = beanType;
  17.         }
  19.         // Allow post-processors to modify the merged bean definition.
  20.         synchronized (mbd.postProcessingLock) {
  21.             if (!mbd.postProcessed) {
  22.                 try {
  23.                     applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
  24.                 }
  25.                 catch (Throwable ex) {
  26.                     throw new BeanCreationException(mbd.getResourceDescription(), beanName,
  27.                             "Post-processing of merged bean definition failed", ex);
  28.                 }
  29.                 mbd.postProcessed = true;
  30.             }
  31.         }
  33.         // Eagerly cache singletons to be able to resolve circular references
  34.         // even when triggered by lifecycle interfaces like BeanFactoryAware.
  35.         boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
  36.                 isSingletonCurrentlyInCreation(beanName));
  37.         if (earlySingletonExposure) {
  38.             if (logger.isTraceEnabled()) {
  39.                 logger.trace("Eagerly caching bean '" + beanName +
  40.                         "' to allow for resolving potential circular references");
  41.             }
  42.             addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
  43.         }
  45.         // Initialize the bean instance.
  46.         Object exposedObject = bean;
  47.         try {
  48.             populateBean(beanName, mbd, instanceWrapper);
  49.             exposedObject = initializeBean(beanName, exposedObject, mbd);
  50.         }
  51.         catch (Throwable ex) {
  52.             if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
  53.                 throw (BeanCreationException) ex;
  54.             }
  55.             else {
  56.                 throw new BeanCreationException(
  57.                         mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
  58.             }
  59.         }
  61.         if (earlySingletonExposure) {
  62.             Object earlySingletonReference = getSingleton(beanName, false);
  63.             if (earlySingletonReference != null) {
  64.                 if (exposedObject == bean) {
  65.                     exposedObject = earlySingletonReference;
  66.                 }
  67.                 else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
  68.                     String[] dependentBeans = getDependentBeans(beanName);
  69.                     Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
  70.                     for (String dependentBean : dependentBeans) {
  71.                         if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
  72.                             actualDependentBeans.add(dependentBean);
  73.                         }
  74.                     }
  75.                     if (!actualDependentBeans.isEmpty()) {
  76.                         throw new BeanCurrentlyInCreationException(beanName,
  77.                                 "Bean with name '" + beanName + "' has been injected into other beans [" +
  78.                                 StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +
  79.                                 "] in its raw version as part of a circular reference, but has eventually been " +
  80.                                 "wrapped. This means that said other beans do not use the final version of the " +
  81.                                 "bean. This is often the result of over-eager type matching - consider using " +
  82.                                 "'getBeanNamesForType' with the 'allowEagerInit' flag turned off, for example.");
  83.                     }
  84.                 }
  85.             }
  86.         }
  88.         // Register bean as disposable.
  89.         try {
  90.             registerDisposableBeanIfNecessary(beanName, bean, mbd);
  91.         }
  92.         catch (BeanDefinitionValidationException ex) {
  93.             throw new BeanCreationException(
  94.                     mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
  95.         }
  97.         return exposedObject;
  98.     }
  1.     protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
  2.         // Make sure bean class is actually resolved at this point.
  3.         Class<?> beanClass = resolveBeanClass(mbd, beanName);
  5.         if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {
  6.             throw new BeanCreationException(mbd.getResourceDescription(), beanName,
  7.                     "Bean class isn't public, and non-public access not allowed: " + beanClass.getName());
  8.         }
  10.         Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
  11.         if (instanceSupplier != null) {
  12.             return obtainFromSupplier(instanceSupplier, beanName);
  13.         }
  15.         if (mbd.getFactoryMethodName() != null) {
  16.             return instantiateUsingFactoryMethod(beanName, mbd, args);
  17.         }
  19.         // Shortcut when re-creating the same bean...
  20.         boolean resolved = false;
  21.         boolean autowireNecessary = false;
  22.         if (args == null) {
  23.             synchronized (mbd.constructorArgumentLock) {
  24.                 if (mbd.resolvedConstructorOrFactoryMethod != null) {
  25.                     resolved = true;
  26.                     autowireNecessary = mbd.constructorArgumentsResolved;
  27.                 }
  28.             }
  29.         }
  30.         if (resolved) {
  31.             if (autowireNecessary) {
  32.                 return autowireConstructor(beanName, mbd, null, null);
  33.             }
  34.             else {
  35.                 return instantiateBean(beanName, mbd);
  36.             }
  37.         }
  39.         // Candidate constructors for autowiring?
  40.         Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
  41.         if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
  42.                 mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
  43.             return autowireConstructor(beanName, mbd, ctors, args);
  44.         }
  46.         // Preferred constructors for default construction?
  47.         ctors = mbd.getPreferredConstructors();
  48.         if (ctors != null) {
  49.             return autowireConstructor(beanName, mbd, ctors, null);
  50.         }
  52.         // No special handling: simply use no-arg constructor.
  53.         // 此处是重点，如果没有特殊处理，就使用无参构造创建Bean对象
  54.         return instantiateBean(beanName, mbd);
  55.     }
  1.     protected BeanWrapper instantiateBean(String beanName, RootBeanDefinition mbd) {
  2.         try {
  3.             Object beanInstance;
  4.             if (System.getSecurityManager() != null) {
  5.                 beanInstance = AccessController.doPrivileged(
  6.                         (PrivilegedAction<Object>) () -> getInstantiationStrategy().instantiate(mbd, beanName, this),
  7.                         getAccessControlContext());
  8.             }
  9.             else {
  10.                 // 此处是重点，调用实例化策略，进行实例化
  11.                 beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, this);
  12.             }
  13.             BeanWrapper bw = new BeanWrapperImpl(beanInstance);
  14.             initBeanWrapper(bw);
  15.             return bw;
  16.         }
  17.         catch (Throwable ex) {
  18.             throw new BeanCreationException(
  19.                     mbd.getResourceDescription(), beanName, "Instantiation of bean failed", ex);
  20.         }
  21.     }
  1.     @Override
  2.     public Object instantiate(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner) {
  3.         // Don't override the class with CGLIB if no overrides.
  4.         if (!bd.hasMethodOverrides()) {
  5.             Constructor<?> constructorToUse;
  6.             synchronized (bd.constructorArgumentLock) {
  7.                 constructorToUse = (Constructor<?>) bd.resolvedConstructorOrFactoryMethod;
  8.                 if (constructorToUse == null) {
  9.                     final Class<?> clazz = bd.getBeanClass();
  10.                     if (clazz.isInterface()) {
  11.                         throw new BeanInstantiationException(clazz, "Specified class is an interface");
  12.                     }
  13.                     try {
  14.                         if (System.getSecurityManager() != null) {
  15.                             constructorToUse = AccessController.doPrivileged(
  16.                                     (PrivilegedExceptionAction<Constructor<?>>) clazz::getDeclaredConstructor);
  17.                         }
  18.                         else {
  19.                             // 通过反射，获取构造方法
  20.                             constructorToUse = clazz.getDeclaredConstructor();
  21.                         }
  22.                         bd.resolvedConstructorOrFactoryMethod = constructorToUse;
  23.                     }
  24.                     catch (Throwable ex) {
  25.                         throw new BeanInstantiationException(clazz, "No default constructor found", ex);
  26.                     }
  27.                 }
  28.             }
  29.             // 通过Bean工具来调用构造方法进行实例化
  30.             return BeanUtils.instantiateClass(constructorToUse);
  31.         }
  32.         else {
  33.             // Must generate CGLIB subclass.
  34.             return instantiateWithMethodInjection(bd, beanName, owner);
  35.         }
  36.     }
  1.     public static <T> T instantiateClass(Constructor<T> ctor, Object... args) throws BeanInstantiationException {
  2.         Assert.notNull(ctor, "Constructor must not be null");
  3.         try {
  4.             ReflectionUtils.makeAccessible(ctor);
  5.             if (KotlinDetector.isKotlinReflectPresent() && KotlinDetector.isKotlinType(ctor.getDeclaringClass())) {
  6.                 return KotlinDelegate.instantiateClass(ctor, args);
  7.             }
  8.             else {
  9.                 Class<?>[] parameterTypes = ctor.getParameterTypes();
  10.                 Assert.isTrue(args.length <= parameterTypes.length, "Can't specify more arguments than constructor parameters");
  11.                 Object[] argsWithDefaultValues = new Object[args.length];
  12.                 for (int i = 0 ; i < args.length; i++) {
  13.                     if (args[i] == null) {
  14.                         Class<?> parameterType = parameterTypes[i];
  15.                         argsWithDefaultValues[i] = (parameterType.isPrimitive() ? DEFAULT_TYPE_VALUES.get(parameterType) : null);
  16.                     }
  17.                     else {
  18.                         argsWithDefaultValues[i] = args[i];
  19.                     }
  20.                 }
  21.                 // 此处使用构造方法创建实例
  22.                 return ctor.newInstance(argsWithDefaultValues);
  23.             }
  24.         }
  25.         catch (InstantiationException ex) {
  26.             throw new BeanInstantiationException(ctor, "Is it an abstract class?", ex);
  27.         }
  28.         catch (IllegalAccessException ex) {
  29.             throw new BeanInstantiationException(ctor, "Is the constructor accessible?", ex);
  30.         }
  31.         catch (IllegalArgumentException ex) {
  32.             throw new BeanInstantiationException(ctor, "Illegal arguments for constructor", ex);
  33.         }
  34.         catch (InvocationTargetException ex) {
  35.             throw new BeanInstantiationException(ctor, "Constructor threw exception", ex.getTargetException());
  36.         }
  37.     }

b. Bean的属性赋值及初始化
  1. protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
  2.     throws BeanCreationException {
  4.     // Instantiate the bean.
  5.     BeanWrapper instanceWrapper = null;
  6.     if (mbd.isSingleton()) {
  7.         instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
  8.     }
  9.     if (instanceWrapper == null) {
  10.         instanceWrapper = createBeanInstance(beanName, mbd, args);
  11.     }
  12.     Object bean = instanceWrapper.getWrappedInstance();
  13.     Class<?> beanType = instanceWrapper.getWrappedClass();
  14.     if (beanType != NullBean.class) {
  15.         mbd.resolvedTargetType = beanType;
  16.     }
  18.     // Allow post-processors to modify the merged bean definition.
  19.     synchronized (mbd.postProcessingLock) {
  20.         if (!mbd.postProcessed) {
  21.             try {
  22.                 applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
  23.             }
  24.             catch (Throwable ex) {
  25.                 throw new BeanCreationException(mbd.getResourceDescription(), beanName,
  26.                                                 "Post-processing of merged bean definition failed", ex);
  27.             }
  28.             mbd.postProcessed = true;
  29.         }
  30.     }
  32.     // Eagerly cache singletons to be able to resolve circular references
  33.     // even when triggered by lifecycle interfaces like BeanFactoryAware.
  34.     boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
  35.                                       isSingletonCurrentlyInCreation(beanName));
  36.     if (earlySingletonExposure) {
  37.         if (logger.isTraceEnabled()) {
  38.             logger.trace("Eagerly caching bean '" + beanName +
  39.                          "' to allow for resolving potential circular references");
  40.         }
  41.         addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
  42.     }
  44.     // Initialize the bean instance.
  45.     Object exposedObject = bean;
  46.     try {
  47.         // 填充Bean的属性值
  48.         populateBean(beanName, mbd, instanceWrapper);
  49.         // Bean的初始化
  50.         exposedObject = initializeBean(beanName, exposedObject, mbd);
  51.     }
  52.     catch (Throwable ex) {
  53.         if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
  54.             throw (BeanCreationException) ex;
  55.         }
  56.         else {
  57.             throw new BeanCreationException(
  58.                 mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
  59.         }
  60.     }
  62.     if (earlySingletonExposure) {
  63.         Object earlySingletonReference = getSingleton(beanName, false);
  64.         if (earlySingletonReference != null) {
  65.             if (exposedObject == bean) {
  66.                 exposedObject = earlySingletonReference;
  67.             }
  68.             else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
  69.                 String[] dependentBeans = getDependentBeans(beanName);
  70.                 Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
  71.                 for (String dependentBean : dependentBeans) {
  72.                     if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
  73.                         actualDependentBeans.add(dependentBean);
  74.                     }
  75.                 }
  76.                 if (!actualDependentBeans.isEmpty()) {
  77.                     throw new BeanCurrentlyInCreationException(beanName,
  78.                                                                "Bean with name '" + beanName + "' has been injected into other beans [" +
  79.                                                                StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +
  80.                                                                "] in its raw version as part of a circular reference, but has eventually been " +
  81.                                                                "wrapped. This means that said other beans do not use the final version of the " +
  82.                                                                "bean. This is often the result of over-eager type matching - consider using " +
  83.                                                                "'getBeanNamesForType' with the 'allowEagerInit' flag turned off, for example.");
  84.                 }
  85.             }
  86.         }
  87.     }
  89.     // Register bean as disposable.
  90.     try {
  91.         registerDisposableBeanIfNecessary(beanName, bean, mbd);
  92.     }
  93.     catch (BeanDefinitionValidationException ex) {
  94.         throw new BeanCreationException(
  95.             mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
  96.     }
  98.     return exposedObject;
  99. }
  1. protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
  2.     if (System.getSecurityManager() != null) {
  3.         AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
  4.             invokeAwareMethods(beanName, bean);
  5.             return null;
  6.         }, getAccessControlContext());
  7.     }
  8.     else {
  9.         invokeAwareMethods(beanName, bean);
  10.     }
  12.     Object wrappedBean = bean;
  13.     if (mbd == null || !mbd.isSynthetic()) {
  14.         // 应用BeanPostProcessor的初始化前置方法
  15.         wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
  16.     }
  18.     try {
  19.         // 执行初始化方法
  20.         invokeInitMethods(beanName, wrappedBean, mbd);
  21.     }
  22.     catch (Throwable ex) {
  23.         throw new BeanCreationException(
  24.             (mbd != null ? mbd.getResourceDescription() : null),
  25.             beanName, "Invocation of init method failed", ex);
  26.     }
  27.     if (mbd == null || !mbd.isSynthetic()) {
  28.         // 应用BeanPostProcessor的初始化后置方法
  29.         wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
  30.     }
  32.     return wrappedBean;
  33. }

- Aware接口相关方法执行的时机
  1. protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
  2.     if (System.getSecurityManager() != null) {
  3.         AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
  4.             invokeAwareMethods(beanName, bean);
  5.             return null;
  6.         }, getAccessControlContext());
  7.     }
  8.     else {
  9.         // 此处核心，执行Aware方法，主要执行了BeanFactoryAware接口
  10.         invokeAwareMethods(beanName, bean);
  11.     }
  13.     Object wrappedBean = bean;
  14.     if (mbd == null || !mbd.isSynthetic()) {
  15.         // 此处核心，内部执行Aware方法，主要执行了ApplicationContextAware接口
  16.         wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
  17.     }
  19.     try {
  20.         invokeInitMethods(beanName, wrappedBean, mbd);
  21.     }
  22.     catch (Throwable ex) {
  23.         throw new BeanCreationException(
  24.             (mbd != null ? mbd.getResourceDescription() : null),
  25.             beanName, "Invocation of init method failed", ex);
  26.     }
  27.     if (mbd == null || !mbd.isSynthetic()) {
  28.         wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
  29.     }
  31.     return wrappedBean;
  32. }

BeanFactoryAware接口：

  1. private void invokeAwareMethods(String beanName, Object bean) {
  2.     if (bean instanceof Aware) {
  3.         if (bean instanceof BeanNameAware) {
  4.             ((BeanNameAware) bean).setBeanName(beanName);
  5.         }
  6.         if (bean instanceof BeanClassLoaderAware) {
  7.             ClassLoader bcl = getBeanClassLoader();
  8.             if (bcl != null) {
  9.                 ((BeanClassLoaderAware) bean).setBeanClassLoader(bcl);
  10.             }
  11.         }
  12.         if (bean instanceof BeanFactoryAware) {
  13.             ((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);
  14.         }
  15.     }
  16. }

ApplicationContextAware接口相关：

  1. @Override
  2. public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
  3.     throws BeansException {
  5.     Object result = existingBean;
  6.     for (BeanPostProcessor processor : getBeanPostProcessors()) {
  7.         Object current = processor.postProcessBeforeInitialization(result, beanName);
  8.         if (current == null) {
  9.             return result;
  10.         }
  11.         result = current;
  12.     }
  13.     return result;
  14. }
  1. @Override
  2. @Nullable
  3. public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
  4.     if (!(bean instanceof EnvironmentAware || bean instanceof EmbeddedValueResolverAware ||
  5.           bean instanceof ResourceLoaderAware || bean instanceof ApplicationEventPublisherAware ||
  6.           bean instanceof MessageSourceAware || bean instanceof ApplicationContextAware ||
  7.           bean instanceof ApplicationStartupAware)) {
  8.         return bean;
  9.     }
  11.     AccessControlContext acc = null;
  13.     if (System.getSecurityManager() != null) {
  14.         acc = this.applicationContext.getBeanFactory().getAccessControlContext();
  15.     }
  17.     if (acc != null) {
  18.         AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
  19.             invokeAwareInterfaces(bean);
  20.             return null;
  21.         }, acc);
  22.     }
  23.     else {
  24.         invokeAwareInterfaces(bean);
  25.     }
  27.     return bean;
  28. }
  1. private void invokeAwareInterfaces(Object bean) {
  2.     if (bean instanceof EnvironmentAware) {
  3.         ((EnvironmentAware) bean).setEnvironment(this.applicationContext.getEnvironment());
  4.     }
  5.     if (bean instanceof EmbeddedValueResolverAware) {
  6.         ((EmbeddedValueResolverAware) bean).setEmbeddedValueResolver(this.embeddedValueResolver);
  7.     }
  8.     if (bean instanceof ResourceLoaderAware) {
  9.         ((ResourceLoaderAware) bean).setResourceLoader(this.applicationContext);
  10.     }
  11.     if (bean instanceof ApplicationEventPublisherAware) {
  12.         ((ApplicationEventPublisherAware) bean).setApplicationEventPublisher(this.applicationContext);
  13.     }
  14.     if (bean instanceof MessageSourceAware) {
  15.         ((MessageSourceAware) bean).setMessageSource(this.applicationContext);
  16.     }
  17.     if (bean instanceof ApplicationStartupAware) {
  18.         ((ApplicationStartupAware) bean).setApplicationStartup(this.applicationContext.getApplicationStartup());
  19.     }
  20.     if (bean instanceof ApplicationContextAware) {
  21.         ((ApplicationContextAware) bean).setApplicationContext(this.applicationContext);
  22.     }
  23. }

13. finishRefresh()

完成刷新，做收尾工作。

  1. protected void finishRefresh() {
  2.     // Clear context-level resource caches (such as ASM metadata from scanning).
  3.     clearResourceCaches();
  5.     // Initialize lifecycle processor for this context.
  6.     initLifecycleProcessor();
  8.     // Propagate refresh to lifecycle processor first.
  9.     getLifecycleProcessor().onRefresh();
  11.     // Publish the final event.
  12.     publishEvent(new ContextRefreshedEvent(this));
  14.     // Participate in LiveBeansView MBean, if active.
  15.     if (!NativeDetector.inNativeImage()) {
  16.         LiveBeansView.registerApplicationContext(this);
  17.     }
  18. }

1.2 一种特殊的生命周期

此种方式，不经过上述完整的流程即可创建出指定Bean的示例。在一些特殊的需求中可以用到这种方式。
Spring V2 - 图2