Spring Bean创建过程《源码分析》

前言

因Spring源码内容较多，调用链比较深，所以本文源码部分只列出了核心部分；本文根据个人理解与阅读源码总结，如有不对的地方欢迎指正🙂。

1. 生成BeanDefinition

找到所有需要被Spring管理的Bean，也就是项目中被@Service、@Component修饰的这些类；将这些类包装成BeanDefinition对象，存储至beanDefinitionMap中。

1.1 获取所有BeanDefinition

// 根据扫描的包路径，找到所有的候选组件
Set<BeanDefinition> candidates = findCandidateComponents(basePackage);

// 1.将包路径转换为资源路径    com.xh.service ---> com/xh/service
String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX + resolveBasePackage(basePackage) + '/' + this.resourcePattern;

// 2.扫描指定包下面所有的.class文件    resources ---> 指定包下面所有.class文件
Resource[] resources = getResourcePatternResolver().getResources(packageSearchPath);

// 3.遍历
for (Resource resource : resources) {
	// 4.包装成MetadataReader，MetadataReader可以方便读取到当前这个类上面的一些注解信息等等
	MetadataReader metadataReader = getMetadataReaderFactory().getMetadataReader(resource);
	// 5.判断当前类是不是候选的Bean（当前这个类上是否包含@Component注解、是否包含@Conditional注解，并且满足对应的条件等等，只要能通过这个if条件，也就初步代表当前这个类是一个Bean）
	if (isCandidateComponent(metadataReader)) {
        // 6.如果当前类不是一个接口、如果是抽象类，并符合对应的条件、并且是一个普通的类等等，能通过if条件，也就代表当前这个类最终是一个真正的Bean
        if (isCandidateComponent(sbd)) {
        	// 7.包装成为一个ScannedGenericBeanDefinition
        	ScannedGenericBeanDefinition sbd = new ScannedGenericBeanDefinition(metadataReader);
        	// 设置class资源
        	sbd.setResource(resource);
        	sbd.setSource(resource);
        	
        	// 8.加入到集合中
        	candidates.add(sbd);
        }
    }
}

protected boolean isCandidateComponent(MetadataReader metadataReader) throws IOException {
	// 判断当前的类是否在excludeFilters集合中，如果在：当前类则不是一个Bean
	for (TypeFilter tf : this.excludeFilters) {
		if (tf.match(metadataReader, getMetadataReaderFactory())) {
			return false;
		}
	}
	// 符合includeFilters的会进行条件匹配（Spring默认注册了Component.class，也就是在includeFilters集合中），通过了才是Bean，也就是先看类上面有没有@Component、再看是否符合@Conditional
	for (TypeFilter tf : this.includeFilters) {
		// 类上面包含了@Component注解，就能通过这个判断
		if (tf.match(metadataReader, getMetadataReaderFactory())) {
			// 条件匹配，检查类上是否有@Conditional注解，是否符合条件，如果通过当前条件，则代表当前类是一个Bean
			return isConditionMatch(metadataReader);
		}
	}
	return false;
}

1.2 存储至beanDefinitionMap中

Set<BeanDefinition> candidates = findCandidateComponents(basePackage);

// 遍历BeanDefinition
for (BeanDefinition candidate : candidates) {
    // 设置bean的作用域
    ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate);
    candidate.setScope(scopeMetadata.getScopeName());
    
    // 设置beanName
    String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);
    
    // 给BeanDefinition设置一些默认值
    if (candidate instanceof AbstractBeanDefinition) {
        postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);
    }
	
    // 获取@Lazy @DependsOn等注解的数据设置到BeanDefinition中
    if (candidate instanceof AnnotatedBeanDefinition) {
        AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);
    }
    
    // 判断容器中是否已经存在该BeanDefinition，如果不存在则进入if条件，将BeanDefinition存储至容器中（beanDefinitionMap）
    if (checkCandidate(beanName, candidate)) {
        BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);
        definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
        beanDefinitions.add(definitionHolder);
        
        // 将BeanDefinition存储至容器中（存储至beanDefinitionMap中）
        registerBeanDefinition(definitionHolder, this.registry);
    }
    
}

2. 实例化前

拿到BeanDefinition就可以进行实例化了，但在实例化之前，Spring给我们提供了扩展点，允许用户能够终止某个Bean的创建，允许用户使用自己创建的对象。

InstantiationAwareBeanPostProcessor

@Component
public class CustomBeanPostProcessor implements InstantiationAwareBeanPostProcessor {

	@Override
	public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
		if ("userService".equals(beanName)) {
			// 实例化前打印一下
			System.out.println("userService实例化前打印一下...");
			
			// 或者使用我自己创建的对象存储至容器中，spring就不用再创建对象，进行后续的实例化、属性填充、初始化等等操作，下一步会直接跳到初始化之后
			UserService userService = new UserService();
			return userService;
		}
		return null;
	}
}

protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
    // [bean的扩展点]实例化之前
    Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
    // 实例化之前如果返回了你自己创建了bean，则使用你自己创建的bean
    if (bean != null) {
        return bean;
    }
}

protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
	Object bean = null;
	if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
		// 判断容器中是否存在implements了InstantiationAwareBeanPostProcessors的bean
		if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
			// 获取当前bean 的class对象
			Class<?> targetType = determineTargetType(beanName, mbd);
			if (targetType != null) {
				// 调用实现了InstantiationAwareBeanPostProcessors的bean，postProcessBeforeInstantiation方法
				bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
				if (bean != null) {
					// 如果postProcessBeforeInstantiation方法返回的对象不为空，则直接调用实例化之后的扩展点
					bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
				}
			}
		}
		mbd.beforeInstantiationResolved = (bean != null);
	}
	return bean;
}

3. 实例化

开始根据BeanDefinition进行实例化

3.1 Supplier创建对象

Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
	if (instanceSupplier != null) {
	return obtainFromSupplier(instanceSupplier, beanName);
}

3.2 工厂方法创建对象

if (mbd.getFactoryMethodName() != null) {
	return instantiateUsingFactoryMethod(beanName, mbd, args);
}

3.3 构造方法创建对象

// 有参构造方法实例化
autowireConstructor(beanName, mbd, ctors, args);

// 无参构造方法实例化
instantiateBean(beanName, mbd);

4. 解析注入点

在Spring源码中，AutowiredAnnotationBeanPostProcessor实现了MergedBeanDefinitionPostProcessor接口，它的postProcessMergedBeanDefinition方法中会去查找注入点（需要被注入的属性、方法），并缓存在AutowiredAnnotationBeanPostProcessor对象的一个Map中（injectionMetadataCache）便于后续属性赋值，当然用户自己也可以实现这个接口下面的方法对bean自定义加工

MergedBeanDefinitionPostProcessor

@Component
public class CustomBeanPostProcessor implements MergedBeanDefinitionPostProcessor {

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

@Override
public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName) {
	// 寻找bean中所有被@Autowired修饰的属性，并将属性封装成InjectedElement类型
	InjectionMetadata metadata = findAutowiringMetadata(beanName, beanType, null);
	metadata.checkConfigMembers(beanDefinition);
}

5. 实例化后

实例化之后spring设计了可扩展的点

InstantiationAwareBeanPostProcessor

@Component
public class CustomBeanPostProcessor implements InstantiationAwareBeanPostProcessor {

	@Override
	public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
		if ("userService".equals(beanName)) {
			// 实例化后打印一下
			System.out.println("userService实例化之后打印一下...");
			
			// 自定义UserService实例化之后逻辑
			UserService userService = (UserService) bean;
			
		}
		return true;
	}
}

6. 属性填充

这个步骤中，就会处理@Autowired、@Resource、@Value等注解，也是通过InstantiationAwareBeanPostProcessor.postProcessProperties()扩展点来实现的，我们甚至可以自定义一个注解实现自动注入功能。

InstantiationAwareBeanPostProcessorAdapter

@Component
public class CustomBeanPostProcessor 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(XhInject.class)) {
					field.setAccessible(true);
					try {
						field.set(bean, "xxx");
					} catch (IllegalAccessException e) {
						e.printStackTrace();
					}
				}
			}
		}

		return pvs;
	}
}

@Override
public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName) {
	// 寻找bean中所有被@Autowired修饰的属性，并将属性封装成InjectedElement类型
	InjectionMetadata metadata = findAutowiringMetadata(beanName, beanType, null);
	metadata.checkConfigMembers(beanDefinition);
}

7. 执行Aware回调

完成属性赋值之后，只要在我们业务中Bean实现了下面的Aware接口，Spring会执行对应的回调：

7.1 BeanNameAware

7.2 BeanClassLoaderAware

7.3 BeanFactoryAware

private void invokeAwareMethods(final String beanName, final Object bean) {
	if (bean instanceof Aware) {
		// 我们的bean实现了BeanNameAware
		if (bean instanceof BeanNameAware) {
			((BeanNameAware) bean).setBeanName(beanName);
		}
		// 实现了BeanClassLoaderAware接口
		if (bean instanceof BeanClassLoaderAware) {
			ClassLoader bcl = getBeanClassLoader();
			if (bcl != null) {
				((BeanClassLoaderAware) bean).setBeanClassLoader(bcl);
			}
		}
		// 实现了BeanFactoryAware
		if (bean instanceof BeanFactoryAware) {
			((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);
		}
	}
}

8. 初始化前

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

BeanPostProcessor

@Component
public class CustomBeanPostProcessor implements BeanPostProcessor {

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

		return bean;
	}
	
}

@Override
public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
		throws BeansException {
	Object result = existingBean;
	// 获取我们容器中的所有的bean的后置处理器
	for (BeanPostProcessor processor : getBeanPostProcessors()) {
		// 挨个调用我们的bean的后置处理器的postProcessBeforeInitialization
		Object current = processor.postProcessBeforeInitialization(result, beanName);
		// 若只有有一个返回null 那么直接返回原始的
		if (current == null) {
			return result;
		}
		result = current;
	}
	return result;
}

在Spring源码中：

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

@Override
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;
}

@Override
@Nullable
public Object postProcessBeforeInitialization(final Object bean, String beanName) throws BeansException {
	AccessControlContext acc = null;
	if (System.getSecurityManager() != null &&
			(bean instanceof EnvironmentAware || bean instanceof EmbeddedValueResolverAware ||
					bean instanceof ResourceLoaderAware || bean instanceof ApplicationEventPublisherAware ||
					bean instanceof MessageSourceAware || bean instanceof ApplicationContextAware)) {
		acc = this.applicationContext.getBeanFactory().getAccessControlContext();
	}
	if (acc != null) {
		AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
			invokeAwareInterfaces(bean);
			return null;
		}, acc);
	}
	else {
		invokeAwareInterfaces(bean);
	}
	return bean;
}

private void invokeAwareInterfaces(Object bean) {
	if (bean instanceof Aware) {
		if (bean instanceof EnvironmentAware) {
			((EnvironmentAware) bean).setEnvironment(this.applicationContext.getEnvironment());
		}
		if (bean instanceof EmbeddedValueResolverAware) {
			((EmbeddedValueResolverAware) bean).setEmbeddedValueResolver(this.embeddedValueResolver);
		}
		if (bean instanceof ResourceLoaderAware) {
			((ResourceLoaderAware) bean).setResourceLoader(this.applicationContext);
		}
		if (bean instanceof ApplicationEventPublisherAware) {
			((ApplicationEventPublisherAware) bean).setApplicationEventPublisher(this.applicationContext);
		}
		if (bean instanceof MessageSourceAware) {
			((MessageSourceAware) bean).setMessageSource(this.applicationContext);
		}
		if (bean instanceof ApplicationContextAware) {
			((ApplicationContextAware) bean).setApplicationContext(this.applicationContext);
		}
	}
}

9. 初始化

1、查看当前Bean是否实现了InitializingBean接口，如果实现了就调用afterPropertiesSet()方法

2、调用使用@Bean或者xml中指定的initMethod方法

9.1 InitializingBean

@Component
public class UserService implements InitializingBean {

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("userService初始化...");
    }
    
}

9.2 initMethod

// userServiceInit方法必须在UserService类中
public void userServiceInit() {
    System.out.println("userService初始化...");
}

@Bean(initMethod = "userServiceInit")
public UserService userService() {
    return new UserService();
}

protected void invokeInitMethods(String beanName, final Object bean, @Nullable RootBeanDefinition mbd)
		throws Throwable {
	//判断我们的容器中是否实现了InitializingBean接口
	boolean isInitializingBean = (bean instanceof InitializingBean);
	if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {
		if (logger.isDebugEnabled()) {
			logger.debug("Invoking afterPropertiesSet() on bean with name '" + beanName + "'");
		}
		if (System.getSecurityManager() != null) {
			try {
				AccessController.doPrivileged((PrivilegedExceptionAction<Object>) () -> {
					((InitializingBean) bean).afterPropertiesSet();
					return null;
				}, getAccessControlContext());
			}
			catch (PrivilegedActionException pae) {
				throw pae.getException();
			}
		}
		else {
			//回调InitializingBean的afterPropertiesSet()方法
			((InitializingBean) bean).afterPropertiesSet();
		}
	}
	// 调用initMethod
	if (mbd != null && bean.getClass() != NullBean.class) {
		//我们beanclass中看是否有自己定义的init方法
		String initMethodName = mbd.getInitMethodName();
		//判断自定义的init方法名称不叫afterPropertiesSet
		if (StringUtils.hasLength(initMethodName) &&
				!(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) &&
				!mbd.isExternallyManagedInitMethod(initMethodName)) {
			//调用我们自己的初始化方法
			invokeCustomInitMethod(beanName, bean, mbd);
		}
	}
}

10. 初始化后

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

BeanPostProcessor

@Component
public class CustomBeanPostProcessor 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对象。

@Override
public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
		throws BeansException {
	Object result = existingBean;
	//获取我们容器中的所有的bean的后置处理器
	for (BeanPostProcessor processor : getBeanPostProcessors()) {
		/**
		 * 在这里是后置处理器的【第九次调用】 aop和事务都会在这里生存代理对象
		 *
		 * 【很重要】
		 * 我们AOP @EnableAspectJAutoProxy 为我们容器中导入了 AnnotationAwareAspectJAutoProxyCreator
		 * 我们事务注解@EnableTransactionManagement 为我们的容器导入了 InfrastructureAdvisorAutoProxyCreator
		 * 都是实现了我们的 BeanPostProcessor接口,InstantiationAwareBeanPostProcessor,
		 * 在这里实现的是BeanPostProcessor接口的postProcessAfterInitialization来生成我们的代理对象
		 */
		Object current = processor.postProcessAfterInitialization(result, beanName);
		//若只有有一个返回null 那么直接返回原始的
		if (current == null) {
			return result;
		}
		result = current;
	}
	return result;
}

目录CONTENT

Spring Bean创建过程《源码分析》

前言

1. 生成BeanDefinition

1.1 获取所有BeanDefinition

1.2 存储至beanDefinitionMap中

2. 实例化前

InstantiationAwareBeanPostProcessor

3. 实例化

3.1 Supplier创建对象

3.2 工厂方法创建对象

3.3 构造方法创建对象

4. 解析注入点

MergedBeanDefinitionPostProcessor

5. 实例化后

InstantiationAwareBeanPostProcessor

6. 属性填充

InstantiationAwareBeanPostProcessorAdapter

7. 执行Aware回调

7.1 BeanNameAware

7.2 BeanClassLoaderAware

7.3 BeanFactoryAware

8. 初始化前

BeanPostProcessor

9. 初始化

9.1 InitializingBean

9.2 initMethod

10. 初始化后

BeanPostProcessor

评论区