一、简介
所有 Bean 实例的创建都会委托给该方法实现。
该方法其实只是做一些检查和验证工作，真正的初始化工作是由doCreateBean()实现
二、源码分析
AbstractAutowireCapableBeanFactory类的createBean方法
源码：
protected Object createBean(String beanName, RootBeanDefinition mbd, Object[] args) throws BeanCreationException {
if (logger.isDebugEnabled()) {
logger.debug("Creating instance of bean '" + beanName + "'");
}
RootBeanDefinition mbdToUse = mbd;
//解析bean的类型
Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
mbdToUse = new RootBeanDefinition(mbd);
mbdToUse.setBeanClass(resolvedClass);
}
//处理override method方法
try {
mbdToUse.prepareMethodOverrides();
}
catch (BeanDefinitionValidationException ex) {
throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
beanName, "Validation of method overrides failed", ex);
}
try {
//bean的后置处理器，如果有，这里会返回代理的实例。AOP的实现基础就是基于这里来实现的
Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
if (bean != null) {
return bean;
}
}
catch (Throwable ex) {
throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
"BeanPostProcessor before instantiation of bean failed", ex);
}
//创建bean的实例
Object beanInstance = doCreateBean(beanName, mbdToUse, args);
if (logger.isDebugEnabled()) {
logger.debug("Finished creating instance of bean '" + beanName + "'");
}
return beanInstance;
}做了4件事：
1.resolveBeanClass方法()，解析bean的类型
2.处理override method方法。 lookup-method 和 replace-method 配置，Spring统称为override method。
lookup-method可以是XML配置 ，也可以是@lookup注解，通俗的解释@lookup的使用场景是单例A中依赖注入B，这个B要是个多例，每次在A中注入的B都不是同一个B。
relace-method是方法替换
3.resolveBeforeInstantiation()方法，bean的实例化后前置处理器，如果有，这里会返回代理的实例。AOP的实现基础就是基于这里来实现的
bean的生命周期的中实现了InstantiationAwareBeanPostProcessor会在这里调用实现的postProcessBeforeInstantiation
4.创建bean的实例,交给doCreateBean()方法实现
三、创建bean的实例doCreateBean方法
源码：
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args)
throws BeanCreationException {
//bean实例包装类，用于操作bean的属性
BeanWrapper instanceWrapper = null;
//如果是单例的话，则先把工厂bean缓存中的同名bean清除
if (mbd.isSingleton()) {
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
if (instanceWrapper == null) {
//实际创建的交给createBeanInstance来完成，
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
//获取BeanWrapper中封装的Object对象，其实就是bean对象的实例
final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null);
//获取BeanWrapper中封装的bean的Class
Class<?> beanType = (instanceWrapper != null ? instanceWrapper.getWrappedClass() : null);
mbd.resolvedTargetType = beanType;
// 使用合并BeanDefinition的后处理器
synchronized (mbd.postProcessingLock) {
if (!mbd.postProcessed) {
try {
//bean 的生命周期之一。如果实现了MergedBeanDefinitionPostProcessor会在这里调用postProcessMergedBeanDefinition方
applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
}
catch (Throwable ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Post-processing of merged bean definition failed", ex);
}
mbd.postProcessed = true;
}
}
//如果RootBeanDefinition是单例的，并且开启了自动尝试解析bean之间的循环引用，并且当前bean正在创建中，则将其加入单例工厂缓存singletonFactories中，是个MAP
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, mbd, bean);
}
});
}
// 对已有的bean的实例初始化 一般情况下依赖注入就在这里发生
Object exposedObject = bean;
try {
//填充bean的属性
populateBean(beanName, mbd, instanceWrapper);
if (exposedObject != null) {
//初始化bean的实例，应用工厂回调以及init方法和bean后处理器
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) {
// 从BeanFactory的单例缓存中获取bean的实例
Object earlySingletonReference = getSingleton(beanName, false);
// 如果bean工厂的 单例缓存中获取不到
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.");
}
}
}
}
//注册bean的销毁逻辑
try {
registerDisposableBeanIfNecessary(beanName, bean, mbd);
}
catch (BeanDefinitionValidationException ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
}
return exposedObject;
}做了7件事：
1.创建bean的实例，createBeanInstance()方法，这里得到的bean的实例还未被填充相关的属性
2.applyMergedBeanDefinitionPostProcessors()方法，如果BeanPostProcessors后置处理器实现了MergedBeanDefinitionPostProcessor接口会在这里调用后置处理器的postProcessMergedBeanDefinition方法
3. 处理是否提前暴露bean的引用（如果RootBeanDefinition是单例的，并且开启了自动尝试解析bean之间的循环引用，并且当前bean正在创建中），如果提前暴露bean的引用则将其加入单例工厂缓存singletonFactories中，加入到registeredSingletons 中
4：填充bean实例的属性populateBean()方法
5：初始化bean，initializeBean()方法，（初始方法前操作，调用初始化方法，执行初始化后的方法）
初始化bean的实例，应用工厂回调以及init方法和bean后处理器
6. 如果需要提前暴露，处理循环依赖
7：注册bean的销毁逻辑，registerDisposableBeanIfNecessary()方法
3.1 createBeanInstance()方法
源码：
protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, Object[] args) {
// 确保 bean class 已经解析过了.
Class<?> beanClass = resolveBeanClass(mbd, beanName);
//如果bean的类修饰符不是public则报错
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());
}
// 如果beanDefinition中有工厂方法的名字
if (mbd.getFactoryMethodName() != null) {
// 使用工厂方法来进行bean的实例化
return instantiateUsingFactoryMethod(beanName, mbd, args);
}
// 重新创建相同的bean时快捷方式...
boolean resolved = false;
boolean autowireNecessary = false;
if (args == null) {
synchronized (mbd.constructorArgumentLock) {
// 如果beanDefinition中已经解析了构造函数或工厂方法
if (mbd.resolvedConstructorOrFactoryMethod != null) {
resolved = true;
autowireNecessary = mbd.constructorArgumentsResolved;
}
}
}
// 如果已经解析了
if (resolved) {
// 如果需要自动注入
if (autowireNecessary) {
return autowireConstructor(beanName, mbd, null, null);
}
else {
return instantiateBean(beanName, mbd);
}
}
// 需要确定构造函数,然后使用构造函数进行bean实例化
Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
if (ctors != null ||
mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR ||
mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
return autowireConstructor(beanName, mbd, ctors, args);
}
// 没有特殊的处理，简单使用无参数构造函数。（默认构造函数）
return instantiateBean(beanName, mbd);
}做了6件事：
1.resolveBeanClass方法，如果没有解析Bean的类型，则解析。
2.不是public则抛出异常
3.如果beanDefinition中有工厂方法名字，则调用instantiateUsingFactoryMethod(beanName, mbd, args)进行实例化，并返回
4.如果已经解析过构造器或工厂方法（说明这个bean是重新创建）：是autowireNecessary就调用autowireConstructor(beanName, mbd, null, null)进行实例化，不是，就调用instantiateBean(beanName, mbd)进行实例化，并返回
5.由BeanPostProcessors后置处理器决定使用哪个构造器，调用autowireConstructor(beanName, mbd, ctors, args)进行实例化，并返回
6.如果前面的实例化方式都不符合，则调用instantiateBean(beanName, mbd)方法，使用无参构造器进行实例化，并返回。
3.1.1 instantiateUsingFactoryMethod方法
源码：
protected BeanWrapper instantiateUsingFactoryMethod(
String beanName, RootBeanDefinition mbd, Object[] explicitArgs) {
return new ConstructorResolver(this).instantiateUsingFactoryMethod(beanName, mbd, explicitArgs);
}做了2件事：
1.实例化ConstructorResolver类。ConstructorResolver 是构造方法或者工厂类初始化 bean 的委托类。
2.调用 ConstructorResolver类的instantiateUsingFactoryMethod方法，使用工厂方法的方式来实例化bean。
这个方法也真的很恶心！spring不同部分的源码，代码质量和可读性真的差别很大！
总结一下，这个 instantiateUsingFactoryMehtod方法里面就是做了几件事 ：
2.1 得到FactoryBean的实例，得到FactoryBean的类，确定使用什么工厂方法，确定方法入参
2.2 调用this.beanFactory.getInstantiationStrategy().instantiate( mbd, beanName, this.beanFactory, factoryBean, factoryMethodToUse, argsToUse)方法来实例化bean。
3.1.2 autowireConstructor方法
源码：
指定构造器来实例化是用该方法，autowrieNecessary也是调用该方法只是这个时候入参不用传构造器和args。
protected BeanWrapper autowireConstructor(
String beanName, RootBeanDefinition mbd, Constructor<?>[] ctors, Object[] explicitArgs) {
return new ConstructorResolver(this).autowireConstructor(beanName, mbd, ctors, explicitArgs);
}做了2件事：
1.实例化ConstructorResolver
2.调用 ConstructorResolver的autowrieConstructor方法进行实例化。autowrieConstructor方法里面最终还是用的beanInstance = this.beanFactory.getInstantiationStrategy().instantiate( mbd, beanName, this.beanFactory, constructorToUse, argsToUse);方法来得到bean的实例
3.1.3 instantiateBean方法
用无参构造方法注入来创建bean的实例
源码：
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>() {
@Override
public Object run() {
return getInstantiationStrategy().instantiate(mbd, beanName, parent);
}
}, getAccessControlContext());
}
else {
// 获取创建bean实例的策略，调用策略的instantiate方法进行实例化。
// 默认的实例化策略是cglib。
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);
}
}做了3件事：
1.获取创建bean实例的策略，默认的实例化策略是cglib。
2.调用策略的instantiate方法创建bean的实例。
3.把实例包装成BeanWrapper并且初始化一下beanWrapper的值，返回。
3.1.3.1 SimpleInstantiationStrategy类的instantiate方法
源码：
public Object instantiate(RootBeanDefinition bd, String beanName, BeanFactory owner) {
// Don't override the class with CGLIB if no overrides.
// 如果MethodOverrides为空
if (bd.getMethodOverrides().isEmpty()) {
Constructor<?> constructorToUse;
synchronized (bd.constructorArgumentLock) {
// 获取bd.resolvedConstructorOrFactoryMethod已解析的构造器或工厂方法
constructorToUse = (Constructor<?>) bd.resolvedConstructorOrFactoryMethod;
//如果为空
if (constructorToUse == null) {
// 从beanDefition中得到bean的类
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 {
// 通过bean的类clazz来得到声明的构造函数
constructorToUse = clazz.getDeclaredConstructor((Class[]) null);
}
// 并赋值回给bd.resolvedConstructorOrFactoryMethod
bd.resolvedConstructorOrFactoryMethod = constructorToUse;
}
catch (Throwable ex) {
throw new BeanInstantiationException(clazz, "No default constructor found", ex);
}
}
}
// 调用BeanUtils.instantiateClass(constructorToUse)方法进行实例化。
return BeanUtils.instantiateClass(constructorToUse);
}
// 如果MethodOverrides不为空
else {
// Must generate CGLIB subclass.
return instantiateWithMethodInjection(bd, beanName, owner);
}
}做了2件事：
1.如果MethodOverrides不为空，直接调用instantiateWithMethodInjection(bd,beanName,owner)方法，这会生成CGLIB的子类
2.如果MethodOverrides为空：获取bd.resolvedConstructorOrFactoryMethod已解析的构造器或工厂方法，如果为空则通过bean的类clazz来得到声明的构造函数，并赋值回给bd.resolvedConstructorOrFactoryMethod，调用BeanUtils.instantiateClass(constructorToUse)方法进行实例化。
3.2 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);
}
}
}做了2件事：
1.得到之前注册的BeanPostProcessors后置处理器。debug出来这里有有3个
ApplicationContextAwareProcessor
ApplicationListenerDetector
WebApplicationContextServletContextAwareProcessor2.遍历后置处理器，找出实现了 MergedBeanDefinitionPostProcessor接口的后置处理器，执行该后置处理器的postProcessMergedBeanDefinition方法
3.4 populateBean()方法
填充属性，把bean定义的属性填充到刚生成的bean实例中，依赖注入就发生在这里
源码：
protected void populateBean(String beanName, RootBeanDefinition mbd, BeanWrapper bw) {
//获取到BeanDefinition中设置的property值，封装成PropertyValues
PropertyValues pvs = mbd.getPropertyValues();
if (bw == null) {
if (!pvs.isEmpty()) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");
}
else {
// Skip property population phase for null instance.
return;
}
}
boolean continueWithPropertyPopulation = true;
// 如果BeanWrapper不为空， beandefinition不是合成Synthetic的并且有InstantiationAware后置处理器
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
//遍历beanPostProcessor
for (BeanPostProcessor bp : getBeanPostProcessors()) {
//如果该beanPostProcessor实现了InstantiationAwareBeanPostProcessor接口
if (bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
// 调用InstantiationAwareBeanPostProcessor Bean的后置处理器，在Bean注入属性前改变BeanDefinition的信息，且可跳过后面的属性填充
if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
continueWithPropertyPopulation = false;
break;
}
}
}
}
// 如果上面设置 continueWithPropertyPopulation = false，表明用户可能已经自己填充了
bean 的属性，不需要 Spring 填充。直接返回
if (!continueWithPropertyPopulation) {
return;
}
// 这里取得在BeanDefinition中设置的property值，这些property来自对BeanDefinition的解析
32 // 用于在配置文件中通过<property>配置的属性并且显示在配置文件中配置了autowireMode属性
//处理autowire的注入，根据bean的名称、类型来注入
if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME ||
mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
// Add property values based on autowire by name if applicable.
if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME) {
autowireByName(beanName, mbd, bw, newPvs);
}
// Add property values based on autowire by type if applicable.
if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
autowireByType(beanName, mbd, bw, newPvs);
}
pvs = newPvs;
}
boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
boolean needsDepCheck = (mbd.getDependencyCheck() != RootBeanDefinition.DEPENDENCY_CHECK_NONE);
if (hasInstAwareBpps || needsDepCheck) {
PropertyDescriptor[] filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
if (hasInstAwareBpps) {
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
//@Autowire @Resource @Value @Inject 等注解的依赖注入过程
pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
if (pvs == null) {
return;
}
}
}
}
if (needsDepCheck) {
checkDependencies(beanName, mbd, filteredPds, pvs);
}
}
// 注入配置文件中<property>配置的属性
applyPropertyValues(beanName, mbd, bw, pvs);
}做了6件事：
1.如果传进来的BeanWrapper为空，RootBeanDefinition中的propertyValus也是空，直接返回。BeanWrapper为空，propertyValus不为空，抛出异常。
2.如果BeanWrapper不为空， beandefinition不是合成Synthetic的并且有InstantiationAware后置处理器，遍历beanPostProcessor,如果该beanPostProcessor实现了InstantiationAwareBeanPostProcessor接口，调用该后置处理器的postProcessAfterInstantiation方法
3.处理autowire的注入，根据bean的名称、类型来注入。这里取得在BeanDefinition中设置的property值，这些property来自对BeanDefinition的解析。用于在配置文件中通过<property>配置的属性并且显示在配置文件中配置了autowireMode属性
4.如果beanPostProcessor实现了InstantiationAwareBeanPostProcessor接口，调用所有InstantiationAwareBeanPostProcessor类的postProcessPropertyValues方法。
这是@Autowire @Resource @Value @Inject 等注解的依赖注入过程
实际执行依赖注入逻辑的是AutowiredAnnotationBeanPostProcessor#postProcessPropertyValues
5.如果bean需要进行依赖检查，则检测依赖。
6.applyPropertyValues方法，使用propertyValue，注入配置文件中<property>配置的属性
3.5 initializeBean()方法
初始化bean的实例，应用工厂回调以及init方法和bean后处理器
源码：
protected Object initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd) {
if (System.getSecurityManager() != null) {
AccessController.doPrivileged(new PrivilegedAction<Object>() {
@Override
public Object run() {
invokeAwareMethods(beanName, bean);
return null;
}
}, getAccessControlContext());
}
else {
// 对bean设置：Aware、BeanClassLoaderAware、BeanFactoryAware
invokeAwareMethods(beanName, bean);
}
Object wrappedBean = bean;
if (mbd == null || !mbd.isSynthetic()) {
// 使用bean初始化前的后置处理器BeanPostProcessors
wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
}
try {
// 使用初始化方法（用户自定义的 init 方法）
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()) {
// 使用bean初始化后的后置处理器BeanPostProcessors
wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
}
return wrappedBean;
}做了4件事
1. invokeAwareMethods方法，首先判读该bean是否实现了Aware接口，根据实现的Aware接口类型的不同（BeanNameAware、BeanClassLoaderAware、BeanFactoryAware）调用相应的方法设置进相应的参数（BeanName、BeanClassLoader、AbstractAutowireCapableBeanFactory)
2. 使用bean初始化前的后置处理器BeanPostProcessor的postProcessBeforeInitialization方法
3. 使用初始化方法
设置Bean的初始化方法有两种方法，一种是在xml或者@Bean指定init-method方法。另一种是让bean实现InitializingBean接口重写afterPropertiesSet()方法。
而这个里面的执行顺序是：先执行afterPropertiesSet()方法，再进行init-method
4. 使用bean初始化后的后置处理器BeanPostProcessor的postProcessAfterInitialization方法
1628
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
