Spring之Bean的生命周期

最新推荐文章于 2024-04-26 20:19:53 发布

越走越远的风

最新推荐文章于 2024-04-26 20:19:53 发布

阅读量200

点赞数

分类专栏： java spring 文章标签： spring java

本文链接：https://blog.csdn.net/qq_14946371/article/details/129338965

版权

java 同时被 2 个专栏收录

11 篇文章 0 订阅

订阅专栏

spring

4 篇文章 0 订阅

订阅专栏

Spring版本

spring5.3.10

欢迎关注个人公众号【好好学技术】交流学习

Bean介绍

spring最重要的功能就是帮助我们创建对象，也就是IOC。
启动spring就是为创建Bean对象做准备，所以我们必须先明白Spring到底是怎么去创建Bean的，也就是要先弄明白Bean的生命周期。

Bean的生命周期流程图

bean的生命周期

Bean的生成过程

1.生成BeanDefinition

Spring启动的时候会进行扫描scan(basePackages)，会调用org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider#scanCandidateComponents(String basePackage)扫描包路径，并得到BeanDefinition的Set集合

Spring扫描流程图

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加入结果集

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

1.获取类的名字、
2.获取父类的名字
3.获取所实现的所有接口名
4.获取所有内部类的名字
5.判断是不是抽象类
6.判断是不是接口
7.判断是不是一个注解
8.获取拥有某个注解的方法集合
9.获取类上添加的所有注解信息
10.获取类上添加的所有注解类型集合

CachingMetadataReaderFactory解析某个.class文件得到MetadataReader对象是利用的ASM技术，并没有加载这个类到JVM。并且，最终得到的ScannedGenericBeanDefinition对象，beanClass属性存储的是当前类的名字，而不是class对象。（beanClass属性的类型是Object，它即可以存储类的名字，也可以存储class对象）

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

2.合并BeanDefinition

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

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

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

上述定义的情况下，child是单例Bean。

<bean id="parent" class="com.fandf.service.Parent" scope="prototype"/>
<bean id="child" class="com.fandf.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);

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

//org.springframework.beans.factory.support.AbstractBeanFactory

  @Nullable
	protected Class<?> resolveBeanClass(RootBeanDefinition mbd, String beanName, Class<?>... typesToMatch)
			throws CannotLoadBeanClassException {

		try {
			// 如果beanClass被加载了
			if (mbd.hasBeanClass()) {
				return mbd.getBeanClass();
			}

			// 如果beanClass没有被加载
			if (System.getSecurityManager() != null) {
				return AccessController.doPrivileged((PrivilegedExceptionAction<Class<?>>)
						() -> doResolveBeanClass(mbd, typesToMatch), getAccessControlContext());
			}
			else {
				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);
		}
	}

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

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

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

ClassUtils.getDefaultClassLoader()

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

4.实例化前

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

/**
 * @author fandongfeng
 * @date 2023/3/4 16:43
 */
@Component
public class OrderPostProcessor implements InstantiationAwareBeanPostProcessor {

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

orderService在实例化前，会进行打印。

postProcessBeforeInstantiation方法是有返回值的，如果这么实现

@Component
public class OrderPostProcessor implements InstantiationAwareBeanPostProcessor {

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

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

5.实例化

根据BeanDefinition去创建对象。

5.1 Supplier创建对象

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

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

5.2 工厂方法创建对象

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

方式一:

<bean id="userService" class="com.fandf.service.OrderService" factory-method="createOrderService" />

对应OrderService代码为:

public class OrderService {

	public static OrderService createOrderService() {
		System.out.println("createOrderService()");
		return new OrderService();
	}
	
}

方式二:

<bean id="commonService" class="com.fandf.service.CommonService"/>
<bean id="orderService1" factory-bean="commonService" factory-method="createOrderService" />

对应OrderService代码为:

public class CommonService {

 public OrderService createOrderService() {
  return new OrderService();
 }
}

Spring发现当前BeanDefinition方法设置了工厂方法后，就会区分这两种方式，然后调用工厂方法得到对象。

我们通过@Bean所定义的BeanDefinition，是存在factoryMethod和factoryBean的，也就是和上面的方式二非常类似，@Bean所注解的方法就是factoryMethod，所在类对象就是factoryBean。如果@Bean所所注解的方法是static的，那么对应的就是方式一。

5.3 推断构造方法

AbstractAutowireCapableBeanFactory#createBeanInstance

protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
		// Make sure bean class is actually resolved at this point.
		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());
		}

		// BeanDefinition中添加了Supplier，则调用Supplier来得到对象
		Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
		if (instanceSupplier != null) {
			return obtainFromSupplier(instanceSupplier, beanName);
		}

		// @Bean对应的BeanDefinition
		if (mbd.getFactoryMethodName() != null) {
			return instantiateUsingFactoryMethod(beanName, mbd, args);
		}

		// Shortcut when re-creating the same bean...
		// 一个原型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);
		}

		// Preferred constructors for default construction?
		ctors = mbd.getPreferredConstructors();
		if (ctors != null) {
			return autowireConstructor(beanName, mbd, ctors, null);
		}

		// No special handling: simply use no-arg constructor.
		// 不匹配以上情况，则直接使用无参构造方法
		return instantiateBean(beanName, mbd);
	}

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

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

@Lookup注解就是方法注入，使用demo如下：

@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 UserMergedBeanDefinitionPostProcessor implements MergedBeanDefinitionPostProcessor {

	@Override
	public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName) {
		//为userService对象中的属性orderService赋值
		if ("userService".equals(beanName)) {
			beanDefinition.getPropertyValues().add("orderService", new OrderService());
		}
	}
}

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

7. 实例化后

在处理完BeanDefinition后，Spring又设计了一个扩展点：InstantiationAwareBeanPostProcessor.postProcessAfterInstantiation()。

@Component
public class UserInstantiationAwareBeanPostProcessor 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 FandfInstantiationAwareBeanPostProcessor 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(FandfInject.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 FandfBeanPostProcessor implements BeanPostProcessor {

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

		return bean;
	}
}

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

在Spring源码中：

InitDestroyAnnotationBeanPostProcessor会在初始化前这个步骤中执行@PostConstruct的方法，
ApplicationContextAwareProcessor会在初始化前这个步骤中进行其他Aware的回调：
- EnvironmentAware：回传环境变量
- EmbeddedValueResolverAware：回传占位符解析器
- ResourceLoaderAware：回传资源加载器
- ApplicationEventPublisherAware：回传事件发布器
- MessageSourceAware：回传国际化资源
- ApplicationStartupAware：回传应用其他监听对象，可忽略
- ApplicationContextAware：回传Spring容器ApplicationContext

12. 初始化

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

13. 初始化后

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

@Component
public class FandfBeanPostProcessor implements BeanPostProcessor {

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

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

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

总结BeanPostProcessor

1.InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation()
2.实例化
3.MergedBeanDefinitionPostProcessor.postProcessMergedBeanDefinition()
4.InstantiationAwareBeanPostProcessor.postProcessAfterInstantiation()
5.自动注入
6.InstantiationAwareBeanPostProcessor.postProcessProperties()
7.Aware对象
8.BeanPostProcessor.postProcessBeforeInitialization()
9.初始化
10.BeanPostProcessor.postProcessAfterInitialization()

Bean的销毁过程

Bean销毁是在Spring容器关闭时，比如：

@ComponentScan("com.fandf")
public class AppConfig {
}

public static void main(String[] args) {
	AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
	UserService userService = (UserService) context.getBean("userService");

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

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

1.当前Bean是否实现了DisposableBean接口
2.或者，当前Bean是否实现了AutoCloseable接口
3.BeanDefinition中是否指定了destroyMethod
4.调用DestructionAwareBeanPostProcessor.requiresDestruction(bean)进行判断
- ApplicationListenerDetector中直接使得ApplicationListener是DisposableBean
- InitDestroyAnnotationBeanPostProcessor中使得拥有@PreDestroy注解了的方法就是DisposableBean
5.把符合上述任意一个条件的Bean适配成DisposableBeanAdapter对象，并存入disposableBeans中（一个LinkedHashMap）

在Spring容器关闭过程时：

1.首先发布ContextClosedEvent事件
2.调用lifecycleProcessor的onCloese()方法
3.销毁单例Bean
- 遍历disposableBeans
  - 把每个disposableBean从单例池中移除
  - 调用disposableBean的destroy()
  - 如果这个disposableBean还被其他Bean依赖了，那么也得销毁其他Bean
  - 如果这个disposableBean还包含了inner beans，将这些Bean从单例池中移除掉 (inner bean参考https://docs.spring.io/spring-framework/docs/current/spring-framework-reference/core.html#beans-inner-beans)
- 清空manualSingletonNames，是一个Set，存的是用户手动注册的单例Bean的beanName
- 清空allBeanNamesByType，是一个Map，key是bean类型，value是该类型所有的beanName数组
- 清空singletonBeanNamesByType，和allBeanNamesByType类似，只不过只存了单例Bean

这里涉及到一个设计模式：适配器模式

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

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

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

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

越走越远的风

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Spring之Bean的生命周期

spring最重要的功能就是帮助我们创建对象，也就是IOC。启动spring就是为创建Bean对象做准备，所以我们必须先明白Spring到底是怎么去创建Bean的，也就是要先弄明白Bean的生命周期。
复制链接

扫一扫