本文基于 SpringBoot5.1.8.RELEASE 版本源码解析
Spring IOC源码解析(1)
Spring拓展点及调用顺序
目录
-
-
- 1. AbstractApplicationContext.finishBeanFactoryInitialization(beanFactory)
- 2. DefaultListableBeanFactory.preInstantiateSingletons
- 3. getBean(beanName)
- 4. AbstractAutowireCapableBeanFactory.createBean
- 我们先看看创建Bean实例(重点一)
- 5. AbstractAutowireCapableBeanFactory.createBeanInstance
- 6. SimpleInstantiationStrategy.instantiate
- 我们下面看看Bean的初始化，注入属性（重点二）
- 7. AbstractAutowireCapableBeanFactory.populateBean
- 我们下面看看Bean的初始化，回调，我们自定义大部分拓展点都在此处（重点三）
- 8. AbstractAutowireCapableBeanFactory.initializeBean
- 总结
-
我们阅读源码：重点还是要关注其中的拓展点，这样是为了我们更方便的去使用框架的强大功能；其次读懂主要原理，这样给我们带来新的编码思想。对于细枝末节，不必关注太多，除非是碰到问题，或者刚好需要使用这方面功能。
1. AbstractApplicationContext.finishBeanFactoryInitialization(beanFactory)
AbstractApplicationContext.finishBeanFactoryInitialization
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
// 用来类型转换的ConversionService
if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
beanFactory.setConversionService(
beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
}
//省略代码...
// Allow for caching all bean definition metadata, not expecting further changes.
// 冻结所有bean定义，注册的bean定义不会被修改或进一步后处理，因为马上要创建 Bean 实例对象了
beanFactory.freezeConfiguration();
// Instantiate all remaining (non-lazy-init) singletons.
//实例化所有剩余的（非懒加载）的单例Bean
beanFactory.preInstantiateSingletons();
}
2. DefaultListableBeanFactory.preInstantiateSingletons
@Override
public void preInstantiateSingletons() throws BeansException {
//这就是之前加载到BeanFactory中的Bean名称
List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
//遍历所有的Bean名称
for (String beanName : beanNames) {
//获取合并的BeanDefinition。因为Bean定义存在继承关系，子类要继承父类的相关属性，所以BeanDefinition要合并父类的BeanDefinition
RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
//非抽象，单例，非懒加载
if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
//处理FactoryBean
if (isFactoryBean(beanName)) {
Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
if (bean instanceof FactoryBean) {
final FactoryBean<?> factory = (FactoryBean<?>) bean;
boolean isEagerInit;
if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
isEagerInit = AccessController.doPrivileged((PrivilegedAction<Boolean>)
((SmartFactoryBean<?>) factory)::isEagerInit,
getAccessControlContext());
}
else {
isEagerInit = (factory instanceof SmartFactoryBean &&
((SmartFactoryBean<?>) factory).isEagerInit());
}
if (isEagerInit) {
getBean(beanName);
}
}
}
else {
//普通Bean，直接getBean初始化
getBean(beanName);
}
}
}
// Trigger post-initialization callback for all applicable beans...
//Bean初始化完成，回调SmartInitializingSingleton.afterSingletonsInstantiated
for (String beanName : beanNames) {
Object singletonInstance = getSingleton(beanName);
if (singletonInstance instanceof SmartInitializingSingleton) {
final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
if (System.getSecurityManager() != null) {
AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
smartSingleton.afterSingletonsInstantiated();
return null;
}, getAccessControlContext());
}
else {
smartSingleton.afterSingletonsInstantiated();
}
}
}
}
3. getBean(beanName)
AbstractBeanFactory.getBean(beanName)
@Override
public Object getBean(String name) throws BeansException {
return doGetBean(name, null, null, false);
}
protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
@Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
//把name转换成真正的beanName
final String beanName = transformedBeanName(name);
Object bean;
// 获取Bean，如果该Bean存在于缓存中，就返回；如果不存在，返回null（这里面的缓存指的就是Spring的三级缓存，后续再说明）
Object sharedInstance = getSingleton(beanName);
if (sharedInstance != null && args == null) {
//省略代码...
bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
}
else {
//省略代码...
try {
//省略代码...
//获取当前bean依赖的所有Bean，先初始化依赖的Bean，这里的依赖是Dependon定义的依赖
String[] dependsOn = mbd.getDependsOn();
if (dependsOn != null) {
for (String dep : dependsOn) {
if (isDependent(beanName, dep)) {
throw new BeanCreationException();
}
//注册依赖Bean
registerDependentBean(dep, beanName);
try {
//递归调用，初始化
getBean(dep);
}
}
}
//如果是单例的，创建Bean实例
if (mbd.isSingleton()) {
sharedInstance = getSingleton(beanName, () -> {
try {
//创建Bean实例
return createBean(beanName, mbd, args);
}
catch (BeansException ex) {
destroySingleton(beanName);
throw ex;
}
});
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
//Prototype类型的
else if (mbd.isPrototype()) {
// It's a prototype -> create a new instance.
Object prototypeInstance = null;
try {
beforePrototypeCreation(beanName);
prototypeInstance = createBean(beanName, mbd, args);
}
finally {
afterPrototypeCreation(beanName);
}
bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
}
else {
//其他Scope类型，委托给相应的实现类来处理。SpringCloud刷新@Value值就是用了RefreshScope，有兴趣可以看一下
String scopeName = mbd.getScope();
final Scope scope = this.scopes.get(scopeName);
try {
Object scopedInstance = scope.get(beanName, () -> {
beforePrototypeCreation(beanName);
try {
return createBean(beanName, mbd, args);
}
finally {
afterPrototypeCreation(beanName);
}
});
bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
}
//省略代码...
}
}
catch (BeansException ex) {
cleanupAfterBeanCreationFailure(beanName);
throw ex;
}
}
// Check if required type matches the type of the actual bean instance.
//省略代码...
return (T) bean;
}
4. AbstractAutowireCapableBeanFactory.createBean
@Override
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
throws BeanCreationException {
//省略代码...
//解析Bean类型：class com.zeng.service.TestBeanFactory
Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
mbdToUse = new RootBeanDefinition(mbd);
mbdToUse.setBeanClass(resolvedClass);
}
//省略代码...
try {
//创建Bean
Object beanInstance = doCreateBean(beanName, mbdToUse, args);
if (logger.isTraceEnabled()) {
logger.trace("Finished creating instance of bean '" + beanName + "'");
}
return beanInstance;
}
}
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
throws BeanCreationException {
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
if (instanceWrapper == null) {
//创建Bean的实例(重点关注)
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
final Object bean = instanceWrapper.getWrappedInstance();
Class<?> beanType = instanceWrapper.getWrappedClass();
if (beanType != NullBean.class) {
mbd.resolvedTargetType = beanType;
}
synchronized (mbd.postProcessingLock) {
if (!mbd.postProcessed) {
try {
//应用后置处理器MergedBeanDefinitionPostProcessor，允许修改MergedBeanDefinition(先不关注)
applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
}
mbd.postProcessed = true;
}
}
boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
isSingletonCurrentlyInCreation(beanName));
if (earlySingletonExposure) {
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}
Object exposedObject = bean;
try {
// 初始化Bean，设置属性（重点关注）
populateBean(beanName, mbd, instanceWrapper);
// 初始化Bean，回调（重点关注，大部分的拓展点都在此处）
exposedObject = initializeBean(beanName, exposedObject, mbd);
}
//省略代码...
// Register bean as disposable.
try {
//注册销毁Bean方法（销毁Bean，1.执行DisposableBean.destory方法；2.再执行Bean的destroy-method方法）
registerDisposableBeanIfNecessary(beanName, bean, mbd);
}
return exposedObject;
}
上面代码我们重点关注两个地方：
- 是Bean的实例化 instanceWrapper = createBeanInstance(beanName, mbd, args);
- 是Bean的初始化，属性注入 populateBean(beanName, mbd, instanceWrapper);
- 是Bean的初始化，回调 initializeBean(beanName, exposedObject, mbd);拓展点执行基本都在此处
我们先看看创建Bean实例(重点一)
5. AbstractAutowireCapableBeanFactory.createBeanInstance
protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
//省略代码... （此处代码不详细分析）
//主要就是采用有参或无参构造来实例化，我们就直接分析，下面那个无参构造函数实例化
return instantiateBean(beanName, mbd);
}
protected BeanWrapper instantiateBean(final String beanName, final RootBeanDefinition mbd) {
try {
Object beanInstance;
final BeanFactory parent = this;
//实例化，我们直接看看实例化代码
if (System.getSecurityManager() != null) {
beanInstance = AccessController.doPrivileged((PrivilegedAction<Object>) () ->
getInstantiationStrategy().instantiate(mbd, beanName, parent),
getAccessControlContext());
}
else {
beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, parent);
}
//返回Bean实例包装类
BeanWrapper bw = new BeanWrapperImpl(beanInstance);
initBeanWrapper(bw);
return bw;
}
}
6. SimpleInstantiationStrategy.instantiate
public Object instantiate(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner) {
// 如果没有Override方法，直接利用反射实例化；否则利用cglib方式实例化
if (!bd.hasMethodOverrides()) {
//省略代码...
//利用构造函数，反射方式实例化
return BeanUtils.instantiateClass(constructorToUse);
}
else {
// Must generate CGLIB subclass.（最终也是反射）
return instantiateWithMethodInjection(bd, beanName, owner);
}
}
到此为止，我们完成了Bean的实例化了
我们下面看看Bean的初始化，注入属性（重点二）
7. AbstractAutowireCapableBeanFactory.populateBean
protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
//省略代码...
boolean continueWithPropertyPopulation = true;
//此处调用InstantiationAwareBeanPostProcessor.postProcessAfterInstantiation;并且通过continueWithPropertyPopulation决定是否继续设置属性（拓展点）
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
continueWithPropertyPopulation = false;
break;
}
}
}
}
if (!continueWithPropertyPopulation) {
return;
}
//获取所有的属性
PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);
if (mbd.getResolvedAutowireMode() == AUTOWIRE_BY_NAME || mbd.getResolvedAutowireMode() == AUTOWIRE_BY_TYPE) {
MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
// Add property values based on autowire by name if applicable.
//通过名称查找依赖的Bean，如果不存在，则实例化；
if (mbd.getResolvedAutowireMode() == AUTOWIRE_BY_NAME) {
autowireByName(beanName, mbd, bw, newPvs);
}
// Add property values based on autowire by type if applicable.
//通过类型装配，里面我们暂时不解析，大家可以看一眼
if (mbd.getResolvedAutowireMode() == 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里边的是调用InstantiationAwareBeanPostProcessor.postProcessProperties，postProcessPropertyValues（拓展点）
//（这个地方我们之前有讲过，@Autowired、@Value注解的属性设置，【SpringBoot源码解析:@Value怎么绑定Environment注入属性值(4)】这篇文章有详细介绍，大家可以先不展开）
if (hasInstAwareBpps) {
if (pvs == null) {
pvs = mbd.getPropertyValues();
}
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
PropertyValues pvsToUse = ibp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
if (pvsToUse == null) {
if (filteredPds == null) {
filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
}
pvsToUse = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
if (pvsToUse == null) {
return;
}
}
pvs = pvsToUse;
}
}
}
//设置Bean的其他属性,我们也不进行拓展了
if (pvs != null) {
applyPropertyValues(beanName, mbd, bw, pvs);
}
}
我们下面看看Bean的初始化，回调，我们自定义大部分拓展点都在此处（重点三）
8. AbstractAutowireCapableBeanFactory.initializeBean
protected Object initializeBean(final String beanName, final 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()) {
//执行BeanPostProcessor.postProcessBeforeInitialization(拓展点)
wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
}
try {
//1. 执行InitializingBean.afterPropertiesSet（拓展点）
//2. 执行Bean自定义的init-method方法（拓展点）
invokeInitMethods(beanName, wrappedBean, mbd);
}
catch (Throwable ex) {
throw new BeanCreationException(
(mbd != null ? mbd.getResourceDescription() : null),
beanName, "Invocation of init method failed", ex);
}
if (mbd == null || !mbd.isSynthetic()) {
//执行BeanPostProcessor.postProcessAfterInitialization(拓展点)
wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
}
return wrappedBean;
}
总结
- 我们上述把实例化Bean，初始化属性，回调方法的流程大致说明了一下。
- 我们总结一下拓展点，重点关注，下一篇介绍。Spring拓展点及调用顺序
![Java小案例——随机数猜测随机数猜测[图]](data:image/gif;base64,R0lGODlhAQABAIAAAP///wAAACwAAAAAAQABAAACAkQBADs=)