Spring Bean大体步骤分为四个阶段

实例化 -> 属性赋值 -> 初始化 -> 销毁

阐释Spring下bean的生命周期

① Spring IoC容器找到关于Bean的定义并实例化该Bean。
② Spring IoC容器对Bean进行依赖注入。
③ 如果Bean实现了BeanNameAware接口，则将该Bean的id传给setBeanName方法。
④ 如果Bean实现了BeanFactoryAware接口，则将BeanFactory对象传给setBeanFactory方法。
⑤ 如果Bean实现了BeanPostProcessor接口，则调用其postProcessBeforeInitialization方法。
⑥ 如果Bean实现了InitializingBean接口，则调用其afterPropertySet方法。
⑦ 如果有和Bean关联的BeanPostProcessors对象，则这些对象的postProcessAfterInitialization方法被调用。
⑧ 当销毁Bean实例时，如果Bean实现了DisposableBean接口，则调用其destroy方法。1) spring对bean进行实例化,默认bean是单例

各种接口方法分类

Bean的完整生命周期经理了各种方法调用，这些方法可以划分为以下几类：
1、Bean 自身的方法：这个包括了Bean本身调用的方法和通过配置文件中的init-method和destroy-method指定的方法
2、生命周期接口方法：这包括了BeanNameAware、BeanFactoryAware、InitializingBean和DiposableBean这些接口的方法
3、容器级生命周期接口方法：这个包括了InstantiationAwareBeanPostProcessor 和 BeanPostProcessor 这两个接口实现，一般称它们的实现类为“后处理器”。
4、工厂处理器接口方法：　这个包括了AspectJWeavingEnabler, ConfigurationClassPostProcessor, CustomAutowireConfigurer等等非常有用的工厂后处理器　　接口的方法。工厂后处理器也是容器级的。在应用上下文装配配置文件之后立即调用。、

API 解释

BeanNameAware

//设置beanName的名称

  1. public interface BeanNameAware extends Aware {
  2.     //设置beanName名称
  3.     void setBeanName(String name);
  4. }

BeanFactoryAware

//设置bean工厂

  1. public interface BeanFactoryAware extends Aware {
  2.     //设置bean工厂
  3.     void setBeanFactory(BeanFactory beanFactory) throws BeansException;
  4. }

ApplicationContextAware

//设置业务上下文

  1. public interface ApplicationContextAware extends Aware {
  2.     void setApplicationContext(ApplicationContext applicationContext) throws BeansException;
  3. }

BeanPostProcessor

//Spring后置处理器,在每个bean的初始化前后调用，首先调用的是before方法

  1. public interface BeanPostProcessor {
  2.     Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException;    
  3.     Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException;
  4. }

InitializingBean

  1. public interface InitializingBean {
  2.     void afterPropertiesSet() throws Exception;
  3. }

BeanPostProcessor

//Spring后置处理器,在每个bean的初始化前后调用，调用的是after方法

  1. public interface BeanPostProcessor {
  2.     Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException;    
  3.     Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException;
  4. }

调用初始化方法

使用/销毁

总结
1.调用无参构造进行实例化
2.Aware接口表示的就是属性注入的接口

源码解读

GenericBeanDefinition

存放对象元信息
image.png

AbstractBeanFactory

image.png

AnnotationConfigApplicationContext

  1. public AnnotationConfigApplicationContext(Class<?>... annotatedClasses) {
  2.     this();
  3.     //this.beanDefinitionMap.put(beanName, beanDefinition);
  4.     register(annotatedClasses);
  5.     //还未开始扫描和解析
  6.     refresh();
  7. }

AbstractApplicationContext

  1. //扫描解析
  2. invokeBeanFactoryPostProcessors(beanFactory);
  3. //实例化bean
  4. finishBeanFactoryInitialization(beanFactory);

//实例化所以单例对象,此时bean工厂的spring 单例池中已经包含了bean的定义信息
beanFactory.preInstantiateSingletons()

  1. protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
  2.     // Initialize conversion service for this context.
  3.     if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
  4.         beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
  5.         beanFactory.setConversionService(
  6.             beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
  7.     }
  9.     // Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early.
  10.     String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
  11.     for (String weaverAwareName : weaverAwareNames) {
  12.         getBean(weaverAwareName);
  13.     }
  15.     // Stop using the temporary ClassLoader for type matching.
  16.     beanFactory.setTempClassLoader(null);
  18.     // Allow for caching all bean definition metadata, not expecting further changes.
  19.     beanFactory.freezeConfiguration();
  21.     // Instantiate all remaining (non-lazy-init) singletons.
  22.     //实例化所以单例对象
  23.     beanFactory.preInstantiateSingletons();
  24. }

DefaultListableBeanFactory

  1. @Override
  2. public void preInstantiateSingletons() throws BeansException {
  3.     if (this.logger.isDebugEnabled()) {
  4.         this.logger.debug("Pre-instantiating singletons in " + this);
  5.     }
  6.     //获取所以bean的名称
  7.     List<String> beanNames;
  8.     synchronized (this.beanDefinitionMap) {
  9.         // Iterate over a copy to allow for init methods which in turn register new bean definitions.
  10.         // While this may not be part of the regular factory bootstrap, it does otherwise work fine.
  11.         beanNames = new ArrayList<String>(this.beanDefinitionNames);
  12.     }
  14.     // Trigger initialization of all non-lazy singleton beans...
  15.     //触发所有非延迟加载单例beans的初始化,主要步骤为调用getBean
  16.     for (String beanName : beanNames) {
  17.         //合并父BeanDefinition
  18.         RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
  19.         //如果不是抽象的 & 是单例的 & 不是懒加载的
  20.         if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
  21.             //BeanFactory 和 FactoryBean 的区别？面试点
  22.             if (isFactoryBean(beanName)) {
  23.                 final FactoryBean<?> factory = (FactoryBean<?>) getBean(FACTORY_BEAN_PREFIX + beanName);
  24.                 boolean isEagerInit;
  25.                 if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
  26.                     isEagerInit = AccessController.doPrivileged(new PrivilegedAction<Boolean>() {
  27.                         @Override
  28.                         public Boolean run() {
  29.                             return ((SmartFactoryBean<?>) factory).isEagerInit();
  30.                         }
  31.                     }, getAccessControlContext());
  32.                 }
  33.                 else {
  34.                     isEagerInit = (factory instanceof SmartFactoryBean &&
  35.                                    ((SmartFactoryBean<?>) factory).isEagerInit());
  36.                 }
  37.                 if (isEagerInit) {
  38.                     getBean(beanName);
  39.                 }
  40.             }
  41.             else {
  42.                 //进这里
  43.                 getBean(beanName);
  44.             }
  45.         }
  46.     }
  48.     // Trigger post-initialization callback for all applicable beans...
  49.     for (String beanName : beanNames) {
  50.         Object singletonInstance = getSingleton(beanName);
  51.         if (singletonInstance instanceof SmartInitializingSingleton) {
  52.             final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
  53.             if (System.getSecurityManager() != null) {
  54.                 AccessController.doPrivileged(new PrivilegedAction<Object>() {
  55.                     @Override
  56.                     public Object run() {
  57.                         smartSingleton.afterSingletonsInstantiated();
  58.                         return null;
  59.                     }
  60.                 }, getAccessControlContext());
  61.             }
  62.             else {
  63.                 smartSingleton.afterSingletonsInstantiated();
  64.             }
  65.         }
  66.     }
  67. }

AbstractBeanFactory

//spring bean 生命周期关键代码
//spring单例池
//private final Map singletonObjects = new ConcurrentHashMap(64);

  1. public Object getBean(String name) throws BeansException {
  2.     return doGetBean(name, null, null, false);
  3. }
  4. protected <T> T doGetBean(
  5.     final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly)
  6.     throws BeansException {
  7.     //获取对应的beanName
  8.     final String beanName = transformedBeanName(name);
  9.     Object bean;
  11.     // Eagerly check singleton cache for manually registered singletons.
  12.     /**
  13.       * 检查缓存中或者实例工厂中是否有对应的bean
  14.       * 为什么首先会使用这段代码呢？
  15.       * 因为在创建单例bean的时候会存在依赖注入的情况，而创建依赖的时候为了避免循环依赖
  16.       * Spring创建bean的原则是不等bean创建完成就将创建bean的ObjectFactory提早曝光
  17.       * 也就是将ObjectFactory加入缓存，一旦下一个bean创建的时候需要依赖上一个bean的时候直接使用objectFactory
  18.       * 
  19.       */
  20.     //为什么要先去调用一遍获取bean?spring启动的时候会调用一次,返回null,获取一个bean的时候
  21.     //也会调用这个方法,并且返回对象。
  22.     //直接尝试从缓存中获取，或者singletonFacotory中获取
  23.     Object sharedInstance = getSingleton(beanName);
  24.     if (sharedInstance != null && args == null) {
  25.         if (logger.isDebugEnabled()) {
  26.             if (isSingletonCurrentlyInCreation(beanName)) {
  27.                 logger.debug("Returning eagerly cached instance of singleton bean '" + beanName +
  28.                              "' that is not fully initialized yet - a consequence of a circular reference");
  29.             }
  30.             else {
  31.                 logger.debug("Returning cached instance of singleton bean '" + beanName + "'");
  32.             }
  33.         }
  34.         //返回对应的实例，有时候存在诸如beanFactory的情况并不是直接返回实例本身，而是返回指定方法返回的实例
  35.         bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
  36.     }
  38.     else {
  39.         //进这里
  40.         // Fail if we're already creating this bean instance:
  41.         // We're assumably within a circular reference.
  42.         //如果是原型,不应该在初始化的时候创建
  43.         //只有在单例情况才会尝试解决循环依赖。原型模式下如果存在A中有b,b中有A，
  44.         //那么当依赖注入的时候就会产生当A还未创建完的时候对于B的创建再次返回创建A
  45.         //造成循环依赖 也就是下面的情况
  46.         if (isPrototypeCurrentlyInCreation(beanName)) {
  47.             throw new BeanCurrentlyInCreationException(beanName);
  48.         }
  50.         // Check if bean definition exists in this factory.
  51.         BeanFactory parentBeanFactory = getParentBeanFactory();
  52.         //如果beanDefinitionMap中也就是已经加载的bean类中不包括beanName，则尝试从parentbeanfactory中获取
  53.         if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
  54.             // Not found -> check parent.
  55.             String nameToLookup = originalBeanName(name);
  56.             if (args != null) {
  57.                 //递归到parentFacotory中寻找
  58.                 // Delegation to parent with explicit args.
  59.                 return (T) parentBeanFactory.getBean(nameToLookup, args);
  60.             }
  61.             else {
  62.                 // No args -> delegate to standard getBean method.
  63.                 return parentBeanFactory.getBean(nameToLookup, requiredType);
  64.             }
  65.         }
  66.         //如果不是仅仅做类型检查而是创建bean这里要进行记录
  67.         if (!typeCheckOnly) {
  68.             //如果bean被创建，在这里会标记一遍
  69.             markBeanAsCreated(beanName);
  70.         }
  71.         //检查BeanDefinition
  72.         //将存储XML配置文件的GericBeanDefinition转换为RootBeanDefinition，如果指定BeanName是子类的话会同时合并父类的相关属性
  73.         final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
  74.         checkMergedBeanDefinition(mbd, beanName, args);
  76.         // Guarantee initialization of beans that the current bean depends on.
  77.         String[] dependsOn = mbd.getDependsOn();
  78.         //若存在依赖则要递归实例化依赖的bean
  79.         if (dependsOn != null) {
  80.             for (String dependsOnBean : dependsOn) {
  81.                 getBean(dependsOnBean);
  82.                 //缓存依赖调用
  83.                 registerDependentBean(dependsOnBean, beanName);
  84.             }
  85.         }
  87.         // Create bean instance.
  88.         //实例化依赖的bean后就可以实例化mdb本身了
  89.         //singleton模式的创建
  90.         if (mbd.isSingleton()) {
  91.             sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {
  92.                 public Object getObject() throws BeansException {
  93.                     try {
  94.                         //创建bean对象
  95.                         return createBean(beanName, mbd, args);
  96.                     }
  97.                     catch (BeansException ex) {
  98.                         // Explicitly remove instance from singleton cache: It might have been put there
  99.                         // eagerly by the creation process, to allow for circular reference resolution.
  100.                         // Also remove any beans that received a temporary reference to the bean.
  101.                         destroySingleton(beanName);
  102.                         throw ex;
  103.                     }
  104.                 }
  105.             });
  106.             bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
  107.         }
  108.         //prototype的创建（new）
  109.         else if (mbd.isPrototype()) {
  110.             // It's a prototype -> create a new instance.
  111.             Object prototypeInstance = null;
  112.             try {
  113.                 beforePrototypeCreation(beanName);
  114.                 prototypeInstance = createBean(beanName, mbd, args);
  115.             }
  116.             finally {
  117.                 afterPrototypeCreation(beanName);
  118.             }
  119.             bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
  120.         }
  121.         //指定scope上的实例化
  122.         else {
  123.             String scopeName = mbd.getScope();
  124.             final Scope scope = this.scopes.get(scopeName);
  125.             if (scope == null) {
  126.                 throw new IllegalStateException("No Scope registered for scope '" + scopeName + "'");
  127.             }
  128.             try {
  129.                 Object scopedInstance = scope.get(beanName, new ObjectFactory<Object>() {
  130.                     public Object getObject() throws BeansException {
  131.                         beforePrototypeCreation(beanName);
  132.                         try {
  133.                             return createBean(beanName, mbd, args);
  134.                         }
  135.                         finally {
  136.                             afterPrototypeCreation(beanName);
  137.                         }
  138.                     }
  139.                 });
  140.                 bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
  141.             }
  142.             catch (IllegalStateException ex) {
  143.                 throw new BeanCreationException(beanName,
  144.                                                 "Scope '" + scopeName + "' is not active for the current thread; " +
  145.                                                 "consider defining a scoped proxy for this bean if you intend to refer to it from a singleton",
  146.                                                 ex);
  147.             }
  148.         }
  149.     }
  150.     //检查需要的类型是否符合bean的实际类型
  151.     // Check if required type matches the type of the actual bean instance.
  152.     if (requiredType != null && bean != null && !requiredType.isAssignableFrom(bean.getClass())) {
  153.         try {
  154.             return getTypeConverter().convertIfNecessary(bean, requiredType);
  155.         }
  156.         catch (TypeMismatchException ex) {
  157.             if (logger.isDebugEnabled()) {
  158.                 logger.debug("Failed to convert bean '" + name + "' to required type [" +
  159.                              ClassUtils.getQualifiedName(requiredType) + "]", ex);
  160.             }
  161.             throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
  162.         }
  163.     }
  164.     return (T) bean;
  165. }

DefaultSingletonBeanRegistry

  1. public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
  2.     Assert.notNull(beanName, "'beanName' must not be null");
  3.     synchronized (this.singletonObjects) {
  4.         Object singletonObject = this.singletonObjects.get(beanName);
  5.         if (singletonObject == null) {
  6.             if (this.singletonsCurrentlyInDestruction) {
  7.                 throw new BeanCreationNotAllowedException(beanName,
  8.                                                           "Singleton bean creation not allowed while the singletons of this factory are in destruction " +
  9.                                                           "(Do not request a bean from a BeanFactory in a destroy method implementation!)");
  10.             }
  11.             if (logger.isDebugEnabled()) {
  12.                 logger.debug("Creating shared instance of singleton bean '" + beanName + "'");
  13.             }
  14.             //防止重新创建bean,告诉spring我要开始创建bean了
  15.             beforeSingletonCreation(beanName);
  16.             boolean newSingleton = false;
  17.             boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
  18.             if (recordSuppressedExceptions) {
  19.                 this.suppressedExceptions = new LinkedHashSet<Exception>();
  20.             }
  21.             try {
  22.                 //这里singletonFactory.getObject()才会去真正的创建对象
  23.                 //创建对象，但创建出来的是代理对象
  24.                 //先创建原对象,再创建代理对象
  25.                 singletonObject = singletonFactory.getObject();
  26.                 newSingleton = true;
  27.             }
  28.             catch (IllegalStateException ex) {
  29.                 // Has the singleton object implicitly appeared in the meantime ->
  30.                 // if yes, proceed with it since the exception indicates that state.
  31.                 singletonObject = this.singletonObjects.get(beanName);
  32.                 if (singletonObject == null) {
  33.                     throw ex;
  34.                 }
  35.             }
  36.             catch (BeanCreationException ex) {
  37.                 if (recordSuppressedExceptions) {
  38.                     for (Exception suppressedException : this.suppressedExceptions) {
  39.                         ex.addRelatedCause(suppressedException);
  40.                     }
  41.                 }
  42.                 throw ex;
  43.             }
  44.             finally {
  45.                 if (recordSuppressedExceptions) {
  46.                     this.suppressedExceptions = null;
  47.                 }
  48.                 afterSingletonCreation(beanName);
  49.             }
  50.             if (newSingleton) {
  51.                 addSingleton(beanName, singletonObject);
  52.             }
  53.         }
  54.         return (singletonObject != NULL_OBJECT ? singletonObject : null);
  55.     }
  56. }

解决循环依赖的办法,初始化执行
1.
2.implements InitializingBean
3.[@PostConstruct](https://docs.spring.io/spring-framework/docs/current/spring-framework-reference/core.html#beans-postconstruct-and-predestroy-annotations)

AbstractAutowireCapableBeanFactory

//设置属性
populateBean(beanName, mbd, instanceWrapper);
//执行后置处理器,aop就在这里完成处理
exposedObject = initializeBean(beanName, exposedObject, mbd);

  1. protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args) {
  2.     // Instantiate the bean.
  3.     BeanWrapper instanceWrapper = null;
  4.     if (mbd.isSingleton()) {
  5.         instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
  6.     }
  7.     if (instanceWrapper == null) {
  8.         instanceWrapper = createBeanInstance(beanName, mbd, args);
  9.     }
  10.     final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null);
  11.     Class<?> beanType = (instanceWrapper != null ? instanceWrapper.getWrappedClass() : null);
  13.     // Allow post-processors to modify the merged bean definition.
  14.     synchronized (mbd.postProcessingLock) {
  15.         if (!mbd.postProcessed) {
  16.             applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
  17.             mbd.postProcessed = true;
  18.         }
  19.     }
  21.     // Eagerly cache singletons to be able to resolve circular references
  22.     // even when triggered by lifecycle interfaces like BeanFactoryAware.
  23.     boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
  24.                                       isSingletonCurrentlyInCreation(beanName));
  25.     if (earlySingletonExposure) {
  26.         if (logger.isDebugEnabled()) {
  27.             logger.debug("Eagerly caching bean '" + beanName +
  28.                          "' to allow for resolving potential circular references");
  29.         }
  30.         addSingletonFactory(beanName, new ObjectFactory<Object>() {
  31.             @Override
  32.             public Object getObject() throws BeansException {
  33.                 return getEarlyBeanReference(beanName, mbd, bean);
  34.             }
  35.         });
  36.     }
  38.     // Initialize the bean instance.
  39.     Object exposedObject = bean;
  40.     try {
  41.         //设置属性
  42.         populateBean(beanName, mbd, instanceWrapper);
  43.         //执行后置处理器,aop就在这里完成处理
  44.         if (exposedObject != null) {
  45.             exposedObject = initializeBean(beanName, exposedObject, mbd);
  46.         }
  47.     }
  48.     catch (Throwable ex) {
  49.         if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
  50.             throw (BeanCreationException) ex;
  51.         }
  52.         else {
  53.             throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
  54.         }
  55.     }
  57.     if (earlySingletonExposure) {
  58.         Object earlySingletonReference = getSingleton(beanName, false);
  59.         if (earlySingletonReference != null) {
  60.             if (exposedObject == bean) {
  61.                 exposedObject = earlySingletonReference;
  62.             }
  63.             else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
  64.                 String[] dependentBeans = getDependentBeans(beanName);
  65.                 Set<String> actualDependentBeans = new LinkedHashSet<String>(dependentBeans.length);
  66.                 for (String dependentBean : dependentBeans) {
  67.                     if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
  68.                         actualDependentBeans.add(dependentBean);
  69.                     }
  70.                 }
  71.                 if (!actualDependentBeans.isEmpty()) {
  72.                     throw new BeanCurrentlyInCreationException(beanName,
  73.                                                                "Bean with name '" + beanName + "' has been injected into other beans [" +
  74.                                                                StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +
  75.                                                                "] in its raw version as part of a circular reference, but has eventually been " +
  76.                                                                "wrapped. This means that said other beans do not use the final version of the " +
  77.                                                                "bean. This is often the result of over-eager type matching - consider using " +
  78.                                                                "'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");
  79.                 }
  80.             }
  81.         }
  82.     }
  84.     // Register bean as disposable.
  85.     try {
  86.         registerDisposableBeanIfNecessary(beanName, bean, mbd);
  87.     }
  88.     catch (BeanDefinitionValidationException ex) {
  89.         throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
  90.     }
  92.     return exposedObject;
  93. }

AbstractAutowireCapableBeanFactory

//解决循环依赖
//wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName); PostConstruct被执行
//invokeInitMethods(beanName, wrappedBean, mbd);InitializingBean被执行

  1. protected Object initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd) {
  2.     if (System.getSecurityManager() != null) {
  3.         AccessController.doPrivileged(new PrivilegedAction<Object>() {
  4.             @Override
  5.             public Object run() {
  6.                 invokeAwareMethods(beanName, bean);
  7.                 return null;
  8.             }
  9.         }, getAccessControlContext());
  10.     }
  11.     else {
  12.         invokeAwareMethods(beanName, bean);
  13.     }
  15.     Object wrappedBean = bean;
  16.     if (mbd == null || !mbd.isSynthetic()) {
  17.         //第七次执行后置处理器
  18.         //执行后置处理器 ----- @PostConstruct
  19.         //执行到此时,spring 对象已经产生
  20.         wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
  21.     }
  23.     try {
  24.         //执行springbean 的生命周期回调 init 方法
  25.         invokeInitMethods(beanName, wrappedBean, mbd);
  26.     }
  27.     catch (Throwable ex) {
  28.         throw new BeanCreationException(
  29.             (mbd != null ? mbd.getResourceDescription() : null),
  30.             beanName, "Invocation of init method failed", ex);
  31.     }
  33.     if (mbd == null || !mbd.isSynthetic()) {
  34.         wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
  35.     }
  36.     return wrappedBean;
  37. }

无参构造
PostConstruct… <- 后置处理器PostProcessors befor 执行 PostConstruct //第七次执行
InitializingBean… <- 后置处理器PostProcessors after 执行 InitializingBean //第八次执行

先后顺序
1.扫描
2.解析
3.getBean -> 实例化
4.填充属性 -> 自动装配
5.left callback -> InitializingBean or [@PostConstruct](https://docs.spring.io/spring-framework/docs/current/spring-framework-reference/core.html#beans-postconstruct-and-predestroy-annotations)
6.代理 -> 目标对象转换成代理对象

sprigbean 生命周期是没法模拟的

总结步骤

1.利用SimpleInstantiationStragety进行初始化（可以是工厂方式的，也可以是单参数形式的，也可以是无参数的简单初始化），结果是我们得到了一个实例，但是属性都是空的

2.进行属性的注入，这里分别通过byName或者byType获取属性信息，并递归调用getBean方法获取属性bean

3.根据bean实现的aware接口调用相应的aware方法设置资源（beanNameAware，BeanClassLoaderAware，BeanFactoryAware）

4.如果实现了后处理器BeanPostProcessor，则遍历后处理器调用postProcessBeforeInitialization方法处理逻辑

5.调用用户自定义的init-method方法

6.如果实现了InitializingBean接口则调用afterPropertiesSet方法，这个方法只会在所有属性都被设置的时候才会触发

7. 如果实现了后处理器BeanPostProcessor，则遍历后处理器调用postProcessAfterInitialization方法处理逻辑

8.bean可以使用了