AbstractApplicationContext#refresh()

  1. @Override
  2. public void refresh() throws BeansException, IllegalStateException {
  3.     synchronized (this.startupShutdownMonitor) {
  4.         // Prepare this context for refreshing.
  5.         // 1. 设置启动时间、开启活跃状态
  6.         // 2. 初始化子类自定义属性（placeholder property）
  7.         // 3. 验证环境里的属性
  8.         prepareRefresh();
  10.         // Tell the subclass to refresh the internal bean factory.
  11.         // 获取beanFactory，实际类型是DefaultListableBeanFactory
  12.         ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
  14.         // Prepare the bean factory for use in this context.
  15.         // 设置beanFactory内属性，比如类加载器、后置处理器（BeanPostProcessor）
  16.         prepareBeanFactory(beanFactory);
  18.         try {
  19.             // Allows post-processing of the bean factory in context subclasses.
  20.             // hook:添加对beanfactory的后置处理配置，此处是个hook，留给子类具体实现（模版方法）
  21.             postProcessBeanFactory(beanFactory);
  23.             // Invoke factory processors registered as beans in the context.
  24.             // 从Spring容器中找出实现了BeanFactoryPostProcessor接口的类并执行。
  25.             // 具体执行委托给PostProcessorRegistrationDelegate#invokeBeanFactoryPostProcessors()
  26.             // 执行内容主要是记录注册表以及修改Spring容器内已经存在的BeanDefinition顺便实例化BeanFactoryPostProcessor及其子类BeanDefinitionPostProcessor类型的bean
  27.             invokeBeanFactoryPostProcessors(beanFactory);
  29.             // Register bean processors that intercept bean creation.
  30.             // 1. 获取beanFactory中类型为BeanPostProcessor的BeanName，然后实例化、初始化，保证优先于我们的业务bean
  31.             // 2. 装载到beanFactory中（顺序依照priorityOrderedPostProcessors、orderedPostProcessors、internalPostProcessors）
  32.             registerBeanPostProcessors(beanFactory);
  34.             // Initialize message source for this context.
  35.             // 初始化消息源，用于解析消息，支持解析消息参数化和国际化
  36.             initMessageSource();
  38.             // Initialize event multicaster for this context.
  39.             // 初始化ApplicationEventMulticaster（事件广播器），用于事件监听器的注册和事件的广播
  40.             // 如果用户没有指定，Spring会默认用SimpleApplicationEventMulticaster作为实现
  41.             initApplicationEventMulticaster();
  43.             // Initialize other special beans in specific context subclasses.
  44.             // hook:单例实例化之前初始化特殊bean，此处实现为空，此处是个hook，子类扩展实现（模版方法）
  45.             onRefresh();
  47.             // Check for listener beans and register them.
  48.             // 将监听器（ApplicationListener）添加到广播器中(ApplicationEventMulticaster)
  49.             registerListeners();
  51.             // Instantiate all remaining (non-lazy-init) singletons.
  52.             // 1. 实例化剩余的单例bean（除了懒加载的实例）
  53.             finishBeanFactoryInitialization(beanFactory);
  55.             // Last step: publish corresponding event.
  56.             finishRefresh();
  57.         }
  59.         catch (BeansException ex) {
  60.             if (logger.isWarnEnabled()) {
  61.                 logger.warn("Exception encountered during context initialization - " +
  62.                             "cancelling refresh attempt: " + ex);
  63.             }
  65.             // Destroy already created singletons to avoid dangling resources.
  66.             destroyBeans();
  68.             // Reset 'active' flag.
  69.             cancelRefresh(ex);
  71.             // Propagate exception to caller.
  72.             throw ex;
  73.         }
  75.         finally {
  76.             // Reset common introspection caches in Spring's core, since we
  77.             // might not ever need metadata for singleton beans anymore...
  78.             resetCommonCaches();
  79.         }
  80.     }
  81. }

#obtainFreshBeanFactory()

获取实际类型是DefaultListableBeanFactory的BeanFactory，并且生成注册BeanDefinition到DefaultListableBeanFactory.beanDefinitionMap容器内。
如果是从ClassPathXmlApplicationContext类进入的话，此处的obtainFreshBeanFactory()是调用其父类AbstractRefreshableApplicationContext的实现。
AbstractRefreshableApplicationContext#obtainFreshBeanFactory()调用的核心方法如下：

  1. @Override
  2. protected final void refreshBeanFactory() throws BeansException {
  3.     // 关闭先前的bean工厂（如果存在的话）
  4.     if (hasBeanFactory()) {
  5.         destroyBeans();
  6.         closeBeanFactory();
  7.     }
  8.     try {
  9.         // 初始化一个新工厂
  10.         DefaultListableBeanFactory beanFactory = createBeanFactory();
  11.         beanFactory.setSerializationId(getId());
  12.         // 设置beanFactory的属性，是否允许循环引用、beanDefinition的重写
  13.         customizeBeanFactory(beanFactory);
  14.         // 1. 解析xml文件转换成document对象，解析节点生成BeanDefinition（解析属性：scope、singleton、class、parent等）
  15.         // 2. 注册beanDefinition到DefaultListableBeanFactory.beanDefinitionMap中（spring容器中）
  16.         loadBeanDefinitions(beanFactory);
  17.         synchronized (this.beanFactoryMonitor) {
  18.             this.beanFactory = beanFactory;
  19.         }
  20.     }
  21.     catch (IOException ex) {
  22.         throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
  23.     }
  24. }

#invokeBeanFactoryPostProcessors(beanFactory)

修改BeanDefinition对象，方法内关键代码invokeBeanFactoryPostProcessor。如子类ConfigurationClassPostProcessor#postProcessBeanFactory()
�会使用CGLIB对BeanDefinition的BeanClass做代码增强，生成它的CGLIB子类，然后替换掉原来的BeanClass，如下图所示：
image.png

另外在对BeanDefinition对象做增强等修改之前，beanFactory会先根据beanFactory.getBeanNamesForType()方法，将BeanDefinitionRegistryPostProcessor和BeanFactoryPostProcessor都先实例化。
简而言之，会实例化BeanFactoryPostProcessor和BeanDefinitionRegistryPostProcessor类型的bean，然后使用这些增强bean对BeanDefinition做修改（增强）

#registerBeanPostProcessors(beanFactory)

功能如方法名，实例化并注册BeanPostProcessor。内部是由代理类PostProcessorRegistrationDelegate.registerBeanPostProcessor()实现的，按照优先级分别实例化和注册，优先级队列从高到低分为priorityOrderedPostProcessors、orderedPostProcessors、noneOrderPostProcessors。

#finishBeanFactoryInitialization(beanFactory)

实例化剩余的单例Bean（前面方法已经实例化了BeanFactoryPostProcessor、BeanPostProcessor），关键的内部方法是beanFactory.preInstantialSingletons()，该方法内部的核心方法是AbstractBeanFactory#doGetBean()。

  1. protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
  2.             @Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
  4.     // 返回工厂名称，比如将别名解析成正规名称
  5.     final String beanName = transformedBeanName(name);
  6.     Object bean;
  8.     // Eagerly check singleton cache for manually registered singletons.
  9.     // 从缓存中获取单例bean 对象
  10.     Object sharedInstance = getSingleton(beanName);
  11.     if (sharedInstance != null && args == null) {
  12.         if (logger.isTraceEnabled()) {
  13.             if (isSingletonCurrentlyInCreation(beanName)) {
  14.                 logger.trace("Returning eagerly cached instance of singleton bean '" + beanName +
  15.                              "' that is not fully initialized yet - a consequence of a circular reference");
  16.             }
  17.             else {
  18.                 logger.trace("Returning cached instance of singleton bean '" + beanName + "'");
  19.             }
  20.         }
  21.         bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
  22.     }
  23.     // 缓存中不存在单例bean 对象
  24.     else {
  25.         // Fail if we're already creating this bean instance:
  26.         // We're assumably within a circular reference.
  27.         if (isPrototypeCurrentlyInCreation(beanName)) {
  28.             throw new BeanCurrentlyInCreationException(beanName);
  29.         }
  31.         // Check if bean definition exists in this factory.
  32.         // 校验BeanDefinition是否存在Spring容器中
  33.         BeanFactory parentBeanFactory = getParentBeanFactory();
  34.         if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
  35.             // Not found -> check parent.
  36.             String nameToLookup = originalBeanName(name);
  37.             if (parentBeanFactory instanceof AbstractBeanFactory) {
  38.                 return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
  39.                     nameToLookup, requiredType, args, typeCheckOnly);
  40.             }
  41.             else if (args != null) {
  42.                 // Delegation to parent with explicit args.
  43.                 return (T) parentBeanFactory.getBean(nameToLookup, args);
  44.             }
  45.             else if (requiredType != null) {
  46.                 // No args -> delegate to standard getBean method.
  47.                 return parentBeanFactory.getBean(nameToLookup, requiredType);
  48.             }
  49.             else {
  50.                 return (T) parentBeanFactory.getBean(nameToLookup);
  51.             }
  52.         }
  54.         if (!typeCheckOnly) {
  55.             markBeanAsCreated(beanName);
  56.         }
  58.         try {
  59.             // 获取BeanDefinition对象
  60.             final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
  61.             checkMergedBeanDefinition(mbd, beanName, args);
  63.             // Guarantee initialization of beans that the current bean depends on.
  64.             // 获取依赖bean对象，保证依赖bean对象先被创建
  65.             String[] dependsOn = mbd.getDependsOn();
  66.             if (dependsOn != null) {
  67.                 for (String dep : dependsOn) {
  68.                     if (isDependent(beanName, dep)) {
  69.                         throw new BeanCreationException(mbd.getResourceDescription(), beanName,
  70.                                                         "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
  71.                     }
  72.                     registerDependentBean(dep, beanName);
  73.                     try {
  74.                         getBean(dep);
  75.                     }
  76.                     catch (NoSuchBeanDefinitionException ex) {
  77.                         throw new BeanCreationException(mbd.getResourceDescription(), beanName,
  78.                                                         "'" + beanName + "' depends on missing bean '" + dep + "'", ex);
  79.                     }
  80.                 }
  81.             }
  83.             // Create bean instance.
  84.             // 如果是单例（scope为singleton），则创建对象
  85.             if (mbd.isSingleton()) {
  86.                 sharedInstance = getSingleton(beanName, () -> {
  87.                     try {
  88.                         return createBean(beanName, mbd, args);
  89.                     }
  90.                     catch (BeansException ex) {
  91.                         // Explicitly remove instance from singleton cache: It might have been put there
  92.                         // eagerly by the creation process, to allow for circular reference resolution.
  93.                         // Also remove any beans that received a temporary reference to the bean.
  94.                         destroySingleton(beanName);
  95.                         throw ex;
  96.                     }
  97.                 });
  98.                 bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
  99.             }
  100.             // 创建scope为prototype（每次调用都会创建一个实例）对象
  101.             else if (mbd.isPrototype()) {
  102.                 // It's a prototype -> create a new instance.
  103.                 Object prototypeInstance = null;
  104.                 try {
  105.                     beforePrototypeCreation(beanName);
  106.                     prototypeInstance = createBean(beanName, mbd, args);
  107.                 }
  108.                 finally {
  109.                     afterPrototypeCreation(beanName);
  110.                 }
  111.                 bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
  112.             }
  114.             else {
  115.                 String scopeName = mbd.getScope();
  116.                 final Scope scope = this.scopes.get(scopeName);
  117.                 if (scope == null) {
  118.                     throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
  119.                 }
  120.                 try {
  121.                     Object scopedInstance = scope.get(beanName, () -> {
  122.                         beforePrototypeCreation(beanName);
  123.                         try {
  124.                             return createBean(beanName, mbd, args);
  125.                         }
  126.                         finally {
  127.                             afterPrototypeCreation(beanName);
  128.                         }
  129.                     });
  130.                     bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
  131.                 }
  132.                 catch (IllegalStateException ex) {
  133.                     throw new BeanCreationException(beanName,
  134.                                                     "Scope '" + scopeName + "' is not active for the current thread; consider " +
  135.                                                     "defining a scoped proxy for this bean if you intend to refer to it from a singleton",
  136.                                                     ex);
  137.                 }
  138.             }
  139.         }
  140.         catch (BeansException ex) {
  141.             cleanupAfterBeanCreationFailure(beanName);
  142.             throw ex;
  143.         }
  144.     }
  146.     // Check if required type matches the type of the actual bean instance.
  147.     if (requiredType != null && !requiredType.isInstance(bean)) {
  148.         try {
  149.             T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);
  150.             if (convertedBean == null) {
  151.                 throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
  152.             }
  153.             return convertedBean;
  154.         }
  155.         catch (TypeMismatchException ex) {
  156.             if (logger.isTraceEnabled()) {
  157.                 logger.trace("Failed to convert bean '" + name + "' to required type '" +
  158.                              ClassUtils.getQualifiedName(requiredType) + "'", ex);
  159.             }
  160.             throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
  161.         }
  162.     }
  163.     return (T) bean;
  164. }

方法内部调用了getSingleton()，具体方法如下：

  1. protected Object getSingleton(String beanName, boolean allowEarlyReference) {
  2.     // 一级缓存 singletonObjects
  3.     Object singletonObject = this.singletonObjects.get(beanName);
  4.     if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
  5.         synchronized (this.singletonObjects) {
  6.             // 二级缓存 earlySingletonObjects
  7.             singletonObject = this.earlySingletonObjects.get(beanName);
  8.             if (singletonObject == null && allowEarlyReference) {
  9.                 // 三级缓存 singletonFactories
  10.                 ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
  11.                 if (singletonFactory != null) {
  12.                     // 通过ObjectFactory#getObject()创建
  13.                     singletonObject = singletonFactory.getObject();
  14.                     // 创建成功放入二级缓存
  15.                     this.earlySingletonObjects.put(beanName, singletonObject);
  16.                     this.singletonFactories.remove(beanName);
  17.                 }
  18.             }
  19.         }
  20.     }
  21.     return singletonObject;
  22. }

缓存中不存在则创建bean，createBean(beanName, mbd, args)，内部逻辑是先给BeanPostProcessor一个机会扫描下需要创建的bean（resolveBeforeInstantiation(beanName, mbdToUse)
�），如果bean符合条件目标类型生成代理类直接返回
image.png
resolveBeforeInstantiation(beanName, mbdToUse)代码如下，通过Object result = ibp.postProcessBeforeInstantiation(beanClass, beanName);其InstantiationAwareBeanPostProcessor的子类创建了代理类。
�

  1. protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
  2.     Object bean = null;
  3.     if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
  4.         // Make sure bean class is actually resolved at this point.
  5.         if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
  6.             Class<?> targetType = determineTargetType(beanName, mbd);
  7.             if (targetType != null) {
  8.                 bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
  9.                 if (bean != null) {
  10.                     bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
  11.                 }
  12.             }
  13.         }
  14.         mbd.beforeInstantiationResolved = (bean != null);
  15.     }
  16.     return bean;
  17. }
  20. protected Object applyBeanPostProcessorsBeforeInstantiation(Class<?> beanClass, String beanName) {
  21.     for (BeanPostProcessor bp : getBeanPostProcessors()) {
  22.         if (bp instanceof InstantiationAwareBeanPostProcessor) {
  23.             InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
  24.             // 创建代理类
  25.             Object result = ibp.postProcessBeforeInstantiation(beanClass, beanName);
  26.             if (result != null) {
  27.                 return result;
  28.             }
  29.         }
  30.     }
  31.     return null;
  32. }

�
createBean(beanName, mbd, args)其内部另个核心方法是doCreateBean()具体方法如下，简而言之就是：实例化bean—放入三级缓存—填充属性-初始化

  1. protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @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.     final 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.         // 加入到三级缓存
  43.         addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
  44.     }
  46.     // Initialize the bean instance.
  47.     Object exposedObject = bean;
  48.     try {
  49.         // 填充属性
  50.         populateBean(beanName, mbd, instanceWrapper);
  51.         // 初始化
  52.         exposedObject = initializeBean(beanName, exposedObject, mbd);
  53.     }
  54.     catch (Throwable ex) {
  55.         if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
  56.             throw (BeanCreationException) ex;
  57.         }
  58.         else {
  59.             throw new BeanCreationException(
  60.                 mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
  61.         }
  62.     }
  64.     if (earlySingletonExposure) {
  65.         Object earlySingletonReference = getSingleton(beanName, false);
  66.         if (earlySingletonReference != null) {
  67.             if (exposedObject == bean) {
  68.                 exposedObject = earlySingletonReference;
  69.             }
  70.             else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
  71.                 String[] dependentBeans = getDependentBeans(beanName);
  72.                 Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
  73.                 for (String dependentBean : dependentBeans) {
  74.                     if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
  75.                         actualDependentBeans.add(dependentBean);
  76.                     }
  77.                 }
  78.                 if (!actualDependentBeans.isEmpty()) {
  79.                     throw new BeanCurrentlyInCreationException(beanName,
  80.                                                                "Bean with name '" + beanName + "' has been injected into other beans [" +
  81.                                                                StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +
  82.                                                                "] in its raw version as part of a circular reference, but has eventually been " +
  83.                                                                "wrapped. This means that said other beans do not use the final version of the " +
  84.                                                                "bean. This is often the result of over-eager type matching - consider using " +
  85.                                                                "'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");
  86.                 }
  87.             }
  88.         }
  89.     }
  91.     // Register bean as disposable.
  92.     try {
  93.         registerDisposableBeanIfNecessary(beanName, bean, mbd);
  94.     }
  95.     catch (BeanDefinitionValidationException ex) {
  96.         throw new BeanCreationException(
  97.             mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
  98.     }
  100.     return exposedObject;
  101. }

初始化方法initialBean()：【4】【5】

  1. protected Object initializeBean(final String beanName, final 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接口中的方法
  10.         invokeAwareMethods(beanName, bean);
  11.     }
  13.     Object wrappedBean = bean;
  14.     if (mbd == null || !mbd.isSynthetic()) {
  15.         //调用BeanPostProcessor的postProcessorsBeforeInitialization方法
  16.         wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
  17.     }
  19.     try {
  20.         // 调用初始化方法(自定义的初始化方法或者实现InitialzingBean接口)
  21.         invokeInitMethods(beanName, wrappedBean, mbd);
  22.     }
  23.     catch (Throwable ex) {
  24.         throw new BeanCreationException(
  25.             (mbd != null ? mbd.getResourceDescription() : null),
  26.             beanName, "Invocation of init method failed", ex);
  27.     }
  28.     if (mbd == null || !mbd.isSynthetic()) {
  29.         // 调用BeanPostProcessor的postProcessAfterInitialization方法
  30.         wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
  31.     }
  33.     return wrappedBean;
  34. }

applyBeanPostProcessorsAfterInitialization创建代理类：
image.png

关键类梳理

DefalutListableBeanFactory

image.png

AbstractApplicationContext

image.png

BeanPostProcessor【1】

image.png

事件监听器（ApplicationEvent）和广播器（ApplicationEventMulticaster）【2】

Spring的事件监听是一种观察者模式，只要是观察者模式一定包含主题（Subject）、订阅者（Observer）、发布人（Publisher）。
Spring的事件机制主要包括4个类：

  • ApplicationEvent：消息事件，每个实现类代表一个具体事件（主题）
  • ApplicationListener：事件监听器，处理接收到的事件（订阅者）
  • ApplicationEventMulticaster：事件广播器，用于事件监听器的注册和事件的广播
  • ApplicationEventPublisher：事件发布者，委托ApplicationEventMulticatser完成事件发布（发布人）

    事件广播器

    事件广播器，Spring默认实现是SimpleApplicationMulticaster作为广播器。

    事件发布者

    实现ApplicationEventPublisher的即为事件发布者，Spring中的ApplicationContext实现了ApplicationEventPublisher接口，所以应用上下文本身就是一个事件发布者。

参考

【1】别再问Spring Bean的生命周期了！：https://mp.weixin.qq.com/s?src=11&timestamp=1633596915&ver=3359&signature=PGv-XuqtF8XEo5qctBzabuXNenhtLjOCMR07nhqa-aHAaS9MbjAaogGZ5IqMZNzgZ3ylh41r1PDvtRi8Ox8YBkoUQcVCZP4xrQ50HL*qld0isnrjD51B9uKOk44rFM&new=1
【2】Spring Event 事件发布/监听机制 详解并使用：https://mp.weixin.qq.com/s?src=11&timestamp=1633613866&ver=3360&signature=EOBrJwuu2D9RV5uPXRSW8MelYqy0jOS97F8gSRqdtbsEh89DS29sHWXipzfdhzgGtvuIiiHXH8zVh-n8i-zHV6w7VA-m*qImo0p3gC3uAnT5TH7RqVr7kxJMe97Z6nV6&new=1
【3】《轻松读懂spring》之 IOC的主干流程（上）：https://mp.weixin.qq.com/s?src=11&timestamp=1633181508&ver=3350&signature=fdRcdb8clLPSBWTzFUSF8loeg6pMyNhUQYAmxIt-GdNoDqzumMb0jBM6Zy8g-B7VfVYGr0Yd2Spm7M-w9VnAb-98VZSaAdjP9UrDBXDRzqZ0iuOE0tuGeKqzSZdr2k&new=1
【4】Spring的Bean的生命周期_面试系列之Spring ：https://mp.weixin.qq.com/s?src=11&timestamp=1633684945&ver=3362&signature=D3sYy9hoBtylApU8BWW9SoycqhbevViO3QLKNDEy1vQxs9BXn76Gfu39kjJmVKDy4ttrWz-BbWzrt2GXHaPAITBiJlwGGSYV6oaRFzqpN-o6FdbCHmakA6OAZOtsxk&new=1
【5】spring 依赖注入时，什么时候会创建代理类：https://www.yuque.com/u1687194/hspkbf/lcqlhv#lJ34A