Spring之Bean生命周期源码解析网站首页 其他

Spring之Bean生命周期源码解析

loli_kong 2023-06-16 00:00:02

简介Spring之Bean生命周期源码解析

Bean的生成过程

1.生成BeanDefinition

Spring启动的时候会进行扫描，会先调用org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider#scanCandidateComponents(String basePackage)

扫描某个包路径，并得到BeanDefinition的Set集合。

关于Spring启动流程，后续会单独的课详细讲，这里先讲一下Spring扫描的底层实现：

首先，通过ResourcePatternResolver获得指定包路径下的所有.class文件（Spring源码中将此文件包装成了Resource对象）
遍历每个Resource对象
利用MetadataReaderFactory解析Resource对象得到MetadataReader（在Spring源码中MetadataReaderFactory具体的实现类为CachingMetadataReaderFactory，MetadataReader的具体实现类为SimpleMetadataReader）
利用MetadataReader进行excludeFilters和includeFilters，以及条件注解@Condition的筛选（条件注解并不能理解：某个类上是否存在@Condition注解，如果存在则调用注解中所指定的类的match方法进行匹配，匹配成功则通过筛选，匹配失败则pass掉。）
筛选通过后，基于metadataReader生成ScannedGenericBeanDefinition
再基于metadataReader判断是不是对象的类，是否为接口或抽象类
如果筛选通过，那么久表示扫描到了一个Bean，将ScannedGenericBeanDefinition加入结果集。

MetadataReader表示类的元数据读取器，主要包含了一个AnnotationMetadata，功能有：

获取类的名字
获取父类的名字
获取所实现的所有接口名
获取所有内部类的名字
判断是不是抽象类
判断是不是接口
判断是不是注解
判断拥有某个注解的方法集合
获取类上添加的所有注解信息
获取类上添加的所有注解类型集合

最后，上面是说的通过扫描得到BeanDefinition对象，我们还可以通过直接定义BeanDefinition，或解析spring.xml文件的·<bean/>，或者@Bean注解得到BeanDefinition对象。

2. 合并BeanDefinition

通过扫描得到所有BeanDefinition之后，就可以根据BeanDefinition创建Bean对象，但是在SPring中支持父子BeanDefinition，和Java父子类类似，但又不完全一样。

父子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来生成Bean对象之前，需要进行BeanDefinition的合并，得到完整的child的BeanDefinition。

3.加载类

BeanDefinition合并之后，就可以去创建Bean对象了，而创建Bean就必须实例化对象，而实例化就必须先加载当前BeanDefinition所对应的class，在AbstractAutowireCapableBeanFactory类的createBean()方法中，一开始就会调用：

Class<?> resolvedClass = resolveBeanClass(mbd, beanName);

这行代码就是去加载类，该方法是这么实现的：

if (mbd.hasBeanClass()) {
	return mbd.getBeanClass();
}
if (System.getSecurityManager() != null) {
	return AccessController.doPrivileged((PrivilegedExceptionAction<Class<?>>) () ->
		doResolveBeanClass(mbd, typesToMatch), getAccessControlContext());
	}
else {
	return doResolveBeanClass(mbd, typesToMatch);
}

public boolean hasBeanClass() {
	return (this.beanClass instanceof Class);
}

如果beanClass属性的类型是Class，那么就直接返回，如果不是，则会根据类名进行加载（doResolveBeanClass方法所做的事情）。

会利用BeanFactory所设置的类加载器来加载类，如果没有设置，则默认使用ClassUtils.getDefaultClassLoader()所返回的类加载器来加载。

ClassUtils.getDefaultClassLoader()

优先返回当前线程中的ClassLoader
线程中类加载器为null的情况下，返回ClassUtils类的类加载器
如果ClassUtils类的类加载器为空，那么则表示是Bootstrap类加载器加载的ClassUtils类，那么则返回系统类加载器

4.实例化前

当前BeanDefinition对应的类成功加载后，就可以实例化对象了，但在Spring中，实例化对象之前，Spring提供了一个扩展点，允许用户来控制某个或者某些Bean实例化之前做一些启动动作。这个扩展点叫InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation()。比如：

@Component
public class ZhouyuBeanPostProcessor implements InstantiationAwareBeanPostProcessor {
	@Override
	public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
		if ("userService".equals(beanName)) {
			System.out.println("实例化前");
		}
		return null;
	}
}

如上代码，在userService这个Bean实例化之前，会进行打印。

值得注意的是，postProcessBeforeInstantiation()是有返回值的，如果这么实现：

@Component
public class ZhouyuBeanPostProcessor implements InstantiationAwareBeanPostProcessor {

	@Override
	public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
		if ("userService".equals(beanName)) {
			System.out.println("实例化前");
			return new UserService();
		}
		return null;
	}
}

userService这个Bean，在实例化前会直接返回一个由我们所定义的UserService对象。如果是这样，表示不需要Spring来实例化了，并且后续的Spring依赖注入也不会进行了，会跳过一些步骤，直接执行初始化后这一步。

5. 实例化

在这个步骤中就会根据BeanDefinition去创建一个对象了。

5.1 Supplier创建对象

首先判断BeanDefinition中是否设置了Supplier，如果设置了则调用Supplier的get()得到对象。

得直接使用BeanDefintion对象来设置Supplier，比如：

AbstractBeanDefinition beanDefinition = BeanDefinitionBuilder.genericBeanDefinition().getBeanDefinition();
beanDefinition.setInstanceSupplier(new Supplier<Object>() {
	@Override
	public Object get() {
		return new UserService();
	}
});
context.registerBeanDefinition("userService", beanDefinition);

5.2 工厂方法创建对象

如果没有设置Supplier，则检查BeanDefinition中是否设置了factoryMethod,也就是工厂方法，有两种方法可以设置factoryMethod，比如：

方式一：

<bean id="userService" class="com.zhouyu.service.UserService" factory-method="createUserService" />

对应的UserService类为：

public class UserService {
	public static UserService createUserService() {
		System.out.println("执行createUserService()");
		UserService userService = new UserService();
		return userService;
	}
	public void test() {
		System.out.println("test");
	}
}

方式二：

<bean id="commonService" class="com.zhouyu.service.CommonService"/>
<bean id="userService1" factory-bean="commonService" factory-method="createUserService" />

对应的CommonService的类为：

public class CommonService {
	public UserService createUserService() {
		return new UserService();
	}
}

5.3 推断构造方法

推断完构造方法后，就会使用构造来进行实例化了。

额外的，在推断构造方法逻辑中除开会去选择构造方法以及查找入参对象以外，还会判断是否在对应的类中是否存在使用@Lookup注解，如果存在则把该方法封装为LookupOverride对象并添加到BeanDefinition中。

在实例化时，如果判断出来当前BeanDefinition中没有LookupOverride，那就直接用构造方法反射得到一个实例对象。如果存在LookUpOverride对象，也就是类中存在@Lookup注解了的方法，那就会生成一个代理对象。

@lookup：用于单例组件引用prototype组件。单例组件使用@Autwried方式注入prototype组件时，被引入prototype组件也会变成单例的。@Lookup可以保证被引入的组件保持prototype模式。

用于解决什么问题：

在Spring的诸多应用场景中bean都是单例形式，当一个单例bean需要和一个非单例的bean组合使用或者一个单例bean和另一个非单例bean组合使用时，我们通常都是将依赖属性的方式放到bean中来引用，然后以@Autowried 来标记需要注入的属性。但是这种方式再bean的生命周期不同时会出现问题，假设单例bean A需要一个非单例 bean B(原型)，我们在A中注入 Bean B,每次调用Bean A中的方法时都会用到bean B，我们知道Spring Ioc容器只在初始化执行一次，也就是bean A中的依赖bean B只有一次注入的机会，但实际上bean B我们需要的是每次调用方法时都获取一个新的对象所以问题明显就是：我们需要bean B是一个原型bean，而事实bean B只注入了一次变成了事实上的单例bean。

遇到这种情况，只需要在方法上面添加@Lookup就可以使他把变成原型，如下面代码：

@Component
public class UserService {

	private OrderService orderService;

	public void test() {
		OrderService orderService = createOrderService();
		System.out.println(orderService);
	}

	@Lookup("orderService")
	public OrderService createOrderService() {
		return null;
	}
}

6. BeanDefinition的后置处理

Bean对象实例化出来之后，接下来就应该给对象的属性赋值了。在真正给属性赋值之前，Spring有提供了一个扩展点MergedBeanDefinitionPostProcessor.postProcessMergedBeanDefinition()，可以对此时的BeanDefinition进行加工，比如：

-@Component
public class ZhouyuMergedBeanDefinitionPostProcessor implements MergedBeanDefinitionPostProcessor {

	@Override
	public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName) {
		if ("userService".equals(beanName)) {
			beanDefinition.getPropertyValues().add("orderService", new OrderService());
		}
	}
}

在Spring源码中，AutowiredAnnotationBeanPostProcessor就是一个MergedBeanDefinitionPostProcessor，它的postProcessMergedBeanDefinition()中会去查找注入点，并缓存在AutowiredAnnotationBeanPostProcessor对象的一个Map中（injectionMetadataCache）。

7.实例化后

处理完BeanDefinition后，Spring又设计了一个扩展点：

InstantiationAwareBeanPostProcessor.postProcessAfterInstantiation()，比如：

@Component
public class ZhouyuInstantiationAwareBeanPostProcessor implements InstantiationAwareBeanPostProcessor {
	@Override
	public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
		if ("userService".equals(beanName)) {
			UserService userService = (UserService) bean;
			userService.test();
		}
		return true;
	}
}

上述代码就是对userService所实例化出来的对象进行处理。

这个扩展点，在Spring源码中基本没有怎么使用。

8. 自动注入

这里的自动注入指的是Spring的自动注入，后续依赖注入课程中单独讲

9.处理属性

这个步骤中，用来处理@AutoWired、@Resource、@Value等注解，也是通过**InstantiationAwareBeanPostProcessor.postProcessProperties()**扩展点来实现的。我们甚至可以实现一个自己的自动注入功能，比如：

@Component
public class ZhouyuInstantiationAwareBeanPostProcessor implements InstantiationAwareBeanPostProcessor {
	@Override
	public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) throws BeansException {
		if ("userService".equals(beanName)) {
			for (Field field : bean.getClass().getFields()) {
				if (field.isAnnotationPresent(ZhouyuInject.class)) {
					field.setAccessible(true);
					try {
						field.set(bean, "123");
					} catch (IllegalAccessException e) {
						e.printStackTrace();
					}
				}
			}
		}

		return pvs;
	}
}

10. 执行Aware

完成了属性赋值之后，Spring会执行一些回调，包括：

BeanNameAware：回传beanName给bean对象。
BeanClassLoaderAware：回传classLoader给bean对象。
BeanFactoryAware：回传beanFactory给对象。

11.初始化前

初始化前，也是Spring提供的一个扩展点：BeanPostProcessor.postProcessBeforeInitialization()，比如

@Component
public class ZhouyuBeanPostProcessor implements BeanPostProcessor {
	@Override
	public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
		if ("userService".equals(beanName)) {
			System.out.println("初始化前");
		}
		return bean;
	}
}

利用初始化前，可以对进行了依赖注入的Bean进行处理。

在Spring源码中：

InitDestroyAnnotaionBeanPostProcessor会在初始化前这个步骤中执行@PostConstruct的方法，
ApplicationContextAwareProcessor会在初始化前这个步骤中进行其他Aware的回调：

a.EnvironmentAware：回传环境变量

b.EmbeddedValueResolverAware：回传占位符解析器

c.ResourceLoaderAware：回传资源加载器

d.ApplicationEventPublisherAware：回传事件发布器

e.MessageSourceAware：回传国际化资源

f.ApplicationStartupAware：回传应用其他监听对象，可忽略

g.ApplicationContextAware：回传Spring容器ApplicationContext

12.初始化

查看当前Bean对象是否实现了InitializingBean接口，如果实现了就调用其afterPropertiesSet()方法
执行BeanDefinition中指定的初始化方法

13.初始化后

这是Bean创建生命周期中的最后一个步骤，也是Spring提供的一个扩展点：BeanPostProcessor.postProcessAfterInitialization()，比如：

@Component
public class ZhouyuBeanPostProcessor implements BeanPostProcessor {
	@Override
	public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
		if ("userService".equals(beanName)) {
			System.out.println("初始化后");
		}
		return bean;
	}
}

可以在这个步骤中，对Bean对重进行处理，Spring中的AOP就是基于初始化后实现的，初始化后返回的对象才是最终的Bean对象。

总结BeanPostProcessor

InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation()
实例化
MergedBeanDefinitionPostProcessor.postProcessMergedBeanDefinition()
InstantiationAwareBeanPostProcessor.postProcessAfterInstantiation()
自动注入
InstantiationAwareBeanPostProcessor.postProcessProperties()
Aware对象
BeanPostProcessor.postProcessBeforeInitialization()
初始化
BeanPostProcessor.postProcessAfterInitialization()

Bean的销毁过程

Bean销毁是发生在Spring容器关闭过程中的。

比如：

AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
UserService userService = (UserService) context.getBean("userService");
userService.test();

// 容器关闭
context.close();

在Bean创建过程中，在最后（初始化之后），有一个步骤回去判断当前创建的Bean是不是DisposableBean：

当前Bean是否实现了DisposableBean接口
或者，当前Bean是否实现了AutoCloseable接口
BeanDefinition中是否指定了destroyMethod
调用DestructionAwareBeanPostProcessor.requiresDestruction(bean)进行判断

a.ApplicationListenerDetector中直接使得ApplicationListener是DisposableBean

b.InitDestroyAnnotationBeanPostProcessor中使得拥有@preDestroy注解的方法就是DisposableBean
吧符合上述任意一个条件的Bean适配成DisposableBeanAdapter对象，并存入disposableBeans中（一个LinkedHashMap）

在关闭Spring容器过程时：

首先发布ContextClosedEvent事件
调用lifecycleProcessor的onClose（）方法
销毁单例Bean

a.遍历disposableBeans

i.把每个disposableBean从单例池中移除

ii.调用disposableBean的destroy()

iii.如果这个disposableBean还被其他Bean依赖了那么也得销毁其他Bean

iV.如果这个disposableBean还包含了inner beans，将这些Bean从单例池中移除掉

b.清空manualSingletonnames，是一个Set，存的是用户手动注册的单例Bean的beanName

c.清空allBeanNamesByType，是一个Map，可以是bean类型，value是该类型所有的beanName数组

d.清空singletonBeanNamesByType，和allBeanNamesByType类似，只不过只存了单例Bean

在销毁时，Spring会找出实现了DisponsableBean接口的Bean。

但是我们在定义一个Bean时，如果这个bean实现了DisposableBean接口，或者实现了AutoCloseAble接口，或者在BeanDefinition中指定了destroyMethodName，那么这个Bean都属于“DisposableBean”，这些Bean在容器关闭时都要调用相应的销毁方法。

所以，这里就需要进行适配，将实现了DisposableBean接口、或者AutoCloseable接口等适配成实现了DisposableBean接口，所以就用到了DisposableBeanAdapter。

会把实现了AutoCloseable接口的类封装成DisposableBeanAdapter，而DisposableBeanAdapter实现了DisposableBean接口。

风语者！平时喜欢研究各种技术，目前在从事后端开发工作，热爱生活、热爱工作。