这里会进行spring的第一次扩展。也就是我们可以通过BeanFactoryPostProcess来对BeanDefinition做一些处理，如修改属性的值。其实spring已经为我们开发了几个默认实现类，我们使用就好了。比如propertyPlaceholderConfigure,propertyOverrideConfigurer,CustomEditorConfiguter. 好了，开始实例化。调用构造方法进行实例化。然后设置属性值。然后调用BeanPost前置处理方法，调用实现initializingBean接口的方法，调用显示初始化方法，调用BeanPost后置方法。
现在开始使用Bean了。。。。
使用完后调用实现disposableBean接口的方法，调用显示配置的destory方法。
下面我们进入源码。
public void refresh() {
synchronized (this.startupShutdownMonitor) {
//设置环境变量和容器的开关标志
prepareRefresh();//1
//刷新beanFactory，删除旧的beanFactory，创建新的beanFactory
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
// 准备beanfactory来使用这个上下文.做一些准备工作，例如classloader，beanPostProcessor等
prepareBeanFactory(beanFactory);
try {
//设置BeanFactory后处理器
postProcessBeanFactory(beanFactory);
//开始调用BeanFactory后处理器
invokeBeanFactoryPostProcessors(beanFactory);
//注册BeanPostProcessor,这里仅仅是注册，没有invoke
registerBeanPostProcessors(beanFactory);
initMessageSource();
initApplicationEventMulticaster();
onRefresh();
registerListeners();
//创建所有非懒加载的单例类（并invoke BeanPostProcessors）
finishBeanFactoryInitialization(beanFactory);
finishRefresh();
}catch (BeansException ex) {
}
}
}
我们进入finishBeanFactoryInitialization(beanFactory)看看。
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
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));
}
String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
for (String weaverAwareName : weaverAwareNames) {
getBean(weaverAwareName);
}
beanFactory.setTempClassLoader(null);
beanFactory.freezeConfiguration();
// Instantiate all remaining (non-lazy-init) singletons.
beanFactory.preInstantiateSingletons();
}
直接进入最重要的beanFactory.preInstantiateSingletons().
public void preInstantiateSingletons() throws BeansException {
//得到所有beanName
List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
//遍历beanName
for (String beanName : beanNames) {
RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
//工厂bean实例化
if (isFactoryBean(beanName)) {
//工厂bean 以 &开头
final FactoryBean<?> factory = (FactoryBean<?>) getBean(FACTORY_BEAN_PREFIX + beanName);
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 {
/**
*最终都会调用这个方法
*/
getBean(beanName);
}
}
}
}
getBean()方法很长，我们分为几个部分来解析。
protected <T> T doGetBean(String name, Class<T> requiredType, final Object[] args, boolean typeCheckOnly) throws BeansException {
final String beanName = this.transformedBeanName(name);
//缓存查找
Object sharedInstance = this.getSingleton(beanName);
Object bean;
if(sharedInstance != null && args == null) {
if(this.logger.isDebugEnabled()) {
if(this.isSingletonCurrentlyInCreation(beanName)) {
this.logger.debug("Returning eagerly cached instance of singleton bean '" + beanName + "' that is not fully initialized yet - a consequence of a circular reference");
} else {
this.logger.debug("Returning cached instance of singleton bean '" + beanName + "'");
}
}
bean = this.getObjectForBeanInstance(sharedInstance, name, beanName, (RootBeanDefinition)null);
}
首先通过getSingleton(beanName)方法去singleton缓存中找bean实例，应该是拿不到的，因为我们是第一次初始化，缓存中肯定不存在。所以会走到下面的部分
if(this.isPrototypeCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
BeanFactory parentBeanFactory = this.getParentBeanFactory();
if(parentBeanFactory != null && !this.containsBeanDefinition(beanName)) {
String nameToLookup = this.originalBeanName(name);
if(args != null) {
return parentBeanFactory.getBean(nameToLookup, args);
}
return parentBeanFactory.getBean(nameToLookup, requiredType);
}
这里parentBeanFactory和上面一样为null，继续往下走
if(!typeCheckOnly) {
//1 标记 加锁
this.markBeanAsCreated(beanName);
}
try {
//2
final RootBeanDefinition mbd = this.getMergedLocalBeanDefinition(beanName);
this.checkMergedBeanDefinition(mbd, beanName, args);
//3
String[] dependsOn = mbd.getDependsOn();
String[] var11;
if(dependsOn != null) {
var11 = dependsOn;
int var12 = dependsOn.length;
for(int var13 = 0; var13 < var12; ++var13) {
String dependsOnBean = var11[var13];
if(this.isDependent(beanName, dependsOnBean)) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Circular depends-on relationship between '" + beanName + "' and '" + dependsOnBean + "'");
}
this.registerDependentBean(dependsOnBean, beanName);
this.getBean(dependsOnBean);//4获取依赖bean
}
1.markBeanAsCreated(beanName)在开始为要创建的bean加标记，表示正在创建，让别的线程别创建了。该方法肯定是个同步加锁synchronized的方法。
2.然后获取到beanDefinition。ioc容器创建初期或读取配置文件，把相应的配置映射到beanDefinition,当然也包括依赖的bean。
3.获取beanDefinition依赖的bean，然后实例化//4
//单例实例化
if(mbd.isSingleton()) {
sharedInstance = this.getSingleton(beanName, new ObjectFactory<Object>() {
public Object getObject() throws BeansException {
try {
return AbstractBeanFactory.this.createBean(beanName, mbd, args);
} catch (BeansException var2) {...} } });
bean = this.getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
如果当前是单例，则会进入到createBean(beanName, mbd, args)。
protected Object createBean(String beanName, RootBeanDefinition mbd, Object[] args) throws BeanCreationException {
RootBeanDefinition mbdToUse = mbd;
//1
Class<?> resolvedClass = this.resolveBeanClass(mbd, beanName, new Class[0]);
if(resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
mbdToUse = new RootBeanDefinition(mbd);
mbdToUse.setBeanClass(resolvedClass);
}
try {//2
mbdToUse.prepareMethodOverrides();
} catch (BeanDefinitionValidationException var7) {
}
Object beanInstance;
try {//3 "短路"扩展点
beanInstance = this.resolveBeforeInstantiation(beanName, mbdToUse);
if(beanInstance != null) {
return beanInstance;
}
} catch (Throwable var8) {
}
beanInstance = this.doCreateBean(beanName, mbdToUse, args);
}
return beanInstance;
}
//1。判断bean的class是否存在，也就是该bean是可以通过class创建的 //2.准备方法重写 //3.此处在bean常规实例化之前，调下扩展点接口。此处，可能直接返回Bean。造成短路效应。
resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
Object bean = null;
if(!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
if(!mbd.isSynthetic()&&this.hasInstantiationAwareBeanPostProcessors()) {
Class<?> targetType = this.determineTargetType(beanName, mbd, new Class[0]);
if(targetType != null) {
//4 如果某个bean定义时实现了Instantiation接口，会调用到它的扩展方法
bean = this.applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
if(bean != null) {
//5上面实例化后，调用初始化扩展点的方法
bean = this.applyBeanPostProcessorsAfterInitialization(bean, beanName);
}
}
}
mbd.beforeInstantiationResolved = Boolean.valueOf(bean != null);
}
return bean;
}
如果经过4，5后，bean==null，那么进入doCreateBean(beanName, mbdToUse, args)常规创建bean.
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, Object[] args) {
BeanWrapper instanceWrapper = null;
if(instanceWrapper == null) {
//6这里调用bean的构造方法，创建bean
instanceWrapper = this.createBeanInstance(beanName, mbd, args);
}
final Object bean = instanceWrapper != null?instanceWrapper.getWrappedInstance():null;
Class<?> beanType = instanceWrapper != null?instanceWrapper.getWrappedClass():null;
Object var7 = mbd.postProcessingLock;
synchronized(mbd.postProcessingLock) {
if(!mbd.postProcessed) {
this.applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
mbd.postProcessed = true;
}
}
boolean earlySingletonExposure = mbd.isSingleton() && this.allowCircularReferences && this.isSingletonCurrentlyInCreation(beanName);
if(earlySingletonExposure) {
this.addSingletonFactory(beanName, new ObjectFactory<Object>() {
public Object getObject() throws BeansException {
return AbstractAutowireCapableBeanFactory.this.getEarlyBeanReference(beanName, mbd, bean);
}
});
}
Object exposedObject = bean;
try {
this.populateBean(beanName, mbd, instanceWrapper);
if(exposedObject != null) {
exposedObject = this.initializeBean(beanName, exposedObject, mbd);
}
} catch (Throwable var17) {
}
if(earlySingletonExposure) {
Object earlySingletonReference = this.getSingleton(beanName, false);
if(earlySingletonReference != null) {
if(exposedObject == bean) {
exposedObject = earlySingletonReference;
} else if(!this.allowRawInjectionDespiteWrapping && this.hasDependentBean(beanName)) {
String[] dependentBeans = this.getDependentBeans(beanName);
Set<String> actualDependentBeans = new LinkedHashSet(dependentBeans.length);
String[] var12 = dependentBeans;
int var13 = dependentBeans.length;
for(int var14 = 0; var14 < var13; ++var14) {
String dependentBean = var12[var14];
if(!this.removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
actualDependentBeans.add(dependentBean);
}
}
if(!actualDependentBeans.isEmpty()) {
}
}
}
}
try {
this.registerDisposableBeanIfNecessary(beanName, bean, mbd);
return exposedObject;
} catch (BeanDefinitionValidationException var16) {
}
}
//6处 最终会进入instantiateBean方法
protected BeanWrapper instantiateBean(final String beanName, final RootBeanDefinition mbd) {
try {
Object beanInstance;
if(System.getSecurityManager() != null) {
beanInstance = AccessController.doPrivileged(new PrivilegedAction<Object>() {
public Object run() {
//7调用构造方法实例化
return AbstractAutowireCapableBeanFactory.this.getInstantiationStrategy().instantiate(mbd, beanName, AbstractAutowireCapableBeanFactory.this);
}
}, this.getAccessControlContext());
} else {
beanInstance = this.getInstantiationStrategy().instantiate(mbd, beanName, this);
}
//得到bean后，对bean进行一次包装。返回
BeanWrapper bw = new BeanWrapperImpl(beanInstance);
this.initBeanWrapper(bw);
return bw;
} catch (Throwable var6) {
}
}
最后this.populateBean(beanName, mbd, instanceWrapper)，就得到了bean实例了。
testAdvisor
testTarget
&testAOP
