一: Bean的生命周期
第一阶段: 扫描第二阶段: 实例化第三阶段: 属性注入第四阶段: 初始化
二: 举例验证
本文使用Spring源码的版本是5.0
在Spring启动的过程中, 容器中加载的都是非懒加载的单例Bean, 并且容器中都是一个个的BeanDefition,而原型Bean是在需要使用到Bean时新创建一个; 以在配置类中使用注解@ComponentScan定义扫描路径, 使用AnnotationConfigApplicationContext做为容器, 来了解Bean的生命周期;
生命周期从大类分 : 创建 + 销毁
从细化可分为: 扫描 + 实例化 + 属性注入 + 初始化 + 销毁
为何是非懒加载的单例Bean ?
在源码DefaultListableBeanFactory.preInstantiateSingletons()中有明确的判断条件, 见★标识处
public void preInstantiateSingletons() throws BeansException {
if (logger.isDebugEnabled()) {
logger.debug("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.
// beanNames : 容器中所有BeanDefition对应的bean主名称
List beanNames = new ArrayList<>(this.beanDefinitionNames);
// Trigger initialization of all non-lazy singleton beans...
// 加载所有非懒加载的单例Bean
for (String beanName : beanNames) {
// 1.bean可能存在父子级关系,子BeanDefinition需要继承父BeanDefinition的某些特性, 所以需要做父子BeanDefinition的属性合并
RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
// ★ 2.BeanDefinition不能是抽象的,必须是单例Bean,必须是非懒加载的, 满足此三个条件才允许加载
if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
if (isFactoryBean(beanName)) {
// 如果是工厂Bean, 那么beanName必须拼接上"&"前缀, 将工厂Bean与普通Bean做区分
// 加载工厂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) ((SmartFactoryBean>) factory)::isEagerInit,
getAccessControlContext());
} else {
isEagerInit = (factory instanceof SmartFactoryBean &&
((SmartFactoryBean>) factory).isEagerInit());
}
if (isEagerInit) {
// 加载类
getBean(beanName);
}
}
} else {
// 3. 根据主名称加载Bean
getBean(beanName);
}
}
}
// Trigger post-initialization callback for all applicable beans...
// 5. 将所有的非懒加载的单例Bean实例化初始化完成后,如果有单例Bean实现了SmartInitializingSingleton接口
// 实现afterSingletonsInstantiated()方法, 做回调使用
for (String beanName : beanNames) {
Object singletonInstance = getSingleton(beanName);
if (singletonInstance instanceof SmartInitializingSingleton) {
SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
if (System.getSecurityManager() != null) {
AccessController.doPrivileged((PrivilegedAction
一: Bean的生命周期
第一阶段: 扫描
扫描阶段, 创建初始状态的BeanDefinition
通过解析配置类AppConfig上注解@ComponentScan定义的扫描路径,将路径下的.class类封装成BeanDefition赋初始值,解析注解,并注册(解析的注解包括 @Lazy,@Primary,@DependsOn,@Description)合并BeanDefition
ClassPathBeanDefinitionScanner.doScan(String… basePackages)
/** * 根据指定路径扫描,生成BeanDefinition,并注册到容器中 * 此方法不会向容器中注册注释配置处理器processor * * @param basePackages @ComponentScan 注解定义的扫描路径,可以是多个 * @throws * @return: java.util.Set1. 解析配置类上@ComponentScan注解定义的扫描路径,获取资源路径,并生成BeanDefinition* @date 2022/1/12 8:40 */ protected Set doScan(String... basePackages) { // @ComponentScan 注解扫描路径可以配置多个 Assert.notEmpty(basePackages, "At least one base package must be specified"); Set beanDefinitions = new linkedHashSet<>(); for (String basePackage : basePackages) { Set candidates = findCandidateComponents(basePackage); // ★ 核心方法: 真正的扫描 for (BeanDefinition candidate : candidates) { Scopemetadata scopemetadata = this.scopemetadataResolver.resolveScopemetadata(candidate); candidate.setScope(scopemetadata.getScopeName()); String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry); if (candidate instanceof AbstractBeanDefinition) { // 给BeanDefinition的部分属性赋初始值,并判断bena是否有被自动注入到别的bean中 postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName); } if (candidate instanceof AnnotatedBeanDefinition) { // 判断bean是否被@Lazy,@Primary,@DependsOn,@Description 注解定义 AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate); } // 检查Spring容器中是否已经存在, key为beanName和value为 candidate 的键值对 // BeanDefinitionHolder 可以理解将将 BeanDefinition封装成一个 key - value形式的结构 // key 是beanName , value 是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); //注册BeanDefinition } } } return beanDefinitions; }
ClassPathScanningCandidateComponentProvider.scanCandidateComponents(String basePackage)
private Set2. 赋初始值,解析注解,并注册scanCandidateComponents(String basePackage) { Set candidates = new linkedHashSet<>(); try { //转化指定的资源文件路径, packageSearchPath = classpath*:com/maker/**/*.class String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX + resolvebasePackage(basePackage) + '/' + this.resourcePattern; // 通过通配符获取targetclasses指定目录所有的.class文件 Resource[] resources = getResourcePatternResolver().getResources(packageSearchPath); boolean traceEnabled = logger.isTraceEnabled(); boolean debugEnabled = logger.isDebugEnabled(); for (Resource resource : resources) { // 遍历扫描到的.class资源文件 if (traceEnabled) { logger.trace("Scanning " + resource); } if (resource.isReadable()) { // 是否可以读取此资源的内容, 像getInputStream 默认true try { // getmetadataReaderFactory() -> 获取一个元信息读取器工厂,如果初始工厂metadataReaderFactory为null,就创建一个CachingmetadataReaderFactory // getmetadataReader(resource) -> 通过资源resource从元数据读取器缓存中获取对应的metadataReader // 如果没有获取到就让CachingmetadataReaderFactory的父级SimplemetadataReaderFactory去创建一个SimplemetadataReader,最后放入元数据读取器缓存中, 并返回 // 如果获取到,直接返回 metadataReader metadataReader = getmetadataReaderFactory().getmetadataReader(resource); // 判断是否为一个bean // 成为一个bean的要求: // (1) 被@Component注解定义, 并且如果同时被@Conditional定义, 匹配的条件是通过的 // (2) 使用@import注解导入,可以不在扫描路径上,但是必须被@Component定义,并且注解上必须定义别名 // (3) 使用@Bean注解, 类上可以不使用@Component注解 // (4) 一般不能是接口、抽象类或者非静态内部类; 如果是抽象类, 但是抽象类中有方法被注解@Lookup定义, 可以做为bean if (isCandidateComponent(metadataReader)) { ScannedGenericBeanDefinition sbd = new ScannedGenericBeanDefinition(metadataReader); sbd.setSource(resource); if (isCandidateComponent(sbd)) { if (debugEnabled) { logger.debug("Identified candidate component class: " + resource); } candidates.add(sbd); // 所有的校验都通过, 确定是一个bean, 添加到BeanDefinition集合中 } 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 (Throwable ex) { throw new BeanDefinitionStoreException( "Failed to read candidate component class: " + resource, ex); } } else { if (traceEnabled) { logger.trace("Ignored because not readable: " + resource); } } } } catch (IOException ex) { throw new BeanDefinitionStoreException("I/O failure during classpath scanning", ex); } return candidates; }
赋初始值 : AbstractBeanDefinition.applyDefaults()
解析注解 : AnnotationConfigUtils.processCommonDefinitionAnnotations()
static void processCommonDefinitionAnnotations(AnnotatedBeanDefinition abd, AnnotatedTypemetadata metadata) {
//判断bean是否被@Lazy定义
AnnotationAttributes lazy = attributesFor(metadata, Lazy.class);
if (lazy != null) {
abd.setLazyInit(lazy.getBoolean("value"));
} else if (abd.getmetadata() != metadata) {
lazy = attributesFor(abd.getmetadata(), Lazy.class);
if (lazy != null) {
abd.setLazyInit(lazy.getBoolean("value"));
}
}
//判断bean是否被@Primary定义
if (metadata.isAnnotated(Primary.class.getName())) {
abd.setPrimary(true);
}
//判断bean是否被@DependsOn定义
AnnotationAttributes dependsOn = attributesFor(metadata, DependsOn.class);
if (dependsOn != null) {
abd.setDependsOn(dependsOn.getStringArray("value"));
}
if (abd instanceof AbstractBeanDefinition) {
AbstractBeanDefinition absBd = (AbstractBeanDefinition) abd;
//判断bean是否被@Role定义
AnnotationAttributes role = attributesFor(metadata, Role.class);
if (role != null) {
absBd.setRole(role.getNumber("value").intValue());
}
//判断bean是否被@Description定义
AnnotationAttributes description = attributesFor(metadata, Description.class);
if (description != null) {
absBd.setDescription(description.getString("value"));
}
}
}
3. 合并BeanDefition
由于Bean存在父子级的关系, 所以当父子Bean都被扫描成独立的BeanDefition时,子BeanDefition就需要从父BeanDefition中继承到某些属性值, 然后生成一个新的BeanDefition
AbstractBeanFactory.getMergedBeanDefinition()
/**
* 合并父子BeanDefinition, 生成新的BeanDefinition
*
* @param beanName 非懒加载的单例Bean的名称
* @param bd 与beanName对应的BeanDefinition
* @param containingBd
* @throws
* @return: org.springframework.beans.factory.support.RootBeanDefinition
* @date 2022/1/12 15:00
*/
protected RootBeanDefinition getMergedBeanDefinition(String beanName, BeanDefinition bd, @Nullable BeanDefinition containingBd) throws BeanDefinitionStoreException {
synchronized (this.mergedBeanDefinitions) {
RootBeanDefinition mbd = null;
// Check with full lock now in order to enforce the same merged instance.
// containingBd 一般情况都是为null
// 通过Bean的名称去合并BeanDefinition缓存中获取对应的BeanDefinition
// 此时获取的BeanDefinition,已经是合并完成的了
if (containingBd == null) {
mbd = this.mergedBeanDefinitions.get(beanName);
}
if (mbd == null) {
// 不存在父级,说明当前的BeanDefinitions已经是一个顶级的BeanDefinitions,不需要做合并处理
if (bd.getParentName() == null) {
// Use copy of given root bean definition.
if (bd instanceof RootBeanDefinition) {
mbd = ((RootBeanDefinition) bd).cloneBeanDefinition();
} else {
mbd = new RootBeanDefinition(bd); // 相当于属性复制,生成一个新的顶级BeanDefinition
}
} else {
// Child bean definition: needs to be merged with parent.
// 存在父级, 做父子BeanDefinition的合并处理
// 合并后原本的父子BeanDefinition不会清除,而是会生成一个新的BeanDefinition,并存于合并缓存中
BeanDefinition pbd;
try {
// 如果是工厂Bean,需要去除beanName的前缀 "&"
String parentBeanName = transformedBeanName(bd.getParentName());
if (!beanName.equals(parentBeanName)) {
// 如果beanName与父级名称不一致,即可做合并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 a ConfigurableBeanFactory parent");
}
}
} catch (NoSuchBeanDefinitionException ex) {
throw new BeanDefinitionStoreException(bd.getResourceDescription(), beanName, "Could not resolve parent bean definition '" + bd.getParentName() + "'", ex);
}
// Deep copy with overridden values.
mbd = new RootBeanDefinition(pbd);
mbd.overrideFrom(bd);
}
// Set default singleton scope, if not configured before.
// 如果没有定义@Scope注解, 则默认是单例Bean
if (!StringUtils.hasLength(mbd.getScope())) {
mbd.setScope(SCOPE_SINGLETON);
}
// A bean contained in a non-singleton bean cannot be a singleton itself.
// Let's correct this on the fly here, since this might be the result of
// parent-child merging for the outer bean, in which case the original inner bean
// definition will not have inherited the merged outer bean's singleton status.
if (containingBd != null && !containingBd.isSingleton() && mbd.isSingleton()) {
mbd.setScope(containingBd.getScope());
}
// Cache the merged bean definition for the time being
// (it might still get re-merged later on in order to pick up metadata changes)
// 将合并后的BeanDefinitions放入缓存中
if (containingBd == null && isCacheBeanmetadata()) {
this.mergedBeanDefinitions.put(beanName, mbd);
}
}
return mbd;
}
}
扫描步骤完成, 接下来就是真正的创建Bean阶段了, 这也是Bean生命周期的核心阶段, 此步骤走完,Bean也是真正完整的创建好了;
看了其他大佬的文章认为此阶段是Bean生命周期的开始阶段, 我不这么认为。 Spring容器中的Bean并不是对象,而是一个个独立的BeanDefition, Bean的所有信息都包含在内, 既然容器中存放的是BeanDefition,那么扫描阶段生成的初始形态BeanDefition,虽然内部信息还不完整, 但是既以诞生, 就是生命周期的开始
核心源码如下: AbstractAutowireCapableBeanFactory.createBean()
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException {
if (logger.isDebugEnabled()) {
logger.debug("Creating instance of bean '" + beanName + "'");
}
RootBeanDefinition mbdToUse = mbd;
// Make sure bean class is actually resolved at this point, and
// clone the bean definition in case of a dynamically resolved Class
// which cannot be stored in the shared merged bean definition.
// ★ 1.加载类(马上就要实例化Bean了,确保beanClass被加载了)
Class> resolvedClass = resolveBeanClass(mbd, beanName);
if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
mbdToUse = new RootBeanDefinition(mbd);
mbdToUse.setBeanClass(resolvedClass);
}
// Prepare method overrides.
try {
mbdToUse.prepareMethodOverrides();
} catch (BeanDefinitionValidationException ex) {
throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(), beanName, "Validation of method overrides failed", ex);
}
try {
// Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
// 通过BeanPostProcessors的处理逻辑,返回一个bean的代理对象,而不是bean的实例对象
// ★ 2.实例化前
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);
}
try {
// ★ 3.创建Bean(实例化 -> 填充属性 -> 初始化bean)
Object beanInstance = doCreateBean(beanName, mbdToUse, args);
if (logger.isDebugEnabled()) {
logger.debug("Finished creating instance of bean '" + beanName + "'");
}
return beanInstance;
} catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
// A previously detected exception with proper bean creation context already,
// or illegal singleton state to be communicated up to DefaultSingletonBeanRegistry.
throw ex;
} catch (Throwable ex) {
throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);
}
}
AbstractAutowireCapableBeanFactory.doCreateBean()
protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException {
// Instantiate the bean.
// 1.实例化bean
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {
// 有可能在本Bean创建之前,就有其他Bean把当前Bean给创建出来了(比如依赖注入过程中)
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
if (instanceWrapper == null) {
// 实例化Bean
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
Object bean = instanceWrapper.getWrappedInstance();
Class> beanType = instanceWrapper.getWrappedClass();
if (beanType != NullBean.class) {
mbd.resolvedTargetType = beanType;
}
// Allow post-processors to modify the merged bean definition.
// 2.实例化后
// Spring扩展点MergedBeanDefinitionPostProcessor.postProcessMergedBeanDefinition(),允许后处理器修改合并的bean定义
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.isDebugEnabled()) {
logger.debug("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 {
// 3.属性注入
populateBean(beanName, mbd, instanceWrapper);
// 4.初始化bean
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 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 {
// 5.Bean销毁的逻辑
registerDisposableBeanIfNecessary(beanName, bean, mbd);
} catch (BeanDefinitionValidationException ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
}
return exposedObject;
}
第二阶段: 实例化
1. 加载类第二阶段的大致步骤如下:
加载类实例化前实例化实例化后
BeanDefinition合并之后,就可以去创建Bean对象了,而创建Bean就必须实例化对象,而实例化就必须先加载当前BeanDefinition所对应的class,在AbstractAutowireCapableBeanFactory类的createBean()方法中,一开始就会调用 :
AbstractBeanFactory.resolveBeanClass()
protected Class> resolveBeanClass(RootBeanDefinition mbd, String beanName, Class>... typesToMatch) throws CannotLoadBeanClassException {
try {
if (mbd.hasBeanClass()) {
// 如果beanClass属性的类型是Class,那么就直接返回
return mbd.getBeanClass();
}
if (System.getSecurityManager() != null) {
return AccessController.doPrivileged((PrivilegedExceptionAction>)
() -> doResolveBeanClass(mbd, typesToMatch), getAccessControlContext());
} else {
// 如果不是,则会根据类名进行加载(doResolveBeanClass方法所做的事情)
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);
}
}
2. 实例化前
涉及Spring的扩展点InstantiationAwareBeanPostProcessor,继承了BeanPostProcessor, 提供了两个方法postProcessBeforeInstantiation(), postProcessAfterInstantiation()和postProcessPropertyValues(); 可在实例化前后对Bean做自定义的扩展逻辑
AbstractAutowireCapableBeanFactory.resolveBeforeInstantiation()
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.
// 校验bean是否是合成的
// 是否有实现BeanPostProcessors接口的实例类, 如果有先执行
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
Class> targetType = determineTargetType(beanName, mbd);
if (targetType != null) {
// 实例化前 - InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation()
// 当执行完postProcessBeforeInstantiation()的步骤后, 如果返回值不为空,表示利用Spring的扩展点完成了实例化的操作
// 但是必须还需要执行postProcessAfterInitialization()步骤,因为AOP的就是在此步骤执行的
// 创建完成的Bean其实是一个代理Bean对象
bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
if (bean != null) {
// 实例化后 - InstantiationAwareBeanPostProcessor.postProcessAfterInitialization()
bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
}
}
}
mbd.beforeInstantiationResolved = (bean != null);
}
return bean;
}
3. 实例化
在实例化之前, 判断如果是单例Bean,并且有可能在本Bean创建之前,就有其他Bean把当前Bean给创建出来了(比如依赖注入过程中)
① 是否使用Supplier创建对象
② 如果没有设置Supplier,则检查BeanDefinition中是否设置了factoryMethod (最常见就是使用注解@Bean)
③ 在进行推断构造方法之前,先判断下是否有缓存的构造方法
④ 进行推断构造方法 (Spring提供扩展点,可以利用SmartInstantiationAwareBeanPostProcessor来控制用beanClass中的哪些构造方法)
⑤ 不匹配以上情况,则直接使用无参构造方法
AbstractAutowireCapableBeanFactory.doCreateBean()
protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException {
// Instantiate the bean.
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {
// 有可能在本Bean创建之前,就有其他Bean把当前Bean给创建出来了(比如依赖注入过程中)
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
if (instanceWrapper == null) {
// 实例化Bean
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
Object bean = instanceWrapper.getWrappedInstance();
Class> beanType = instanceWrapper.getWrappedClass();
if (beanType != NullBean.class) {
mbd.resolvedTargetType = beanType;
}
........
return exposedObject;
}
AbstractAutowireCapableBeanFactory.createBeanInstance()
protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
// Make sure bean class is actually resolved at this point.
// 确保beanClass被加载了
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());
}
// 1. BeanDefinition中添加了Supplier,则调用Supplier来得到对象
Supplier> instanceSupplier = mbd.getInstanceSupplier();
if (instanceSupplier != null) {
return obtainFromSupplier(instanceSupplier, beanName);
}
// 2.@Bean对应的BeanDefinition
if (mbd.getFactoryMethodName() != null) {
return instantiateUsingFactoryMethod(beanName, mbd, args);
}
// Shortcut when re-creating the same bean...
// 3. 构造方法推断
// 一个原型BeanDefinition,会多次来创建Bean,那么就可以把该BeanDefinition所要使用的构造方法缓存起来,避免每次都进行构造方法推断
boolean resolved = false;
boolean autowireNecessary = false;
if (args == null) {
synchronized (mbd.constructorArgumentLock) {
if (mbd.resolvedConstructorOrFactoryMethod != null) {
resolved = true;
// autowireNecessary表示有没有必要进行注入,比如当前BeanDefinition用的是无参构造方法,那么autowireNecessary为false,否则为true,表示需要给构造方法参数注入值
autowireNecessary = mbd.constructorArgumentsResolved;
}
}
}
if (resolved) {
// 如果确定了当前BeanDefinition的构造方法,那么看是否需要进行对构造方法进行参数的依赖注入(构造方法注入)
if (autowireNecessary) {
// 方法内会拿到缓存好的构造方法的入参
return autowireConstructor(beanName, mbd, null, null);
} else {
// 构造方法已经找到了,但是没有参数,那就表示是无参,直接进行实例化 -> 无参的构造函数
return instantiateBean(beanName, mbd);
}
}
// Candidate constructors for autowiring?
// 如果没有找过构造方法,就需要开始找了(推断构造方法)
// 提供一个扩展点,可以利用SmartInstantiationAwareBeanPostProcessor来控制用beanClass中的哪些构造方法
// 比如AutowiredAnnotationBeanPostProcessor会把加了@Autowired注解的构造方法找出来,具体看代码实现会更复杂一点
Constructor>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName); // ★ 核心源码
// 如果推断出来了构造方法,则需要给构造方法赋值,也就是给构造方法参数赋值,也就是构造方法注入
// 如果没有推断出来构造方法,但是autowiremode为AUTOWIRE_CONSTRUCTOR,则也可能需要给构造方法赋值,因为不确定是用无参的还是有参的构造方法
// 如果通过BeanDefinition指定了构造方法参数值,那肯定就是要进行构造方法注入了
// 如果调用getBean的时候传入了构造方法参数值,那肯定就是要进行构造方法注入了
if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR || mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
return autowireConstructor(beanName, mbd, ctors, args);
}
// No special handling: simply use no-arg constructor.
// 5. 不匹配以上情况,则直接使用默认无参构造函数实例化给定bean
return instantiateBean(beanName, mbd); // ★ 核心源码
}
推断构造方法: Spring的扩展点SmartInstantiationAwareBeanPostProcessor.determineCandidateConstructors()
AbstractAutowireCapableBeanFactory.determineConstructorsFromBeanPostProcessors()
protected Constructor>[] determineConstructorsFromBeanPostProcessors(@Nullable Class> beanClass, String beanName) throws BeansException {
if (beanClass != null && hasInstantiationAwareBeanPostProcessors()) {
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {
SmartInstantiationAwareBeanPostProcessor ibp = (SmartInstantiationAwareBeanPostProcessor) bp;
Constructor>[] ctors = ibp.determineCandidateConstructors(beanClass, beanName);
if (ctors != null) {
return ctors;
}
}
}
}
return null;
}
使用默认无参构造函数实例化给定bean
AbstractAutowireCapableBeanFactory.instantiateBean()
protected BeanWrapper instantiateBean(String beanName, RootBeanDefinition mbd) {
try {
Object beanInstance;
if (System.getSecurityManager() != null) {
beanInstance = AccessController.doPrivileged((PrivilegedAction
4. 实例化后
Bean对象实例化出来之后,接下来就应该给对象的属性赋值了。在真正给属性赋值之前,Spring做了两件事
提供一个扩展点MergedBeanDefinitionPostProcessor.postProcessMergedBeanDefinition(), 可以对此时的BeanDefinition进行加工如果此时的Bean是一个单例的Bean, 那么在属性注入之前, 先将其添加到相应的单例缓存中,以便后面解决循环引用的问题
AbstractAutowireCapableBeanFactory.doCreateBean()
protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException {
......
// Allow post-processors to modify the merged bean definition.
//★ 1.Spring扩展点MergedBeanDefinitionPostProcessor.postProcessMergedBeanDefinition(),可以对此时的BeanDefinition进行加工
synchronized (mbd.postProcessingLock) {
if (!mbd.postProcessed) {
try {
// 扩展点 MergedBeanDefinitionPostProcessor
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.
// ★ 2.如果是单例Bean, 那么在属性注入前, 先缓存, 便于后面解决循环引用的问题
boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences && isSingletonCurrentlyInCreation(beanName));
if (earlySingletonExposure) {
if (logger.isDebugEnabled()) {
logger.debug("Eagerly caching bean '" + beanName + "' to allow for resolving potential circular references");
}
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}
......
return exposedObject;
}
第三阶段: 属性注入
第三阶段的大致步骤如下:
Spring扩展点: InstantiationAwareBeanPostProcessor.postProcessAfterInstantiation(), 后置处理Spring的自动注入执行Spring扩展点InstantiationAwareBeanPostProcessor.postProcessPropertyValues()方法
AbstractAutowireCapableBeanFactory.populateBean()
protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
if (bw == null) {
if (mbd.hasPropertyValues()) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");
} else {
// Skip property population phase for null instance.
return;
}
}
// 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.
// 1.实例化之后,属性设置之前
// 执行Spring扩展点InstantiationAwareBeanPostProcessor.postProcessAfterInstantiation()方法
// 可以实现对Bean的某些属性赋值,当返回false时, 说明属性值已经赋值完毕,直接返回
// isSynthetic: 判断是否为合并之后的BeanDefition, 不是合并的BeanDefition,无法执行postProcessAfterInstantiation()方法
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
return;
}
}
}
}
//2.Spring的自动注入
//方式一: 配置文件中, 标签中设置autowire属性, 属性值有byName/byType
//方式二: @Bean注解中设置autowire属性, Autowire.BY_NAME / Autowire.BY_TYPE
PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);
int resolvedAutowireMode = mbd.getResolvedAutowireMode();
if (resolvedAutowireMode == AUTOWIRE_BY_NAME || resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
// Add property values based on autowire by name if applicable.
if (resolvedAutowireMode == AUTOWIRE_BY_NAME) {
autowireByName(beanName, mbd, bw, newPvs);
}
// Add property values based on autowire by type if applicable.
if (resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
autowireByType(beanName, mbd, bw, newPvs);
}
pvs = newPvs;
}
//3. 执行Spring扩展点InstantiationAwareBeanPostProcessor.postProcessPropertyValues()方法
boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
boolean needsDepCheck = (mbd.getDependencyCheck() != AbstractBeanDefinition.DEPENDENCY_CHECK_NONE);
if (hasInstAwareBpps || needsDepCheck) {
if (pvs == null) {
pvs = mbd.getPropertyValues();
}
PropertyDescriptor[] filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
if (hasInstAwareBpps) {
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
if (pvs == null) {
return;
}
}
}
}
if (needsDepCheck) {
checkDependencies(beanName, mbd, filteredPds, pvs);
}
}
if (pvs != null) {
applyPropertyValues(beanName, mbd, bw, pvs);
}
}
第四阶段: 初始化
第四阶段的大致步骤如下:
初始化前
执行Aware回调 (BeanNameAware,BeanClassLoaderAware,BeanFactoryAware)
Spring扩展点BeanPostProcessor.postProcessBeforeInitialization()
Spring扩展点InstantiationAwareBeanPostProcessor.postProcessBeforeInitialization()初始化
如果当前Bean对象实现了InitializingBean接口,当前Bean对象是否实现了InitializingBean接口
没有实现,则执行BeanDefinition中指定的初始化方法初始化后
Spring扩展点BeanPostProcessor.postProcessAfterInitialization()
Spring扩展点InstantiationAwareBeanPostProcessor.postProcessAfterInitialization()
AbstractAutowireCapableBeanFactory.initializeBean()
protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
//Spring的安全框架, 源码中有很多, 不必理会
if (System.getSecurityManager() != null) {
AccessController.doPrivileged((PrivilegedAction
1. 初始化前 - 执行Aware回调
AbstractAutowireCapableBeanFactory.invokeAwareMethods()
private void invokeAwareMethods(String beanName, 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);
}
}
}
2.初始化前 - Spring扩展点BeanPostProcessor.postProcessBeforeInitialization()
在真正初始化的之前, 如果有自定义的初始化initMethord()方法, 就会在此步骤执行
AbstractAutowireCapableBeanFactory.applyBeanPostProcessorsBeforeInitialization
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;
}
3.初始化
AbstractAutowireCapableBeanFactory.invokeInitMethods()
protected void invokeInitMethods(String beanName, Object bean, @Nullable RootBeanDefinition mbd) throws Throwable {
// 判断Bean是否实现了InitializingBean
// 实现了,执行afterPropertiesSet()方法
boolean isInitializingBean = (bean instanceof InitializingBean);
if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {
if (logger.isDebugEnabled()) {
logger.debug("Invoking afterPropertiesSet() on bean with name '" + beanName + "'");
}
if (System.getSecurityManager() != null) {
try {
AccessController.doPrivileged((PrivilegedExceptionAction
AbstractAutowireCapableBeanFactory.invokeCustomInitMethod() : 执行初始化方法
protected void invokeCustomInitMethod(String beanName, Object bean, RootBeanDefinition mbd) throws Throwable {
// 通过initMethodName名称获取初始化方法
String initMethodName = mbd.getInitMethodName();
Assert.state(initMethodName != null, "No init method set");
Method initMethod = (mbd.isNonPublicAccessAllowed() ?
BeanUtils.findMethod(bean.getClass(), initMethodName) :
ClassUtils.getMethodIfAvailable(bean.getClass(), initMethodName));
if (initMethod == null) {
if (mbd.isEnforceInitMethod()) { // 校验初始方法是否是默认的
throw new BeanDefinitionValidationException("Could not find an init method named '" +
initMethodName + "' on bean with name '" + beanName + "'");
} else {
if (logger.isDebugEnabled()) {
logger.debug("No default init method named '" + initMethodName + "' found on bean with name '" + beanName + "'");
}
// Ignore non-existent default lifecycle methods.
return;
}
}
if (logger.isDebugEnabled()) {
logger.debug("Invoking init method '" + initMethodName + "' on bean with name '" + beanName + "'");
}
if (System.getSecurityManager() != null) {
AccessController.doPrivileged((PrivilegedAction
4.初始化后 - Spring扩展点BeanPostProcessor.postProcessAfterInitialization()
在这个步骤中,对Bean最终进行处理,Spring中的AOP就是基于初始化后实现的,初始化后返回的对象才是最终的Bean对象
AbstractAutowireCapableBeanFactory.applyBeanPostProcessorsAfterInitialization()
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;
}
二: 举例验证
## 配置类
@ComponentScan({"com.maker", "com.factory"})
@Configuration
@Description("扫描配置类")
public class AppConfig {
}
## UserService 在 "com.maker" 扫描路径下
@Component
public class UserService implements BeanNameAware, BeanClassLoaderAware, BeanFactoryAware, InitializingBean {
public void run() {
System.out.println("人在奔跑");
}
@Override
public void setBeanClassLoader(ClassLoader classLoader) {
System.out.println("[初始化前 - (Spring扩展点)BeanClassLoaderAware.setBeanClassLoader()]");
}
@Override
public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
System.out.println("[初始化前 - (Spring扩展点)BeanFactoryAware.setBeanFactory()]");
}
@Override
public void setBeanName(String name) {
System.out.println("[初始化前 - (Spring扩展点)BeanNameAware.setBeanName()]");
}
@Override
public void afterPropertiesSet() throws Exception {
System.out.println("[初始化 - (Spring扩展点)InitializingBean.afterPropertiesSet()]");
}
}
## 启动类
public class SpringTest {
public static void main(String[] args) {
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
UserService userService = context.getBean("userService", UserService.class);
userService.run();
}
}
BeanPostProcessor, 在"com.factory"扫描路径下
## InstantiationAwareBeanPostProcessor 实现类
@Component
public class MakerInstantiationAwareBeanPostProcessor implements InstantiationAwareBeanPostProcessor {
@Override
public Object postProcessBeforeInstantiation(Class> beanClass, String beanName) throws BeansException {
if ("userService".equals(beanName)) {
System.out.println("[实例化前 - (Spring扩展点)InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation()]");
}
return null;
}
@Override
public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
if ("userService".equals(beanName)) {
System.out.println("[实例化后 - (Spring扩展点)InstantiationAwareBeanPostProcessor.postProcessAfterInstantiation()]");
}
return true;
}
@Override
public PropertyValues postProcessPropertyValues(PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeansException {
if ("userService".equals(beanName)) {
System.out.println("[属性注入 - (Spring扩展点)InstantiationAwareBeanPostProcessor.postProcessPropertyValues()]");
}
return null;
}
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
if ("userService".equals(beanName)) {
System.out.println("[初始化 - (Spring扩展点)InstantiationAwareBeanPostProcessor.postProcessBeforeInitialization()]");
}
return null;
}
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
if ("userService".equals(beanName)) {
System.out.println("[初始化后 - (Spring扩展点)InstantiationAwareBeanPostProcessor.postProcessAfterInitialization()]");
}
return null;
}
## MergedBeanDefinitionPostProcessor 实现类
@Component
public class MakerMergedBeanDefinitionPostProcessor implements MergedBeanDefinitionPostProcessor {
@Override
public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class> beanType, String beanName) {
if ("userService".equals(beanName)) {
System.out.println("[实例化 - (Spring扩展点)MergedBeanDefinitionPostProcessor.postProcessMergedBeanDefinition");
}
}
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
return bean;
}
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
return bean;
}
}
## SmartInstantiationAwareBeanPostProcessor 实现类
public class MakerSmartInstantiationAwareBeanPostProcessor implements SmartInstantiationAwareBeanPostProcessor {
@Override
public Class> predictBeanType(Class> beanClass, String beanName) throws BeansException {
return null;
}
@Override
public Constructor>[] determineCandidateConstructors(Class> beanClass, String beanName) throws BeansException {
if ("userService".equals(beanName)) {
System.out.println("[实例化-推断构造方法 - SmartInstantiationAwareBeanPostProcessor.determineCandidateConstructors()]");
}
return null;
}
@Override
public Object getEarlyBeanReference(Object bean, String beanName) throws BeansException {
return null;
}
}
## BeanPostProcessor实现类 - 普通
@Component
public class MakerBeanPostProcessor implements BeanPostProcessor {
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
if ("userService".equals(beanName)) {
System.out.println("[初始化前 - (Spring扩展点)BeanPostProcessor.postProcessBeforeInitialization-> (普通)]");
return new UserService();
}
return bean;
}
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
if ("userService".equals(beanName)) {
System.out.println("[初始化后 - (Spring扩展点)BeanPostProcessor.postProcessAfterInitialization-> (普通)]");
}
return bean;
}
}
## BeanPostProcessor实现类 - PriorityOrdered
@Component
public class MakerBeanPostProcessor2 implements BeanPostProcessor, PriorityOrdered {
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
if ("userService".equals(beanName)) {
System.out.println("[初始化前 - (Spring扩展点)BeanPostProcessor.postProcessBeforeInitialization-> (PriorityOrdered)]");
}
return bean;
}
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
if ("userService".equals(beanName)) {
System.out.println("[初始化后 - (Spring扩展点)BeanPostProcessor.postProcessAfterInitialization-> (PriorityOrdered)]");
}
return bean;
}
@Override
public int getOrder() {
return 0;
}
}
## BeanPostProcessor实现类 - Ordered
public class MakerBeanPostProcessor3 implements BeanPostProcessor, Ordered {
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
if ("userService".equals(beanName)) {
System.out.println("[初始化前 - (Spring扩展点)BeanPostProcessor.postProcessBeforeInitialization-> (Ordered)]");
}
return bean;
}
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
if ("userService".equals(beanName)) {
System.out.println("[初始化后 - (Spring扩展点)BeanPostProcessor.postProcessAfterInitialization-> (Ordered)]");
}
return bean;
}
@Override
public int getOrder() {
return 0;
}
}
执行结果:
[扫描-生成BeanDefinition] - userService [赋初始值,解析注解,并注册] - userService [合并BeanDefinition] - userService [加载类] - userService [实例化前 - (Spring扩展点)InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation()] [实例化 - (Spring扩展点)MergedBeanDefinitionPostProcessor.postProcessMergedBeanDefinition [实例化后 - (Spring扩展点)InstantiationAwareBeanPostProcessor.postProcessAfterInstantiation()] [属性注入 - (Spring扩展点)InstantiationAwareBeanPostProcessor.postProcessPropertyValues()] [初始化前 - Aware回调 - (Spring扩展点)BeanNameAware.setBeanName()] [初始化前 - Aware回调 - (Spring扩展点)BeanClassLoaderAware.setBeanClassLoader()] [初始化前 - Aware回调 - (Spring扩展点)BeanFactoryAware.setBeanFactory()] [初始化前 - (Spring扩展点)BeanPostProcessor.postProcessBeforeInitialization-> (PriorityOrdered)] [初始化前 - (Spring扩展点)BeanPostProcessor.postProcessBeforeInitialization-> (普通)] [初始化前 - (Spring扩展点)InstantiationAwareBeanPostProcessor.postProcessBeforeInitialization()] [初始化 - (Spring扩展点)InitializingBean.afterPropertiesSet()] [初始化后 - (Spring扩展点)BeanPostProcessor.postProcessAfterInitialization-> (PriorityOrdered)] [初始化后 - (Spring扩展点)BeanPostProcessor.postProcessAfterInitialization-> (普通)] [初始化后 - (Spring扩展点)InstantiationAwareBeanPostProcessor.postProcessAfterInitialization()] 人在奔跑



