参考源

《Spring源码深度解析(第2版)》

版本

本文章基于 Spring 5.3.15

---

Spring IOC 的核心是 AbstractApplicationContext 的 refresh 方法。

其中一共有 13 个主要方法，这里分析第 10 个：registerListeners。

1 AbstractApplicationContext

1-1 注册监听器

registerListeners()

protected void registerListeners() {    // 获取应用程序监听器。硬编码方法注册的监听器处理    for (ApplicationListener
     listener : getApplicationListeners()) {        // 获取应用程序事件多播器        getApplicationEventMulticaster().addApplicationListener(listener);    }    // 配置文件注册的监听器处理    String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);    for (String listenerBeanName : listenerBeanNames) {        // 获取应用程序事件多播器        getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);    }    Set
    
      earlyEventsToProcess = this.earlyApplicationEvents;    this.earlyApplicationEvents = null;    if (!CollectionUtils.isEmpty(earlyEventsToProcess)) {        for (ApplicationEvent earlyEvent : earlyEventsToProcess) {            // 多播事件            getApplicationEventMulticaster().multicastEvent(earlyEvent);        }    }}
    

1-2 获取应用程序监听器

getApplicationListeners()

private final Set
    
     > applicationListeners = new LinkedHashSet<>();public Collection
     
      > getApplicationListeners() {   return this.applicationListeners;}
     
    

1-2 获取应用程序事件多播器

getApplicationEventMulticaster()

ApplicationEventMulticaster getApplicationEventMulticaster() throws IllegalStateException {   if (this.applicationEventMulticaster == null) {      throw new IllegalStateException("ApplicationEventMulticaster not initialized - " +            "call 'refresh' before multicasting events via the context: " + this);   }   return this.applicationEventMulticaster;}

由于前面注册了多播器，这里直接返回。

1-2 配置文件注册的监听器

getBeanNamesForType(ApplicationListener.class, true, false)

public String[] getBeanNamesForType(@Nullable Class
     type, boolean includeNonSingletons, boolean allowEagerInit) {   // 断言 Bean 工厂活动   assertBeanFactoryActive();   // 返回与给定类型匹配的 bean 的名称   return getBeanFactory().getBeanNamesForType(type, includeNonSingletons, allowEagerInit);}

1-3 断言 Bean 工厂活动

assertBeanFactoryActive()

protected void assertBeanFactoryActive() {   if (!this.active.get()) {      if (this.closed.get()) {         // 获取显示名称         throw new IllegalStateException(getDisplayName() + " has been closed already");      }      else {         // 获取显示名称         throw new IllegalStateException(getDisplayName() + " has not been refreshed yet");      }   }}

1-4 获取显示名称

private String displayName = ObjectUtils.identityToString(this);public String getDisplayName() {   return this.displayName;}

1-3 返回与给定类型匹配的 bean 的名称

getBeanNamesForType(type, includeNonSingletons, allowEagerInit)

2 DefaultListableBeanFactory

public String[] getBeanNamesForType(@Nullable Class
     type, boolean includeNonSingletons, boolean allowEagerInit) {   // 判断是否配置冻结   if (!isConfigurationFrozen() || type == null || !allowEagerInit) {      // 进一步返回与给定类型匹配的 bean 的名称      return doGetBeanNamesForType(ResolvableType.forRawClass(type), includeNonSingletons, allowEagerInit);   }   Map
    
     , String[]> cache =         (includeNonSingletons ? this.allBeanNamesByType : this.singletonBeanNamesByType);   String[] resolvedBeanNames = cache.get(type);   if (resolvedBeanNames != null) {      return resolvedBeanNames;   }   // 进一步返回与给定类型匹配的 bean 的名称   resolvedBeanNames = doGetBeanNamesForType(ResolvableType.forRawClass(type), includeNonSingletons, true);   if (ClassUtils.isCacheSafe(type, getBeanClassLoader())) {      cache.put(type, resolvedBeanNames);   }   return resolvedBeanNames;}
    

2-1 判断是否配置冻结

isConfigurationFrozen()

private volatile boolean configurationFrozen;public boolean isConfigurationFrozen() {   return this.configurationFrozen;}

2-1 进一步返回与给定类型匹配的 bean 的名称

doGetBeanNamesForType(ResolvableType.forRawClass(type), includeNonSingletons, allowEagerInit)

private String[] doGetBeanNamesForType(ResolvableType type, boolean includeNonSingletons, boolean allowEagerInit) {   List
    
      result = new ArrayList<>();   // Check all bean definitions.   // 检查所有的 Bean 定义信息   for (String beanName : this.beanDefinitionNames) {      // Only consider bean as eligible if the bean name is not defined as alias for some other bean.      // 是否别名。如果 bean 名称未定义为其他 bean 的别名，则将 bean 视为合格      if (!isAlias(beanName)) {         try {            // 获取合并的本地 Bean 定义信息            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.            // 注册异常，以防 bean 意外无法解析            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.         // 判断是否是工厂 Bean         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);}
    

2-2 是否别名

isAlias(beanName)

3 SimpleAliasRegistry

private final Map
    
      aliasMap = new ConcurrentHashMap<>(16);public boolean isAlias(String name) {   return this.aliasMap.containsKey(name);}
    

2 DefaultListableBeanFactory

2-2 获取合并的本地 Bean 定义信息

getMergedLocalBeanDefinition(beanName)

4 AbstractBeanFactory

protected RootBeanDefinition getMergedLocalBeanDefinition(String beanName) throws BeansException {   RootBeanDefinition mbd = this.mergedBeanDefinitions.get(beanName);   if (mbd != null && !mbd.stale) {      return mbd;   }   // 获取合并的 Bean 定义信息   return getMergedBeanDefinition(beanName, getBeanDefinition(beanName));}

protected RootBeanDefinition getMergedBeanDefinition(String beanName, BeanDefinition bd)      throws BeanDefinitionStoreException {   // 获取合并的 Bean 定义信息   return getMergedBeanDefinition(beanName, bd, null);}

protected RootBeanDefinition getMergedBeanDefinition(String beanName, BeanDefinition bd, @Nullable BeanDefinition containingBd) throws BeanDefinitionStoreException {    synchronized (this.mergedBeanDefinitions) {        RootBeanDefinition mbd = null;        RootBeanDefinition previous = null;        if (containingBd == null) {            mbd = this.mergedBeanDefinitions.get(beanName);        }        if (mbd == null || mbd.stale) {            previous = mbd;            if (bd.getParentName() == null) {                if (bd instanceof RootBeanDefinition) {                    mbd = ((RootBeanDefinition) bd).cloneBeanDefinition();                } else {                    mbd = new RootBeanDefinition(bd);                }            } else {                BeanDefinition pbd;                try {                    // 转换 Bean 名称                    String parentBeanName = transformedBeanName(bd.getParentName());                    if (!beanName.equals(parentBeanName)) {                        // 获取合并的 Bean 定义信息                        pbd = getMergedBeanDefinition(parentBeanName);                    } else {                        BeanFactory parent = getParentBeanFactory();                        if (parent instanceof ConfigurableBeanFactory) {                            // 获取合并的 Bean 定义信息                            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);                }                mbd = new RootBeanDefinition(pbd);                mbd.overrideFrom(bd);            }            if (!StringUtils.hasLength(mbd.getScope())) {                mbd.setScope(SCOPE_SINGLETON);            }            if (containingBd != null && !containingBd.isSingleton() && mbd.isSingleton()) {                mbd.setScope(containingBd.getScope());            }            if (containingBd == null && isCacheBeanMetadata()) {                this.mergedBeanDefinitions.put(beanName, mbd);            }        }        if (previous != null) {            // 复制合并相关的 Bean 定义缓存            copyRelevantMergedBeanDefinitionCaches(previous, mbd);        }        return mbd;    }}

4-1 转换 Bean 名称

transformedBeanName(bd.getParentName())

protected String transformedBeanName(String name) {    // 转换 Bean 名称    // 规范名称    return canonicalName(BeanFactoryUtils.transformedBeanName(name));}

4-2 转换 Bean 名称

transformedBeanName(name)

5 BeanFactoryUtils

public static String transformedBeanName(String name) {   Assert.notNull(name, "'name' must not be null");   if (!name.startsWith(BeanFactory.FACTORY_BEAN_PREFIX)) {      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;   });}

4 AbstractBeanFactory

4-2 规范名称

canonicalName(BeanFactoryUtils.transformedBeanName(name))

public String canonicalName(String name) {   String canonicalName = name;   // Handle aliasing...   String resolvedName;   do {      resolvedName = this.aliasMap.get(canonicalName);      if (resolvedName != null) {         canonicalName = resolvedName;      }   }   while (resolvedName != null);   return canonicalName;}

4-1 获取合并的 Bean 定义信息

getMergedBeanDefinition(parentBeanName)

public BeanDefinition getMergedBeanDefinition(String name) throws BeansException {   String beanName = transformedBeanName(name);   // Efficiently check whether bean definition exists in this factory.   if (!containsBeanDefinition(beanName) && getParentBeanFactory() instanceof ConfigurableBeanFactory) {      return ((ConfigurableBeanFactory) getParentBeanFactory()).getMergedBeanDefinition(beanName);   }   // Resolve merged bean definition locally.   // 获取合并的 Bean 定义信息   return getMergedLocalBeanDefinition(beanName);}

4-2 获取合并的本地 Bean 定义信息

getMergedLocalBeanDefinition(beanName)

protected RootBeanDefinition getMergedLocalBeanDefinition(String beanName) throws BeansException {   // Quick check on the concurrent map first, with minimal locking.   RootBeanDefinition mbd = this.mergedBeanDefinitions.get(beanName);   if (mbd != null && !mbd.stale) {      return mbd;   }   // 获取合并的 Bean 定义信息   return getMergedBeanDefinition(beanName, getBeanDefinition(beanName));}

4-3 获取合并的 Bean 定义信息

getMergedBeanDefinition(beanName, getBeanDefinition(beanName))

protected RootBeanDefinition getMergedBeanDefinition(String beanName, BeanDefinition bd) throws BeanDefinitionStoreException {   // 获取合并的 Bean 定义信息   return getMergedBeanDefinition(beanName, bd, null);}

protected RootBeanDefinition getMergedBeanDefinition(String beanName, BeanDefinition bd, @Nullable BeanDefinition containingBd) throws BeanDefinitionStoreException {    synchronized (this.mergedBeanDefinitions) {        RootBeanDefinition mbd = null;        RootBeanDefinition previous = null;        if (containingBd == null) {            mbd = this.mergedBeanDefinitions.get(beanName);        }        if (mbd == null || mbd.stale) {            previous = mbd;            if (bd.getParentName() == null) {                if (bd instanceof RootBeanDefinition) {                    mbd = ((RootBeanDefinition) bd).cloneBeanDefinition();                } else {                    mbd = new RootBeanDefinition(bd);                }            } else {                BeanDefinition pbd;                try {                    // 转换 Bean 名称                    String parentBeanName = transformedBeanName(bd.getParentName());                    if (!beanName.equals(parentBeanName)) {                        // 获取合并的 Bean 定义信息                        pbd = getMergedBeanDefinition(parentBeanName);                    } else {                        BeanFactory parent = getParentBeanFactory();                        if (parent instanceof ConfigurableBeanFactory) {                            // 获取合并的 Bean 定义信息                            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);                }                mbd = new RootBeanDefinition(pbd);                mbd.overrideFrom(bd);            }            if (!StringUtils.hasLength(mbd.getScope())) {                mbd.setScope(SCOPE_SINGLETON);            }            if (containingBd != null && !containingBd.isSingleton() && mbd.isSingleton()) {                mbd.setScope(containingBd.getScope());            }            if (containingBd == null && isCacheBeanMetadata()) {                this.mergedBeanDefinitions.put(beanName, mbd);            }        }        if (previous != null) {            // 复制合并相关的 Bean 定义缓存            copyRelevantMergedBeanDefinitionCaches(previous, mbd);        }        return mbd;    }}

这里递归调用又回到了前面的方法。直到 if (!beanName.equals(parentBeanName)) 不再满足，即不再包含父类。

4-1 复制合并相关的 Bean 定义缓存

copyRelevantMergedBeanDefinitionCaches(previous, mbd)

private void copyRelevantMergedBeanDefinitionCaches(RootBeanDefinition previous, RootBeanDefinition mbd) {   if (ObjectUtils.nullSafeEquals(mbd.getBeanClassName(), previous.getBeanClassName()) &&         ObjectUtils.nullSafeEquals(mbd.getFactoryBeanName(), previous.getFactoryBeanName()) &&         ObjectUtils.nullSafeEquals(mbd.getFactoryMethodName(), previous.getFactoryMethodName())) {      ResolvableType targetType = mbd.targetType;      ResolvableType previousTargetType = previous.targetType;      if (targetType == null || targetType.equals(previousTargetType)) {         mbd.targetType = previousTargetType;         mbd.isFactoryBean = previous.isFactoryBean;         mbd.resolvedTargetType = previous.resolvedTargetType;         mbd.factoryMethodReturnType = previous.factoryMethodReturnType;         mbd.factoryMethodToIntrospect = previous.factoryMethodToIntrospect;      }   }}