文章目录
前言
Bean的生命周期就是指:在Spring中,一个Bean是如何生成的,如何销毁的
在了解如何生成Bean之前,需要了解Spring的底层扫描逻辑、以及生成BeanDefintion
这一篇主要讲源码底层扫描逻辑,下一篇开始讲生成和销毁流程
零、BeanDefinition是什么?
要知道创建一个Bean,他是基于BeanDefinition来生成Bean的,
而BeanDefinition 是定义 Bean 的配置元信息接口,他包含一个Bean所需的属性
大概包含以下几点
Bean 的类名
设置父 bean 名称、是否为 primary、
Bean 行为配置信息,作用域、自动绑定模式、生命周期回调、延迟加载、初始方法、销毁方法等
Bean 之间的依赖设置,dependencies
构造参数、属性设置
一、Spring扫描、BeanDefinition生成(invokeBeanFactoryPostProcessors核心方法)
1、 生成BeanDefinition
Spring启动的时候会进行扫描,会先调用下面的这段代码,主要是扫描某个包路径,并得到BeanDefinition的Set集合。
// 在启动时,调用refresh()->this.invokeBeanFactoryPostProcessors(beanFactory)-->下会调用下面这个扫描的方法
org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider#scanCandidateComponents(String basePackage)
关于Spring启动流程,后续会有后续章节详细细讲,这里主要以Spring扫描的底层实现
2、Spring扫描底层总流程
1、首先,通过ResourcePatternResolver获得指定包路径下的所有.class文件(Spring源码中将此文件包装成了Resource对象)
2、遍历每个Resource对象
3、利用MetadataReaderFactory解析Resource对象得到MetadataReader(在Spring源码中MetadataReaderFactory具体的实现类为CachingMetadataReaderFactory,MetadataReader的具体实现类为SimpleMetadataReader)
4、利用MetadataReader进行excludeFilters和includeFilters,以及条件注解@Conditional的筛选(条件注解并不能理解:某个类上是否存在@Conditional注解,如果存在则调用注解中所指定的类的match方法进行匹配,匹配成功则通过筛选,匹配失败则pass掉。)
5、筛选通过后,基于metadataReader生成ScannedGenericBeanDefinition
6、再基于metadataReader判断是不是对应的类是不是接口或抽象类
7、如果筛选通过,那么就表示扫描到了一个Bean,将ScannedGenericBeanDefinition加入结果集
8、后续则是一些校验…end
3、扫描流程图
4、扫描核心源码解析
这里就不过多贴每个细节的源码, 有需要可以自己在本地点进去看。
protected Set<BeanDefinitionHolder> doScan(String... basePackages) {
Assert.notEmpty(basePackages, "At least one base package must be specified");
Set<BeanDefinitionHolder> beanDefinitions = new LinkedHashSet<>();
// 1、遍历包路径
for (String basePackage : basePackages) {
// 2、扫描到包路径下的bean定义
Set<BeanDefinition> candidates = findCandidateComponents(basePackage);
// 3、遍历Bean定义
for (BeanDefinition candidate : candidates) {
// 4、通过ASM解析得到Bean定义元数据
ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate);
// 5、设置作用域
candidate.setScope(scopeMetadata.getScopeName());
// 6、生成beanName,方便后续赋值给bean定义
String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);
if (candidate instanceof AbstractBeanDefinition) {
postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);
}
if (candidate instanceof AnnotatedBeanDefinition) {
// 7、解析@Lazy、@Primary、@DependsOn、@Role、@Description赋值给BeanDefinition
AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);
}
// 8、Bean定义是否已经存在bean,不存在则通过
if (checkCandidate(beanName, candidate)) {
BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);
definitionHolder =
AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
beanDefinitions.add(definitionHolder);
// 9、注册BeanDefinition
registerBeanDefinition(definitionHolder, this.registry);
}
}
}
return beanDefinitions;
}
5、扫描到包路径下的beanDefintion
private Set<BeanDefinition> scanCandidateComponents(String basePackage) {
Set<BeanDefinition> candidates = new LinkedHashSet<>();
try {
// 1、组装解析文件类的url
String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX +
resolveBasePackage(basePackage) + '/' + this.resourcePattern;
// 2、利用resource加载url
Resource[] resources = getResourcePatternResolver().getResources(packageSearchPath);
boolean traceEnabled = logger.isTraceEnabled();
boolean debugEnabled = logger.isDebugEnabled();
// 3、遍历所有的文件类对象
for (Resource resource : resources) {
if (traceEnabled) {
logger.trace("Scanning " + resource);
}
if (resource.isReadable()) {
try {
// 4、元数据解析资源
MetadataReader metadataReader = getMetadataReaderFactory().getMetadataReader(resource);
// 5、是否文件类对象注解上有@Component、以及有@Conding,并且满足条件则通过
if (isCandidateComponent(metadataReader)) {
// 6、生成ScannedGenericBeanDefinition
ScannedGenericBeanDefinition sbd = new ScannedGenericBeanDefinition(metadataReader);
// 7、设置资源
sbd.setSource(resource);
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 (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;
}
二、MetadataReader表示类的元数据读取器
主要包含了一个AnnotationMetadata,功能有
获取类的名字
获取父类的名字
获取所实现的所有接口名
获取所有内部类的名字
判断是不是抽象类
判断是不是接口
判断是不是一个注解
获取拥有某个注解的方法集合
获取类上添加的所有注解信息
获取类上添加的所有注解类型集合
值得注意的是,CachingMetadataReaderFactory解析某个.class文件得到MetadataReader对象是利用的ASM技术,并没有加载这个类到JVM。
并且,最终得到的ScannedGenericBeanDefinition对象,beanClass属性存储的是当前类的名字,而不是class对象。(beanClass属性的类型是Object,它即可以存储类的名字,也可以存储class对象)
最后,上面是说的通过扫描得到BeanDefinition对象,我们还可以通过直接定义BeanDefinition,或解析spring.xml文件的,或者@Bean注解得到BeanDefinition对象。
三、合并BeanDefinition
通过扫描得到所有BeanDefinition之后,就可以根据BeanDefinition创建Bean对象了,但是在Spring中支持父子BeanDefinition,和Java父子类类似,但是完全不是一回事。
父子BeanDefinition实际用的比较少,使用是这样的,比如:
<bean id="parent" class="com.ljc.service.Parent" scope="prototype"/>
<bean id="child" class="com.ljc.service.Child"/>
这么定义的情况下,child是单例Bean。
<bean id="parent" class="com.ljc.service.Parent" scope="prototype"/>
<bean id="child" class="com.ljc.service.Child" parent="parent"/>
但是这么定义的情况下,child就是原型Bean了。
因为child的父BeanDefinition是parent,所以会继承parent上所定义的scope属性。
而在根据child来生成Bean对象之前,需要进行BeanDefinition的合并,得到完整的child的BeanDefinition。
3.1、源码调用地方
RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
在不影响原本存在的BeanDefintion的情况下,创建了新的RootBeanDefinition。
synchronized (this.mergedBeanDefinitions) {
RootBeanDefinition mbd = null;
RootBeanDefinition previous = null;
if (mbd == null || mbd.stale) {
previous = mbd;
if (bd.getParentName() == null) {
// 创建RootBeanDefinition
if (bd instanceof RootBeanDefinition) {
mbd = ((RootBeanDefinition) bd).cloneBeanDefinition();
}
else {
mbd = new RootBeanDefinition(bd);
}
}
四、FactoryBean–可以创建自定义Bean
可以通过实现FactoryBean接口创造出来的自定义的Bean,只会经过初始化后,其他Spring的生命周期步骤是不会经过的
for (String beanName : beanNames) {
// 合并后的BeanDefintion
RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
// 校验不是抽象的并且是单例并且不是懒加载
if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
// 看他是不是一个FactoryBean
if (isFactoryBean(beanName)) {
// 拿到Bean
Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
// 判断他是否实现了FactoryBean
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 {
getBean(beanName);
}
}
}
在合并完BeanDefinition后,判断他不是抽象的并且是单例并且不是懒加载,则判断他实现了FactoryBean,最后开始真正创建Bean,调用getBean方法,进行创建Bean