*  在给定的(beans)根元素中注册每个bean定义, 这里的 Element 是 xml 根元素 */ @SuppressWarnings("deprecation")   // for Environment.acceptsProfiles(String...) protected void doRegisterBeanDefinitions (Element root) { // Any nested <beans> elements will cause recursion in this method. In // order to propagate and preserve <beans> default-* attributes correctly, // keep track of the current (parent) delegate, which may be null. Create // the new (child) delegate with a reference to the parent for fallback purposes, // then ultimately reset this.delegate back to its original (parent) reference. // this behavior emulates a stack of delegates without actually necessitating one. /** * 在此方法中，任何嵌套的<beans>元素都将导致递归调用 *   为了正确地传播和保存<beans>默认属性，请跟踪当前(父)委托(它可能为空)。 *   创建新的(子)委托，并将其引用到父(父)委托用于回退目的，然后最终将 this.delegate重置为其原始(父)引用。 *   此行为模拟委托堆栈，而实际上不需要委托堆栈。 * * 应该是嵌套解析/递归时, 都用这一个 delegate解析, 保存状态, 用于传递上下文的参数; */ BeanDefinitionParserDelegate parent = this .delegate; /** * 委托 namespaceHandlerResolver */ this .delegate = createDelegate(getReaderContext(), root, parent); //parent 委派, 上级的parent /** * 是否默认命名空间; 这里是 xml 的命名空间解析判断 *    简而言之默认命名空间判定是: http://www.springframework.org/schema/beans 或者是 org/springframework/beans/factory/xml/spring-beans.dtd 其DTD定义的标签 *    如: *    <beans..></beans>, <bean></bean>, <import resource="" /> 这些标签是默认命名空间 *    <tx:TAG ...> , <aop:TAG ...> 这些标签不是默认命名空间 */ if ( this .delegate.isDefaultNamespace(root)) { String profileSpec = root.getAttribute(PROFILE_ATTRIBUTE); if (StringUtils.hasText(profileSpec)) { String[] specifiedProfiles = StringUtils.tokenizeToStringArray( profileSpec, BeanDefinitionParserDelegate.MULTI_VALUE_ATTRIBUTE_DELIMITERS); // We cannot use Profiles.of(...) since profile expressions are not supported // in XML config. See SPR-12458 for details. if (!getReaderContext().getEnvironment().acceptsProfiles(specifiedProfiles)) { if (logger.isDebugEnabled()) { logger.debug( "Skipped XML bean definition file due to specified profiles [" + profileSpec + "] not matching: " + getReaderContext().getResource()); } return ; } } } // 前置-钩子方法, 预留扩展, 这里是空实现 preProcessXml(root); // 真正解析逻辑 parseBeanDefinitions(root, this .delegate); // 后置-钩子方法, 预留扩展, 这里是空实现

* "import", "alias", "bean". * @param root the DOM root element of the document */ protected void parseBeanDefinitions (Element root, BeanDefinitionParserDelegate delegate) { if (delegate.isDefaultNamespace(root)) { NodeList nl = root.getChildNodes(); for ( int i = 0 ; i < nl.getLength(); i++) { Node node = nl.item(i); if (node instanceof Element ele) { //是否 是元素标签 /** * 处理默认命名空间的标签, 有如下四个 * <import></import>, <alias></alias>, <bean></bean>, <beans></beans> * */ if (delegate.isDefaultNamespace(ele)) { parseDefaultElement(ele, delegate); } else { /** * 处理 非默认命名空间的标签; * 注意这里包括 <context:bean ...> <aop:xx ...> <tx:xx ...> 等等所有指定命名空间的xml配置 */ delegate.parseCustomElement(ele);

* @param ele * @param delegate */ private void parseDefaultElement (Element ele, BeanDefinitionParserDelegate delegate) { // 默认命名空间的 import 元素处理 if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) { importBeanDefinitionResource(ele); } // 默认命名空间的 alias 元素处理 else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) { processAliasRegistration(ele); } // 默认命名空间的 bean 元素处理 else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) { processBeanDefinition(ele, delegate); } // 默认命名空间的 beans 元素处理 else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) { // recurse doRegisterBeanDefinitions(ele);

* 主要逻辑是 拿到元素的命名空间URI, 再从 XmlReaderContext 找到对应的 NamespaceHandler 调用解析 `parse`方法解析到 BeanDefinition 返回 *  Parse a custom element (outside the default namespace). * @param ele the element to parse * @param containingBd the containing bean definition (if any) * @return the resulting bean definition */ @Nullable public BeanDefinition parseCustomElement (Element ele, @Nullable BeanDefinition containingBd) { //拿到 命名空间URI String namespaceUri = getNamespaceURI(ele); if (namespaceUri == null ) { return null ; } /** * 拿到对应命名空间的 Handler , this.readerContext 是在 * @see org.springframework.beans.factory.xml.XmlBeanDefinitionReader#registerBeanDefinitions(org.w3c.dom.Document, org.springframework.core.io.Resource) 创建的 * 它会从父属性的 namespaceHandlerResolver 中拿到命名空间处理器, 调用NamespaceHandler#parse 进行解析 * 它默认读取的配置是 `META-INF/spring.handlers` 文件 * * spring 对于 注解 AOP TX事务 的支持, 均是同个这种方式扩展的, 但这些不属IOC内容, 本篇不作说明.. */ NamespaceHandler handler = this .readerContext.getNamespaceHandlerResolver().resolve(namespaceUri); if (handler == null ) { error( "Unable to locate Spring NamespaceHandler for XML schema namespace [" + namespaceUri + "]" , ele); return null ; }

* Process the given bean element, parsing the bean definition * and registering it with the registry. * * - 处理bean元素，解析 BeanDefinition 并将其注册到注册中心。 * - 其实就是往 DefaultListableBeanFactory 的这两个集合属性添加: * 1. 这个list 存储所有的 bean definition 名称 { @link org.springframework.beans.factory.support.DefaultListableBeanFactory#beanDefinitionNames} * 2. 这个map存储所有的BeanDefinition, key是bean主name, value是BeanDefinition { @link org.springframework.beans.factory.support.DefaultListableBeanFactory#beanDefinitionMap} */ protected void processBeanDefinition (Element ele, BeanDefinitionParserDelegate delegate) { /** * 对于 BeanDefinitionHolder 其实它就是一个DTO对象, 它包含以下属性: * private final BeanDefinition beanDefinition;//Bean  beanDefinition * private final String beanName; //Bean 名称 *  private final String[] aliases; //Bean 别名列表 * */ BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele); // 此时, 就完成了 对 BeanDefinition 解析了 if (bdHolder != null ) { /** * 装饰 BeanDefinition（如果需要）, 类似于: * <bean id="user" class=".."> *   <myBean:user username="这是 Spring"/> * </bean> *  对应`myBean:user` 这种自定义标签进行处理; *  后面会找到对应的命名空间 Handler (NamespaceHandler) 进行处理 : NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri); */ bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder); try { /** * 注册到 Registry */ // Register the final decorated instance. BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry()); } catch (BeanDefinitionStoreException ex) { getReaderContext().error( "Failed to register bean definition with name '" + bdHolder.getBeanName() + "'" , ele, ex);

* Register the given bean definition with the given bean factory. * @param definitionHolder the bean definition including name and aliases * @param registry the bean factory to register with * @throws BeanDefinitionStoreException if registration failed */ public static void registerBeanDefinition ( BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry) throws BeanDefinitionStoreException { // Register bean definition under primary name. /** * 以 beanName 向 Register 注册 * 其实就是往 DefaultListableBeanFactory 的这两个集合属性添加: * 1. 这个list 存储所有的 bean definition 名称 { @link org.springframework.beans.factory.support.DefaultListableBeanFactory#beanDefinitionNames} * 2. 这个map存储所有的BeanDefinition, key是bean主name, value是BeanDefinition { @link org.springframework.beans.factory.support.DefaultListableBeanFactory#beanDefinitionMap} */ String beanName = definitionHolder.getBeanName(); registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition()); /** * 向 Register 注册别名列表 * 其实就是 { @link org.springframework.core.SimpleAliasRegistry#aliasMap} * 在这个 map存储bean 的别名, key是别名, value 是bean主name; */ // Register aliases for bean name, if any. String[] aliases = definitionHolder.getAliases(); if (aliases != null ) { for (String alias : aliases) { registry.registerAlias(beanName, alias);

* such as the context's ClassLoader and post-processors. * @param beanFactory the BeanFactory to configure */ protected void prepareBeanFactory (ConfigurableListableBeanFactory beanFactory) { // Tell the internal bean factory to use the context's class loader etc. /** * 为 beanFactory 设置 bean 的类加载器 */ beanFactory.setBeanClassLoader(getClassLoader()); /** * 为 beanFactory 设置 bean 的表达式(Spring EL)解析器 * 默认风格是: `#{var}`  当然这些 前缀 后缀都是可以自定义 * 关于 (Spring EL)解析器: StandardBeanExpressionResolver 的设计是组合优于继承, 内部有两个 SpelExpressionParser(真正解析的) SpelParserConfiguration(配置类) */ beanFactory.setBeanExpressionResolver( new StandardBeanExpressionResolver (beanFactory.getBeanClassLoader())); /** *  为 beanFactory 设置 PropertyEditorRegistrar *  这个主要为 Bean 设置属性的管理类, 比如, 日期类型的数据: 可以是特定格式的字符串, 数字, 还可以是时间戳... *  Spring 为 bean 填充属性, 使用 BeanWrapperImpl 包装了一下(装饰模式) *  BeanWrapperImpl 实现了 PropertyEditorRegistry, 可以往里面注册 PropertyEditor, 可以自定义属性的转换, 编辑逻辑 */ beanFactory.addPropertyEditorRegistrar( new ResourceEditorRegistrar ( this , getEnvironment())); /** * 添加一个 BeanPostProcessor 回调, 作用是如果Bean实现这些接口: * (bean instanceof EnvironmentAware || bean instanceof EmbeddedValueResolverAware || * bean instanceof ResourceLoaderAware || bean instanceof ApplicationEventPublisherAware || * bean instanceof MessageSourceAware || bean instanceof ApplicationContextAware || * bean instanceof ApplicationStartupAware) *  它负责调用其对应 Aware 的方法, 给Bean 注入对象 * * in short 就是给 bean 设置 上下文, 内置的对象; 注意是 (postProcessBeforeInitialization) */ // Configure the bean factory with context callbacks. beanFactory.addBeanPostProcessor( new ApplicationContextAwareProcessor ( this )); /** * 因为上面由 ApplicationContextAwareProcessor 负责注入 7个接口 * 这里就忽略掉这7个接口的自动注入 * EnvironmentAware.class, EmbeddedValueResolverAware.class, ResourceLoaderAware.class, * ApplicationEventPublisherAware.class, MessageSourceAware.class, ApplicationContextAware.class, ApplicationStartupAware.class */ beanFactory.ignoreDependencyInterface(EnvironmentAware.class); beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class); beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class); beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class); beanFactory.ignoreDependencyInterface(MessageSourceAware.class); beanFactory.ignoreDependencyInterface(ApplicationContextAware.class); beanFactory.ignoreDependencyInterface(ApplicationStartupAware.class); /** * 类似 @Primary, 当有多个的相同类型的时候, 指定谁优先注入 * 指定内置的 BeanFactory,ResourceLoader,ApplicationEventPublisher,ApplicationContext *  几个Bean对象,  自动注入的 Primary * registerResolvableDependency */ // BeanFactory interface not registered as resolvable type in a plain factory. // MessageSource registered (and found for autowiring) as a bean. beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory); beanFactory.registerResolvableDependency(ResourceLoader.class, this ); beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this ); beanFactory.registerResolvableDependency(ApplicationContext.class, this ); // Register early post-processor for detecting inner beans as ApplicationListeners. /** * TODO 时间监听器相关 */ beanFactory.addBeanPostProcessor( new ApplicationListenerDetector ( this )); /** * TODO  这里是 AOP AspectJ处理 * LoadTimeWeaver (AOP的加载时织入) */ // Detect a LoadTimeWeaver and prepare for weaving, if found. if (!NativeDetector.inNativeImage() && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) { beanFactory.addBeanPostProcessor( new LoadTimeWeaverAwareProcessor (beanFactory)); // Set a temporary ClassLoader for type matching. beanFactory.setTempClassLoader( new ContextTypeMatchClassLoader (beanFactory.getBeanClassLoader())); } /** * beanFactory 中如果没有以下这些名称的 bean 则 直接给 BeanFactory 的一级缓存, 注册几个默认环境 Bean */ // Register default environment beans. if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) { beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment()); } if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) { beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties()); } if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) { beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment()); } if (!beanFactory.containsLocalBean(APPLICATION_STARTUP_BEAN_NAME)) {

1. PropertyEditorRegistrar 这个主要为 Bean 设置属性的管理类, 比如, 日期类型的数据: 可以是特定格式的字符串, 数字, 还可以是时间戳...
   Spring 为 bean 填充属性, 使用 BeanWrapperImpl 包装了一下(装饰模式)
   BeanWrapperImpl 实现了 PropertyEditorRegistry, 可以往里面注册 PropertyEditor, 可以自定义属性的转换, 编辑逻辑
2. 给 beanFactory 添加一个 处理Aware的 BeanPostProcessor (ApplicationContextAwareProcessor) 并忽略掉这7个接口的自动注入:{@link ConfigurableBeanFactory#addBeanPostProcessor(BeanPostProcessor)}
   EnvironmentAware.class, EmbeddedValueResolverAware.class, ResourceLoaderAware.class, ApplicationEventPublisherAware.class, MessageSourceAware.class, ApplicationContextAware.class, ApplicationStartupAware.class
3. 指定内置的 BeanFactory,ResourceLoader,ApplicationEventPublisher,ApplicationContext {@link ConfigurableListableBeanFactory#registerResolvableDependency(Class, Object)}
   这几个Bean对象, 自动注入的 Primary
4. 给 beanFactory 添加一个 BeanPostProcessor (ApplicationListenerDetector)TODO (事件监听相关)
5. 给 beanFactory 添加一个 BeanPostProcessor(LoadTimeWeaverAwareProcessor) TODO (AOP AspectJ 织入处理相关的)
6. beanFactory中如果没有以下名称的bean, 则直接给 BeanFactory 的一级缓存, 注册几个环境对象 Bean {@link SingletonBeanRegistry#registerSingleton(String, Object)}

* respecting explicit order if given. * <p>Must be called before singleton instantiation. */ protected void invokeBeanFactoryPostProcessors (ConfigurableListableBeanFactory beanFactory) { /** * 调用 BeanFactory 内的所有 BeanFactoryPostProcessor 和 BeanDefinitionRegistryPostProcessor */ PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors()); /** * LOAD_TIME_WEAVER_BEAN_NAME bean 是AOP相关的. * 在 GraalVM 中能编译为本地代码, 不支持AOP的 */ // Detect a LoadTimeWeaver and prepare for weaving, if found in the meantime // (e.g. through an @Bean method registered by ConfigurationClassPostProcessor) if (!NativeDetector.inNativeImage() && beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) { //这里 beanFactory 不包含 LOAD_TIME_WEAVER_BEAN_NAME beanFactory.addBeanPostProcessor( new LoadTimeWeaverAwareProcessor (beanFactory))

* 总的来说, 调用的时候优先级是:qssfzm.com， * 1. 调用接口的优先级 * 优先调用(子类) BeanDefinitionRegistryPostProcessor * 再调用(父类) BeanFactoryPostProcessor * * 2. 调用添加的方式的优先级 * 优先调用外部入参类, 即直接通过 { @link AbstractApplicationContext#addBeanFactoryPostProcessor(org.springframework.beans.factory.config.BeanFactoryPostProcessor)} 代码添加的 * 再调用容器中 实现 BeanFactoryPostProcessor或者 BeanDefinitionRegistryPostProcessor 的 Bean */ public static void invokeBeanFactoryPostProcessors ( ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) { // 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: // https://github.com/spring-projects/spring-framework/issues?q=PostProcessorRegistrationDelegate+is%3Aclosed+label%3A%22status%3A+declined%22 // Invoke BeanDefinitionRegistryPostProcessors first, if any. /** * 存储已经调用 BeanDefinitionRegistryPostProcessor 过的 bean name * 避免重复处理 */ Set<String> processedBeans = new HashSet <>(); if (beanFactory instanceof BeanDefinitionRegistry registry) { /** * 存储 BeanFactoryPostProcessor 的集合, 后面统一调用 */ List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList <>(); /** * 存储已经调用过的 BeanDefinitionRegistryPostProcessor 集合 */ List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList <>(); /** * 先调用外部入参的 BeanDefinitionRegistryPostProcessor (代码添加的) */ for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) { if (postProcessor instanceof BeanDefinitionRegistryPostProcessor registryProcessor) { // 这就调了 registryProcessor.postProcessBeanDefinitionRegistry(registry); // 是 BeanDefinitionRegistryPostProcessor 接口 存入registryProcessors registryProcessors.add(registryProcessor);xyzdh.cn， } else { // 不是 BDRPP  是 BeanFactoryPostProcessor(BFPP) 存入regularPostProcessors, 后面在统一调用 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. /** * 当前将调用的 BeanDefinitionRegistryPostProcessor 集合 */ List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList <>(); // First, invoke the BeanDefinitionRegistryPostProcessors that implement PriorityOrdered. // 1. 先调用 实现PriorityOrdered (排序)的 BDRPP String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true , false ); for (String ppName : postProcessorNames) { if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) { //<!> beanFactory.getBean, 先走实例化bean流程; currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));czjzz.com， processedBeans.add(ppName); } } //排序 sortPostProcessors(currentRegistryProcessors, beanFactory); registryProcessors.addAll(currentRegistryProcessors); //调用 BDRPP invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry, beanFactory.getApplicationStartup()); //调完了就清调 currentRegistryProcessors.clear(); // Next, invoke the BeanDefinitionRegistryPostProcessors that implement Ordered.yousLab.com， // 2. 再调用 实现 Ordered (排序)的 BDRPP 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, beanFactory.getApplicationStartup());nmghssc.com， currentRegistryProcessors.clear(); // Finally, invoke all other BeanDefinitionRegistryPostProcessors until no further ones appear. // 3. 再调用在容器中实现 BeanDefinitionRegistryPostProcessors (BDRPP)的 boolean reiterate = true ; while (reiterate) { reiterate = false ; postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true , false ); for (String ppName : postProcessorNames) { if (!processedBeans.contains(ppName)) {yqfh.cn， currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));skjcxs.cn， processedBeans.add(ppName); reiterate = true ; } } sortPostProcessors(currentRegistryProcessors, beanFactory); registryProcessors.addAll(currentRegistryProcessors); invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry, beanFactory.getApplicationStartup());sx17.cn， currentRegistryProcessors.clear(); } // Now, invoke the postProcessBeanFactory callback of all processors handled so far. invokeBeanFactoryPostProcessors(registryProcessors, beanFactory); // 3. 最后再调用BeanFactoryPostProcessor(BFPP)winered.cn， 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.skjcxs.cn， List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList <>(); List<String> orderedPostProcessorNames = new ArrayList <>(); List<String> nonOrderedPostProcessorNames = new ArrayList <>(); 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); }tjdxfjg.cn， } // 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 <>(orderedPostProcessorNames.size()); 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 <>(nonOrderedPostProcessorNames.size()); for (String postProcessorName :www.tcwjzs.com， 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();