Bean生命周期源码

我们创建一个ApplicationContext对象时，这其中主要会做两件时间：包扫描得到BeanDefinition的set集合，创建非懒加载的单例Bean

public static void main(String[] args) {// 创建一个Spring容器AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);UserService userService = (UserService) context.getBean("userService");userService.test();
}

生成BeanDefinition

在线流程图

首先我们来看AnnotationConfigApplicationContext的构造方法

public AnnotationConfigApplicationContext(Class<?>... componentClasses) {// 构造DefaultListableBeanFactory、AnnotatedBeanDefinitionReader、ClassPathBeanDefinitionScanner// 这里创建ClassPathBeanDefinitionScanner时，还会添加一个includeFilters，包含@Component注解this();register(componentClasses);refresh();
}

接下来是refresh()方法

public void refresh() throws BeansException, IllegalStateException {...// 会拿到上一步创建的ClassPathBeanDefinitionScanner，调用scan方法进行包扫描invokeBeanFactoryPostProcessors(beanFactory);/// 会创建非懒加载单例beanfinishBeanFactoryInitialization(beanFactory);...
}

先看包扫描的逻辑，ClassPathBeanDefinitionScanner类主要做的事情就是包扫描完后再将得到的BeanDefinition注册进Spring容器中。

在scan(String... basePackages)方法中会调用doScan(String... basePackages)方法

protected Set<BeanDefinitionHolder> doScan(String... basePackages) {Assert.notEmpty(basePackages, "At least one base package must be specified");// 创建一个set集合存放扫描到的BeanDefinitionSet<BeanDefinitionHolder> beanDefinitions = new LinkedHashSet<>();// 可以传多个包路径，但我们一般都只传一个包路径for (String basePackage : basePackages) {// 调这个方法就会得到BeanDefinition集合，该方法扫描得到的BeanDefinition对象中主要只是有metadata、beanclass和source属性Set<BeanDefinition> candidates = findCandidateComponents(basePackage);// 遍历BeanDefinition集合，解析类的元数据信息为BeanDefinition的其他属性赋值for (BeanDefinition candidate : candidates) {// 解析类上@Scope注解信息ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate);candidate.setScope(scopeMetadata.getScopeName());// 得到beanName，首先解析@Component注解中有没有指定beanName，如果没有指定再去按照默认是生成规则生成String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);// 包扫描的ScannedGenericBeanDefinition和AnnotatedGenericBeanDefinition，这两个BeanDefinition都满足下面两个ifif (candidate instanceof AbstractBeanDefinition) {// 给BeanDefinition赋一些默认值postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);}if (candidate instanceof AnnotatedBeanDefinition) {// 解析@Lazy、@Primary、@DependsOn、@Role、@DescriptionAnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);}// 检查Spring容器beanDefinitionMap中是否已经存在该beanName，不存在才会走下面的if逻辑if (checkCandidate(beanName, candidate)) {// BeanDefinition中没有存beanName，而是把他们封装为了一个BeanDefinitionHolder对象BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);definitionHolder =AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);// 保存到set集合中beanDefinitions.add(definitionHolder);// 这里又从BeanDefinitionHolder取出beanName和BeanDefinition，把BeanDefinition注册进容器中的beanDefinitionMap中registerBeanDefinition(definitionHolder, this.registry);}}}return beanDefinitions;}

findCandidateComponents(String basePackage)方法逻辑

public Set<BeanDefinition> findCandidateComponents(String basePackage) {if (this.componentsIndex != null && indexSupportsIncludeFilters()) {// 我们可以定义一个resources/META-INF/Spring.components文件，然后就仅仅匹配个文件中指定的类与注解// 而不扫描指定包路径下的所有*.class文件return addCandidateComponentsFromIndex(this.componentsIndex, basePackage);}else {// 我们创建的Spring项目一般会走这个逻辑return scanCandidateComponents(basePackage);}
}

scanCandidateComponents(String basePackage)方法逻辑，该方法扫描得到的BeanDefinition对象中主要只是有beanclass和source属性

private Set<BeanDefinition> scanCandidateComponents(String basePackage) {// 返回值 存放BeanDefinition对象的Set集合Set<BeanDefinition> candidates = new LinkedHashSet<>();try {// 获取指定包路径下所有的*.class文件资源，将 com.hs 变为 classpath*:com/hs/**/*.classString packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX +resolveBasePackage(basePackage) + '/' + this.resourcePattern;// 封装为Resource对象Resource[] resources = getResourcePatternResolver().getResources(packageSearchPath);boolean traceEnabled = logger.isTraceEnabled();boolean debugEnabled = logger.isDebugEnabled();// 遍历每一个class文件资源对象for (Resource resource : resources) {if (traceEnabled) {logger.trace("Scanning " + resource);}// 判断当前资源是否可读if (resource.isReadable()) {try {// 得到元数据读取器MetadataReader metadataReader = getMetadataReaderFactory().getMetadataReader(resource);// excludeFilters、includeFilters判断，判断类上是否有@Component，再去判断是否符合@Conditionalif (isCandidateComponent(metadataReader)) {// 当上面的条件满足后，才会将当前类封装为BeanDefinition对象ScannedGenericBeanDefinition sbd = new ScannedGenericBeanDefinition(metadataReader);sbd.setSource(resource);// 这里还会对当前类进行进一步判断，这个条件满足之后才会将BeanDefinition对象添加进set集合中if (isCandidateComponent(sbd)) {if (debugEnabled) {logger.debug("Identified candidate component class: " + resource);}candidates.add(sbd);}... ...}catch (Throwable ex) {throw new BeanDefinitionStoreException("Failed to read candidate component class: " + resource, ex);}}else {...}}}catch (IOException ex) {throw new BeanDefinitionStoreException("I/O failure during classpath scanning", ex);}return candidates;
}

Spring容器启动时创建单例Bean

在线流程图网址

首先我们来看AnnotationConfigApplicationContext的构造方法

public AnnotationConfigApplicationContext(Class<?>... componentClasses) {// 构造DefaultListableBeanFactory、AnnotatedBeanDefinitionReader、ClassPathBeanDefinitionScanner// 这里创建ClassPathBeanDefinitionScanner时，还会添加一个includeFilters，包含@Component注解this();register(componentClasses);refresh();
}

接下来是refresh()方法

public void refresh() throws BeansException, IllegalStateException {...// 会拿到上一步创建的ClassPathBeanDefinitionScanner，调用scan方法进行包扫描invokeBeanFactoryPostProcessors(beanFactory);/// 会创建非懒加载单例beanfinishBeanFactoryInitialization(beanFactory);...
}

现在就跟finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory)方法

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {... ...// 实例化非懒加载的单例BeanbeanFactory.preInstantiateSingletons();
}

最终创建的方法是preInstantiateSingletons()

// 首先遍历beanNames集合，将包扫描时创建的BeanDefinition全部完成合并操作
// 判断非懒加载的单例bean
// 判断是不是FactoryBean，如果是则创建FactoryBean对象，如果不是则创建Bean对象
// 所有非懒加载单例Bean都存入单例池之后，再遍历一次beanNames集合，判断有没有实现SmartInitializingSingleton接口
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);// 所以非懒加载单例Bean初始化for (String beanName : beanNames) {// 根据beanName 获取合并后的BeanDefinitionRootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);// 判断不是抽象的BeanDefinition、单例、不是懒加载// 一般使用注解方式创建的Bean都不是抽象的，使用XML方式定义Bean时有一个abstract属性来指定if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {// 判断当前类是不是FactoryBeanif (isFactoryBean(beanName)) {// 获取FactoryBean对象，加&前缀后获取的是factoryBean对象，而不是getObject()方法返回的对象Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);if (bean instanceof FactoryBean) {FactoryBean<?> factory = (FactoryBean<?>) bean;// 判断当前类有没有实现SmartFactoryBean接口，如果实现了则调用isEagerInit()方法，将方法返回值赋值给isEagerInitboolean 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());}// 所以我们一般实现FactoryBean接口，在Spring容器启动时是不会去创建getObject()方法的Bean对象// 除非我们实现的是SmartFactoryBean接口重写isEagerInit()方法并返回trueif (isEagerInit) {// 创建FactoryBean.getObject()方法返回的对象getBean(beanName);}}}else {// 一般的Bean都不是FactoryBean，就会直接调用getBean()方法去创建Bean对象getBean(beanName);}}}// 所有的非懒加载单例Bean都创建完了后，又会进行一次遍历// Trigger post-initialization callback for all applicable beans...for (String beanName : beanNames) {Object singletonInstance = getSingleton(beanName);// 判断当前已经创建好了的单例Bean有没有实现SmartInitializingSingleton接口，如果实现了则调用重写的afterSingletonsInstantiated()方法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();}}
}

合并BeanDefinition

通过扫描得到所有BeanDefinition之后，就可以根据BeanDefinition创建Bean对象了，但是在Spring中支持父子BeanDefinition

父子BeanDefinition实际用的比较少，使用是这样的，比如：

<bean id="parent" class="com.zhouyu.service.Parent" scope="prototype"/>
<bean id="child" class="com.zhouyu.service.Child"/>

这么定义的情况下，child是单例Bean。

<bean id="parent" class="com.zhouyu.service.Parent" scope="prototype"/>
<bean id="child" class="com.zhouyu.service.Child" parent="parent"/>

但是这么定义的情况下，child就是原型Bean了。

因为child的父BeanDefinition是parent，所以会继承parent上所定义的scope属性。

如果child它自己定义了scope属性那么就用自己的，如果没有定义那么就用的parent的

之后child需要根据BeanDefinition来生成Bean对象之前，需要进行BeanDefinition的合并，得到完整的child的BeanDefinition，也就是RootBeanDefinition。

上面的两行代码最终会生成四个BeanDefinition，合并之后不会在原BeanDefinition上修改，而是会创建一个RootBeanDefinition，会保存在mergedBeanDefinitions这个Map<String, RootBeanDefinition>中

我们现在所知的就有两个Map了：beanDefinitions、mergedBeanDefinitions。

在线流程图网址

底层源码是在AbstractBeanFactory类的 getMergedLocalBeanDefinition(String beanName)方法中进行合并的

protected RootBeanDefinition getMergedBeanDefinition(String beanName, BeanDefinition bd, @Nullable BeanDefinition containingBd)throws BeanDefinitionStoreException {synchronized (this.mergedBeanDefinitions) {RootBeanDefinition mbd = null;RootBeanDefinition previous = null;if (containingBd == null) {mbd = this.mergedBeanDefinitions.get(beanName);}if (mbd == null || mbd.stale) {previous = mbd;// 如果当前BeanDefinition没有指定parentName属性，那么就会根据当前BeanDefinition直接创建一个RootBeanDefinitionif (bd.getParentName() == null) {// Use copy of given root bean definition.if (bd instanceof RootBeanDefinition) {mbd = ((RootBeanDefinition) bd).cloneBeanDefinition();}else {mbd = new RootBeanDefinition(bd);}}else {// 如果当前BeanDefinition指定parentName属性那么走下面的逻辑// pbd表示parentBeanDefinition，是父BeanDefinition，下面的逻辑是为pdb赋值，采用的方式的递归调用本方法BeanDefinition pbd;try {String parentBeanName = transformedBeanName(bd.getParentName());if (!beanName.equals(parentBeanName)) {pbd = getMergedBeanDefinition(parentBeanName);}else {BeanFactory parent = getParentBeanFactory();if (parent instanceof ConfigurableBeanFactory) {pbd = ((ConfigurableBeanFactory) parent).getMergedBeanDefinition(parentBeanName);}else {throw new NoSuchBeanDefinitionException(...);}}}catch (NoSuchBeanDefinitionException ex) {throw new BeanDefinitionStoreException(...);}// 子BeanDefinition的属性覆盖父BeanDefinition的属性，这就是合并mbd = new RootBeanDefinition(pbd);mbd.overrideFrom(bd);}// 如果scope没值就给默认值singletonif (!StringUtils.hasLength(mbd.getScope())) {mbd.setScope(SCOPE_SINGLETON);}if (containingBd != null && !containingBd.isSingleton() && mbd.isSingleton()) {mbd.setScope(containingBd.getScope());}// 将新创建的RootBeanDefinition存入Map集合中if (containingBd == null && isCacheBeanMetadata()) {this.mergedBeanDefinitions.put(beanName, mbd);}}if (previous != null) {copyRelevantMergedBeanDefinitionCaches(previous, mbd);}return mbd;}
}