spring启动主要看AbstractBeanFactory.refresh方法
public void refresh() throws BeansException, IllegalStateException {
....
try {
// 一个模板方法 允许子类实现beanfactory后置处理
postProcessBeanFactory(beanFactory);
// 调用beanfactory处理器
invokeBeanFactoryPostProcessors(beanFactory);
// 注册bean的后置处理器beanpostprocessor
registerBeanPostProcessors(beanFactory);
//初始化消息源
initMessageSource();
// 初始化应用实际事件发布的委托
initApplicationEventMulticaster();
// 一个模板方法 子类实现 可定义特定的刷新方法
onRefresh();
// 查询监听器 并注册
registerListeners();
// 实例化所有非懒加载单利bean.
finishBeanFactoryInitialization(beanFactory);
//发布相应的事件
finishRefresh();
}
...
}
创建Bean对象是在finishBeanFactoryInitialization方法中
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
//此处代码做一些初始化准备工作
...
// 缓存beanDefinitionName
beanFactory.freezeConfiguration();
//实例化所有非懒加载单例对象
beanFactory.preInstantiateSingletons();
}
接下来看真正的创建方法
public void preInstantiateSingletons() throws BeansException {
//获取所有的已注册的beanNames
List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
// 初始化所有非懒加载bean
for (String beanName : beanNames) {
//获取bean定义信息
RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
//如果不是抽象对象并且是单例并且非懒加载则进入方法
if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
//判断是否是FactoryBean对象
if (isFactoryBean(beanName)) {
...
}
else {
//创建bean对象
getBean(beanName);
}
}
}
}
首先获取所有已注册的bean的名字，然后遍历所有beanName，获取到bean定义信息之后(beanDefinition保存了bean的基本信息包括是否单例，是否懒加载等)，判断该对象是否是正常的bean对象，然后走接下来看AbstractBeanFatory.getBean方法，里面调用了一个doGetBean方法，众所周知spring里面do开头才是干活儿的。。。
public Object getBean(String name) throws BeansException {
return doGetBean(name, null, null, false);
}
这里有两个类A和B相互依赖，首先创建A对象 接下来看AbstractBeanFatory.doGetBean方法，先看大体流程，后面逐个分析
protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
@Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
final String beanName = transformedBeanName(name);
Object bean;
// 分别从一级缓存 二级缓存 三级缓存中查询是否存在
Object sharedInstance = getSingleton(beanName);
if (sharedInstance != null && args == null) {
...
//
bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
}
else {
//如果处于原型模式并且正在被创建则抛出异常
if (isPrototypeCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
//获取工厂
BeanFactory parentBeanFactory = getParentBeanFactory();
//如果不存在bean定义信息，则尝试通过factory获取
if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
...
}
}
//如果不是类型检查
if (!typeCheckOnly) {
//将bean标记为以创建或即将创建
markBeanAsCreated(beanName);
}
try {
//获取bean定义信息
final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
//检查bean信息
checkMergedBeanDefinition(mbd, beanName, args);
//获取bean所依赖的depends-on信息
String[] dependsOn = mbd.getDependsOn();
if (dependsOn != null) {
//dependon的作用是加上注解的bean要后于注解指定的bean创建
for (String dep : dependsOn) {
//判断是否互相depends-on
if (isDependent(beanName, dep)) {
...
}
registerDependentBean(dep, beanName);
try {
getBean(dep);
}
catch (NoSuchBeanDefinitionException ex) {
...
}
}
}
// 是否是单例模式
if (mbd.isSingleton()) {
//调用getSingleton方法，传入的参数是beanName以及一个Lambda表达式
sharedInstance = getSingleton(beanName, () -> {
try {
//创建bean
return createBean(beanName, mbd, args);
}
catch (BeansException ex) {
...
}
});
//实例化bean
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
//原型（多例）创建
else if (mbd.isPrototype()) {
...
}
//其他模式创建
else {
...
}
}
catch (BeansException ex) {
cleanupAfterBeanCreationFailure(beanName);
throw ex;
}
}
// 检查所需类型是否与bean类型匹配
if (requiredType != null && !requiredType.isInstance(bean)) {
...
}
return (T) bean;
}
首先看DefaultSingletonBeanRegistry.getSingleton方法 1.singletonObjects：一级缓存，存放了完整的bean 2.earlySingletonObjects：二级缓存，存放了尚未完成的bean，只执行了部分postprocessor 3.singletonFactories:三级缓存，存放了一个ObjectFactory生成bean
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
//从一级缓存中获取对象
Object singletonObject = this.singletonObjects.get(beanName);
//单例并且不在被创建
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) {
//调用三级缓存getObject方法，这边是一个lambda表达式，待会儿分析
singletonObject = singletonFactory.getObject();
//将对象放入二级缓存
this.earlySingletonObjects.put(beanName, singletonObject);
//清理三级缓存
this.singletonFactories.remove(beanName);
}
}
}
}
return singletonObject;
}
接下来看第二个重要方法DefaultSingletonBeanRegistry.getSingleton方法,此处我省略了一些日志以及异常
public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
synchronized (this.singletonObjects) {
//一级缓存中获取对象
Object singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
if (this.singletonsCurrentlyInDestruction) {
...
}
...
//创建对象前检查
beforeSingletonCreation(beanName);
boolean newSingleton = false;
boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
if (recordSuppressedExceptions) {
this.suppressedExceptions = new LinkedHashSet<>();
}
try {
//走刚刚传入的lambda表达式
singletonObject = singletonFactory.getObject();
newSingleton = true;
}
catch (IllegalStateException ex) {
singletonObject = this.singletonObjects.get(beanName);
...
}
catch (BeanCreationException ex) {
...
}
finally {
if (recordSuppressedExceptions) {
this.suppressedExceptions = null;
}
//创建bean之后检查
afterSingletonCreation(beanName);
}
if (newSingleton) {
//加入一级缓存
addSingleton(beanName, singletonObject);
}
}
return singletonObject;
}
}
接下来看getObject方法
sharedInstance = getSingleton(beanName, () -> {
try {
//创建bean
return createBean(beanName, mbd, args);
}
catch (BeansException ex) {
...
}
});
调用了AbstractAutowireCapableBeanFactory.createBean方法
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
throws BeanCreationException {
...
RootBeanDefinition mbdToUse = mbd;
...
//根据设置的class或者className决定bean指定的类
Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
mbdToUse = new RootBeanDefinition(mbd);
mbdToUse.setBeanClass(resolvedClass);
}
//准备并验证重写方法 spring是没有overrides的但是有
//lookup-method以及replace-method需要解析
try {
mbdToUse.prepareMethodOverrides();
}
catch (BeanDefinitionValidationException ex) {
...
}
try {
//返回代理对象代替真正的实例，这是在实例化之前操作的
Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
if (bean != null) {
return bean;
}
}
catch (Throwable ex) {
...
}
try {
//真正做事的创建bean
Object beanInstance = doCreateBean(beanName, mbdToUse, args);
return beanInstance;
}
catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
...
}
catch (Throwable ex) {
...
}
}
看其中的两个方法第一个方法AbstractAutowireCapableBeanFactory.resolveBeforeInstantiation方法，在生成对象前可生成代理对象返回，如下：
protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
Object bean = null;
if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
// 判断这个类是外部定义的，并且拥有实例化后置处理器
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
//获取目标对象
Class<?> targetType = determineTargetType(beanName, mbd);
if (targetType != null) {
//走实例化后置处理器
bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
if (bean != null) {
//走初始化后置处理器
bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
}
}
}
//标记是否已解析
mbd.beforeInstantiationResolved = (bean != null);
}
return bean;
}
看一下实例化后置处理器处理逻辑AbstractAutowireCapableBeanFactory.applyBeanPostProcessorsBeforeInstantiation方法：
protected Object applyBeanPostProcessorsBeforeInstantiation(Class<?> beanClass, String beanName) {
//遍历对象所有后置处理器
for (BeanPostProcessor bp : getBeanPostProcessors()) {
//如果是此类的子类则进入
if (bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
//执行后置处理器实现的实例化之前处理方法
Object result = ibp.postProcessBeforeInstantiation(beanClass, beanName);
if (result != null) {
return result;
}
}
}
return null;
}
初始化后置处理器AbstractAutowireCapableBeanFactory.applyBeanPostProcessorsAfterInitialization方法，逻辑基本与之前的实例化后置处理器方法相同这边就不看了。 如果没有特别的操作接下来就走正常的doCreateBean方法。首先看大体流程：
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) {
//实例化对象
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
final Object bean = instanceWrapper.getWrappedInstance();
Class<?> beanType = instanceWrapper.getWrappedClass();
if (beanType != NullBean.class) {
mbd.resolvedTargetType = beanType;
}
// 允许后置处理器修改合并bean定义，这边主要解析了@autowired等注解
synchronized (mbd.postProcessingLock) {
if (!mbd.postProcessed) {
try {
applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
}
catch (Throwable ex) {
...
}
mbd.postProcessed = true;
}
}
//判断是否单例 是否允许循环依赖 是否是正在创建中的对象，如果是就标记提前暴露也就是放入三级缓存
boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
isSingletonCurrentlyInCreation(beanName));
if (earlySingletonExposure) {
...
//将自己放入三级缓存，此处存入的是beanName对应的ObjectFactory对象
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}
Object exposedObject = bean;
try {
//赋值属性
populateBean(beanName, mbd, instanceWrapper);
//初始化对象
exposedObject = initializeBean(beanName, exposedObject, mbd);
}
catch (Throwable ex) {
...
}
if (earlySingletonExposure) {
//尝试从二级缓存获取自己
Object earlySingletonReference = getSingleton(beanName, false);
if (earlySingletonReference != null) {
if (exposedObject == bean) {
//二级缓存代替自己
exposedObject = earlySingletonReference;
}
else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
String[] dependentBeans = getDependentBeans(beanName);
Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
for (String dependentBean : dependentBeans) {
if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
actualDependentBeans.add(dependentBean);
}
}
if (!actualDependentBeans.isEmpty()) {
...
}
}
}
}
// 如果需要的话在工厂可丢弃bean列表注册
try {
registerDisposableBeanIfNecessary(beanName, bean, mbd);
}
catch (BeanDefinitionValidationException ex) {
...
}
return exposedObject;
}
主要看几个重点方法首先看AbstractAutowireCapableBeanFactory.applyMergedBeanDefinitionPostProcessors方法的作用：
protected void applyMergedBeanDefinitionPostProcessors(RootBeanDefinition mbd, Class<?> beanType, String beanName) {
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof MergedBeanDefinitionPostProcessor) {
MergedBeanDefinitionPostProcessor bdp = (MergedBeanDefinitionPostProcessor) bp;
bdp.postProcessMergedBeanDefinition(mbd, beanType, beanName);
}
}
}
可以看到是获取所有的后置处理器，然后找到MergedBeanDefinitionPostProcessor的子类，然后再执行子类的方法
处理细节以后在分析。
接下来看populateBean方法，这个方法是注入属性的方法，配置文件以及autowired都是在这处理的
protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
...
boolean continueWithPropertyPopulation = true;
//执行实例化后置处理器
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
for (BeanPostProcessor bp : getBeanPostProcessors()) {
...
}
}
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);
// 按照名字赋值
if (mbd.getResolvedAutowireMode() == AUTOWIRE_BY_NAME) {
autowireByName(beanName, mbd, bw, newPvs);
}
// 按照类型赋值
if (mbd.getResolvedAutowireMode() == AUTOWIRE_BY_TYPE) {
autowireByType(beanName, mbd, bw, newPvs);
}
pvs = newPvs;
}
//是否拥有实例化后置处理器
boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
//是否需要依赖检查
boolean needsDepCheck = (mbd.getDependencyCheck() != AbstractBeanDefinition.DEPENDENCY_CHECK_NONE);
if (hasInstAwareBpps || needsDepCheck) {
if (pvs == null) {
pvs = mbd.getPropertyValues();
}
//获取过滤后的属性描述信息
PropertyDescriptor[] filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
if (hasInstAwareBpps) {
//遍历后置处理器
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
//走实例化后置处理器的postProcessPropertyValues方法
pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
if (pvs == null) {
return;
}
}
}
}
if (needsDepCheck) {
//依赖检查
checkDependencies(beanName, mbd, filteredPds, pvs);
}
}
if (pvs != null) {
//xml配置的属性赋值
applyPropertyValues(beanName, mbd, bw, pvs);
}
}
AutowiredAnnotationBeanPostProcessor.postProcessPropertyValues就是autowired赋值属性的方法
public PropertyValues postProcessPropertyValues(
PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeanCreationException {
//注入的元数据
InjectionMetadata metadata = findAutowiringMetadata(beanName, bean.getClass(), pvs);
try {
//注入属性
metadata.inject(bean, beanName, pvs);
}
catch (Exception ex) {
..
}
return pvs;
}
过程比较长，主要看AutowiredAnnotationBeanPostProcessor.inject方法,红框标注的地方就是解决依赖的方法
进入该方法，就可以看到熟悉的do开头的方法，也就是真正开始做事的方法了
中途有很多判断和准备工作，过程有点长，这边不做展示，有兴趣的小伙伴可以自行去看看，进入该方法之后直接关注如下方法
这个方法就是创建依赖对象的方法，其中这个desriptor是一个DependencyDescriptor对象，进入该对象的resolveCondidate方法，就可以看到一个熟悉的方法了：
一个getBean方法，所以又开始走创建B对象的流程了。
这边直接跳过B对象的创建，看B对象依赖注入A对象时，A与第一次创建的区别
首先在最开始getSingleton获取对象时，在三级缓存中可查询到A存入的ObjectFactory对象，然后这个对象会调用自身的getObject()方法，这个方法就是之前传入的lambda表达式方法。
接下来分析一下AbstractAutowireCapableBeanFactory.getEarlyBeanReference方法，很熟悉的操作
protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {
Object exposedObject = bean;
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
//遍历所有后置处理器
for (BeanPostProcessor bp : getBeanPostProcessors()) {
//查找SmartInstantiationAwareBeanPostProcessor的子类
if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {
SmartInstantiationAwareBeanPostProcessor ibp = (SmartInstantiationAwareBeanPostProcessor) bp;
//执行子类的方法
exposedObject = ibp.getEarlyBeanReference(exposedObject, beanName);
}
}
}
return exposedObject;
}
可以看一下SmartInstantiationAwareBeanPostProcessor的子类，包含了Aop处理类
所以在循环依赖时，当对象从三级缓存拿出来创建时会完成aop的操作以及一些其他后置处理器的操作
主要分析AbstractAutoProxyCreator的getEarlyBeanReference方法，在调用之前会先标记对象为早期代理引用，也就是提醒该对象已经进行过增强了
PS:补充如下方法是AbstractAutoProxyCreator初始化后置处理做的事情会先判断是否因为循环依赖进行过aop增强
getEarlyBeanReference调用了wrapIfNecessary方法
protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
...一些判断
//合并所有需要拦截增强的并整理
Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
if (specificInterceptors != DO_NOT_PROXY) {
//表示需要生成代理对象
this.advisedBeans.put(cacheKey, Boolean.TRUE);
//创建代理对象
Object proxy = createProxy(
bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
this.proxyTypes.put(cacheKey, proxy.getClass());
return proxy;
}
//表示不需要生成代理对象
this.advisedBeans.put(cacheKey, Boolean.FALSE);
return bean;
}
生成代理对象以及如何合并增强的这次先不做分析，在完成getObject之后会回到刚刚的getSingleton方法，然后将对象放入二级缓存 同时删除三级缓存
然后返回创建完成的对象，这时B对象就是一个完整的Bean对象了，B创建完成后会将自己放入一级缓存然后清空二级三级缓存
然后回到A对象的创建，这时候属性赋值已经结束，开始初始化Bean对象，这边可以看到首先是要判断执行各种aware方法，之后在执行初始化前置处理，之后是invokeInitMethod
其中之后是invokeInitMethod方法如下，可以看到先执行afterPropertiesSet，然后执行init-method方法，ps：@PostConstruct注解方法优于这两个方法
执行完后置处理器之后就会到二级或三级缓存获取到之前存入的对象。
最后将对象放入一级缓存清空二级三级缓存。
以下是个人的一个疑问以及解释 为什么循环依赖的时候先生成代理对象，之后在赋值属性 答：代理对象引用了原来的对象，所以先创建代理对象然后再给原对象赋值，代理对象也会同步更新。
