think in spring refresh 6
refresh 方法的第6步： （ 主要处理 BeanPostProcessor， 该接口是对bean的扩展，用在 bean实例化之后，执行初始化方法前后，允许开发者对bean实例进行修改 ）
主要就是创建了所有的 Bean后置处理器实例，并将他们添加到了 beanFactory中的 list 变量中进行存储。
// Register bean processors that intercept bean creation. registerBeanPostProcessors(beanFactory);
/** * Instantiate and register all BeanPostProcessor beans, * respecting explicit order if given. * <p>Must be called before any instantiation of application beans. */ protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) { PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this); }
public static void registerBeanPostProcessors( ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) { // 1 找到所有实现了 BeanPostProcessor 接口的类 从哪里，怎么找的？？ 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.
// 为什么是这样算数量 ？ int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
// 注册了一个后置处理器 beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount)); // Separate between BeanPostProcessors that implement PriorityOrdered, // Ordered, and the rest.
//
List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>(); // 存放的是对象实例，不是说BeanDefinition List<BeanPostProcessor> internalPostProcessors = new ArrayList<>(); // 这个有什么用 List<String> orderedPostProcessorNames = new ArrayList<>(); // 存放的是beanName， 不是对象实例 List<String> nonOrderedPostProcessorNames = new ArrayList<>(); for (String ppName : postProcessorNames) { if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) { BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class); // 创建bean的后置处理器 priorityOrderedPostProcessors.add(pp); // 存放的是对象实例 if (pp instanceof MergedBeanDefinitionPostProcessor) { internalPostProcessors.add(pp); } } else if (beanFactory.isTypeMatch(ppName, Ordered.class)) { orderedPostProcessorNames.add(ppName); // 存放的只是beanName,没有存放对象实例，而且此时对象实列也没有创建出来。 } else { nonOrderedPostProcessorNames.add(ppName); // 存放的是beanName } } // First, register the BeanPostProcessors that implement PriorityOrdered. sortPostProcessors(priorityOrderedPostProcessors, beanFactory); // 进行排序，底层用到了 Comparable。 registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors); // 将创建好的 后置处理器添加到 beanFactory 的变量中 // 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); // 添加到beanFactory的变量中，具体是在 AbstractApplicationContext中 // 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) { internalPostProcessors.add(pp); } } registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors); // Finally, re-register all internal BeanPostProcessors. sortPostProcessors(internalPostProcessors, beanFactory); registerBeanPostProcessors(beanFactory, internalPostProcessors); // 为什么要重新注册一次呢？？ <<<<< // Re-register post-processor for detecting inner beans as ApplicationListeners, // moving it to the end of the processor chain (for picking up proxies etc).
// 重新注册 监听器探测器，之前注册过一次，为什么要重新注册一次 ？
beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext)); }
AbstractApplicationContext中有一个list变量，用来存储后置处理器。
/** BeanPostProcessors to apply. */ private final List<BeanPostProcessor> beanPostProcessors = new CopyOnWriteArrayList<>();
问题1 ： 如何做到找到所有实现了BeanFactory接口的类的？
@Override public String[] getBeanNamesForType(@Nullable Class<?> type, boolean includeNonSingletons, boolean allowEagerInit) { if (!isConfigurationFrozen() || type == null || !allowEagerInit) { return doGetBeanNamesForType(ResolvableType.forRawClass(type), includeNonSingletons, allowEagerInit); // 调用这个方法 } Map<Class<?>, String[]> cache = (includeNonSingletons ? this.allBeanNamesByType : this.singletonBeanNamesByType); String[] resolvedBeanNames = cache.get(type); if (resolvedBeanNames != null) { return resolvedBeanNames; } resolvedBeanNames = doGetBeanNamesForType(ResolvableType.forRawClass(type), includeNonSingletons, true); if (ClassUtils.isCacheSafe(type, getBeanClassLoader())) { cache.put(type, resolvedBeanNames); } return resolvedBeanNames; }
《《《《《
在 DefaultApplicationContext 类中：
private String[] doGetBeanNamesForType(ResolvableType type, boolean includeNonSingletons, boolean allowEagerInit) { List<String> result = new ArrayList<>(); // Check all bean definitions. for (String beanName : this.beanDefinitionNames) { // 遍历一个存储了所有 beanName的list型的变量， 什么时候将beanName存储进去的？？ // Only consider bean as eligible if the bean name is not defined as alias for some other bean. if (!isAlias(beanName)) { // 如果这个beanName 没有别名 try {
// 1 得到 RootBeanDefinition RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName); // // Only check bean definition if it is complete. if (!mbd.isAbstract() && (allowEagerInit || (mbd.hasBeanClass() || !mbd.isLazyInit() || isAllowEagerClassLoading()) && !requiresEagerInitForType(mbd.getFactoryBeanName()))) { boolean isFactoryBean = isFactoryBean(beanName, mbd); BeanDefinitionHolder dbd = mbd.getDecoratedDefinition(); boolean matchFound = false; boolean allowFactoryBeanInit = (allowEagerInit || containsSingleton(beanName)); boolean isNonLazyDecorated = (dbd != null && !mbd.isLazyInit()); if (!isFactoryBean) { if (includeNonSingletons || isSingleton(beanName, mbd, dbd)) { matchFound = isTypeMatch(beanName, type, allowFactoryBeanInit); } } else { if (includeNonSingletons || isNonLazyDecorated || (allowFactoryBeanInit && isSingleton(beanName, mbd, dbd))) { matchFound = isTypeMatch(beanName, type, allowFactoryBeanInit); } if (!matchFound) { // In case of FactoryBean, try to match FactoryBean instance itself next. beanName = FACTORY_BEAN_PREFIX + beanName; matchFound = isTypeMatch(beanName, type, allowFactoryBeanInit); } } if (matchFound) { result.add(beanName); } } } catch (CannotLoadBeanClassException | BeanDefinitionStoreException ex) { if (allowEagerInit) { throw ex; } // Probably a placeholder: let's ignore it for type matching purposes. LogMessage message = (ex instanceof CannotLoadBeanClassException ? LogMessage.format("Ignoring bean class loading failure for bean '%s'", beanName) : LogMessage.format("Ignoring unresolvable metadata in bean definition '%s'", beanName)); logger.trace(message, ex); // Register exception, in case the bean was accidentally unresolvable. onSuppressedException(ex); } catch (NoSuchBeanDefinitionException ex) { // Bean definition got removed while we were iterating -> ignore. } } } // Check manually registered singletons too. for (String beanName : this.manualSingletonNames) { try { // In case of FactoryBean, match object created by FactoryBean. if (isFactoryBean(beanName)) { if ((includeNonSingletons || isSingleton(beanName)) && isTypeMatch(beanName, type)) { result.add(beanName); // Match found for this bean: do not match FactoryBean itself anymore. continue; } // In case of FactoryBean, try to match FactoryBean itself next. beanName = FACTORY_BEAN_PREFIX + beanName; } // Match raw bean instance (might be raw FactoryBean). if (isTypeMatch(beanName, type)) { result.add(beanName); } } catch (NoSuchBeanDefinitionException ex) { // Shouldn't happen - probably a result of circular reference resolution... logger.trace(LogMessage.format( "Failed to check manually registered singleton with name '%s'", beanName), ex); } } return StringUtils.toStringArray(result); }
AbstractBeanFactory 中的 getMergedLocalBeanDefinition。 保证返回的就是一个 RootBeanDefinition 类型的对象。
protected RootBeanDefinition getMergedLocalBeanDefinition(String beanName) throws BeansException { // Quick check on the concurrent map first, with minimal locking. RootBeanDefinition mbd = this.mergedBeanDefinitions.get(beanName); // 有一个 Map型的变量专门用来存储 MergedBeanDefinition if (mbd != null && !mbd.stale) { return mbd; }
// 第一个参数是 beanName ; 第二个参数是 BeanDefinition return getMergedBeanDefinition(beanName, getBeanDefinition(beanName)); // 如果map中不存在，那么创建一个 MergedBeanDefinition }
// 创建 根据 beanName 和 beanName对应的 BeanDefinition， 来获取 RootBeanDefinition
其实就是将 BeanDefinition 转换为了 RootBeanDefinition.
/** * Return a RootBeanDefinition for the given bean, by merging with the * parent if the given bean's definition is a child bean definition. * @param beanName the name of the bean definition * @param bd the original bean definition (Root/ChildBeanDefinition) * @param containingBd the containing bean definition in case of inner bean, * or {@code null} in case of a top-level bean * @return a (potentially merged) RootBeanDefinition for the given bean * @throws BeanDefinitionStoreException in case of an invalid bean definition */ protected RootBeanDefinition getMergedBeanDefinition( String beanName, BeanDefinition bd, @Nullable BeanDefinition containingBd) throws BeanDefinitionStoreException { synchronized (this.mergedBeanDefinitions) { RootBeanDefinition mbd = null; RootBeanDefinition previous = null; // Check with full lock now in order to enforce the same merged instance. if (containingBd == null) { // 为 null mbd = this.mergedBeanDefinitions.get(beanName); // mdb为 null } if (mbd == null || mbd.stale) { previous = mbd; if (bd.getParentName() == null) { // parentName 变量的作用是什么？？ <<<< 如果不存在父定义 // Use copy of given root bean definition. if (bd instanceof RootBeanDefinition) { // 如果该beanDefinition 是 RootBeanDefinition 的类型 mbd = ((RootBeanDefinition) bd).cloneBeanDefinition(); // 通过克隆，创建一个新的 RootBeanDefinition } else {
// 如果 该BeanDefiniton 不是 RootBeanDefinition的类型，那么根据当前的 beanDefinition 去创建一个 RootBeanDefinition mbd = new RootBeanDefinition(bd); } } else { // 如果当前 beanDefinition存在 父定义 // Child bean definition: needs to be merged with parent. BeanDefinition pbd; try {
// 获取父定义的 beanName. String parentBeanName = transformedBeanName(bd.getParentName()); // 1.1
// 如果 父定义的 beanName和当前的 beanName 不一致 if (!beanName.equals(parentBeanName)) { pbd = getMergedBeanDefinition(parentBeanName); // 1.2 } else {
// 获取 父BeanFactory BeanFactory parent = getParentBeanFactory();
// if (parent instanceof ConfigurableBeanFactory) {
// 通过父BeanFactory获取 父定义的 MergerdBeanDefinition pbd = ((ConfigurableBeanFactory) parent).getMergedBeanDefinition(parentBeanName); } else { throw new NoSuchBeanDefinitionException(parentBeanName, "Parent name '" + parentBeanName + "' is equal to bean name '" + beanName + "': cannot be resolved without a ConfigurableBeanFactory parent"); } } } catch (NoSuchBeanDefinitionException ex) { throw new BeanDefinitionStoreException(bd.getResourceDescription(), beanName, "Could not resolve parent bean definition '" + bd.getParentName() + "'", ex); } // Deep copy with overridden values.
mbd = new RootBeanDefinition(pbd); // 使用父定义来创建 RootBeanDefinition mbd.overrideFrom(bd); // 使用当前 BeanDefinition 去覆盖父定义 } // Set default singleton scope, if not configured before.
// 如果没有配置scope ，则设置成默认的单例模式
if (!StringUtils.hasLength(mbd.getScope())) { mbd.setScope(SCOPE_SINGLETON); } // A bean contained in a non-singleton bean cannot be a singleton itself. // Let's correct this on the fly here, since this might be the result of // parent-child merging for the outer bean, in which case the original inner bean // definition will not have inherited the merged outer bean's singleton status.
// 如果 containingBd不为空，并且 containingBd不是单例的，那么mbd就不能是单例的。 if (containingBd != null && !containingBd.isSingleton() && mbd.isSingleton()) { mbd.setScope(containingBd.getScope()); } // Cache the merged bean definition for the time being // (it might still get re-merged later on in order to pick up metadata changes)
// 缓存，之后可以直接使用
if (containingBd == null && isCacheBeanMetadata()) { this.mergedBeanDefinitions.put(beanName, mbd); } } if (previous != null) { copyRelevantMergedBeanDefinitionCaches(previous, mbd); } return mbd; } }
1.1 transformedBeanName 做的主要就是去掉开头的 & , 和 解析别名。
protected String transformedBeanName(String name) { return canonicalName(BeanFactoryUtils.transformedBeanName(name)); }
BeanFactoryUtils中的方法：
public static String transformedBeanName(String name) { Assert.notNull(name, "'name' must not be null"); if (!name.startsWith(BeanFactory.FACTORY_BEAN_PREFIX)) { // 如果 name 不是以 & 开头的，则直接返回 name return name; } return transformedBeanNameCache.computeIfAbsent(name, beanName -> { // 如果是，则去掉开头的 & do { beanName = beanName.substring(BeanFactory.FACTORY_BEAN_PREFIX.length()); } while (beanName.startsWith(BeanFactory.FACTORY_BEAN_PREFIX)); return beanName; }); }
SimpleAliasRegistry 中的方法：
/** * Determine the raw name, resolving aliases to canonical names. * @param name the user-specified name * @return the transformed name */ public String canonicalName(String name) { String canonicalName = name; // Handle aliasing... String resolvedName; do {
// 如果是别名，则解析成真正的 beanName resolvedName = this.aliasMap.get(canonicalName); if (resolvedName != null) { canonicalName = resolvedName; } } while (resolvedName != null); return canonicalName; }
1.2
@Override public BeanDefinition getMergedBeanDefinition(String name) throws BeansException {
// 获取真正的 beanName String beanName = transformedBeanName(name); // Efficiently check whether bean definition exists in this factory.
// 如果当前 BeanFactory 中不存在beanName的 Bean定义 && 父 BeanFactory 是 ConfigurableBeanFactory if (!containsBeanDefinition(beanName) && getParentBeanFactory() instanceof ConfigurableBeanFactory) {
// 调用父 beanFactory 去获取 beanName 的 MergedBeanDefinition return ((ConfigurableBeanFactory) getParentBeanFactory()).getMergedBeanDefinition(beanName); } // Resolve merged bean definition locally.
// 在当前BeanFactory 中解析 beanName 的 MergedBeanDefinition return getMergedLocalBeanDefinition(beanName); }
父 BeanFactory.
在 Spring 中可能存在多个 BeanFactory，多个 BeanFactory 可能存在 “父工厂” 与 “子工厂” 的关系。最常见的例子就是：Spring MVC 的 BeanFactory 和 Spring 的 BeanFactory，通常情况下，Spring 的 BeanFactory 是 “父工厂”，Spring MVC 的 BeanFactory 是 “子工厂”，在 Spring 中，子工厂可以使用父工厂的 BeanDefinition，因而，如果在当前 BeanFactory 中找不到，而又存在父工厂，则会去父工厂中查找。
MergedBeanDefinition: 合并的bean定义 合并是因为 存在 ”自定义“ 和 ”父定义“ 的情况。 对于一个Bean的定义，存在下面几种情况：
1） 该BeanDefinition存在 ”父定义“ ，首先使用 ”父定义“的参数构建一个RootBeanDefinition， 然后再使用 该 BeanDefinition的参数来进行覆盖。
2）该BeanDefinition不存在 ”父定义“， 并且该 BeanDefinition 的类型是 RootBeanDefinition , 则直接返回 RootBeanDefinition 的一个克隆
3） 该BeanDefinition不存在 ”父定义“， 但该 BeanDefinition 的类型不是 RootBeanDefinition ，使用该 BeanDefinition的参数构建一个RootBeanDefiniton.
通常 BeanDefinition 在之间加载到 BeanFactory中的时候，通常是被封装成 GeniricBeanDefinition 或者 ScannedGenericBeanDefiniton. 前者是通过XML配置来注册的bean, 后者是通过注解的方式注册的bean. 在这里都会被转换成 RootBeanDefinition, 因为后续的操作都是针对RootBeanDefinition来的。
我们通常遇到的是上面的第三种情形。
问题2： 什么时候将beanName的信息添加到beanFactory的list变量中的？？
参考文档：
https://blog.csdn.net/v123411739/article/details/87907784
也许会有遗憾，但是不应该在失败之前
浙公网安备 33010602011771号