Spring Bean生命周期

火影 · 2022-9-1 22:14:20

Spring Bean生命周期

本文基于图灵课堂周瑜老师的讲解整理，包括spring bean加载的过程，主要是扫描BeanDefinition以及初始化非懒加载单例Bean两部分，源码取自SpringFramework 5.3.22

1. Bean扫描

本小节介绍的是Spring从给定的扫描位置扫描到待加载的Bean，生成BeanDefinitionMap的过程
SpringBoot启动过程中使用的ApplicationContext是AnnotationConfigApplicationContext，而它初始化的时候会顺带初始化两个BeanDefinitionReader：AnnotatedBeanDefinitionReader和ClassPathBeanDefinitionScanner，前者是可以直接通过给定的class注册Bean，后者则可以扫描给定目录下所有的目标Bean，下面着重介绍后者扫描Bean组件的过程。
ClassPathBeanDefinitionScanner扫描的入口是public int scan(String... basePackages)，而真正做事情的是protected Set doScan(String... basePackages)方法，代码如下:

/** * Perform a scan within the specified base packages, * returning the registered bean definitions. * This method does not register an annotation config processor * but rather leaves this up to the caller. * @param basePackages the packages to check for annotated classes * @return set of beans registered if any for tooling registration purposes (never {@code null}) */ protected Set<BeanDefinitionHolder> doScan(String... basePackages) { Assert.notEmpty(basePackages, "At least one base package must be specified"); Set<BeanDefinitionHolder> beanDefinitions = new LinkedHashSet<>(); for (String basePackage : basePackages) { // 找到basePackage下的所有候选组件，这里只是把classname赋值给了BeanDefinition Set<BeanDefinition> candidates = findCandidateComponents(basePackage); for (BeanDefinition candidate : candidates) { // 获取组件的scope，默认是单例的 ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate); candidate.setScope(scopeMetadata.getScopeName()); // 获取beanname String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry); if (candidate instanceof AbstractBeanDefinition) { postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName); } // 处理通用的注解 if (candidate instanceof AnnotatedBeanDefinition) { AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate); } // 最后再对BeanDefinition做检查，看下是否有重名的 if (checkCandidate(beanName, candidate)) { BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName); definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry); beanDefinitions.add(definitionHolder); registerBeanDefinition(definitionHolder, this.registry); } } } return beanDefinitions; }

复制代码

下面将以上部分代码展开去讲
1.1 扫描包下面的所有组件

即对应findCandidateComponents方法的操作，该方法如下：

/** * Scan the class path for candidate components. * @param basePackage the package to check for annotated classes * @return a corresponding Set of autodetected bean definitions */ public Set<BeanDefinition> findCandidateComponents(String basePackage) { if (this.componentsIndex != null && indexSupportsIncludeFilters()) { return addCandidateComponentsFromIndex(this.componentsIndex, basePackage); } else { return scanCandidateComponents(basePackage); } }

复制代码

首先来判断是否有对应的索引，即看componentsIndex是否有值，它加载的是META-INF/spring.components中的信息，内容格式如下：
1. com.sgw.demo=org.springframework.stereotype.Component
复制代码
之后，就加载这里的Bean组件，不去做扫描，对于项目过于庞大，扫描耗费时间的情况，可以考虑这种方案，个人感觉对于现在的微服务架构，这种应该没太多实际场景
如果没有索引，即进入真正的扫描流程scanCandidateComponents，代码如下：
1. private Set<BeanDefinition> scanCandidateComponents(String basePackage) { Set<BeanDefinition> candidates = new LinkedHashSet<>(); try { // 根据传入的包名，得到对应的classpath中的路径 String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX + resolveBasePackage(basePackage) + '/' + this.resourcePattern; // 获取该路径下的所有class文件 Resource[] resources = getResourcePatternResolver().getResources(packageSearchPath); boolean traceEnabled = logger.isTraceEnabled(); boolean debugEnabled = logger.isDebugEnabled(); for (Resource resource : resources) { if (traceEnabled) { logger.trace("Scanning " + resource); } try { // 使用ASM读取class文件 MetadataReader metadataReader = getMetadataReaderFactory().getMetadataReader(resource); // 判断是否是要扫描的组件 if (isCandidateComponent(metadataReader)) { ScannedGenericBeanDefinition sbd = new ScannedGenericBeanDefinition(metadataReader); // 设置resource文件 sbd.setSource(resource); // 判断扫描到的组件是否是正常的类（是不是独立的，检查是不是接口、抽象类（带LookUp注解的除外）） if (isCandidateComponent(sbd)) { if (debugEnabled) { logger.debug("Identified candidate component class: " + resource); } candidates.add(sbd); } else { if (debugEnabled) { logger.debug("Ignored because not a concrete top-level class: " + resource); } } } else { if (traceEnabled) { logger.trace("Ignored because not matching any filter: " + resource); } } } catch (FileNotFoundException ex) { if (traceEnabled) { logger.trace("Ignored non-readable " + resource + ": " + ex.getMessage()); } } catch (Throwable ex) { throw new BeanDefinitionStoreException( "Failed to read candidate component class: " + resource, ex); } } } catch (IOException ex) { throw new BeanDefinitionStoreException("I/O failure during classpath scanning", ex); } return candidates; }
复制代码
- 根据传入的包名，得到对应的classpath中的路径
 前面加上classpath*:前缀，后面加上**/*.class，同时把包名中的.替换成/
- 基于第一步拼接的搜索路径，得到下面所有的class文件，并以Resource数组的形式返回
- 遍历得到的Resource数组，使用ASM读取class文件
 有个问题是为什么这里已经取得了类名，不直接用jdk的classloader加载进去呢，原因是效率问题，把扫描到的类都加载上去第一没必要，第二浪费时间
- 判断是否是要扫描的组件
 这里是基于exclude以及include两类filter以及conditional注解来做的，看下具体代码实现
 1. /** * Determine whether the given class does not match any exclude filter * and does match at least one include filter. * @param metadataReader the ASM ClassReader for the class * @return whether the class qualifies as a candidate component */ protected boolean isCandidateComponent(MetadataReader metadataReader) throws IOException { for (TypeFilter tf : this.excludeFilters) { if (tf.match(metadataReader, getMetadataReaderFactory())) { return false; } } for (TypeFilter tf : this.includeFilters) { if (tf.match(metadataReader, getMetadataReaderFactory())) { return isConditionMatch(metadataReader); } } return false; }
 复制代码
 这些是从ComponentScan这个注解中解析出来的，是includeFilters和excludeFilters这俩属性，平时我们什么都不配置，默认扫描的是@Component @Repository @Service @Controller 这些注解，它们是会默认出现在includeFilters中的。
 如果命中了includefilter，接下来检查是否有conditional注解，如果有，则判断是否满足条件。
- 判断扫描到的组件是否是正常的类
 这里是有一套逻辑，因为一些内部类、抽象类、接口编译之后也会生成class文件，而这些文件到这一步是没有被过滤的，这里涉及到一个概念，说类是不是独立的，注释中是这么说的：
 Determine whether the underlying class is independent, i.e. whether it is a top-level class or a nested class (static inner class) that can be constructed independently of an enclosing class.
 即不依赖其他类也能正常被构建，因为后面扫描完成，有一个很重要的步骤，是实例化，而那些非静态的内部类、接口、抽象类是不能被实例化的，故这里排除在外。

1.2 依次处理扫描到的组件

获取组件的scope
通过解析scope注解获取，默认是单例属性

获取BeanDefinition的名称，即BeanName，首先从注解中取，如果没有就基于类名生成一个，用到了Introspector.decapitalize(shortClassName)方法
处理AbstractBeanDefinition ，设置BeanDefinition中的默认值
解析bean的一些注解，并记录到BeanDefinition中，包括Lazy、Primary、DependsOn、Role、Description
之后，再次检查对应的BeanDefinition是否已经被加载了，出现这种情况可能是同一个类被扫描到了两次，这里就是检查如果是有两个同名的，只能允许它们是同一个类被扫描了两次，如果是其他情况，即两个bean同名，那么直接报错
都检查通过之后，注册该BeanDefinition，等待之后的处理

2. 非懒加载单例Bean的创建

本小节介绍在扫描完BeanDefinition之后的，在初始化的时候做的事情，对于每一个扫描到的BeanDefinition，合并成RootBeanDefinition，之后调用getSingleton，如果是单例非懒加载Bean，就实例化、初始化Bean，加载到单例池中。
这里是在ApplicitionContext的refresh()方法中调用的，其中有beanFactory.preInstantiateSingletons();这么一步，即初始化所有的非懒加载的单例Bean，具体实现如下：

public void preInstantiateSingletons() throws BeansException { if (logger.isTraceEnabled()) { logger.trace("Pre-instantiating singletons in " + this); } // Iterate over a copy to allow for init methods which in turn register new bean definitions. // While this may not be part of the regular factory bootstrap, it does otherwise work fine. List<String> beanNames = new ArrayList<>(this.beanDefinitionNames); // Trigger initialization of all non-lazy singleton beans... for (String beanName : beanNames) { // 因为之前BeanDefinition存在继承的概念，这里是合并子BeanDefinition和父BeanDefinition RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName); if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) { // 非懒加载单例bean if (isFactoryBean(beanName)) { // 处理工厂Bean Object bean = getBean(FACTORY_BEAN_PREFIX + beanName); if (bean instanceof FactoryBean) { FactoryBean<?> factory = (FactoryBean<?>) bean; boolean isEagerInit; if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) { isEagerInit = AccessController.doPrivileged( (PrivilegedAction<Boolean>) ((SmartFactoryBean<?>) factory)::isEagerInit, getAccessControlContext()); } else { isEagerInit = (factory instanceof SmartFactoryBean && ((SmartFactoryBean<?>) factory).isEagerInit()); } if (isEagerInit) { getBean(beanName); } } } else { // 初始化Bean getBean(beanName); } } } // Trigger post-initialization callback for all applicable beans... for (String beanName : beanNames) { Object singletonInstance = getSingleton(beanName); if (singletonInstance instanceof SmartInitializingSingleton) { StartupStep smartInitialize = this.getApplicationStartup().start("spring.beans.smart-initialize") .tag("beanName", beanName); SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance; if (System.getSecurityManager() != null) { AccessController.doPrivileged((PrivilegedAction<Object>) () -> { smartSingleton.afterSingletonsInstantiated(); return null; }, getAccessControlContext()); } else { smartSingleton.afterSingletonsInstantiated(); } smartInitialize.end(); } } }

复制代码

之后的核心实现在getBean(beanName)的doGetBean();方法中，如下:

/** * Return an instance, which may be shared or independent, of the specified bean. * @param name the name of the bean to retrieve * @param requiredType the required type of the bean to retrieve * @param args arguments to use when creating a bean instance using explicit arguments * (only applied when creating a new instance as opposed to retrieving an existing one) * @param typeCheckOnly whether the instance is obtained for a type check, * not for actual use * @return an instance of the bean * @throws BeansException if the bean could not be created */ @SuppressWarnings("unchecked") protected <T> T doGetBean( String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly) throws BeansException { // 处理BeanName，如果是前面加了&符号，去除之，如果是别名，得到其正式的名称 String beanName = transformedBeanName(name); Object beanInstance; // 这里先试着获取下单例池中有没有对应的单例对象，如果有的话，就直接返回 // Eagerly check singleton cache for manually registered singletons. Object sharedInstance = getSingleton(beanName); if (sharedInstance != null && args == null) { if (logger.isTraceEnabled()) { if (isSingletonCurrentlyInCreation(beanName)) { logger.trace("Returning eagerly cached instance of singleton bean '" + beanName + "' that is not fully initialized yet - a consequence of a circular reference"); } else { logger.trace("Returning cached instance of singleton bean '" + beanName + "'"); } } beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, null); } else { // Fail if we're already creating this bean instance: // We're assumably within a circular reference. if (isPrototypeCurrentlyInCreation(beanName)) { throw new BeanCurrentlyInCreationException(beanName); } // 如果本bean工厂不存在传进来的BeanName，并且存在父工厂，则到父工厂中寻找 // Check if bean definition exists in this factory. BeanFactory parentBeanFactory = getParentBeanFactory(); if (parentBeanFactory != null && !containsBeanDefinition(beanName)) { // Not found -> check parent. String nameToLookup = originalBeanName(name); if (parentBeanFactory instanceof AbstractBeanFactory) { return ((AbstractBeanFactory) parentBeanFactory).doGetBean( nameToLookup, requiredType, args, typeCheckOnly); } else if (args != null) { // Delegation to parent with explicit args. return (T) parentBeanFactory.getBean(nameToLookup, args); } else if (requiredType != null) { // No args -> delegate to standard getBean method. return parentBeanFactory.getBean(nameToLookup, requiredType); } else { return (T) parentBeanFactory.getBean(nameToLookup); } } if (!typeCheckOnly) { markBeanAsCreated(beanName); } StartupStep beanCreation = this.applicationStartup.start("spring.beans.instantiate") .tag("beanName", name); try { if (requiredType != null) { beanCreation.tag("beanType", requiredType::toString); } // 取合并之后的rootBeanDefinition RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName); checkMergedBeanDefinition(mbd, beanName, args); // 如果有被dependsOn注解修饰，优先初始化dependsOn中的bean // Guarantee initialization of beans that the current bean depends on. String[] dependsOn = mbd.getDependsOn(); if (dependsOn != null) { for (String dep : dependsOn) { if (isDependent(beanName, dep)) { throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'"); } registerDependentBean(dep, beanName); try { getBean(dep); } catch (NoSuchBeanDefinitionException ex) { throw new BeanCreationException(mbd.getResourceDescription(), beanName, "'" + beanName + "' depends on missing bean '" + dep + "'", ex); } } } // 之后基于不同的scope来创建bean // Create bean instance. if (mbd.isSingleton()) { sharedInstance = getSingleton(beanName, () -> { try { return createBean(beanName, mbd, args); } catch (BeansException ex) { // Explicitly remove instance from singleton cache: It might have been put there // eagerly by the creation process, to allow for circular reference resolution. // Also remove any beans that received a temporary reference to the bean. destroySingleton(beanName); throw ex; } }); beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, mbd); } else if (mbd.isPrototype()) { // It's a prototype -> create a new instance. Object prototypeInstance = null; try { beforePrototypeCreation(beanName); prototypeInstance = createBean(beanName, mbd, args); } finally { afterPrototypeCreation(beanName); } beanInstance = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd); } else { String scopeName = mbd.getScope(); if (!StringUtils.hasLength(scopeName)) { throw new IllegalStateException("No scope name defined for bean '" + beanName + "'"); } Scope scope = this.scopes.get(scopeName); if (scope == null) { throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'"); } try { Object scopedInstance = scope.get(beanName, () -> { beforePrototypeCreation(beanName); try { return createBean(beanName, mbd, args); } finally { afterPrototypeCreation(beanName); } }); beanInstance = getObjectForBeanInstance(scopedInstance, name, beanName, mbd); } catch (IllegalStateException ex) { throw new ScopeNotActiveException(beanName, scopeName, ex); } } } catch (BeansException ex) { beanCreation.tag("exception", ex.getClass().toString()); beanCreation.tag("message", String.valueOf(ex.getMessage())); cleanupAfterBeanCreationFailure(beanName); throw ex; } finally { beanCreation.end(); } } return adaptBeanInstance(name, beanInstance, requiredType); }

复制代码

处理BeanName
如果是前面加了&符号，去除之，如果是别名，得到其正式的名称

先试着获取下单例池中有没有对应的单例对象，如果有的话，就直接返回
如果本bean工厂不存在传进来的BeanName，并且存在父工厂，则到父工厂中寻找
如果有被dependsOn注解修饰，优先初始化dependsOn中的bean
之后基于不同的scope来创建bean
这里的scope主要有以下几种
- singleton
- prototype
- requestScope
 即同一个request中的bean要保持一致
- sessionScope
 即同一个session中的bean要保持一致
之后的两个是通过设置request和session中的属性来实现的
以上的情况，需要真正创建bean的时候，就会落到AbstractAutowireCapableBeanFactory中实现的createBean中，
首先加载BeanClass，resolveBeanClass(mbd, beanName)，把bean加载到对应的classLoader中。
实例化
这里是bean构造的第一个扩展点，如下：
1. try { // Give BeanPostProcessors a chance to return a proxy instead of the target bean instance. Object bean = resolveBeforeInstantiation(beanName, mbdToUse); if (bean != null) { return bean; } } catch (Throwable ex) { throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName, "BeanPostProcessor before instantiation of bean failed", ex); }
复制代码
这里是实例化之前调用的接口，注释中看到的就是给BeanPostProcessor接口的实现类一个构造代理bean的机会，实现偷天幻日的机会。具体如下：
1. /** * Apply before-instantiation post-processors, resolving whether there is a * before-instantiation shortcut for the specified bean. * @param beanName the name of the bean * @param mbd the bean definition for the bean * @return the shortcut-determined bean instance, or {@code null} if none */ @Nullable protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) { Object bean = null; if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) { // Make sure bean class is actually resolved at this point. 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; }
复制代码
首先会看，是否已经实例化了，如果没有实例化，就依次调用已经实现了的postProcessBeforeInstantiation接口，Spring中的AOP即利用的这里的扩展点，将命中切面表达式的Bean替换成对应的代理类，AOP实现的接口是AbstractAutoProxyCreator。
之后确认是走正常的Bean初始化流程，即进入doCreateBean方法，具体实现如下，这里实现了bean生命周期中的多个重要的扩展点，包括依赖注入、初始化前后、实例化后、初始化等：
1. /** * Actually create the specified bean. Pre-creation processing has already happened * at this point, e.g. checking {@code postProcessBeforeInstantiation} callbacks. * Differentiates between default bean instantiation, use of a * factory method, and autowiring a constructor. * @param beanName the name of the bean * @param mbd the merged bean definition for the bean * @param args explicit arguments to use for constructor or factory method invocation * @return a new instance of the bean * @throws BeanCreationException if the bean could not be created * @see #instantiateBean * @see #instantiateUsingFactoryMethod * @see #autowireConstructor */ protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException { // Instantiate the bean. BeanWrapper instanceWrapper = null; if (mbd.isSingleton()) { instanceWrapper = this.factoryBeanInstanceCache.remove(beanName); } if (instanceWrapper == null) { instanceWrapper = createBeanInstance(beanName, mbd, args); } Object bean = instanceWrapper.getWrappedInstance(); Class<?> beanType = instanceWrapper.getWrappedClass(); if (beanType != NullBean.class) { mbd.resolvedTargetType = beanType; } // 调用MergedBeanDefinitionPostProcessor中的postProcessMergedBeanDefinition // Allow post-processors to modify the merged bean definition. synchronized (mbd.postProcessingLock) { if (!mbd.postProcessed) { try { applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName); } catch (Throwable ex) { throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Post-processing of merged bean definition failed", ex); } mbd.postProcessed = true; } } // Eagerly cache singletons to be able to resolve circular references // even when triggered by lifecycle interfaces like BeanFactoryAware. boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences && isSingletonCurrentlyInCreation(beanName)); if (earlySingletonExposure) { if (logger.isTraceEnabled()) { logger.trace("Eagerly caching bean '" + beanName + "' to allow for resolving potential circular references"); } addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean)); } // Initialize the bean instance. Object exposedObject = bean; try { populateBean(beanName, mbd, instanceWrapper); exposedObject = initializeBean(beanName, exposedObject, mbd); } catch (Throwable ex) { if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) { throw (BeanCreationException) ex; } else { throw new BeanCreationException( mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex); } } if (earlySingletonExposure) { Object earlySingletonReference = getSingleton(beanName, false); if (earlySingletonReference != null) { if (exposedObject == bean) { exposedObject = earlySingletonReference; } else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) { String[] dependentBeans = getDependentBeans(beanName); Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length); for (String dependentBean : dependentBeans) { if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) { actualDependentBeans.add(dependentBean); } } if (!actualDependentBeans.isEmpty()) { throw new BeanCurrentlyInCreationException(beanName, "Bean with name '" + beanName + "' has been injected into other beans [" + StringUtils.collectionToCommaDelimitedString(actualDependentBeans) + "] in its raw version as part of a circular reference, but has eventually been " + "wrapped. This means that said other beans do not use the final version of the " + "bean. This is often the result of over-eager type matching - consider using " + "'getBeanNamesForType' with the 'allowEagerInit' flag turned off, for example."); } } } } // Register bean as disposable. try { registerDisposableBeanIfNecessary(beanName, bean, mbd); } catch (BeanDefinitionValidationException ex) { throw new BeanCreationException( mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex); } return exposedObject; }
复制代码
包含的扩展点
- 调用MergedBeanDefinitionPostProcessor中的postProcessMergedBeanDefinition
 这里校验一些关于BeanDefinition的数据，同时也可以做些改动
 CommonAnnotationBeanPostProcessor、AutowiredAnnotationBeanPostProcessor都实现了这个扩展点，这里是做一些注解的前置校验的工作
- 调用InstantiationAwareBeanPostProcessor中的postProcessAfterInstantiation实例化之后的扩展点
 1. // Give any InstantiationAwareBeanPostProcessors the opportunity to modify the // state of the bean before properties are set. This can be used, for example, // to support styles of field injection.
 复制代码
- 做Spring自带的依赖注入
- 调用InstantiationAwareBeanPostProcessor的postProcessProperties以及postProcessPropertyValues(废弃)接口做依赖注入
- 调用setBeanName、setBeanClassLoader、setBeanFactory
- 调用BeanPostProcessor中的postProcessBeforeInitialization接口，初始化前的扩展点
- 调用InitializingBean中的afterPropertiesSet接口
- 调用初始化方法
- 调用BeanPostProcessor中的postProcessAfterInitialization接口，初始化后的扩展点
- 初始化结束

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！

		自动登录	找回密码
密码			立即注册

Spring Bean生命周期

0 个回复

快速回复

楼主热帖

标签云