Spring源码：Bean生命周期（五）

快来打我* 2024-03-22 19:32 14阅读 0赞

## 前言 ##

在上一篇文章中，我们深入探讨了 Spring 框架中 Bean 的实例化过程，该过程包括从 Bean 定义中加载当前类、寻找所有实现了 InstantiationAwareBeanPostProcessor 接口的类并调用实例化前的方法、进行实例化、调用 applyMergedBeanDefinitionPostProcessors 方法等多个步骤，最终生成了一个真正的 Bean 实例。但是，这个 Bean 实例还没有被初始化和注入属性，还不能真正发挥作用。

在今天的文章中，我们将深入探讨 Bean 的属性注入和初始化流程，从而使其成为一个真正意义上的 Bean。这个过程包括属性注入、Aware 接口回调、BeanPostProcessor 的前置和后置处理等多个步骤，通过本文的学习，读者将能够更深入地了解 Spring 框架中 Bean 的属性注入和初始化过程，为后续的学习和实践打下坚实的基础。

## populateBean ##

在 Spring 框架中，属性注入是 Bean 初始化过程中的一个重要环节。在 Bean 实例化完成后，Spring 框架会根据 Bean 定义中的属性设置进行属性注入，同时还会调用一些 Aware 接口回调方法，以及一些 BeanPostProcessor 的前置和后置处理方法，最终完成 Bean 的初始化过程。好的，抛去不用看的，我们来看下剩下的源码：

protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
    	}
    ......
    		PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);
    
    		int resolvedAutowireMode = mbd.getResolvedAutowireMode();
    		if (resolvedAutowireMode == AUTOWIRE_BY_NAME || resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
    			// MutablePropertyValues是PropertyValues具体的实现类
    			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;
    		}
    
    		boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
    		boolean needsDepCheck = (mbd.getDependencyCheck() != AbstractBeanDefinition.DEPENDENCY_CHECK_NONE);
    
    		PropertyDescriptor[] filteredPds = null;
    		if (hasInstAwareBpps) {
    			if (pvs == null) {
    				pvs = mbd.getPropertyValues();
    			}
    			for (InstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().instantiationAware) {
    				// 这里会调用AutowiredAnnotationBeanPostProcessor的postProcessProperties()方法，会直接给对象中的属性赋值
    				// AutowiredAnnotationBeanPostProcessor内部并不会处理pvs，直接返回了
    				PropertyValues pvsToUse = bp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
    				if (pvsToUse == null) {
    					if (filteredPds == null) {
    						filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
    					}
    					pvsToUse = bp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
    					if (pvsToUse == null) {
    						return;
    					}
    				}
    				pvs = pvsToUse;
    			}
    		}
    		......
    
    		// 如果当前Bean中的BeanDefinition中设置了PropertyValues，那么最终将是PropertyValues中的值，覆盖@Autowired
    		if (pvs != null) {
    			applyPropertyValues(beanName, mbd, bw, pvs);
    		}
    	}

### PropertyValues ###

在 Spring 框架中，PropertyValues 对象是从 Bean 定义中获取的，而我们自己定义的 Bean 并没有这个属性值。一般情况下，这一步会被跳过，但如果需要注入属性值，我们可以通过实现 MergedBeanDefinitionPostProcessor 接口的 postProcessMergedBeanDefinition 方法来对 Bean 定义进行修改，从而添加需要注入的属性值。

具体来说，我们可以定义一个实现了 MergedBeanDefinitionPostProcessor 接口的类，比如下面这个例子：：

@Component
    public class MyInstantiationAwareBeanPostProcessors implements InstantiationAwareBeanPostProcessor, MergedBeanDefinitionPostProcessor {
    
    	@Override
    	public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName) {
    		if (beanName.equals("userService")) {
    			beanDefinition.setPropertyValues(new MutablePropertyValues().add("orderService", new First()));
    		}
    	}
    }

在这个例子中，我们判断如果 Bean 的名称是 "userService"，则添加一个名为 "orderService" 的属性，并将其值设置为 First 类的一个实例。需要注意的是，为了能够正常注入属性值，我们需要在 Bean 中定义一个名为 "setOrderService" 的 setter 方法，这样就可以注入进去，当然我写的这个是报错的状态，这样大家可以找到他是在哪里进行调用的。

### autowireByName/autowireByType ###

讲解之前，我先声明一下他跟我们的@autowired注解没有半毛钱关系，除了上面一种我们人为干预的，还有一种Spring自带的方式，在我们配置类中：

@Bean(autowire = Autowire.BY_NAME)
    	public UserService userService(){
    		return new UserService();
    	}

这样定义时，他就会自动扫描你这个当前类中所有的set方法，是所有的、而且不区分的。这里以autowireByName为例讲解，autowireByType类似：

protected void autowireByName(
    			String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) {
    
    		// 当前Bean中能进行自动注入的属性名
    		String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);
    		// 遍历每个属性名，并去获取Bean对象，并设置到pvs中
    		for (String propertyName : propertyNames) {
    			if (containsBean(propertyName)) {
    				Object bean = getBean(propertyName);
    				pvs.add(propertyName, bean);
    				// 记录一下propertyName对应的Bean被beanName给依赖了
    				registerDependentBean(propertyName, beanName);
    				if (logger.isTraceEnabled()) {
    					logger.trace("Added autowiring by name from bean name '" + beanName +
    							"' via property '" + propertyName + "' to bean named '" + propertyName + "'");
    				}
    			}
    			else {
    				if (logger.isTraceEnabled()) {
    					logger.trace("Not autowiring property '" + propertyName + "' of bean '" + beanName +
    							"' by name: no matching bean found");
    				}
    			}
    		}
    	}

1.  unsatisfiedNonSimpleProperties：找到所有set方法
2.  getBean：按照set方法名字获取bean
3.  pvs.add(propertyName, bean)：设置到MutablePropertyValues属性中，不是对我们的bean进行属性注入

那有些同学可能会想到了，为什么Spring已经默认提供了一套注入方式还有弄一个@autowired注解呢？主要是因为它们各自有不同的优点和适用场景。

默认的注入方式非常灵活，它会遍历 Bean 中所有的 setter 方法，对每个属性进行注入，从而实现自动装配。这种方式适用于大多数情况，因为它能够自动识别并注入所有需要的依赖项，并且不需要进行任何额外的配置。

而 @Autowired 注解则提供了更加精细的控制，它可以指定需要注入的属性或方法，并且还可以指定注入的方式、名称、是否必须等属性。这种方式适用于需要更加精细的控制和配置的情况，@Autowired 注解是一个可插拔的组件，它只有在 Spring 容器启动时扫描到该注解时才能够进行自动装配。如果我们使用 XML 配置的方式启动 Spring 容器，需要在配置文件中添加 context:component-scan 元素来开启自动扫描功能，否则即使写了 @Autowired 注解也不会进行注入。

### postProcessProperties ###

这一步将会对@autowired注解进行属性注入，其他的不看，这里只看下AutowiredAnnotationBeanPostProcessor对属性或者方法的注入：

private InjectionMetadata buildAutowiringMetadata(final Class<?> clazz) {
    		// 如果一个Bean的类型是String...，那么则根本不需要进行依赖注入
    		if (!AnnotationUtils.isCandidateClass(clazz, this.autowiredAnnotationTypes)) {
    			return InjectionMetadata.EMPTY;
    		}
    
    		List<InjectionMetadata.InjectedElement> elements = new ArrayList<>();
    		Class<?> targetClass = clazz;
    
    		do {
    			final List<InjectionMetadata.InjectedElement> currElements = new ArrayList<>();
    
    			// 遍历targetClass中的所有Field
    			ReflectionUtils.doWithLocalFields(targetClass, field -> {
    				// field上是否存在@Autowired、@Value、@Inject中的其中一个
    				MergedAnnotation<?> ann = findAutowiredAnnotation(field);
    				if (ann != null) {
    					// static filed不是注入点，不会进行自动注入
    					if (Modifier.isStatic(field.getModifiers())) {
    						if (logger.isInfoEnabled()) {
    							logger.info("Autowired annotation is not supported on static fields: " + field);
    						}
    						return;
    					}
    
    					// 构造注入点
    					boolean required = determineRequiredStatus(ann);
    					currElements.add(new AutowiredFieldElement(field, required));
    				}
    			});
    
    			// 遍历targetClass中的所有Method
    			ReflectionUtils.doWithLocalMethods(targetClass, method -> {
    
    				Method bridgedMethod = BridgeMethodResolver.findBridgedMethod(method);
    				if (!BridgeMethodResolver.isVisibilityBridgeMethodPair(method, bridgedMethod)) {
    					return;
    				}
    				// method上是否存在@Autowired、@Value、@Inject中的其中一个
    				MergedAnnotation<?> ann = findAutowiredAnnotation(bridgedMethod);
    				if (ann != null && method.equals(ClassUtils.getMostSpecificMethod(method, clazz))) {
    					// static method不是注入点，不会进行自动注入
    					if (Modifier.isStatic(method.getModifiers())) {
    						if (logger.isInfoEnabled()) {
    							logger.info("Autowired annotation is not supported on static methods: " + method);
    						}
    						return;
    					}
    					// set方法最好有入参
    					if (method.getParameterCount() == 0) {
    						if (logger.isInfoEnabled()) {
    							logger.info("Autowired annotation should only be used on methods with parameters: " +
    									method);
    						}
    					}
    					boolean required = determineRequiredStatus(ann);
    					PropertyDescriptor pd = BeanUtils.findPropertyForMethod(bridgedMethod, clazz);
    					currElements.add(new AutowiredMethodElement(method, required, pd));
    				}
    			});
    
    			elements.addAll(0, currElements);
    			targetClass = targetClass.getSuperclass();
    		}
    		while (targetClass != null && targetClass != Object.class);
    
    		return InjectionMetadata.forElements(elements, clazz);
    	}

1.  如果一个Bean的类型是String...，那么则根本不需要进行依赖注入
2.  遍历targetClass中的所有Field,static filed不是注入点，不会进行自动注入
3.  遍历targetClass中的所有Method,static method不是注入点，不会进行自动注入
4.  上面的注入点构造好后，会在外层直接invoke调用注入

这里强调一下在对方法注入点进行注入时，会先判断一下是否有PropertyValues，如果有的话则跳过注入，AutowiredMethodElement源码如下：

protected void inject(Object bean, @Nullable String beanName, @Nullable PropertyValues pvs) throws Throwable {
    			// 如果pvs中已经有当前注入点的值了，则跳过注入
    			if (checkPropertySkipping(pvs)) {
    				return;
    			}
    			......
    		}

### applyPropertyValues ###

直接应用PropertyValues注入属性，可以看到这一步在我们的@autowired解析注入之后，如果你有的属性字段已经被@autowired注入了，但是又有一个PropertyValues那么这个set方法会把你的@Autowired之前注入进去的对象值覆盖，源码很多为了篇幅就不看了。知道这个方法是干啥的就行。

## initializeBean ##

属性填充完之后，终于进入到了初始化阶段，为什么需要初始化这一步呢？这是对bean的最终处理，该方法返回的对象才是Spring管理的最终对象，Spring AOP就是对初始化这一步做 的扩展。

protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
    		if (System.getSecurityManager() != null) {
    			AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
    				invokeAwareMethods(beanName, bean);
    				return null;
    			}, getAccessControlContext());
    		}
    		else {
    			invokeAwareMethods(beanName, bean);
    		}
    
    		Object wrappedBean = bean;
    
    		// 初始化前
    		if (mbd == null || !mbd.isSynthetic()) {
    			wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
    		}
    
    		// 初始化
    		try {
    			invokeInitMethods(beanName, wrappedBean, mbd);
    		}
    		catch (Throwable ex) {
    			throw new BeanCreationException(
    					(mbd != null ? mbd.getResourceDescription() : null),
    					beanName, "Invocation of init method failed", ex);
    		}
    
    		// 初始化后 AOP
    		if (mbd == null || !mbd.isSynthetic()) {
    			wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
    		}
    
    		return wrappedBean;
    	}

### invokeAwareMethods ###

该方法就是Aware接口的实现

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);
    			}
    		}
    	}

### applyBeanPostProcessorsBeforeInitialization ###

初始化前的类处理，我们主讲两个类：ApplicationContextAwareProcessor、

InitDestroyAnnotationBeanPostProcessor通过这两个类看看可以初始化前我们可以做哪些内容：

#### ApplicationContextAwareProcessor ####

public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
    		if (!(bean instanceof EnvironmentAware || bean instanceof EmbeddedValueResolverAware ||
    				bean instanceof ResourceLoaderAware || bean instanceof ApplicationEventPublisherAware ||
    				bean instanceof MessageSourceAware || bean instanceof ApplicationContextAware ||
    				bean instanceof ApplicationStartupAware)) {
    			return bean;
    		}
    ......
    			// 执行aware方法
    			invokeAwareInterfaces(bean);
    		}
    		return bean;
    	}

初始化前会判断当前是否是某个Aware类，那么则执行aware方法进行回调。

#### InitDestroyAnnotationBeanPostProcessor ####

public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
    		LifecycleMetadata metadata = findLifecycleMetadata(bean.getClass());
    		try {
    			metadata.invokeInitMethods(bean, beanName);
    		}
    		catch (InvocationTargetException ex) {
    			throw new BeanCreationException(beanName, "Invocation of init method failed", ex.getTargetException());
    		}
    		catch (Throwable ex) {
    			throw new BeanCreationException(beanName, "Failed to invoke init method", ex);
    		}
    		return bean;
    	}

1.  findLifecycleMetadata：好奇的小伙伴可以看下这个方法，他会构造@PostConstruct、@PreDestroy执行点
2.  metadata.invokeInitMethods：执行带有@PostConstruct方法

### invokeInitMethods ###

protected void invokeInitMethods(String beanName, Object bean, @Nullable RootBeanDefinition mbd)
    			throws Throwable {
    
    		boolean isInitializingBean = (bean instanceof InitializingBean);
    		if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {
    			......
    				((InitializingBean) bean).afterPropertiesSet();
    			}
    		}
    
    		if (mbd != null && bean.getClass() != NullBean.class) {
    			String initMethodName = mbd.getInitMethodName();
    			if (StringUtils.hasLength(initMethodName) &&
    					!(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) &&
    					!mbd.isExternallyManagedInitMethod(initMethodName)) {
    				invokeCustomInitMethod(beanName, bean, mbd);
    			}
    		}
    	}

1.  如果当前类实现了InitializingBean接口，那么执行afterPropertiesSet方法进行初始化
2.  initMethodName：如果当前类指定了初始方法，那么直接invoke执行

### 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;
    	}

执行完postProcessAfterInitialization方法后，那么这个对象终于初始化成功了

## 总结 ##

今天我们主讲bean的初始化，主要流程如下:

1.  属性注入，执行@autowired、PropertyValues注入等
2.  初始化前置方法，执行@PostConstruct方法、回调Aware接口等
3.  初始化，调用afterPropertiesSet或者initMethod
4.  初始化后置方法

最后一节我们会讲bean的销毁，那么bean的生命周期系列文章会结束，实际上 Spring 框架还有很多其他的功能和特性，例如 AOP、事务管理、Web 开发等等，博主还会进行对Spring系列继续更新，请大家继续跟紧学习。