org.springframework.context.support.AbstractApplicationContext#registerBeanPostProcessors
org.springframework.context.support.PostProcessorRegistrationDelegate#registerBeanPostProcessors(org.springframework.beans.factory.config.ConfigurableListableBeanFactory, org.springframework.context.support.AbstractApplicationContext)

*  1. 拿到所有实现 BeanPostProcessor 的 bean, 然后进行分类存起来 *  这有一点, Spring 对 BeanDefinition 分成三种角色: *   1. 用户定义的 Bean (ROLE_APPLICATION) *      2. 较复杂的 (ROLE_SUPPORT) 较复杂的? 通常是一个外部配置 *      3. Spring 内置的(ROLE_INFRASTRUCTURE) *  2. 如果实现了 BeanPostProcessor 则会实例化这个bean, 但注意这里只是注册,并不会调用BeanPostProcessor的相关方法 * *  另外 BeanPostProcessor 粗粒度太大, Spring 还细分一些子接口: *  - SmartInstantiationAwareBeanPostProcessor 它提供了更高级的Bean实例化控制方法。主要作用在于允许对Bean的实例化过程进行更精细的控制和定制。 *  - MergedBeanDefinitionPostProcessor 在合并Bean定义（MergedBeanDefinition）之后但在实例化Bean之前，允许对合并后的Bean定义进行修改、调整或附加元数据。 *  - DestructionAwareBeanPostProcessor 它允许在Bean被销毁之前（例如，容器关闭或特定作用域的Bean销毁）执行一些操作。 */ public static void registerBeanPostProcessors ( ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) { // WARNING: Although it may appear that the body of this method can be easily // refactored to avoid the use of multiple loops and multiple lists, the use // of multiple lists and multiple passes over the names of processors is // intentional. We must ensure that we honor the contracts for PriorityOrdered // and Ordered processors. Specifically, we must NOT cause processors to be // instantiated (via getBean() invocations) or registered in the ApplicationContext // in the wrong order. // // Before submitting a pull request (PR) to change this method, please review the // list of all declined PRs involving changes to PostProcessorRegistrationDelegate // to ensure that your proposal does not result in a breaking change:winered.cn // https://github.com/spring-projects/spring-framework/issues?q=PostProcessorRegistrationDelegate+is%3Aclosed+label%3A%22status%3A+declined%22 /** * 拿到所有实现 BeanPostProcessor 的 bean名称 */ String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true , false ); // Register BeanPostProcessorChecker that logs an info message when // a bean is created during BeanPostProcessor instantiation, i.e. when // a bean is not eligible for getting processed by all BeanPostProcessors. /** * 计算 BeanPostProcessor(BPP) 的总数. * +1 是什么操作? 原因是: 下一行,又加了一个 BeanPostProcessorChecker */ int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length; // BeanPostProcessorChecker 这个BeanPostProcessor, 没啥实际作用, 就是记录了一些日志; beanFactory.addBeanPostProcessor( new BeanPostProcessorChecker (beanFactory, postProcessorNames, beanProcessorTargetCount)); // Separate between BeanPostProcessors that implement PriorityOrdered, // Ordered, and the rest. /** * 对 BeanPostProcessor 进行分类存起来,  再调用, 每个集合分别是 * 1. priorityOrderedPostProcessors //有实现(PriorityOrdered)排序接口的 * 2. internalPostProcessors //Spring内部的bean, 见: Spring将bean分为三种角色 * 3. orderedPostProcessorNames //实现 Ordered 接口 * 4. nonOrderedPostProcessorNames //没有指定顺序, 无序的 */ List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList <>(); List<BeanPostProcessor> internalPostProcessors = new ArrayList <>(); List<String> orderedPostProcessorNames = new ArrayList <>(); List<String> nonOrderedPostProcessorNames = new ArrayList <>(); for (String ppName : postProcessorNames) { if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) { /** * 注意, 若 bean 实现了 PriorityOrdered 接口, 则会优先实例化它; */ BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class); priorityOrderedPostProcessors.add(pp); if (pp instanceof MergedBeanDefinitionPostProcessor) { internalPostProcessors.add(pp); } } else if (beanFactory.isTypeMatch(ppName, Ordered.class)) { orderedPostProcessorNames.add(ppName); } else { nonOrderedPostProcessorNames.add(ppName); } } // First, register the BeanPostProcessors that implement PriorityOrdered. sortPostProcessors(priorityOrderedPostProcessors, beanFactory); registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors); // Next, register the BeanPostProcessors that implement Ordered. List<BeanPostProcessor> orderedPostProcessors = new ArrayList <>(orderedPostProcessorNames.size()); for (String ppName : orderedPostProcessorNames) { BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class); orderedPostProcessors.add(pp); if (pp instanceof MergedBeanDefinitionPostProcessor) { internalPostProcessors.add(pp); } } sortPostProcessors(orderedPostProcessors, beanFactory); registerBeanPostProcessors(beanFactory, orderedPostProcessors); /** * 注册所有常规BeanPostProcessors * 这里 getBean 实例化bean !; */ // Now, register all regular(常规) BeanPostProcessors. List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList <>(nonOrderedPostProcessorNames.size()); for (String ppName : nonOrderedPostProcessorNames) { BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class); nonOrderedPostProcessors.add(pp); if (pp instanceof MergedBeanDefinitionPostProcessor) {qssfzm.com， internalPostProcessors.add(pp); } } registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors); /** * 最后, 注册所有 内置 BeanPostProcessor */ // Finally, re-register all internal BeanPostProcessors. sortPostProcessors(internalPostProcessors, beanFactory); registerBeanPostProcessors(beanFactory, internalPostProcessors); //最后再放一个 ApplicationListenerDetector 让它在最后 (不是重点, 见名应该是事件相关的) // Re-register post-processor for detecting inner beans as ApplicationListeners, // moving it to the end of the processor chain (for picking up proxies etc).

1. 进行分类存到集合 {@link PostProcessorRegistrationDelegate#registerBeanPostProcessors(ConfigurableListableBeanFactory, AbstractApplicationContext)}
   对 BeanPostProcessor 进行分类存起来, 再调用, 每个集合分别是
   1. priorityOrderedPostProcessors //有实现(PriorityOrdered)排序接口的
   2. internalPostProcessors //Spring内部的bean, 见: Spring将bean分为三种角色
   3. orderedPostProcessorNames //实现 Ordered 接口
   4. nonOrderedPostProcessorNames //没有指定顺序, 无序的
      这有一点, Spring 对 BeanDefinition 分成三种角色:
      • 用户定义的 业务相关的 Bean Bean (ROLE_APPLICATION)
      • 较复杂的 (ROLE_SUPPORT) 较复杂的, 支持 AOP、事务等功能的内部实现? (不重要, 不要每一个细节都扣...)
      • Spring 内置的(ROLE_INFRASTRUCTURE)
2. 排序并注册到 beanFactory
   1. 这里按实现(PriorityOrdered)排序接口的、@Ordered注解的 等排序存起来. 实际调用的顺序 其实就是存起来的顺序
   2. 另外 BeanPostProcessor 接口粗粒度太大了, Spring 还细分一些子接口:
      1. SmartInstantiationAwareBeanPostProcessor 它提供了更高级的Bean实例化控制方法。主要作用在于允许对Bean的实例化过程进行更精细的控制和定制。
      2. MergedBeanDefinitionPostProcessor 在合并Bean定义（MergedBeanDefinition）之后但在实例化Bean之前，允许对合并后的Bean定义进行修改、调整或附加元数据。
      3. DestructionAwareBeanPostProcessor 它允许在Bean被销毁之前（

/** * Initialize the MessageSource. * Use parent's if none defined in this context. * 主要是对I18N国际化的处理， */ protected void initMessageSource () { /** * //拿到 bean factory */ ConfigurableListableBeanFactory beanFactory = getBeanFactory(); /** * 是否有定义名称为 MESSAGE_SOURCE_BEAN_NAME 的 Bean *  { @link org.springframework.context.support.AbstractApplicationContext#MESSAGE_SOURCE_BEAN_NAME } */ if (beanFactory.containsLocalBean(MESSAGE_SOURCE_BEAN_NAME)) { this .messageSource = beanFactory.getBean(MESSAGE_SOURCE_BEAN_NAME, MessageSource.class); // Make MessageSource aware of parent MessageSource. if ( this .parent != null && this .messageSource instanceof HierarchicalMessageSource hms && hms.getParentMessageSource() == null ) { // Only set parent context as parent MessageSource if no parent MessageSource // registered already. /** * 如果有的话，就使用该定义的MessageSource 处理消息国际化 */ hms.setParentMessageSource(getInternalParentMessageSource()); } if (logger.isTraceEnabled()) { logger.trace( "Using MessageSource [" + this .messageSource + "]" ); } } else { /** *  如果没有 MESSAGE_SOURCE_BEAN_NAME 则默认使用 DelegatingMessageSource; *  注册到 beanFactory */ // Use empty MessageSource to be able to accept getMessage calls. DelegatingMessageSource dms = new DelegatingMessageSource (); dms.setParentMessageSource(getInternalParentMessageSource()); //注意这 Context属性 this .messageSource = dms; beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this .messageSource); if (logger.isTraceEnabled()) {529529.cn，

* Initialize the ApplicationEventMulticaster. * Uses SimpleApplicationEventMulticaster if none defined in the context. * @see org.springframework.context.event.SimpleApplicationEventMulticaster */ protected void initApplicationEventMulticaster () { ConfigurableListableBeanFactory beanFactory = getBeanFactory(); /** * 1. 如果 beanFactory 中包含名称为 APPLICATION_EVENT_MULTICASTER_BEAN_NAME的bean定义, 则使用这个 ApplicationEventMulticaster 作为 事件多播器 * 如果不包含则创建 SimpleApplicationEventMulticaster作为事件多播器; */ if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) { this .applicationEventMulticaster = beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class); if (logger.isTraceEnabled()) { logger.trace( "Using ApplicationEventMulticaster [" + this .applicationEventMulticaster + "]" ); } } else { /** * 2. 创建 SimpleApplicationEventMulticaster 作为默认的事件多播器 (Event Channel) *  其实就是初始化了一个 用于存放/管理 ApplicationListener 监听器(观察者)的类 *   在Spring 事件机制中, 在容器发布事件时 `this.applicationEventMulticaster.multicastEvent(new ObjectEvent());` *   @see org.springframework.context.event.AbstractApplicationEventMulticaster#defaultRetriever 用户存放/管理 各个监听器的(观察者) *   @see AbstractApplicationContext#publishEvent(Object, ResolvableType) 调用容器发布事件 * *  这个 applicationEventMulticaster 除了在容器发布事件时用它, 在注册监听器时直接用它 { @link AbstractApplicationContext#registerListeners()} */ this .applicationEventMulticaster = new SimpleApplicationEventMulticaster (beanFactory); /** * 将其注册到 beanFactory; * 注意 这是实例, 它直接放到一级缓存中. */ beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this .applicationEventMulticaster); if (logger.isTraceEnabled()) {zgongfu.cn， logger.trace( "No '" + APPLICATION_EVENT_MULTICASTER_BEAN_NAME + "' bean, using " + "[" + this .applicationEventMulticaster.getClass().getSimpleName() + "]" );

*/ protected void registerListeners () { /** * 1. 向多播器中注册 在context中的监听器(观察者) */ // Register statically specified listeners first. for (ApplicationListener<?> listener : getApplicationListeners()) { getApplicationEventMulticaster().addApplicationListener(listener); } // Do not initialize FactoryBeans here: We need to leave all regular beans // uninitialized to let post-processors apply to them! /** *  2. 向多播器中注册 在beanFactory中的bean是监听器(ApplicationListener.class)的(观察者) *  注意: *  2.1 这里是会先从 BeanFactory (getBeanNamesForType)获取是 ApplicationListener.class 的 bean name *  2.2 注意只是查找匹配类型的 bean 名称, 没有实例化 存的也是 bean name; */ String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true , false ); for (String listenerBeanName : listenerBeanNames) { getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName); } /** * 3. 广播 this.earlyApplicationEvents 属性中的事件; * 为什么? * 因为有可能 在容器生命周期中调用了当前 `AbstractApplicationContext#publishEvent` 发布事件, 但是多播器没有初始化完成, 所以会将事件存在this.earlyApplicationEvents 中; * 待容器初始化完成后, 在流程  { @link org.springframework.context.support.AbstractApplicationContext#registerListeners()} 中会发布存在这里面的事件 * (例如: 在 BeanFactoryPostProcessor 的业务逻辑触发容器的广播事件, 这时候多播器都不存在, 也不知道有哪些 bean作为观察者) * @see AbstractApplicationContext#prepareRefresh() */ // Publish early application events now that we finally have a multicaster... Set<ApplicationEvent> earlyEventsToProcess = this .earlyApplicationEvents; this .earlyApplicationEvents = null ; //下一步 multicastEvent 后就没用了, 赋 null 释放资源.1rt.cn， if (!CollectionUtils.isEmpty(earlyEventsToProcess)) { for (ApplicationEvent earlyEvent : earlyEventsToProcess) {

* Finish the initialization of this context's bean factory, * initializing all remaining singleton beans. */ protected void finishBeanFactoryInitialization (ConfigurableListableBeanFactory beanFactory) { // Initialize conversion service for this context. /** * * 1. 为 beanFactory 初始化类型转换器(ConversionService) *   注意: 在 Spring 中`ConversionService` 是用于类型转换的服务接口, 它是转换类型的入口点, 但是真正的转换逻辑功能 则由 Converter 和 GenericConverter 接口的实现处理的 */ 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)); } // Register a default embedded value resolver if no BeanFactoryPostProcessor // (such as a PropertySourcesPlaceholderConfigurer bean) registered any before: // at this point, primarily for resolution in annotation attribute values. /** * 2. 如果 beanFactory 上下文中不包含 "默认的变量解析器 (类似 PropertySourcesPlaceholderConfigurer) 解析类似 '${}' 这样的变量 " * 则使用环境对象(ConfigurableEnvironment)中的 ConfigurablePropertyResolver实现来作为 StringValueResolver 添加进去 */ if (!beanFactory.hasEmbeddedValueResolver()) { beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal)); } // Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early. /** * 3. 先实例化化 LoadTimeWeaverAware bean，以便尽早注册它们的转换器。 * TODO AOP 相关的 */ String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false , false ); for (String weaverAwareName : weaverAwareNames) { getBean(weaverAwareName); } // Stop using the temporary ClassLoader for type matching. // 停止使用临时ClassLoader进行类型匹配 beanFactory.setTempClassLoader( null ); // Allow for caching all bean definition metadata, not expecting further changes. /** * 4. 冻结配置, 这时候就不再允许更改 beanDefinition 了; (其实就是 clearMetadataCache 和 设置了一个标识符) */ beanFactory.freezeConfiguration(); czjzz.com， // Instantiate all remaining (non-lazy-init) singletons. /** * 5. 实例化所有剩余的 (非lazy-init) 单例 Bean */

public void preInstantiateSingletons () throws BeansException { if (logger.isTraceEnabled()) { logger.trace( "Pre-instantiating singletons in " + this ); } // Iterate over a copy to allow for init methods which in turn register new bean definitions. // While this may not be part of the regular factory bootstrap, it does otherwise work fine. /** *  所有已注册的Bean name 列表; *  这里复制一份, 方便遍历; */ List<String> beanNames = new ArrayList <>( this .beanDefinitionNames); // Trigger initialization of all non-lazy singleton beans... for (String beanName : beanNames) { /** * 合并到父类的 BeanDefinition 得到 RootBeanDefinition, 放入缓存中. * (每一个Bean都有 RootBeanDefinition, 没有的话 getMergedLocalBeanDefinition 会创建一个, 并放入缓存中) * * 为什么需要往上缓存 RootBeanDefinition ? * 实例化一个对象的时候, 肯定是先实例化父对象, 有父对象才能实例子对象 */ RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName); //如果该 bean 是: 非抽象, 是单例, 非懒加载 if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) { /** * 如果该bean是 FactoryBean, 则在 bean name 前面加一个 '&' 前缀, 先获取/实例化 FactoryBean 本身; *  注意一下 FactoryBean 生成对象是不遵循 Spring 的bean生命周期的 * * 这有两个对象, 如何获取? getBean(beanName) : * 1. 传入 FactoryBean 的 name 返回的是其 getObject 的目标对象实例; * 2. 如果想获取 FactoryBean 本身实例, 则前面需要加一个 '&' 前缀; * */ if (isFactoryBean(beanName)) { /** * 获取/实例化 factoryBean 本身 */ Object bean = getBean(FACTORY_BEAN_PREFIX + beanName); xmich.cn， if (bean instanceof SmartFactoryBean<?> smartFactoryBean && smartFactoryBean.isEagerInit()) { /** * 如果是 SmartFactoryBean 并且 是急加载: * 则再获取/实例化该 FactoryBean 的目标对象 */ getBean(beanName); } } else { getBean(beanName); } } } // Trigger post-initialization callback for all applicable beans... for (String beanName : beanNames) { Object singletonInstance = getSingleton(beanName); if (singletonInstance instanceof SmartInitializingSingleton smartSingleton) { StartupStep smartInitialize = getApplicationStartup().start( "spring.beans.smart-initialize" ) .tag( "beanName" , beanName); smartSingleton.afterSingletonsInstantiated();

** * Return an instance, which may be shared or independent, of the specified bean. * @param name the name of the bean to retrieve * @param requiredType the required type of the bean to retrieve * @param args arguments to use when creating a bean instance using explicit arguments * (only applied when creating a new instance as opposed to retrieving an existing one) * @param typeCheckOnly whether the instance is obtained for a type check, * not for actual use * @return an instance of the bean * @throws BeansException if the bean could not be created */ @SuppressWarnings("unchecked") protected <T> T doGetBean (sx17.cn， String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly) throws BeansException { /** * * 转换 bean name; 如果名称中带 BeanFactory.FACTORY_BEAN_PREFIX, 则会去掉它; * { @link BeanFactory#FACTORY_BEAN_PREFIX} */ String beanName = transformedBeanName(name); Object beanInstance; // Eagerly check singleton cache for manually registered singletons. /** * 尝试从当前容器 一 二 三级缓存获取 */ Object sharedInstance = getSingleton(beanName); if (sharedInstance != null && args == null ) { /** * 如果缓存中有 */ if (logger.isTraceEnabled()) { if (isSingletonCurrentlyInCreation(beanName)) { logger.trace( "Returning eagerly cached instance of singleton bean '" + beanName + "' that is not fully initialized yet - a consequence of a circular reference" ); } else { logger.trace( "Returning cached instance of singleton bean '" + beanName + "'" ); } } /** * 如果拿到的Bean是 FactoryBean 实现, 则会调用 `T getObject() throws Exception` 获取其对象 * 再将目标对象放入org.springframework.beans.factory.support.FactoryBeanRegistrySupport#factoryBeanObjectCache缓存中 * 最终在 { @link org.springframework.beans.factory.support.FactoryBeanRegistrySupport#doGetObjectFromFactoryBean} */ beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, null ); } else { /** * 如果缓存中没有 */ /** *  判断该bean是否在创建中 (循环创建), 用的是一个ThreadLocal *  { @link org.springframework.beans.factory.support.AbstractBeanFactory#prototypesCurrentlyInCreation} */ // Fail if we're already creating this bean instance: // We're assumably within a circular reference. if (isPrototypeCurrentlyInCreation(beanName)) { throw new BeanCurrentlyInCreationException (beanName); } /** * 优先尝试从 父 BeanFactory中拿, 类似类加载器的双亲委托机制 * 一般 父容器都是空的 */ // Check if bean definition exists in this factory. BeanFactory parentBeanFactory = getParentBeanFactory(); if (parentBeanFactory != null && !containsBeanDefinition(beanName)) { // Not found -> check parent. String nameToLookup = originalBeanName(name); if (parentBeanFactory instanceof AbstractBeanFactory abf) {skjcxs.cn， return abf.doGetBean(nameToLookup, requiredType, args, typeCheckOnly); } else if (args != null ) { // Delegation to parent with explicit args. return (T) parentBeanFactory.getBean(nameToLookup, args); } else if (requiredType != null ) { // No args -> delegate to standard getBean method. return parentBeanFactory.getBean(nameToLookup, requiredType); } else { return (T) parentBeanFactory.getBean(nameToLookup); } } /** * 标记该 bean为创建中或者已创建; * 其实就是用 Set集合 { @link org.springframework.beans.factory.support.AbstractBeanFactory#alreadyCreated} 存起来 */ if (!typeCheckOnly) { markBeanAsCreated(beanName); } /** * 记录器 (打印某些关键过程日志, 收集分析, 不重要) */ StartupStep beanCreation = this .applicationStartup.start( "spring.beans.instantiate" ) .tag( "beanName" , name); mmsoft.cn， try { if (requiredType != null ) { beanCreation.tag( "beanType" , requiredType::toString); } /** * 拿到其 RootBeanDefinition (完整的Bean元数据描述) */ RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName); //检查BeanDefinition, 就判断一下是该bean 否抽象类 checkMergedBeanDefinition(mbd, beanName, args); tcwjzs.com， /** * 如果存在依赖配置, 则先创建依赖的Bean * (即XML的 <bean id="..." depends-on="" ...></bean> 配置) */ // Guarantee initialization of beans that the current bean depends on. String[] dependsOn = mbd.getDependsOn(); if (dependsOn != null ) { for (String dep : dependsOn) { if (isDependent(beanName, dep)) { throw new BeanCreationException (mbd.getResourceDescription(), beanName, "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'" ); } registerDependentBean(dep, beanName); try { getBean(dep); } catch (NoSuchBeanDefinitionException ex) { throw new BeanCreationException (mbd.getResourceDescription(), beanName, "'" + beanName + "' depends on missing bean '" + dep + "'" , ex); } } } // Create bean instance. if (mbd.isSingleton()) { /** * 如果是单例的 Bean * ============================= */ /** * 注意 传递一个 '创建Bean' 的Lambda函数/对象 (ObjectFactory) * getSingleton 的逻辑是:1rt.cn * 1. 尝试从一级缓存中拿 * 2. 将Bean Name 添加到 创建中状态的集合 记录起来; *  { @link  1rt.cnorg.springframework.beans.factory.support.DefaultSingletonBeanRegistry#singletonsCurrentlyInCreation} *   3. 调用 ObjectFactory#getObject() 回调回来 createBean *   4. 如果是新创建的添加到一级缓冲中 */ sharedInstance = getSingleton(beanName, () -> { try { /** * 见: { @link AbstractAutowireCapableBeanFactory#createBean(java.lang.String, org.springframework.beans.factory.support.RootBeanDefinition, java.lang.Object[])} */ return createBean(beanName, mbd, args); } catch (BeansException ex) { // Explicitly remove instance from singleton cache: It might have been put there // eagerly by the creation process, to allow for circular reference resolution. // Also remove any beans that received a temporary reference to the bean. destroySingleton(beanName); throw ex; }529529.cn， }); beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, mbd); } else if (mbd.isPrototype()) { /** * 如果是原型的 Bean * ============================= */ // It's a prototype -> create a new instance. Object prototypeInstance = null ; try { beforePrototypeCreation(beanName); prototypeInstance = createBean(beanName, mbd, args); } finally { afterPrototypeCreation(beanName); } beanInstance = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd); } else { String scopeName = mbd.getScope(); if (!StringUtils.hasLength(scopeName)) { throw new IllegalStateException ( "No scope name defined for bean '" + beanName + "'" ); } Scope scope = this .scopes.get(scopeName); if (scope == null ) { throw new IllegalStateException ( "No Scope registered for scope name '" + scopeName + "'" ); } try { Object scopedInstance = scope.get(beanName, () -> { beforePrototypeCreation(beanName); try { return createBean(beanName, mbd, args); } finally { afterPrototypeCreation(beanName); } }); beanInstance = getObjectForBeanInstance(scopedInstance, name, beanName, mbd); } 88363.cn， catch (IllegalStateException ex) { throw new ScopeNotActiveException (beanName, scopeName, ex); } } } catch (BeansException ex) { beanCreation.tag( "exception" , ex.getClass().toString());