Spring源码分析之Bean的创建过程详解
LD is tigger forever，CG are not brothers forever， throw the pot and shine forever.
Modesty is not false, solid is not naive, treacherous but not deceitful, stay with good people, and stay away from poor people.
talk is cheap, show others the code,Keep progress，make a better result.
Survive during the day and develop at night。
目录
概述
Bean的生命周期&构建流程源码剖析，
ioc容器启动主线源码剖析。
实现思路分析
参考资料：https://www.processon.com/view/link/5f6174431e08531edf3134fb
SpringIOC
AutowiredAnnotationBeanPostProcessor：在new AnnotatedBeanDefinitionReader时注册
ApplicationContextAwareProcessor: 在prepareBeanFactory时注册
ApplicationListenerDetector: 在prepareBeanFactory时注册
ImportAwareBeanPostProcessor: 在配置类后置处理器调用postProcessBeanFactory注册
同样，我们先从最开始的入口refresh开始分析：
public void refresh(){
//....省略前面部分
// 实例化剩余的单例bean
finishBeanFactoryInitialization(beanFactory);
}
finishBeanFactoryInitialization
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory){
// 将所有非懒加载的bean加载到容器中
beanFactory.preInstantiateSingletons();
}
循环我们之前注册的所有beanDefinition，一个个的进行调用getBean注册到容器中
public void preInstantiateSingletons(){
// 循环所有beanDefinition
for (String beanName : beanNames) {
// 将beanDefinition转化为RootBeanDefinition
RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
// 不是抽象类并且是单例并且非懒加载
if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
// 是否为工厂bean
if (isFactoryBean(beanName)) {
// 由于是以&开头获取bean,这里返回的是一个工厂bean，并且不会调用getObject方法
Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
if (bean instanceof FactoryBean) {
// 判断是否要立即初始化bean
FactoryBean<?> factory = (FactoryBean<?>) bean;
boolean isEagerInit = (factory instanceof SmartFactoryBean &&
((SmartFactoryBean<?>) factory).isEagerInit());
if (isEagerInit) {
// 以为&开头的方式再获取一次，此时会调用FactoryBean的getObject()方法
getBean(beanName);
}
}
}
else {
// 不是FactoryBean，直接使用getBean进行初始化
getBean(beanName);
}
}
}
}
以下为doGetBean中获取单例bean的逻辑
// 转化beanName 如果是以&开头则去除，如果有别名则获取别名
String beanName = transformedBeanName(name);
// 尝试从三级缓存中获取bean
Object sharedInstance = getSingleton(beanName);
// 是否从缓存中获取到了bean
if (sharedInstance != null && args == null) {
// 如果是工厂类且name不以&开头，则调用工厂类的getObject()
// 其他情况返回原对象
bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
}
getSingleton
public Object getSingleton(String beanName) {
return getSingleton(beanName, true);
}
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
// 从单例缓存池中获取
Object singletonObject = this.singletonObjects.get(beanName);
// 获取不到，判断bean是否正在创建
// 如果是正在创建，2种情况 1.多个线程在创建bean 2.发生循环依赖
// 如果是多个线程，则由于同步锁阻塞于此
// 循环依赖的问题较为复杂，将在下章详细分析
if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
synchronized (this.singletonObjects) {
// 从早期对象缓存池中获取
singletonObject = this.earlySingletonObjects.get(beanName);
if (singletonObject == null && allowEarlyReference) {
// 从三级缓存中获取单例工厂
ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
if (singletonFactory != null) {
// 调用回调方法获取早期bean
singletonObject = singletonFactory.getObject();
// 将早期对象放到二级缓存，移除三级缓存
this.earlySingletonObjects.put(beanName, singletonObject);
this.singletonFactories.remove(beanName);
}
}
}
}
return singletonObject;
}
getObjectForBeanInstance
protected Object getObjectForBeanInstance(
Object beanInstance, String name, String beanName, @Nullable RootBeanDefinition mbd) {
// 判断name是否以&开头，是则直接返回该FactoryBean
/*public static boolean isFactoryDereference(@Nullable String name) {
return (name != null && name.startsWith(BeanFactory.FACTORY_BEAN_PREFIX));
}*/
if (BeanFactoryUtils.isFactoryDereference(name)) {
return beanInstance;
}
// 不是工厂bean直接返回原对象
if (!(beanInstance instanceof FactoryBean)) {
return beanInstance;
}
// 尝试从缓存中获取，保证多次从工厂bean获取的bean是同一个bean
object = getCachedObjectForFactoryBean(beanName);
if (object == null) {
FactoryBean<?> factory = (FactoryBean<?>) beanInstance;
boolean synthetic = (mbd != null && mbd.isSynthetic());
// 从FactoryBean获取对象
object = getObjectFromFactoryBean(factory, beanName, !synthetic);
}
return object;
}
以下为续接上面doGetBean中未从缓存中获取到bean的逻辑
// 如果有被@DependsOn标记，先创建DependsOn的bean
String[] dependsOn = mbd.getDependsOn();
if (dependsOn != null) {
for (String dep : dependsOn) {
registerDependentBean(dep, beanName);
getBean(dep);
}
}
// 单例bean
if (mbd.isSingleton()) {
// 开始创建bean
sharedInstance = getSingleton(beanName, () -> {
// 真正创建bean
return createBean(beanName, mbd, args);
});
// 如果是工厂类且name不以&开头，则调用工厂类的getObject()
// 其他情况返回原对象
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
createBeanInstance
determineConstructorsFromBeanPostProcessors
protected Constructor<?>[] determineConstructorsFromBeanPostProcessors(@Nullable Class<?> beanClass, String beanName)
throws BeansException {
if (beanClass != null && hasInstantiationAwareBeanPostProcessors()) {
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {
// 只有AutowiredAnnotationBeanPostProcessor进行了实现，其他的都返回null
SmartInstantiationAwareBeanPostProcessor ibp = (SmartInstantiationAwareBeanPostProcessor) bp;
// 确认候选的构造器
Constructor<?>[] ctors = ibp.determineCandidateConstructors(beanClass, beanName);
if (ctors != null) {
return ctors;
}
}
}
}
return null;
}
applyMergedBeanDefinitionPostProcessors
第三次主要是将标识了需要自动装配注解的属性或方法解析出来，包含的注解主要有 @Resource @Autowired @Value @Inject @PostConstruct @PreDestroy
由于第四次，用于获取早期对象时的处理的调用，在Spring的内置处理器中也没有相应的实现，跳过
这一步和第一步一样，在AOP时将会用到
protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
// 在这里可进行中止填充属性操作，实现InstantiationAwareBeanPostProcessor接口
// 并postProcessAfterInstantiation返回false,则直接返回，不会再往下执行
// Spring内中的后置处理器皆返回的true
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
return;
}
}
}
}
// 获得自动装配的类型，默认为0，
// 这里只有xml配置，ImportBeanDefinitionRegistrar,BeanFactoryPostProcessor可进行改变
// Spring整合Mybatis中，将Mapper的自动装配类型改成了BY_TYPE，
// 于是在Mapper得以在这里被填充SqlSessionTemplate,SqlSessionFactory属性
int resolvedAutowireMode = mbd.getResolvedAutowireMode();
if (resolvedAutowireMode == AUTOWIRE_BY_NAME || resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
if (resolvedAutowireMode == AUTOWIRE_BY_NAME) {
autowireByName(beanName, mbd, bw, newPvs);
}
if (resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
// 获取到依赖的bean并放到newPvs中
autowireByType(beanName, mbd, bw, newPvs);
}
// 将新的属性列表赋给旧的引用
pvs = newPvs;
}
}
protected void autowireByType(
String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) {
// 查询非简单(Java内置 基本类型，String,Date等)的属性
String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);
// 循环所有属性名
for (String propertyName : propertyNames) {
// 获取方法参数
MethodParameter methodParam = BeanUtils.getWriteMethodParameter(pd);
// 构建一个依赖描述符
DependencyDescriptor desc = new AutowireByTypeDependencyDescriptor(methodParam, eager);
// 获取依赖的bean
// resolveDependency方法中调用了doResolveDependency,该方法我们在下一步的后置处理器调用中分析
Object autowiredArgument = resolveDependency(desc, beanName, autowiredBeanNames, converter);
// 将bean放置到属性集合中
if (autowiredArgument != null) {
pvs.add(propertyName, autowiredArgument);
}
}
}
相关工具如下：
分析：
小结：
主要讲述了一些Bean的生命周期&构建流程源码剖析, 里面有许多不足，请大家指正~
参考资料和推荐阅读
1.链接: 参考资料.
545
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
