Spring Bean生命周期

Spring Bean生命周期整体可分为以下几个阶段:

  • Spring Bean元信息处理阶段
  • Spring Bean实例化阶段
  • Spring Bean初始化阶段
  • Spring Bean销毁阶段
  • Spring Bean垃圾收集阶段

Spring Bean生命周期处理是Spring应用上下文生命周期的一部分,可以参考此文了解Spring应用上下文生命周期。

Spring Bean元信息处理阶段

Spring Bean元信息处理阶段可以细分为以下几个阶段:

  • Spring Bean元信息解析阶段
  • Spring BeanDefinition注册阶段
  • Spring BeanDefinition合并阶段

Spring Bean元信息解析阶段

在Spring应用上下文生命周期里有一个创建BeanFactory阶段,在这个阶段会创建底层IoC容器BeanFactory,然后会进行一些别的操作,其中一个操作就是处理Spring Bean元信息,代码如下所示:

    protected final void refreshBeanFactory() throws BeansException {
        if (hasBeanFactory()) {
            destroyBeans();
            closeBeanFactory();
        }
        try {
            DefaultListableBeanFactory beanFactory = createBeanFactory();
            beanFactory.setSerializationId(getId());
            customizeBeanFactory(beanFactory);
            loadBeanDefinitions(beanFactory);
            synchronized (this.beanFactoryMonitor) {
                this.beanFactory = beanFactory;
            }
        }
        catch (IOException ex) {
            throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
        }
    }

可以看出这个方法会调用方法loadBeanDefinitions加载Spring Bean元信息: BeanDefinition。

loadBeanDefinitions在子类AbstractXmlApplicationContext有一个实现,代码如下所示:

    @Override
    protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
        //创建XmlBeanDefinitionReader解析XML配置文件读取Spring Bean元信息
        XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);

        //设置Spring Bean元信息读取配置
        beanDefinitionReader.setEnvironment(this.getEnvironment());
        beanDefinitionReader.setResourceLoader(this);
        beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));

        //初始化XmlBeanDefinitionReader
        initBeanDefinitionReader(beanDefinitionReader);
     //加载Spring Bean元信息 loadBeanDefinitions(beanDefinitionReader); }
    protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws BeansException, IOException {
     //获取资源配置 Resource[] configResources
= getConfigResources();
     //如果不是空,加载对应资源
if (configResources != null) { reader.loadBeanDefinitions(configResources); }
     //获取资源配置字符串,是路径 String[] configLocations
= getConfigLocations();
     //如果不是空,加载对应资源
if (configLocations != null) { reader.loadBeanDefinitions(configLocations); } }

这一块代码逻辑比较简单,就是使用XmlBeanDefinitionReader加载Spring Bean元信息,这里指处理了XML配置的元信息。

还有一种常用Spring Bean元信息配置是注解,针对这种Spring Bean元信息配置的解析,在AnnotationConfigApplicationContext进行处理,代码如下所示:

    public AnnotationConfigApplicationContext(String... basePackages) {
        this();
        scan(basePackages);
        refresh();
    }

AnnotationConfigApplicationContext一个构造器里会调用scan方法扫描指定包路径,会使用ClassPathBeanDefinitionScanner的scan能力扫描具有某些注解的类,把这些类加载为Spring Bean元信息。

Spring BeanDefinition注册阶段

上面着重介绍了Spring Bean元信息解析,Spring Bean元信息解析之后,就要注册并保存起来,方便后续使用。

Spring具有一个数据结构BeanDefinitionRegistry,解析后的BeanDefinition会注册到BeanDefinitionRegistry,BeanDefinitionRegistry是一个接口,一个典型的实现类是DefaultListableBeanFactory。

DefaultListableBeanFactory里的registerBeanDefinition方法实现如下所示(这里删除了一些打印日志分支):

    public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
            throws BeanDefinitionStoreException {
     //校验入参
        Assert.hasText(beanName, "Bean name must not be empty");
        Assert.notNull(beanDefinition, "BeanDefinition must not be null");
    
     //判断BeanDefinition是否是AbstractBeanDefinition类或子类的对象,如果是,进行校验
if (beanDefinition instanceof AbstractBeanDefinition) { try { ((AbstractBeanDefinition) beanDefinition).validate(); } catch (BeanDefinitionValidationException ex) { throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName, "Validation of bean definition failed", ex); } }
     //判断beanName对应BeanDefinition是否存在 BeanDefinition existingDefinition
= this.beanDefinitionMap.get(beanName);
     //如果已经存在,判断是否允许覆盖,这里覆盖是指一个beanName有两个不同BeanDefinition,默认允许
if (existingDefinition != null) {
       //如果不允许覆盖,抛出异常
if (!isAllowBeanDefinitionOverriding()) { throw new BeanDefinitionOverrideException(beanName, beanDefinition, existingDefinition); }
       //如果允许覆盖,覆盖配置 this.beanDefinitionMap.put(beanName, beanDefinition); } else {
       //判断是否已经有Bean被创建了
if (hasBeanCreationStarted()) { //如果是就不能修改之前集合,需要全量覆盖 synchronized (this.beanDefinitionMap) { this.beanDefinitionMap.put(beanName, beanDefinition); List<String> updatedDefinitions = new ArrayList<>(this.beanDefinitionNames.size() + 1); updatedDefinitions.addAll(this.beanDefinitionNames); updatedDefinitions.add(beanName); this.beanDefinitionNames = updatedDefinitions; removeManualSingletonName(beanName); } } else { //如果不是就修改之前集合 this.beanDefinitionMap.put(beanName, beanDefinition); this.beanDefinitionNames.add(beanName); removeManualSingletonName(beanName); } this.frozenBeanDefinitionNames = null; }
     //判断是否存在这个配置且已经创建单例Bean
if (existingDefinition != null || containsSingleton(beanName)) {
       //如果是就清除缓存 resetBeanDefinition(beanName); } }

Spring BeanDefinition合并阶段

Spring BeanDefinition在用来实例化前,还需要做的一件事就是Spring BeanDefinition合并。

在底层IoC容器通常会有两种BeanDefinition,一个是GenericBeanDefinition,一个是RootBeanDefinition,一个Bean在实例化前,对应BeanDefinition都要转化成RootBeanDefinition。

GenericBeanDefinition保存原始的Spring Bean元信息,可以指定父Bean的beanName,但是不会继承父Bean的属性,还不具备实例化的能力。

GenericBeanDefinition在合并之后会变成RootBeanDefinition,这时RootBeanDefinition不会保存父Bean的beanName,但是会从父Bean继承属性。

就算一个GenericBeanDefinition没有父Bean也需要转换成RootBeanDefinition。

BeanDefinition合并操作通常在实例化前进行,ConfigurableBeanFactory#getMergedBeanDefinition方法会合并对应BeanDefinition并且返回,getMergedBeanDefinition(AbstractBeanFactory)代码如下所示:

    public BeanDefinition getMergedBeanDefinition(String name) throws BeansException {
        String beanName = transformedBeanName(name);
        //判断当前BeanFactory不存在对应BeanDefinition,从父BeanFactory获取合并后的BeanDefinition
        if (!containsBeanDefinition(beanName) && getParentBeanFactory() instanceof ConfigurableBeanFactory) {
            return ((ConfigurableBeanFactory) getParentBeanFactory()).getMergedBeanDefinition(beanName);
        }
        //从当前BeanFactory获取合并后的BeanDefintion
        return getMergedLocalBeanDefinition(beanName);
    }
    protected RootBeanDefinition getMergedLocalBeanDefinition(String beanName) throws BeansException {
        //从缓存里获取RootBeanDefinition
        RootBeanDefinition mbd = this.mergedBeanDefinitions.get(beanName);
     //如果不是空并且不需要再次合并,返回缓存的RootBeanDefinition
if (mbd != null && !mbd.stale) { return mbd; }
     //返回合并的BeanDefinition,入参是beanName、GenericBeanDefinition
return getMergedBeanDefinition(beanName, getBeanDefinition(beanName)); }

最后会进到下面这个方法:

    protected RootBeanDefinition getMergedBeanDefinition(
            String beanName, BeanDefinition bd, @Nullable BeanDefinition containingBd)
            throws BeanDefinitionStoreException {

        synchronized (this.mergedBeanDefinitions) {
            RootBeanDefinition mbd = null;
            RootBeanDefinition previous = null;

            //加锁后再从缓存里查询一次,dcl
            if (containingBd == null) {
                mbd = this.mergedBeanDefinitions.get(beanName);
            }

       //如果获取不到或者需要再次合并,执行合并BeanDefinition逻辑
if (mbd == null || mbd.stale) { previous = mbd; if (bd.getParentName() == null) { //如果没有父beanName,直接生成RootBeanDefinition if (bd instanceof RootBeanDefinition) { mbd = ((RootBeanDefinition) bd).cloneBeanDefinition(); } else { mbd = new RootBeanDefinition(bd); } } else { //如果有父beanName,需要用父BeanDefinition合并生成RootBeanDefinition BeanDefinition pbd; try { String parentBeanName = transformedBeanName(bd.getParentName()); if (!beanName.equals(parentBeanName)) {
                 //用parentBeanName获取BeanDefinition pbd
= getMergedBeanDefinition(parentBeanName); } else { BeanFactory parent = getParentBeanFactory(); if (parent instanceof ConfigurableBeanFactory) { pbd = ((ConfigurableBeanFactory) parent).getMergedBeanDefinition(parentBeanName); } else { throw new NoSuchBeanDefinitionException(parentBeanName, "Parent name '" + parentBeanName + "' is equal to bean name '" + beanName + "': cannot be resolved without an AbstractBeanFactory parent"); } } } catch (NoSuchBeanDefinitionException ex) { throw new BeanDefinitionStoreException(bd.getResourceDescription(), beanName, "Could not resolve parent bean definition '" + bd.getParentName() + "'", ex); } //用parentBeanName获取RootBeanDefinition创建RootBeanDefinition mbd = new RootBeanDefinition(pbd);
           //用子BeanDefinition覆盖RootBeanDefinition mbd.overrideFrom(bd); }
//设置scope if (!StringUtils.hasLength(mbd.getScope())) { mbd.setScope(SCOPE_SINGLETON); } if (containingBd != null && !containingBd.isSingleton() && mbd.isSingleton()) { mbd.setScope(containingBd.getScope()); } //把RootBeanDefinition放到缓存 if (containingBd == null && isCacheBeanMetadata()) { this.mergedBeanDefinitions.put(beanName, mbd); } } if (previous != null) { copyRelevantMergedBeanDefinitionCaches(previous, mbd); } return mbd; } }

Spring Bean实例化阶段

Spring Bean实例化阶段可以细分为以下几个阶段:

  • Spring Bean Class加载阶段
  • Spring Bean实例化阶段
  • Spring Bean实例化前阶段
  • Spring Bean实例化后阶段
  • Spring Bean属性赋值前阶段
  • Spring Bean赋值阶段

Spring Bean Class加载阶段

Spring Bean Class加载方法是AbstractBeanFactory#resolveBeanClass,代码如下所示:

 resolveBeanClass方法会使用RootBeanDefinition里记录的beanClassName加载对应类,保存到RootBeanDefinition并且返回。

    protected Class<?> resolveBeanClass(final RootBeanDefinition mbd, String beanName, final Class<?>... typesToMatch)
            throws CannotLoadBeanClassException {

        try {
            if (mbd.hasBeanClass()) {
         //判断RootBeanDefinition里关联了class,直接返回
return mbd.getBeanClass(); } if (System.getSecurityManager() != null) {
         //加载对应class
return AccessController.doPrivileged((PrivilegedExceptionAction<Class<?>>) () -> doResolveBeanClass(mbd, typesToMatch), getAccessControlContext()); } else {
         //加载对应class
return doResolveBeanClass(mbd, typesToMatch); } } catch (PrivilegedActionException pae) { ClassNotFoundException ex = (ClassNotFoundException) pae.getException(); throw new CannotLoadBeanClassException(mbd.getResourceDescription(), beanName, mbd.getBeanClassName(), ex); } catch (ClassNotFoundException ex) { throw new CannotLoadBeanClassException(mbd.getResourceDescription(), beanName, mbd.getBeanClassName(), ex); } catch (LinkageError err) { throw new CannotLoadBeanClassException(mbd.getResourceDescription(), beanName, mbd.getBeanClassName(), err); } }
    private Class<?> doResolveBeanClass(RootBeanDefinition mbd, Class<?>... typesToMatch)
            throws ClassNotFoundException {
     //获取当前类加载器
        ClassLoader beanClassLoader = getBeanClassLoader();
     //定义动态类加载器,默认是上面的类加载器,可以修改扩展 ClassLoader dynamicLoader
= beanClassLoader; boolean freshResolve = false; if (!ObjectUtils.isEmpty(typesToMatch)) { //如果tempClassLoader不是空,动态类加载器设置为tempClassLoader ClassLoader tempClassLoader = getTempClassLoader(); if (tempClassLoader != null) { dynamicLoader = tempClassLoader; freshResolve = true; if (tempClassLoader instanceof DecoratingClassLoader) { DecoratingClassLoader dcl = (DecoratingClassLoader) tempClassLoader; for (Class<?> typeToMatch : typesToMatch) { dcl.excludeClass(typeToMatch.getName()); } } } } String className = mbd.getBeanClassName(); if (className != null) { Object evaluated = evaluateBeanDefinitionString(className, mbd); if (!className.equals(evaluated)) { //如果evaluateBeanDefinitionString if (evaluated instanceof Class) { return (Class<?>) evaluated; } else if (evaluated instanceof String) { className = (String) evaluated; freshResolve = true; } else { throw new IllegalStateException("Invalid class name expression result: " + evaluated); } } if (freshResolve) { //使用dynamicLoader加载class并且不和RootBeanDefinition关联,目前没有用到过,后面确认用处 if (dynamicLoader != null) { try { return dynamicLoader.loadClass(className); } catch (ClassNotFoundException ex) { if (logger.isTraceEnabled()) { logger.trace("Could not load class [" + className + "] from " + dynamicLoader + ": " + ex); } } } return ClassUtils.forName(className, dynamicLoader); } } //常规处理方式,RootBeanDefinition使用默认类加载器并且关联到RootBeanDefinition return mbd.resolveBeanClass(beanClassLoader); }

Spring Bean实例化阶段

AbstractAutowireCapableBeanFactory#createBeanInstance方法处理Spring Bean实例化,给指定beanName创建一个新的实例,先后使用工厂方法、构造器自动注入、简单实例化方式创建,具体代码如下所示: 

    protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
        //使用RootBeanDefinition加载class
        Class<?> beanClass = resolveBeanClass(mbd, beanName);

     //如果访问不到这个类,抛出异常
if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) { throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Bean class isn't public, and non-public access not allowed: " + beanClass.getName()); }
     //配置lamda方式实例化Bean Supplier
<?> instanceSupplier = mbd.getInstanceSupplier(); if (instanceSupplier != null) { return obtainFromSupplier(instanceSupplier, beanName); }
     //如果是工厂方式,用工厂方式实例化对象
if (mbd.getFactoryMethodName() != null) { return instantiateUsingFactoryMethod(beanName, mbd, args); } //如果某个RootBeanDefinition已经实例化过再次实例化,直接使用上次配置,不需要再决策 boolean resolved = false; boolean autowireNecessary = false; if (args == null) { synchronized (mbd.constructorArgumentLock) { if (mbd.resolvedConstructorOrFactoryMethod != null) { resolved = true; autowireNecessary = mbd.constructorArgumentsResolved; } } } if (resolved) { if (autowireNecessary) { return autowireConstructor(beanName, mbd, null, null); } else { return instantiateBean(beanName, mbd); } } //决策候选构造器 Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName); if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR || mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) { return autowireConstructor(beanName, mbd, ctors, args); } //获取合适构造器 ctors = mbd.getPreferredConstructors(); if (ctors != null) { return autowireConstructor(beanName, mbd, ctors, null); } //使用无参构造器实例化对象 return instantiateBean(beanName, mbd); }

Spring Bean实例化前阶段

AbstractAutowireCapableBeanFactory#resolveBeforeInstantiation方法提供一个扩展方式可以让Spring Bean在实例化前做一些扩展,比如一些RPC场景,可以在这里生成RPC接口代理类,不执行实例化逻辑,具体代码如下所示:

    protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
        Object bean = null;
        if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
            //如果有InstantiationAwareBeanPostProcessors,调用applyBeanPostProcessorsBeforeInstantiation方法获取对象
            if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
                Class<?> targetType = determineTargetType(beanName, mbd);
                if (targetType != null) {
                    bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
                    if (bean != null) {
                        bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
                    }
                }
            }
            mbd.beforeInstantiationResolved = (bean != null);
        }
        return bean;
    }
    protected Object applyBeanPostProcessorsBeforeInstantiation(Class<?> beanClass, String beanName) {
        for (BeanPostProcessor bp : getBeanPostProcessors()) {
            if (bp instanceof InstantiationAwareBeanPostProcessor) {
                InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
         //调用InstantiationAwareBeanPostProcessor#postProcessBeforeInstantiation方法创建对象 Object result
= ibp.postProcessBeforeInstantiation(beanClass, beanName); if (result != null) { return result; } } } return null; }

Spring Bean实例化后阶段

AbstractAutowireCapableBeanFactory#applyMergedBeanDefinitionPostProcessors方法是Spring提供的第一个Spring Bean实例化后扩展,实现MergedBeanDefinitionPostProcessor接口即可进行扩展,具体代码如下所示:

protected void applyMergedBeanDefinitionPostProcessors(RootBeanDefinition mbd, Class<?> beanType, String beanName) {
   for (BeanPostProcessor bp : getBeanPostProcessors()) {
      if (bp instanceof MergedBeanDefinitionPostProcessor) {
         MergedBeanDefinitionPostProcessor bdp = (MergedBeanDefinitionPostProcessor) bp;
         bdp.postProcessMergedBeanDefinition(mbd, beanType, beanName);
      }
   }
}

Spring提供的第二个实例化后扩展是InstantiationAwareBeanPostProcessor,在方法AbstractAutowireCapableBeanFactory#populateBean里有一段代码处理这个扩展,具体代码如下所示:

if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
   for (BeanPostProcessor bp : getBeanPostProcessors()) {
      if (bp instanceof InstantiationAwareBeanPostProcessor) {
         InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
         if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
            return;
         }
      }
   }
}

Spring Bean赋值前阶段

Spring Bean赋值前提供扩展是InstantiationAwareBeanPostProcessor#postProcessProperties和InstantiationAwareBeanPostProcessor#postProcessPropertyValues,在方法AbstractAutowireCapableBeanFactory#populateBean里有一段代码处理这两个扩展,具体代码如下所示:

if (hasInstAwareBpps) {
   if (pvs == null) {
      pvs = mbd.getPropertyValues();
   }
   for (BeanPostProcessor bp : getBeanPostProcessors()) {
      if (bp instanceof InstantiationAwareBeanPostProcessor) {
         InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
         PropertyValues pvsToUse = ibp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
         if (pvsToUse == null) {
            if (filteredPds == null) {
               filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
            }
            pvsToUse = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
            if (pvsToUse == null) {
               return;
            }
         }
         pvs = pvsToUse;
      }
   }
}

Spring Bean赋值阶段

Spring Bean赋值阶段代码如下所示:

protected void applyPropertyValues(String beanName, BeanDefinition mbd, BeanWrapper bw, PropertyValues pvs) {
   if (pvs.isEmpty()) {
      return;
   }

   if (System.getSecurityManager() != null && bw instanceof BeanWrapperImpl) {
      ((BeanWrapperImpl) bw).setSecurityContext(getAccessControlContext());
   }

   MutablePropertyValues mpvs = null;
   List<PropertyValue> original;

   if (pvs instanceof MutablePropertyValues) {
      mpvs = (MutablePropertyValues) pvs;
      if (mpvs.isConverted()) {
         // Shortcut: use the pre-converted values as-is.
         try {
            bw.setPropertyValues(mpvs);
            return;
         }
         catch (BeansException ex) {
            throw new BeanCreationException(
                  mbd.getResourceDescription(), beanName, "Error setting property values", ex);
         }
      }
      original = mpvs.getPropertyValueList();
   }
   else {
      original = Arrays.asList(pvs.getPropertyValues());
   }

   TypeConverter converter = getCustomTypeConverter();
   if (converter == null) {
      converter = bw;
   }
   BeanDefinitionValueResolver valueResolver = new BeanDefinitionValueResolver(this, beanName, mbd, converter);

   // Create a deep copy, resolving any references for values.
   List<PropertyValue> deepCopy = new ArrayList<>(original.size());
   boolean resolveNecessary = false;
   for (PropertyValue pv : original) {
      if (pv.isConverted()) {
         deepCopy.add(pv);
      }
      else {
         String propertyName = pv.getName();
         Object originalValue = pv.getValue();
         if (originalValue == AutowiredPropertyMarker.INSTANCE) {
            Method writeMethod = bw.getPropertyDescriptor(propertyName).getWriteMethod();
            if (writeMethod == null) {
               throw new IllegalArgumentException("Autowire marker for property without write method: " + pv);
            }
            originalValue = new DependencyDescriptor(new MethodParameter(writeMethod, 0), true);
         }
         Object resolvedValue = valueResolver.resolveValueIfNecessary(pv, originalValue);
         Object convertedValue = resolvedValue;
         boolean convertible = bw.isWritableProperty(propertyName) &&
               !PropertyAccessorUtils.isNestedOrIndexedProperty(propertyName);
         if (convertible) {
            convertedValue = convertForProperty(resolvedValue, propertyName, bw, converter);
         }
         // Possibly store converted value in merged bean definition,
         // in order to avoid re-conversion for every created bean instance.
         if (resolvedValue == originalValue) {
            if (convertible) {
               pv.setConvertedValue(convertedValue);
            }
            deepCopy.add(pv);
         }
         else if (convertible && originalValue instanceof TypedStringValue &&
               !((TypedStringValue) originalValue).isDynamic() &&
               !(convertedValue instanceof Collection || ObjectUtils.isArray(convertedValue))) {
            pv.setConvertedValue(convertedValue);
            deepCopy.add(pv);
         }
         else {
            resolveNecessary = true;
            deepCopy.add(new PropertyValue(pv, convertedValue));
         }
      }
   }
   if (mpvs != null && !resolveNecessary) {
      mpvs.setConverted();
   }

   // Set our (possibly massaged) deep copy.
   try {
      bw.setPropertyValues(new MutablePropertyValues(deepCopy));
   }
   catch (BeansException ex) {
      throw new BeanCreationException(
            mbd.getResourceDescription(), beanName, "Error setting property values", ex);
   }
}

Spring Bean初始化阶段

Spring Bean初始化阶段可以细分为以下几个阶段:

  • Spring Bean Aware接口回调阶段
  • Spring Bean初始化前阶段
  • Spring Bean初始化阶段
  • Spring Bean初始化后阶段

Spring Bean初始化代码如下所示:

protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
//Spring Bean Aware接口回调
if (System.getSecurityManager() != null) { AccessController.doPrivileged((PrivilegedAction<Object>) () -> { invokeAwareMethods(beanName, bean); return null; }, getAccessControlContext()); } else { invokeAwareMethods(beanName, bean); } Object wrappedBean = bean;
//Spring Bean初始化前阶段
if (mbd == null || !mbd.isSynthetic()) { wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName); }
//Spring Bean初始化阶段
try { invokeInitMethods(beanName, wrappedBean, mbd); } catch (Throwable ex) { throw new BeanCreationException( (mbd != null ? mbd.getResourceDescription() : null), beanName, "Invocation of init method failed", ex); }
//Spring Bean初始化后阶段
if (mbd == null || !mbd.isSynthetic()) { wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName); } return wrappedBean; }

Spring Bean Aware接口回调阶段

invokeAwareMethods具体代码如下所示:

    private void invokeAwareMethods(final String beanName, final Object bean) {
        if (bean instanceof Aware) {
            if (bean instanceof BeanNameAware) {
                ((BeanNameAware) bean).setBeanName(beanName);
            }
            if (bean instanceof BeanClassLoaderAware) {
                ClassLoader bcl = getBeanClassLoader();
                if (bcl != null) {
                    ((BeanClassLoaderAware) bean).setBeanClassLoader(bcl);
                }
            }
            if (bean instanceof BeanFactoryAware) {
                ((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);
            }
        }
    }

Spring Bean初始化前阶段

applyBeanPostProcessorsBeforeInitialization具体代码如下所示:

这个方法会调用BeanPostProcessor#postProcessBeforeInitialization方法。

    public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
            throws BeansException {

        Object result = existingBean;
        for (BeanPostProcessor processor : getBeanPostProcessors()) {
            Object current = processor.postProcessBeforeInitialization(result, beanName);
            if (current == null) {
                return result;
            }
            result = current;
        }
        return result;
    }

Spring Bean初始化阶段

invokeInitMethods具体代码如下所示:

    protected void invokeInitMethods(String beanName, final Object bean, @Nullable RootBeanDefinition mbd)
            throws Throwable {
     //处理InitializingBean#afterPropertiesSet方法初始化Bean
        boolean isInitializingBean = (bean instanceof InitializingBean);
        if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {
            if (logger.isTraceEnabled()) {
                logger.trace("Invoking afterPropertiesSet() on bean with name '" + beanName + "'");
            }
            if (System.getSecurityManager() != null) {
                try {
                    AccessController.doPrivileged((PrivilegedExceptionAction<Object>) () -> {
                        ((InitializingBean) bean).afterPropertiesSet();
                        return null;
                    }, getAccessControlContext());
                }
                catch (PrivilegedActionException pae) {
                    throw pae.getException();
                }
            }
            else {
                ((InitializingBean) bean).afterPropertiesSet();
            }
        }

     //处理自定义初始化方法
if (mbd != null && bean.getClass() != NullBean.class) { String initMethodName = mbd.getInitMethodName(); if (StringUtils.hasLength(initMethodName) && !(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) && !mbd.isExternallyManagedInitMethod(initMethodName)) { invokeCustomInitMethod(beanName, bean, mbd); } } }

Spring Bean初始化后阶段

applyBeanPostProcessorsAfterInitialization具体代码如下所示:

这个方法回调用BeanPostProcessor#postProcessAfterInitialization方法。

    public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
            throws BeansException {

        Object result = existingBean;
        for (BeanPostProcessor processor : getBeanPostProcessors()) {
            Object current = processor.postProcessAfterInitialization(result, beanName);
            if (current == null) {
                return result;
            }
            result = current;
        }
        return result;
    }

Spring Bean销毁阶段

Spring Bean销毁阶段可以细分为以下几个阶段:

  • Spring Bean销毁前阶段
  • Spring Bean销毁阶段

Spring Bean在初始化后会调用registerDisposableBeanIfNecessary方法注册到disposableBeans,方便后续销毁。

    protected void registerDisposableBeanIfNecessary(String beanName, Object bean, RootBeanDefinition mbd) {
        AccessControlContext acc = (System.getSecurityManager() != null ? getAccessControlContext() : null);
        if (!mbd.isPrototype() && requiresDestruction(bean, mbd)) {
            if (mbd.isSingleton()) {
                //注册DisposableBeanAdapter,后续销毁时用
                registerDisposableBean(beanName,
                        new DisposableBeanAdapter(bean, beanName, mbd, getBeanPostProcessors(), acc));
            }
            else {
                //如果不是单例而且不是原生,比如servlet里context、request等作用域,在一定阶段触发scope销毁操作会销毁Bean
                Scope scope = this.scopes.get(mbd.getScope());
                if (scope == null) {
                    throw new IllegalStateException("No Scope registered for scope name '" + mbd.getScope() + "'");
                }
                scope.registerDestructionCallback(beanName,
                        new DisposableBeanAdapter(bean, beanName, mbd, getBeanPostProcessors(), acc));
            }
        }
    }
    public void destroy() {
     //Spring销毁前阶段,调动DestructionAwareBeanPostProcessor#postProcessBeforeDestruction方法
if (!CollectionUtils.isEmpty(this.beanPostProcessors)) { for (DestructionAwareBeanPostProcessor processor : this.beanPostProcessors) { processor.postProcessBeforeDestruction(this.bean, this.beanName); } }
     //调用DisposableBean#destroy方法
if (this.invokeDisposableBean) { if (logger.isTraceEnabled()) { logger.trace("Invoking destroy() on bean with name '" + this.beanName + "'"); } try { if (System.getSecurityManager() != null) { AccessController.doPrivileged((PrivilegedExceptionAction<Object>) () -> { ((DisposableBean) this.bean).destroy(); return null; }, this.acc); } else { ((DisposableBean) this.bean).destroy(); } } catch (Throwable ex) { String msg = "Invocation of destroy method failed on bean with name '" + this.beanName + "'"; if (logger.isDebugEnabled()) { logger.warn(msg, ex); } else { logger.warn(msg + ": " + ex); } } }
     //调用自定义销毁函数
if (this.destroyMethod != null) { invokeCustomDestroyMethod(this.destroyMethod); } else if (this.destroyMethodName != null) { Method methodToInvoke = determineDestroyMethod(this.destroyMethodName); if (methodToInvoke != null) { invokeCustomDestroyMethod(ClassUtils.getInterfaceMethodIfPossible(methodToInvoke)); } } }

Spring Bean垃圾收集阶段

Spring Bean在Spring应用上下文关闭后触发GC会触发Spring Bean垃圾收集。

相关推荐

发表评论

路人甲

网友评论(0)