一个月没更博了，感觉职业生涯遇到了瓶颈，最近啃的东西比较系统大块，没办法不间断发文，想来琢磨完了一块做个总结，也不至于总走弯路。。。
Spring核心之BeanFactory 一张图看懂getBean全过程，讲的有点太具体了，作为一个爪哇小白，直接吓退，适合中高阶学习，不同的阶段看会有不同的理解和收获。
《Spring bean的生命周期，对比源码详解》 看着这篇博文扒源码表示很舒服√
1. 生命周期流程图
Spring Bean的完整生命周期从创建Spring容器开始，直到最终Spring容器销毁Bean，这其中包含了一系列关键点：
2.源码解析
2.1 spring获取bean的时候有两种方式：
BeanFactory bf = new XmlBeanFactory(new ClassPathResource("applicationContext.xml"));
Object t = bf.getBean("myBean");
ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
Object t = ac.getBean("myBean");new ClassPathResource("applicationContext.xml")这句话施加在资源文件的，主要把配置文件映射到spring的配置文件对象Resouce中。当获取到resource后我们进入加载XmlBeanFactory的逻辑，下面重点看getBean方法。
XmlBeanFactory<--DefauleListableBeannFactory<--AbstractAutowireCapbleBeanFactory<--AbstractBeanFactory
====>getBean源码：
public Object getBean(String name) throws BeansException {
return doGetBean(name, null, null, false);
}====>doGetBean源码：
protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
@Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
// 获取对应的beanname
final String beanName = transformedBeanName(name);
Object bean;
// Eagerly check singleton cache for manually registered singletons.
/**
* 检查缓存中或者实例工厂中是否有对应的bean，思考：为什么首先会使用这段代码呢？
* 因为在创建单例bean的时候会存在依赖注入的情况，而创建依赖的时候为了避免循环依赖
* spring创建bean的原则就是不等bean创建完成就将创建bean的ObjectFactory提早曝光
* 也就是将ObejectFactory加入缓存，一旦下一个bean创建的时候需要依赖上一个bean的时候直接使用objectFactory
* 此处方法尝试从缓存中获取，或者singletonFactory中获取
*/
Object sharedInstance = getSingleton(beanName);
/*--------------------------------------------直接插入getSingleton源码-------------------------------------------------*/
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) {
singletonObject = singletonFactory.getObject();
this.earlySingletonObjects.put(beanName, singletonObject);
this.singletonFactories.remove(beanName);
}
}
}
}
return singletonObject;
}
/*---------------------------------------------------------------------------------------------------------------------*/
if (sharedInstance != null && args == null) {
if (logger.isTraceEnabled()) {
if (isSingletonCurrentlyInCreation(beanName)) {
logger.trace("Returning eagerly cached instance of singleton bean '" + beanName +
"' that is not fully initialized yet - a consequence of a circular reference");
}
else {
logger.trace("Returning cached instance of singleton bean '" + beanName + "'");
}
}
// 返回对应的实例，有时候诸如存在beanFactory的情况，并不直接返回实例本身，而是返回指定方法返回的实例
bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
}
else {
// Fail if we're already creating this bean instance:
// We're assumably within a circular reference.
/**
* 只有在单例情况下才会尝试解决循环依赖。
* 原型模型下如果存在a中有b，b中有a，那么当注入依赖的时候就会产生当a还没创建完的时候，对于b的创建再次返回创建a
* 就会造成循环依赖，也就是下面的情况
*/
if (isPrototypeCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
// Check if bean definition exists in this factory.
BeanFactory parentBeanFactory = getParentBeanFactory();
// 如果beanDefinitionMap中也就是已经加载的bean类中不包括beanName，则尝试从paretnBeanFactory中获取
if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
// Not found -> check parent.
String nameToLookup = originalBeanName(name);
if (parentBeanFactory instanceof AbstractBeanFactory) {
return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
nameToLookup, requiredType, args, typeCheckOnly);
}
else if (args != null) {
// Delegation to parent with explicit args.
// 递归到parentbeanFactory中寻找
return (T) parentBeanFactory.getBean(nameToLookup, args);
}
else if (requiredType != null) {
// No args -> delegate to standard getBean method.
return parentBeanFactory.getBean(nameToLookup, requiredType);
}
else {
return (T) parentBeanFactory.getBean(nameToLookup);
}
}
// 如果不是仅仅做类型检查，而是创建bean这里要进行记录
if (!typeCheckOnly) {
markBeanAsCreated(beanName);
}
// 将存储xml配置文件的GericBeanDefinition转换为RootBeanDefinition，如果指定Beanname是子类的话会同时合并父类的相关属性
try {
final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
checkMergedBeanDefinition(mbd, beanName, args);
// Guarantee initialization of beans that the current bean depends on.
String[] dependsOn = mbd.getDependsOn();
// 若存在依赖则要递归实例化依赖的bean
if (dependsOn != null) {
for (String dep : dependsOn) {
if (isDependent(beanName, dep)) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
}
// 缓存依赖调用
registerDependentBean(dep, beanName);
try {
getBean(dep);
}
catch (NoSuchBeanDefinitionException ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"'" + beanName + "' depends on missing bean '" + dep + "'", ex);
}
}
}
// Create bean instance.
// 实例化依赖的bean后，就可以实例化mdb本身了，singleton模式的创建
if (mbd.isSingleton()) {
sharedInstance = getSingleton(beanName, () -> {
try {
return createBean(beanName, mbd, args);
}
catch (BeansException ex) {
// Explicitly remove instance from singleton cache: It might have been put there
// eagerly by the creation process, to allow for circular reference resolution.
// Also remove any beans that received a temporary reference to the bean.
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);
}
// 指定scope上的实例化
else {
String scopeName = mbd.getScope();
final Scope scope = this.scopes.get(scopeName);
if (scope == null) {
throw new IllegalStateException("No Scope registered for scope name '" + 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 (IllegalStateException ex) {
throw new BeanCreationException(beanName,
"Scope '" + scopeName + "' is not active for the current thread; consider " +
"defining a scoped proxy for this bean if you intend to refer to it from a singleton",
ex);
}
}
}
catch (BeansException ex) {
cleanupAfterBeanCreationFailure(beanName);
throw ex;
}
}
// Check if required type matches the type of the actual bean instance.
// 检查需要的类型是否符合bean的实际类型
if (requiredType != null && !requiredType.isInstance(bean)) {
try {
T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);
if (convertedBean == null) {
throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
}
return convertedBean;
}
catch (TypeMismatchException ex) {
if (logger.isTraceEnabled()) {
logger.trace("Failed to convert bean '" + name + "' to required type '" +
ClassUtils.getQualifiedName(requiredType) + "'", ex);
}
throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
}
}
return (T) bean;
}上边的逻辑比较多，我们先重点关注singleaton策略：
1.spring在生成bean的时候其实是先生成一个创建bean的工厂，一般情况（即普通类）是一个ObjectFactory的工厂类来生成bean;
2.这个factoryBean在生成之后并没有完事，还需要把factoryBean放到缓存中，以备后续其它的bean用这个bean的时候来直接调用工厂获取bean，其实工厂生成的bean也已经存到缓存中，当其他bean需要这个bean的时候直接调用工厂生成bean，如果已经生成了，工厂会直接从缓存中拿出这个bean。（很多同学想不通为什么spring要搞个工厂来生成bean，直接存bean不就好了，其实是因为spring需要解决bean质检的循环依赖才引入的，有兴趣可自行挖掘）。
通篇看一遍上面的代码，给bean赋值的只有这个方法了，我们进去看看：
bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);====》getObjectForBeanInstance源码：
protected Object getObjectForBeanInstance(
Object beanInstance, String name, String beanName, RootBeanDefinition mbd) {
// Don't let calling code try to dereference the factory if the bean isn't a factory.
//如果指定的name是工厂相关（以&为前缀）且beanInstance又不是FactoryBean类型验证不通过
if (BeanFactoryUtils.isFactoryDereference(name) && !(beanInstance instanceof FactoryBean)) {
throw new BeanIsNotAFactoryException(transformedBeanName(name), beanInstance.getClass());
}
// Now we have the bean instance, which may be a normal bean or a FactoryBean.
// If it's a FactoryBean, we use it to create a bean instance, unless the
// caller actually wants a reference to the factory.
//现在我们有个bean的实例，这个实例可能是bean或者是beanFactory的实例
//如果是FacotryBean我们使用它创建bean，但是如果用户想要获取工厂实例而不是工厂的getObject方法对应的实例那么传入的name应该加入前缀&
if (!(beanInstance instanceof FactoryBean) || BeanFactoryUtils.isFactoryDereference(name)) {
return beanInstance;
}
//加载FactoryBean
Object object = null;
if (mbd == null) {
//尝试从缓存中加载bean
object = getCachedObjectForFactoryBean(beanName);
}
if (object == null) {
// Return bean instance from factory.
//这一已经知道实例一定是beanFactory类型的
FactoryBean<?> factory = (FactoryBean<?>) beanInstance;
// Caches object obtained from FactoryBean if it is a singleton.
if (mbd == null && containsBeanDefinition(beanName)) {
//将存储xml配置的GenricBeanDefinition转换为rootbeanDefinition，如果指定beanName是子类的话同时会合并父类的相关属性
mbd = getMergedLocalBeanDefinition(beanName);
}
//是否是用户定义的不是应用程序本身定义的
boolean synthetic = (mbd != null && mbd.isSynthetic());
object = getObjectFromFactoryBean(factory, beanName, !synthetic);
}
return object;
}上面的代码我们有这么几个事情需要知道：
1.初始化一个bean我们有三种方案：（1）简单初始化，就是什么都不管，直接调用bean的空创建方法进行初始化；（2）带参初始化，就是我们需要在spring配置文件种指定参数；（3）自定义工厂方式初始化
2.针对上面的自定义工厂方式多说一些：
平常我们在spring中会自定义一个FactoryBean来控制生成的bean，前提是我们的bean需要实现FactoryBean<T>接口：
public class TestFactoryBean implements FactoryBean {
@Override
public Object getObject() throws Exception {
return null;
}
@Override
public Class<?> getObjectType() {
return null;
}
@Override
public boolean isSingleton() {
return false;
}
}然后我们在配置文件里添加bean定义的class为我们新建的factory就可以了：
<bean id="testListener" class="test.beans.TestFactoryBean"></bean>上边的如果采用自定义方式的factory类生成bean，其实我们可以通过在类名前加“&”符号的方式来获取它：
TestFactoryBean ttb = new (TestFactoryBean) getBean("&testListener");接下来我们分析第一次加载，走getObjectFromFactoryBean方法：
object = getObjectFromFactoryBean(factory, beanName, !synthetic); protected Object getObjectFromFactoryBean(FactoryBean factory, String beanName, boolean shouldPostProcess) {
if (factory.isSingleton() && containsSingleton(beanName)) {
synchronized (getSingletonMutex()) {
Object object = this.factoryBeanObjectCache.get(beanName);
if (object == null) {
object = doGetObjectFromFactoryBean(factory, beanName, shouldPostProcess);
this.factoryBeanObjectCache.put(beanName, (object != null ? object : NULL_OBJECT));
}
return (object != NULL_OBJECT ? object : null);
}
}
else {
return doGetObjectFromFactoryBean(factory, beanName, shouldPostProcess);
}
}从上面的方法中所有的bean复制都指向了doGetObjectFromFactoryBean这个方法，接着跟进：
private Object doGetObjectFromFactoryBean(
final FactoryBean factory, final String beanName, final boolean shouldPostProcess)
throws BeanCreationException {
Object object;
try {
//需要权限验证
if (System.getSecurityManager() != null) {
AccessControlContext acc = getAccessControlContext();
try {
object = AccessController.doPrivileged(new PrivilegedExceptionAction<Object>() {
public Object run() throws Exception {
return factory.getObject();
}
}, acc);
}
catch (PrivilegedActionException pae) {
throw pae.getException();
}
}
else {
//直接调动getObject方法
object = factory.getObject();
}
}
catch (FactoryBeanNotInitializedException ex) {
throw new BeanCurrentlyInCreationException(beanName, ex.toString());
}
catch (Throwable ex) {
throw new BeanCreationException(beanName, "FactoryBean threw exception on object creation", ex);
}
// Do not accept a null value for a FactoryBean that's not fully
// initialized yet: Many FactoryBeans just return null then.
if (object == null && isSingletonCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(
beanName, "FactoryBean which is currently in creation returned null from getObject");
}
if (object != null && shouldPostProcess) {
try {
//调用objectFactory的后处理器
object = postProcessObjectFromFactoryBean(object, beanName);
}
catch (Throwable ex) {
throw new BeanCreationException(beanName, "Post-processing of the FactoryBean's object failed", ex);
}
}
return object;
}上面的方法里我们看到最核心的一句话：
//直接调动getObject方法
object = factory.getObject();看到这里我们才知道，原来获取bean获取到最后，还是需要从我们开始定义的FactoryBean中才能找到答案，就和我们刚开始解释的一样，spring所有的bean生成都委托给FactoryBean类，这也是为什么上边要说明一下自定义生成bean的方式了。
接下来看看factoryBean中到底搞了什么事情，依次反查这个方法的调用，找到factoryBean最开始设置的地方，看这里：
//实例化依赖的bean后就可以实例化mdb本身了
//singleton模式的创建
if (mbd.isSingleton()) {
sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {
public Object getObject() throws BeansException {
try {
return createBean(beanName, mbd, args);
}
catch (BeansException ex) {
// Explicitly remove instance from singleton cache: It might have been put there
// eagerly by the creation process, to allow for circular reference resolution.
// Also remove any beans that received a temporary reference to the bean.
destroySingleton(beanName);
throw ex;
}
}
});
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}定位到createBean方法：
@Override
protected Object createBean(final String beanName, final RootBeanDefinition mbd, final Object[] args)
throws BeanCreationException {
if (logger.isDebugEnabled()) {
logger.debug("Creating instance of bean '" + beanName + "'");
}
// Make sure bean class is actually resolved at this point.
//锁定class，根据设置的class属性或者根据classname来解析class
resolveBeanClass(mbd, beanName);
// Prepare method overrides.
//验证及准备覆盖的方法
try {
mbd.prepareMethodOverrides();
}
catch (BeanDefinitionValidationException ex) {
throw new BeanDefinitionStoreException(mbd.getResourceDescription(),
beanName, "Validation of method overrides failed", ex);
}
try {
//给BeanPostProcessors一个机会来返回一个代理类类来替换真正的实例
Object bean = resolveBeforeInstantiation(beanName, mbd);
if (bean != null) {
return bean;
}
}
catch (Throwable ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"BeanPostProcessor before instantiation of bean failed", ex);
}
Object beanInstance = doCreateBean(beanName, mbd, args);
if (logger.isDebugEnabled()) {
logger.debug("Finished creating instance of bean '" + beanName + "'");
}
return beanInstance;
}上面的方法中有个很重要的地方必须要说一下，resolveBeforeInstantiation：
try {
//给BeanPostProcessors一个机会来返回一个代理类类来替换真正的实例
Object bean = resolveBeforeInstantiation(beanName, mbd);
if (bean != null) {
return bean;
}
}在这个函数下面调用doCreateBean之前，调用了个resolveBeforeInstantiation方法，还返回了个bean，并且这个bean不为空的话直接返回，后面的逻辑都不走了，大家可以想想原因。这就是著名的AOP实现的地方，这里是非常重要的代码，resolveBeforeInstantiation中通过AOP制定的代理类生成一个新的bean，这里监控到bean被改变了就直接返回新的代理类了。
接着走发现了doCreateBean这个方法：
其实Spring的代码核心的都是doxxxxxx（），其他的都是组织代码结构的。进去看看。
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args) {
// Instantiate the bean.
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
if (instanceWrapper == null) {
//根据指定bean使用对应的策略创建新的实例，如：工厂方法，构造函数自动注入，简单初始化
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null);
Class beanType = (instanceWrapper != null ? instanceWrapper.getWrappedClass() : null);
// Allow post-processors to modify the merged bean definition.
synchronized (mbd.postProcessingLock) {
if (!mbd.postProcessed) {
//利用MergedBeanDefinitionPostProcessors
applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
mbd.postProcessed = true;
}
}
// Eagerly cache singletons to be able to resolve circular references
// even when triggered by lifecycle interfaces like BeanFactoryAware.
//是否需要提早曝光：单例&允许循环依赖&当前bean正在创建，检测循环依赖
boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
isSingletonCurrentlyInCreation(beanName));
if (earlySingletonExposure) {
if (logger.isDebugEnabled()) {
logger.debug("Eagerly caching bean '" + beanName +
"' to allow for resolving potential circular references");
}
//为避免后期循环依赖，可以在bean初始化完成前将创建实例的ObjectFactory加入工厂
addSingletonFactory(beanName, new ObjectFactory() {
public Object getObject() throws BeansException {
//对bean再一次依赖引用，主要应用SmartInstatiantionAware BeanPostProccessor
//其中我们熟悉的AOP就是在这里将advice动态织入的，若没有则直接返回bean不做任何处理
return getEarlyBeanReference(beanName, mbd, bean);
}
});
}
// Initialize the bean instance.
Object exposedObject = bean;
try {
//对bean进行填充，将各个属性值注入，其中，可能存在依赖于其他bean的属性，则会递归初始依赖bean
populateBean(beanName, mbd, instanceWrapper);
if (exposedObject != null) {
//调用初始化方法，比如init-method
exposedObject = initializeBean(beanName, exposedObject, mbd);
}
}
catch (Throwable ex) {
if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
throw (BeanCreationException) ex;
}
else {
throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
}
}
if (earlySingletonExposure) {
Object earlySingletonReference = getSingleton(beanName, false);
//earlySingletonReference 只有检测到有循环依赖的情况下才会不为空
if (earlySingletonReference != null) {
//如果exposedObject没有被改变也就是没有被增强
if (exposedObject == bean) {
exposedObject = earlySingletonReference;
}
else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
String[] dependentBeans = getDependentBeans(beanName);
Set<String> actualDependentBeans = new LinkedHashSet<String>(dependentBeans.length);
for (String dependentBean : dependentBeans) {
//检测依赖
if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
actualDependentBeans.add(dependentBean);
}
}
/**
* 因为bean创建后，其依赖的bean一定是已经创建的
* actualDependentBeans不为空标识当前bean创建后其依赖的bean却没有创建完成。也就是说存在循环依赖
*/
if (!actualDependentBeans.isEmpty()) {
throw new BeanCurrentlyInCreationException(beanName,
"Bean with name '" + beanName + "' has been injected into other beans [" +
StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +
"] in its raw version as part of a circular reference, but has eventually been " +
"wrapped. This means that said other beans do not use the final version of the " +
"bean. This is often the result of over-eager type matching - consider using " +
"'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");
}
}
}
}
// Register bean as disposable.
try {
//根据scope注册bean
registerDisposableBeanIfNecessary(beanName, bean, mbd);
}
catch (BeanDefinitionValidationException ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
}
return exposedObject;
}需要知道：
1.spring在加载完配置文件后会把这个bean的定义放到叫做RootBeanDefinition的类中保存起来，之后方法调用传参也是用这个类，包括属性的保存等等；
2.然后通过RootBeanDefinition生成了一个beanWrapper的类，这个类中包含了我们的bean和bean的属性不描述信息；
3.而我们需要的其实只是beanWrapper中的bean。
这次思路比较清晰，先生成一个beanWrapper，然后获取其中的bean就好了：
if (instanceWrapper == null) {
//根据指定bean使用对应的策略创建新的实例，如：工厂方法，构造函数自动注入，简单初始化
instanceWrapper = createBeanInstance(beanName, mbd, args);
}protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, Object[] args) {
// Make sure bean class is actually resolved at this point.
//解析class
Class beanClass = resolveBeanClass(mbd, beanName);
if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Bean class isn't public, and non-public access not allowed: " + beanClass.getName());
}
//如果工厂方法不为空则使用工厂方法初始化策略
if (mbd.getFactoryMethodName() != null) {
return instantiateUsingFactoryMethod(beanName, mbd, args);
}
// Shortcut when re-creating the same bean...
boolean resolved = false;
boolean autowireNecessary = false;
if (args == null) {
synchronized (mbd.constructorArgumentLock) {
//一个类有多少构造函数 每个构造函数都有不同的参数，所以调用前要根据参数锁定构造函数或对应的工厂方法
if (mbd.resolvedConstructorOrFactoryMethod != null) {
resolved = true;
autowireNecessary = mbd.constructorArgumentsResolved;
}
}
}
//如果已经解析过则使用解析好的构造方法不需要再次锁定
if (resolved) {
//构造函数自动注入
if (autowireNecessary) {
return autowireConstructor(beanName, mbd, null, null);
}
else {
//使用默认的构造函数
return instantiateBean(beanName, mbd);
}
}
// Need to determine the constructor...
//需要根据参数解析构造函数
Constructor[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
if (ctors != null ||
mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR ||
mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
//构造函数自动注入
return autowireConstructor(beanName, mbd, ctors, args);
}
// No special handling: simply use no-arg constructor.
//使用默认的构造函数
return instantiateBean(beanName, mbd);
}上面的代码看看结构，大概分为三个逻辑：
1.有工厂方法的用工厂方法初始化（同学们不要看错了，这里是工厂方法，不是工厂类，spring中可以通过factory-method标签指定生成当前类的方法）；
2.有参数的用参数初始化（这里有个构造方法缓存的问题，我们不讨论）
3.没有参数的调用默认的构造函数初始化。
接着跟进只看默认构造函数：
//使用默认的构造函数
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(new PrivilegedAction<Object>() {
public Object run() {
return getInstantiationStrategy().instantiate(mbd, beanName, parent);
}
}, getAccessControlContext());
}
else {
beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, parent);
}
BeanWrapper bw = new BeanWrapperImpl(beanInstance);
initBeanWrapper(bw);
return bw;
}
catch (Throwable ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Instantiation of bean failed", ex);
}
}看到这句话，接着跟进：
beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, parent);public Object instantiate(RootBeanDefinition beanDefinition, String beanName, BeanFactory owner) {
// Don't override the class with CGLIB if no overrides.
if (beanDefinition.getMethodOverrides().isEmpty()) {
Constructor<?> constructorToUse;
synchronized (beanDefinition.constructorArgumentLock) {
constructorToUse = (Constructor<?>) beanDefinition.resolvedConstructorOrFactoryMethod;
if (constructorToUse == null) {
final Class clazz = beanDefinition.getBeanClass();
if (clazz.isInterface()) {
throw new BeanInstantiationException(clazz, "Specified class is an interface");
}
try {
if (System.getSecurityManager() != null) {
constructorToUse = AccessController.doPrivileged(new PrivilegedExceptionAction<Constructor>() {
public Constructor run() throws Exception {
return clazz.getDeclaredConstructor((Class[]) null);
}
});
}
else {
constructorToUse = clazz.getDeclaredConstructor((Class[]) null);
}
beanDefinition.resolvedConstructorOrFactoryMethod = constructorToUse;
}
catch (Exception ex) {
throw new BeanInstantiationException(clazz, "No default constructor found", ex);
}
}
}
return BeanUtils.instantiateClass(constructorToUse);
}
else {
// Must generate CGLIB subclass.
return instantiateWithMethodInjection(beanDefinition, beanName, owner);
}
}