在applicationContext加载的时候，已经将BeanDefition保存在一个concurrentHashMap中，然而这些并不是真正的bean,真正的bean其实还没有初始化以及依赖注入。对于整个依赖注入的过程，大致可以分为两个阶段，
第一阶段是Bean的初始化，如何采用设值注入的方式，那么这个阶段就是利用默认构造器去构造一个空对象，等待着注入；如果是构造注入，那么这个过程可能就会触发依赖注入，并递归地初始化依赖对象；
第二个阶段是注入阶段。
下面看看这个初始化阶段触发了哪些关键的方法：
Ioc容器的依赖注入发生的时机是不一样的。对于Singleton的bean，是在refresh()的末尾阶段进行了初始化和注入。对于其他scope的bean,他们的初始化发生在第一次getBean的时候。然后不管是何时发生这些动作，初始化的动作都有getBean方法发起。
1 Singleton的初始化开始
在refresh()方法快要结束的地方，调用了这样一个方法finishbeanfactoryInitialization
// Instantiate all remaining (non-lazy-init) singletons. finishbeanfactoryInitialization(beanfactory);
从它的注释就可以看到，这里是用来装载所有非延迟加载的单例（可以设置Bean的属性 lazy-init=true）对象。从这里开始了singleton对象的加载与注入。从这也可以看出，所有非延迟加载的singleton对象在applicationContext初始化完成的时候，就已经加载完毕。这个方法向下调用了DefaultListablebeanfactory中定义的preInstantiateSingletons方法。这个方法是用来初始化singleton对象的。 这个方法其实很简单，遍历所有定义为singgleton的对象，然后调用getBean方法，完成初始化。然后调用定义的后处理方法，完成初始化。
public void preInstantiateSingletons() throws BeansException {
if (this.logger.isDebugEnabled()) {
this.logger.debug("Pre-instantiating singletons in " + this);
}
// Iterate over a copy to allow for init methods which in turn register new bean definitions.
// While this may not be part of the regular factory bootstrap,it does otherwise work fine.
List<String> beanNames = new ArrayList<String>(this.beanDefinitionNames);
// 遍历所有的singleton对象 实际调用getBean方法
for (String beanName : beanNames) {
RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
if (isfactorybean(beanName)) {
final factorybean<?> factory = (factorybean<?>) getBean(FACTORY_BEAN_PREFIX + beanName);
boolean isEagerInit;
if (System.getSecurityManager() != null && factory instanceof Smartfactorybean) {
isEagerInit = AccessController.doPrivileged(new PrivilegedAction<Boolean>() {
@Override
public Boolean run() {
return ((Smartfactorybean<?>) factory).isEagerInit();
}
},getAccessControlContext());
}
else {
isEagerInit = (factory instanceof Smartfactorybean &&
((Smartfactorybean<?>) factory).isEagerInit());
}
if (isEagerInit) {
getBean(beanName);
}
}
else {
getBean(beanName);
}
}
}
// 注册后处理方法...
for (String beanName : beanNames) {
Object singletonInstance = getSingleton(beanName);
if (singletonInstance instanceof SmartInitializingSingleton) {
final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
if (System.getSecurityManager() != null) {
AccessController.doPrivileged(new PrivilegedAction<Object>() {
@Override
public Object run() {
smartSingleton.afterSingletonsInstantiated();
return null;
}
},getAccessControlContext());
}
else {
smartSingleton.afterSingletonsInstantiated();
}
}
}
}
2 getBean()方法
从前面已经看到，即使是随applicationContext初始化过程启动的singleton对象，它也利用getBean方法进行着初始化。可见所有Bean的生命周期都是由这里开始的。
getBean方法很简单，它向下调用了AbstractBeanFactroy类中定义的doGetBean方法。
3doGetBean方法
doGetBean方法有点类似于前面章节提到了refresh方法，它是整个依赖注入过程的入口，其实也定义了整个依赖注入过程都发生了哪些动作。
protected Object doCreateBean(final String beanName,final RootBeanDefinition mbd,final Object[] args) {
// 实际创建的Bean的包装容器
BeanWrapper instanceWrapper = null;
//对于单例模式下的Bean，可能在创建过程中断过，暂时放在缓存里
if (mbd.isSingleton()) {
//从缓存中恢复未创建完成的Bean对象
instanceWrapper = this.factorybeanInstanceCache.remove(beanName);
}
if (instanceWrapper == null) {
//真正创建对象的入口
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.
//Bean创建后处理
synchronized (mbd.postProcessingLock) {
if (!mbd.postProcessed) {
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.
// 解决循环引用的地方，当singleton遇到循环引用时，会放入singletonsCurrentlyInCreation中，暂停
// 在此处从singletonsCurrentlyInCreation中再拿到这个未完成初始化的对象
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");
}
addSingletonFactory(beanName,new ObjectFactory<Object>() {
@Override
public Object getObject() throws BeansException {
return getEarlyBeanReference(beanName,bean);
}
});
}
// 下面依赖注入
Object exposedObject = bean;
try {
//依赖注入的方法入口
populateBean(beanName,instanceWrapper);
if (exposedObject != null) {
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);
}
}
// 处理未完成注入的循环引用的bean
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<String>(dependentBeans.length);
for (String dependentBean : dependentBeans) {
if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
actualDependentBeans.add(dependentBean);
}
}
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 {
registerDisposableBeanIfNecessary(beanName,bean,mbd);
}
catch (BeanDefinitionValidationException ex) {
throw new BeanCreationException(mbd.getResourceDescription(),"Invalid destruction signature",ex);
}
return exposedObject;
}
4 createBeanInstance 创建Bean的入口
在上面的“纲领性”的代码块中，可以看到创建Bean实例的入口是createBeanInstance。在这里完成了对所有的Bean的实例化工作。它的整个过程如下：
这个过程主要完成了对一些用于实例化Bean的方法的调用。它主要分为四种情况
（1） 如果指定了工厂方法，向下调用instantiateUsingFactoryMethod方法实例化
（2）如果存在缓存过的构造器或者工厂方法，就使用这个缓存的方法进行实例化。在这个过程中，我们经常能看resolvedXXX，例如在源代码里有resolvedConstructorOrFactoryMethod，这是在RootBeanDefinition类中定义的一个属性，类似的属性还有很多。它是一种缓存机制，缓存了实例化的时候需要调用哪个构造方法或者工厂方法。这是非常有用的，对于一个类如果采用了构造注入或者自动装配的方式，在初始化的时候需要对所有构造方法进行适配，这个搜索的过程是耗时的，如果搜索完的结果可以记录下来，下一次直接利用，就减少了搜索的时间。对于这种存在缓存的方法，根据类型选择调用autowireConstructor或者instantiateBean进行实例化。
（3） 如果没有缓存方法，就要选择需要使用的构造器，如果存在适配的构造器，就向下调用autowireConstructor
（4） 否则使用无参的构造方法，向下调用instantiateBean。
protected BeanWrapper createBeanInstance(String beanName,RootBeanDefinition mbd,Object[] args) {
//获得需要创建的Bean的Class
Class<?> beanClass = resolveBeanClass(mbd,beanName);
// 确定需要创建的Bean的实例的类可以实例化
if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {
throw new BeanCreationException(mbd.getResourceDescription(),"Bean class isn't public,and non-public access not allowed: " + beanClass.getName());
}
//如果存在工厂方法，则使用工厂方法去实例化类
if (mbd.getFactoryMethodName() != null) {
return instantiateUsingFactoryMethod(beanName,args);
}
// 使用自动状态的构造方式进行实例化
// 下面10行的代码是在减少重复创建bean的工作量。如果已经创建过同样的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,null,null);
}
else {
//使用构造方法进行构造
return instantiateBean(beanName,mbd);
}
}
// 确定需要使用的构造方法
Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass,beanName);
if (ctors != null ||
mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR ||
mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
//自动装配构造方法
return autowireConstructor(beanName,ctors,args);
}
// 使用默认的无参数的构造方法
return instantiateBean(beanName,mbd);
}
5autowireConstructor
只有在配置文件中指定了autowire的属性时，才会触发这个方法。这个方法实际上也是在搜索构造器的过程，这里面使用了贪心算法对构造器进行适配，而且仅仅去适配第一个找到的合适的方法。如果没有找到，就是抛出异常，如果找到了，向下调用instantiate方法进入实例化阶段。在整个搜索过程，依然贯彻缓存的宗旨。查找都是从缓存中开始，搜索结果存入缓存。
public BeanWrapper autowireConstructor(final String beanName,Constructor<?>[] chosenCtors,final Object[] explicitArgs) {
//构建一个Bean的包装容器
BeanWrapperImpl bw = new BeanWrapperImpl();
this.beanfactory.initBeanWrapper(bw);
// 搜索已经使用过的构造器 节省时间
Constructor<?> constructorToUse = null;
ArgumentsHolder argsHolderToUse = null;
Object[] argsToUse = null;
if (explicitArgs != null) {
argsToUse = explicitArgs;
}
else {
Object[] argsToResolve = null;
synchronized (mbd.constructorArgumentLock) {
constructorToUse = (Constructor<?>) mbd.resolvedConstructorOrFactoryMethod;
if (constructorToUse != null && mbd.constructorArgumentsResolved) {
// Found a cached constructor...
argsToUse = mbd.resolvedConstructorArguments;
if (argsToUse == null) {
argsToResolve = mbd.preparedConstructorArguments;
}
}
}
if (argsToResolve != null) {
argsToUse = resolvePreparedArguments(beanName,bw,constructorToUse,argsToResolve);
}
}
//如果没有使用过的构造器 利用贪心算法去搜索合适的构造器
if (constructorToUse == null) {
// Need to resolve the constructor.
boolean autowiring = (chosenCtors != null ||
mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR);
ConstructorArgumentValues resolvedValues = null;
int minNrOfArgs;
if (explicitArgs != null) {
minNrOfArgs = explicitArgs.length;
}
else {
ConstructorArgumentValues cargs = mbd.getConstructorArgumentValues();
resolvedValues = new ConstructorArgumentValues();
minNrOfArgs = resolveConstructorArguments(beanName,cargs,resolvedValues);
}
// Take specified constructors,if any.
Constructor<?>[] candidates = chosenCtors;
if (candidates == null) {
Class<?> beanClass = mbd.getBeanClass();
try {
candidates = (mbd.isNonPublicAccessAllowed() ?
beanClass.getDeclaredConstructors() : beanClass.getConstructors());
}
catch (Throwable ex) {
throw new BeanCreationException(mbd.getResourceDescription(),"Resolution of declared constructors on bean Class [" + beanClass.getName() +
"] from ClassLoader [" + beanClass.getClassLoader() + "] Failed",ex);
}
}
AutowireUtils.sortConstructors(candidates);
int minTypeDiffWeight = Integer.MAX_VALUE;
Set<Constructor<?>> ambiguousConstructors = null;
LinkedList<UnsatisfiedDependencyException> causes = null;
for (int i = 0; i < candidates.length; i++) {
Constructor<?> candidate = candidates[i];
Class<?>[] paramTypes = candidate.getParameterTypes();
if (constructorToUse != null && argsToUse.length > paramTypes.length) {
// Already found greedy constructor that can be satisfied ->
// do not look any further,there are only less greedy constructors left.
break;
}
if (paramTypes.length < minNrOfArgs) {
continue;
}
ArgumentsHolder argsHolder;
if (resolvedValues != null) {
try {
String[] paramNames = ConstructorPropertiesChecker.evaluate(candidate,paramTypes.length);
if (paramNames == null) {
ParameterNameDiscoverer pnd = this.beanfactory.getParameterNameDiscoverer();
if (pnd != null) {
paramNames = pnd.getParameterNames(candidate);
}
}
argsHolder = createArgumentArray(
beanName,resolvedValues,paramTypes,paramNames,candidate,autowiring);
}
catch (UnsatisfiedDependencyException ex) {
if (this.beanfactory.logger.isTraceEnabled()) {
this.beanfactory.logger.trace(
"Ignoring constructor [" + candidate + "] of bean '" + beanName + "': " + ex);
}
// Swallow and try next constructor.
if (causes == null) {
causes = new LinkedList<UnsatisfiedDependencyException>();
}
causes.add(ex);
continue;
}
}
else {
// Explicit arguments given -> arguments length must match exactly.
if (paramTypes.length != explicitArgs.length) {
continue;
}
argsHolder = new ArgumentsHolder(explicitArgs);
}
int typeDiffWeight = (mbd.isLenientConstructorResolution() ?
argsHolder.getTypeDifferenceWeight(paramTypes) : argsHolder.getAssignabilityWeight(paramTypes));
// Choose this constructor if it represents the closest match.
if (typeDiffWeight < minTypeDiffWeight) {
constructorToUse = candidate;
argsHolderToUse = argsHolder;
argsToUse = argsHolder.arguments;
minTypeDiffWeight = typeDiffWeight;
ambiguousConstructors = null;
}
else if (constructorToUse != null && typeDiffWeight == minTypeDiffWeight) {
if (ambiguousConstructors == null) {
ambiguousConstructors = new LinkedHashSet<Constructor<?>>();
ambiguousConstructors.add(constructorToUse);
}
ambiguousConstructors.add(candidate);
}
}
//如果依然没有找到合适的 抛出异常
if (constructorToUse == null) {
if (causes != null) {
UnsatisfiedDependencyException ex = causes.removeLast();
for (Exception cause : causes) {
this.beanfactory.onSuppressedException(cause);
}
throw ex;
}
throw new BeanCreationException(mbd.getResourceDescription(),"Could not resolve matching constructor " +
"(hint: specify index/type/name arguments for simple parameters to avoid type ambiguities)");
}
else if (ambiguousConstructors != null && !mbd.isLenientConstructorResolution()) {
throw new BeanCreationException(mbd.getResourceDescription(),"Ambiguous constructor matches found in bean '" + beanName + "' " +
"(hint: specify index/type/name arguments for simple parameters to avoid type ambiguities): " +
ambiguousConstructors);
}
if (explicitArgs == null) {
argsHolderToUse.storeCache(mbd,constructorToUse);
}
}
//利用找到的构造器去构造对象 依然使用getInstantiationStrategy().instantiate构造
try {
Object beanInstance;
if (System.getSecurityManager() != null) {
final Constructor<?> ctorToUse = constructorToUse;
final Object[] argumentsToUse = argsToUse;
beanInstance = AccessController.doPrivileged(new PrivilegedAction<Object>() {
@Override
public Object run() {
return beanfactory.getInstantiationStrategy().instantiate(
mbd,beanfactory,ctorToUse,argumentsToUse);
}
},beanfactory.getAccessControlContext());
}
else {
beanInstance = this.beanfactory.getInstantiationStrategy().instantiate(
mbd,this.beanfactory,argsToUse);
}
bw.setWrappedInstance(beanInstance);
return bw;
}
catch (Throwable ex) {
throw new BeanCreationException(mbd.getResourceDescription(),"Bean instantiation via constructor Failed",ex);
}
}
6 instantiateBean 完成Bean的初始化
protected BeanWrapper instantiateBean(final String beanName,final RootBeanDefinition mbd) {
try {
Object beanInstance;//构建出来的Bean实例
final beanfactory parent = this;
if (System.getSecurityManager() != null) {
// 提升权限
beanInstance = AccessController.doPrivileged(new PrivilegedAction<Object>() {
@Override
public Object run() {
//调用具体实例化方法
return getInstantiationStrategy().instantiate(mbd,parent);
}
},getAccessControlContext());
}
else {
//调用具体实例化方法
beanInstance = getInstantiationStrategy().instantiate(mbd,parent);
}
//包装创建好的实例
BeanWrapper bw = new BeanWrapperImpl(beanInstance);
initBeanWrapper(bw);
return bw;
}
catch (Throwable ex) {
throw new BeanCreationException(mbd.getResourceDescription(),"Instantiation of bean Failed",ex);
}
}
在这个方法里面，向下调用了instantiate方法。他是实例化Bean的终点。在这里决定了使用JDK的反射方法还是使用CGLIB的方法进行初始化。
public Object instantiate(RootBeanDefinition bd,String beanName,beanfactory owner) { // 这个if-else 把bean的初始化分为两类 //如果定义了look-up method 或者replace method 将使用CGLIB初始化 //否则使用JDK的反射 if (bd.getMethodOverrides().isEmpty()) { Constructor<?> constructorToUse;//获得构造方法 synchronized (bd.constructorArgumentLock) { //使用工厂方法 或者 构造器 constructorToUse = (Constructor<?>) bd.resolvedConstructorOrFactoryMethod; if (constructorToUse == null) { final Class<?> clazz = bd.getBeanClass(); if (clazz.isInterface()) { throw new BeanInstantiationException(clazz,"Specified class is an interface"); } try { if (System.getSecurityManager() != null) { constructorToUse = AccessController.doPrivileged(new PrivilegedExceptionAction<Constructor<?>>() { @Override public Constructor<?> run() throws Exception { return clazz.getDeclaredConstructor((Class[]) null); } }); } else { constructorToUse = clazz.getDeclaredConstructor((Class[]) null); } bd.resolvedConstructorOrFactoryMethod = constructorToUse; } catch (Exception ex) { throw new BeanInstantiationException(clazz,"No default constructor found",ex); } } } return BeanUtils.instantiateClass(constructorToUse); } else { // 使用CGLIB初始化 return instantiateWithMethodInjection(bd,owner); } }这里根据是否定义了Override方法进行选择，这里的Override方法指的是lookupmethod和replacemethod
6.1 JDK反射生成Bean实例
public static <T> T instantiateClass(Constructor<T> ctor,Object... args) throws BeanInstantiationException {
Assert.notNull(ctor,"Constructor must not be null");
try {
//获得访问权限
ReflectionUtils.makeAccessible(ctor);
//利用反射生成实例
return ctor.newInstance(args);
}
catch (InstantiationException ex) {
throw new BeanInstantiationException(ctor.getDeclaringClass(),"Is it an abstract class?",ex);
}
catch (IllegalAccessException ex) {
throw new BeanInstantiationException(ctor.getDeclaringClass(),"Is the constructor accessible?",ex);
}
catch (IllegalArgumentException ex) {
throw new BeanInstantiationException(ctor.getDeclaringClass(),"Illegal arguments for constructor",ex);
}
catch (InvocationTargetException ex) {
throw new BeanInstantiationException(ctor.getDeclaringClass(),"Constructor threw exception",ex.getTargetException());
}
}
6.2 CGLIB实例化Bean
public Object instantiate(Constructor<?> ctor,Object... args) {
//利用CGLIB生成Class对象
Class<?> subclass = createEnhancedSubclass(this.beanDefinition);
Object instance;
if (ctor == null) {
//利用反射对CGLIB生成的Class对象实例化
instance = BeanUtils.instantiate(subclass);
}
else {
try {
Constructor<?> enhancedSubclassConstructor = subclass.getConstructor(ctor.getParameterTypes());
//利用CGLIB进行实例化
instance = enhancedSubclassConstructor.newInstance(args);
}
catch (Exception ex) {
throw new BeanInstantiationException(this.beanDefinition.getBeanClass(),"Failed to invoke constructor for CGLIB enhanced subclass [" + subclass.getName() + "]",ex);
}
}
// SPR-10785: set callbacks directly on the instance instead of in the
// enhanced class (via the Enhancer) in order to avoid memory leaks.
//在此处设置lookup和replacemethod
Factory factory = (Factory) instance;
factory.setCallbacks(new Callback[] {NoOp.INSTANCE,new LookupOverrideMethodInterceptor(this.beanDefinition,this.owner),new ReplaceOverrideMethodInterceptor(this.beanDefinition,this.owner)});
return instance;
} 原文链接：https://www.f2er.com/javaschema/284593.html