调用流程：AbstractApplicationContext#refresh
=> AbstractApplicationContext#finishBeanFactoryInitialization
=> DefaultListableBeanFactory#preInstantiateSingletons
=> AbstractBeanFactory#getBean
=> AbstractBeanFactory#doGetBean
=> AbstractBeanFactory#createBean
创建Bean对象的方法入口： AbstractAutowireCapableBeanFactory#createBean
// AbstractBeanFactory#doGetBean
if (mbd.isSingleton()) {
// 关键方法 createBean getSingleton
sharedInstance = this.getSingleton(beanName, () -> {
try {
return this.createBean(beanName, mbd, args);
} catch (BeansException var5) {
this.destroySingleton(beanName);
throw var5;
}
});
bean = this.getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
} else if (mbd.isPrototype()) {
var11 = null;
Object prototypeInstance;
try {
this.beforePrototypeCreation(beanName);
prototypeInstance = this.createBean(beanName, mbd, args);
} finally {
this.afterPrototypeCreation(beanName);
}
bean = this.getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
}
准备工作：
1、保证类以及加载完成了
2、处理lookup-method and replace-method（打上标识mo.setOverloaded(false);）
3、断定是否需要spring来管理这个类
4、创建Bean的关键方法(AbstractAutowireCapableBeanFactory#doCreateBean)
回调BeanPostProcessor（一）
第一次回调BeanPostProcessor（InstantiationAwareBeanPostProcessor 的 postProcessBeforeInstantiation 方法），用来断定是否需要spring来管理这个类
// AbstractAutowireCapableBeanFactory#createBean
Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
这里就会返回这个接口中 postProcessBeforeInstantiation 方法返回的对象，spring中默认返回的是null。表示spring会去维护这个类中的一些依赖关系，如果我们不需要spring来维护这些但是又希望将spring将这个类放入容器中，就可以通过这个方法，将我们需要放入spring的对象返回，这里会直接返回这个对象，结束这个bean的创建。
// 方法是判断是否向bean工厂中添加了 InstantiationAwareBeanPostProcessor 类型的后置处理器
protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
Class targetType = determineTargetType(beanName, mbd);
if (targetType != null) {
// InstantiationAwareBeanPostProcessor#postProcessBeforeInstantiation
bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
if (bean != null) {
// 遍历所有的 BeanPostProcessor 执行它的 postProcessAfterInitialization方法
bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
}
}
}
}
关键方法AbstractAutowireCapableBeanFactory#doCreateBean
Object beanInstance = doCreateBean(beanName, mbdToUse, args);
doCreateBean的逻辑如下：
- 检查是否存在与factoryBean的缓存中，
// AbstractAutowireCapableBeanFactory#doCreateBean
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
- 如果不在FactoryBean的缓存中，则创建bean
if (instanceWrapper == null) {
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
- 创建Bean的核心方法
// AbstractAutowireCapableBeanFactory#createBeanInstance
protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, Object[] args) {
// 确保bd中的class已经被加载进来了
Class beanClass = resolveBeanClass(mbd, beanName);
// 检查类的访问权限
if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {throw xxx}
if (mbd.getFactoryMethodName() != null) {
// bd是否存在工厂方法，如果存在工厂方法直接通过工厂方法进行创建
// 参考 @Bean标注的static方法，这个bean就设置了FactoryMethod
// @Bean 标注的普通方法是设置了 UniqueFactoryMethod 这两者的区别？？
return instantiateUsingFactoryMethod(beanName, mbd, args);
}
// Shortcut when re-creating the same bean...
// 创建一个快捷方式，当重新创建相同的bean时，比如创建prototype类型的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) {
// 使用构造函数注入的方式实例化bean
return autowireConstructor(beanName, mbd, null, null);
} else {
// 使用无参构造函数实例化bean
return instantiateBean(beanName, mbd);
}
}
// 未完...
}
回调BeanPostProcessor（二）
Spring是如何知道是使用无参还是有参的构造函数？这与BeanPostProcessor的第二次回调有关
// Candidate constructors for autowiring?
// 这里是 BeanPostProcessor 的第二次回调，主要是推断构造方法
Constructor[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
上面这一句的总体意思就是是否采用有参的构造函数进行注入
1、只存在无参的构造函数时，这里会返回一个null
2、只存在一个有参的构造函数时，这里会返回这个有参的构造函数
3、存在一个无参的构造函数和一个有参的构造函数 ，返回null
4、存在两个有参的构造函数，返回null
5、存在三个或者三个以上的构造方法，返回null
// AbstractAutowireCapableBeanFactory#determineConstructorsFromBeanPostProcessors
protected Constructor[] determineConstructorsFromBeanPostProcessors(@Nullable Class beanClass, String beanName) throws BeansException {
// 执行 AutowiredAnnotationBeanPostProcessor.determineCandidateConstructors推断构造函数
if (beanClass != null && hasInstantiationAwareBeanPostProcessors()) {
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {
SmartInstantiationAwareBeanPostProcessor ibp = (SmartInstantiationAwareBeanPostProcessor) bp;
Constructor[] ctors = ibp.determineCandidateConstructors(beanClass, beanName);
if (ctors != null) {
return ctors;
}
}
}
}
return null;
}
推断构造函数总结：
当只存在一个构造函数时：
（1）默认的无参构造函数，这里会返回null
（2）自己写了一个有参的构造函数时，这里会返回这个有参的构造函数
当存在两个构造函数时
（1）两个都是有参的构造函数，这里会返回null
（2）一个有参的构造函数，一个无参的构造函数，这里还是返回null
在第二种情况中，怎么才能返回两个构造函数呢？
存在无参的构造函数，存在primaryConstructor，并且无参的构造函数和 primaryConstructor 不相等
这里的 primaryConstructor 是针对Kotlin的类的，所以在JAVA中这里永远都会返回一个null
所以在JAVA中这里是不可能返回两个构造函数的
当存在三个或者三个以上的构造函数时
这里一律返回null
所以要么只存在一个无参的构造方法，要么只存在一个有参的构造方法
// AutowiredAnnotationBeanPostProcessor.determineCandidateConstructors
// 1、记录Lookup注解的方法
// 获取类中的所有构造函数
rawCandidates = beanClass.getDeclaredConstructors();
// 遍历所有的构造函数
for (Constructor candidate : rawCandidates) {
// isSynthetic方法判断如果是合成的构造函数就返回true(java自己生成的)，自己写的构造函数会返回false
if (!candidate.isSynthetic()) {
nonSyntheticConstructors++;// 统计构造函数的个数
}else if (primaryConstructor != null) {
// 存在primaryConstructor，会跳出循环
continue;
}
// 获取构造方法上的注解
AnnotationAttributes ann = findAutowiredAnnotation(candidate);
if (ann == null) {
// 构造方法上没有注解
// 如果这个beanClass是被CGlib进行代理的class类型，则获取父类的构造函数
// 进而拿到父类构造函数上的注解
Class userClass = ClassUtils.getUserClass(beanClass);
if (userClass != beanClass) {
Constructor superCtor =
userClass.getDeclaredConstructor(candidate.getParameterTypes());
ann = findAutowiredAnnotation(superCtor);
}
}
if (ann != null) {
if (requiredConstructor != null) {
throw new BeanCreationException(beanName,requiredConstructor);
}
boolean required = determineRequiredStatus(ann);
if (required) {
if (!candidates.isEmpty()) {
throw new BeanCreationException(beanName,candidate);
}
requiredConstructor = candidate;
}
// 只有在构造方法存在注解的情况下向 candidates 集合中添加了构造方法
candidates.add(candidate);
}else if (candidate.getParameterCount() == 0) {
// 没有参数的构造函数，表示为默认的构造函数
defaultConstructor = candidate;
}
}
if (!candidates.isEmpty()) {
// Add default constructor to list of optional constructors, as fallback.
if (requiredConstructor == null) {
if (defaultConstructor != null) {
candidates.add(defaultConstructor);
}else if (candidates.size() == 1 && logger.isInfoEnabled()) {
logger.info("Inconsistent constructor declaration on bean with name");
}
}
candidateConstructors = candidates.toArray(new Constructor[0]);
}else if (rawCandidates.length == 1 && rawCandidates[0].getParameterCount() > 0) {
// rawCandidates表示所有的构造函数，表示只有一个有参的构造函数
candidateConstructors = new Constructor[] {rawCandidates[0]};
}else if (nonSyntheticConstructors == 2 && primaryConstructor != null &&
defaultConstructor != null && !primaryConstructor.equals(defaultConstructor)) {
// 有两个构造函数，必须存在 一个 primaryConstructor 和一个 defaultConstructor
// 并且两者不相等
candidateConstructors = new Constructor[] {primaryConstructor, defaultConstructor};
}else if (nonSyntheticConstructors == 1 && primaryConstructor != null) {
// 有一个primaryConstructor，就返回这个primaryConstructor
candidateConstructors = new Constructor[] {primaryConstructor};
}else {
// 不满足上述条件的一律视为不存在合适的构造函数 返回一个空数组
candidateConstructors = new Constructor[0];
}
this.candidateConstructorsCache.put(beanClass, candidateConstructors);
return (candidateConstructors.length > 0 ? candidateConstructors : null);
调用构造方法创建对象
以下四种情况只有存在一种，都会使用有参构造函数进行bean的实例化
1、存在且只有 有参的构造函数 比较绕
2、bd的装配模式设置为了构造方法装配模式
3、通过操作bd，给定了bd的构造方法的参数（mybatis中Mapper的生成，给定了Mapper构造函数的接口名称 => 通过构造函数去创建Mapper代理对象）
4、传入的args参数不为空，这里传入的参数是构造函数中对应的实参
// AbstractAutowireCapableBeanFactory#createBeanInstance
Constructor[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
// 调用构造函数
if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
// 通过有参的构造函数创建bean
return autowireConstructor(beanName, mbd, ctors, args);
}
// Preferred constructors for default construction? bd中的默认首选构造函数
// 在RootBeanDefinition中默认返回了null，表示默认使用无参的构造函数
ctors = mbd.getPreferredConstructors();
if (ctors != null) {
return autowireConstructor(beanName, mbd, ctors, null);
}
// No special handling: simply use no-arg constructor.
// 使用无参的构造函数创建bean对象
return instantiateBean(beanName, mbd);
有参的构造函数调用
调用有参的构造函数ConstructorResolver#autowireConstructor
- beanName bean对象的名称
- mbd bean合并后的bd
- chosenCtors 选中执行的构造函数
- explicitArgs 使用bd中的构造函数参数
public BeanWrapper autowireConstructor(String beanName, RootBeanDefinition mbd,
Constructor[] chosenCtors, Object[] explicitArgs) {
BeanWrapperImpl bw = new BeanWrapperImpl();
this.beanFactory.initBeanWrapper(bw);
// 将要使用的构造函数
Constructor constructorToUse = null;
// 构造函数的形参列表
ArgumentsHolder argsHolderToUse = null;
// 构造函数的实际参数
Object[] argsToUse = null;
// explicitArgs 是传递过来的实际参数
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, mbd, bw, constructorToUse, argsToResolve, true);
}
}
// 缓存中没有获取到或者没有实参，都会进入这个if
if (constructorToUse == null || argsToUse == null) {
// Take specified constructors, if any.
Constructor[] candidates = chosenCtors;
if (candidates == null) {
Class beanClass = mbd.getBeanClass();
candidates = (mbd.isNonPublicAccessAllowed() ?
beanClass.getDeclaredConstructors() :
beanClass.getConstructors());
}
// mbd中不存在构造函数参数，并且只有一个构造函数
if (candidates.length == 1 && explicitArgs == null && !mbd.hasConstructorArgumentValues()) {
Constructor uniqueCandidate = candidates[0];
if (uniqueCandidate.getParameterCount() == 0) {
// 直接调用这个构造函数，不需要去进行构造函数的匹配
synchronized (mbd.constructorArgumentLock) {
mbd.resolvedConstructorOrFactoryMethod = uniqueCandidate;
mbd.constructorArgumentsResolved = true;
mbd.resolvedConstructorArguments = EMPTY_ARGS;
}
bw.setBeanInstance(instantiate(beanName, mbd, uniqueCandidate, EMPTY_ARGS));
return bw;
}
}
// 这里表示存在多个构造函数，需要进行构造函数的匹配
// Need to resolve the constructor.一般是这样的 autowiring == true
boolean autowiring = (chosenCtors != null ||
mbd.getResolvedAutowireMode() == AutowireCapableBeanFactory.AUTOWIRE_CONSTRUCTOR);
ConstructorArgumentValues resolvedValues = null;
// 最少的参数个数，是根据这个方法传入的实参确定
// 如果传入的实参为null，使用 resolveConstructorArguments 方法来确定最少参数个数
int minNrOfArgs;
if (explicitArgs != null) {
minNrOfArgs = explicitArgs.length;
}else {
ConstructorArgumentValues cargs = mbd.getConstructorArgumentValues();
resolvedValues = new ConstructorArgumentValues();
minNrOfArgs = resolveConstructorArguments(beanName, mbd, bw, cargs, resolvedValues);
}
/**
* 对传入的构造函数集合进行排序
* 安装访问权限由大到小，参数由多到少的顺序排序
*/
AutowireUtils.sortConstructors(candidates);
// 参数和构造方法的差异权重，越小代表越接近
int minTypeDiffWeight = Integer.MAX_VALUE;
Set> ambiguousConstructors = null;
LinkedList causes = null;
for (Constructor candidate : candidates) {
// 拿到构造函数的参数类型数组 1、拿到形参个数 2、拿到新参类型数组
Class[] paramTypes = candidate.getParameterTypes();
// 这个判断满足了，说明已经找到了合适的构造方法
// 因为构造方法按照新参个数进行排序了，如果当前的构造函数的形参个数小于使用参数的个数
// 那么在向下寻找也只会找到更少形参的构造方法，所以在这里直接 break 了
if (constructorToUse != null && argsToUse != 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;
}
// 构造函数的形参个数小于了最小要求的实参个数
// 比如实参有2个参数，这里直接过滤掉1个参数的构造函数
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, mbd,
resolvedValues, bw,
paramTypes, paramNames, getUserDeclaredConstructor(candidate),
autowiring, candidates.length == 1);
}catch (UnsatisfiedDependencyException ex) {
// Swallow and try next constructor.
if (causes == null) {
causes = new LinkedList<>();
}
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<>();
ambiguousConstructors.add(constructorToUse);
}
ambiguousConstructors.add(candidate);
}
}
// 缓存构造函数和解析出来的参数
if (explicitArgs == null && argsHolderToUse != null) {
argsHolderToUse.storeCache(mbd, constructorToUse);
}
}
Assert.state(argsToUse != null, "Unresolved constructor arguments");
// 调用构造函数、实际参数创建对象
bw.setBeanInstance(instantiate(beanName, mbd, constructorToUse, argsToUse));
return bw;
}
最终调用SimpleInstantiationStrategy#instantiate判断如何进行实例化
- 如果不存在方法的复写(lookup-method / replace-method )那么使用反射创建对象
- 如果存在方法的复写，使用cglib进行实例化
// 反射调用构造方法
BeanUtils.instantiateClass(constructorToUse);
// 使用cglib
CglibSubclassingInstantiationStrategy#instantiateWithMethodInjection
// 最终返回
return new CglibSubclassCreator(bd, owner).instantiate(ctor, args);
// CglibSubclassingInstantiationStrategy.CglibSubclassCreator#instantiate
public Object instantiate(@Nullable Constructor ctor, Object... args) {
Class subclass = createEnhancedSubclass(this.beanDefinition);
Object instance;
// ctor如果是null表示使用默认的无参构造函数，这里是和下面调用无参构造函数共用
if (ctor == null) {
instance = BeanUtils.instantiateClass(subclass);
}else {
Constructor enhancedSubclassConstructor = subclass.getConstructor(ctor.getParameterTypes());
instance = enhancedSubclassConstructor.newInstance(args);
}
// enhanced class (via the Enhancer) in order to avoid memory leaks.
Factory factory = (Factory) instance;
// 设置方法的拦截器
factory.setCallbacks(new Callback[] {NoOp.INSTANCE,
new LookupOverrideMethodInterceptor(this.beanDefinition, this.owner),
new ReplaceOverrideMethodInterceptor(this.beanDefinition, this.owner)});
return instance;
}
LookupOverrideMethodInterceptor：拦截@Lookup/lookup-method注解的方法（LookupOverride）
ReplaceOverrideMethodInterceptor：拦截配置的replace-method的方法（ReplaceOverride）
LookupOverrideMethodInterceptor中的intercept会从容器中取出这个Lookup方法返回值类型的bean
public Object intercept(Object obj, Method method, Object[] args, MethodProxy mp) {
// Cast is safe, as CallbackFilter filters are used selectively.
LookupOverride lo = (LookupOverride) getBeanDefinition().getMethodOverrides().getOverride(method);
Object[] argsToUse = (args.length > 0 ? args : null);
if (StringUtils.hasText(lo.getBeanName())) {
// owner=BeanFactory 从容器中获取
return (argsToUse != null ?
this.owner.getBean(lo.getBeanName(), argsToUse) :
this.owner.getBean(lo.getBeanName()));
}else {
return (argsToUse != null ?
this.owner.getBean(method.getReturnType(), argsToUse) :
this.owner.getBean(method.getReturnType()));
}
}
ReplaceOverrideMethodInterceptor中的intercept方法会回调配置的MethodReplacer接口实现类的reimplement方法
public Object intercept(Object obj, Method method, Object[] args, MethodProxy mp) {
ReplaceOverride ro = (ReplaceOverride) getBeanDefinition().getMethodOverrides().getOverride(method);
Assert.state(ro != null, "ReplaceOverride not found");
// TODO could cache if a singleton for minor performance optimization
// 获取replaced-method标签中配置的replacer对应的bean
MethodReplacer mr = this.owner.getBean(ro.getMethodReplacerBeanName(), MethodReplacer.class);
// 回调bean的reimplement方法
return mr.reimplement(obj, method, args);
}
无参的构造函数调用
调用无参的构造函数AbstractAutowireCapableBeanFactory#instantiateBean
protected BeanWrapper instantiateBean(final String beanName, final RootBeanDefinition mbd) {
Object beanInstance;
final BeanFactory parent = this;
// 安全检查
if (System.getSecurityManager() != null) {
// 授权给当前类一个 getInstantiationStrategy().instantiate这个方法的执行权限
}else {
// 实例化 => SimpleInstantiationStrategy.instantiate
beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, parent);
}
// 包裹真实的对象并返回包装对象
BeanWrapper bw = new BeanWrapperImpl(beanInstance);
initBeanWrapper(bw);
return bw;
}
实例化对象的逻辑SimpleInstantiationStrategy.instantiate
public Object instantiate(RootBeanDefinition bd, String beanName, BeanFactory owner) {
// 如果不存在方法的复写(lookup-method / replace-method )那么使用反射创建对象
// 存在方法复写，使用cglib进行实例化
if (!bd.hasMethodOverrides()) {
Constructor constructorToUse;
synchronized (bd.constructorArgumentLock) {
// constructorToUse 表示用来实例对象的构造方法
constructorToUse = (Constructor) bd.resolvedConstructorOrFactoryMethod;
if (constructorToUse == null) {
final Class clazz = bd.getBeanClass();
if (clazz.isInterface()) {
throw new BeanInstantiationException(clazz, "Specified class is an interface");
}
bd.resolvedConstructorOrFactoryMethod = constructorToUse;
}
}
// 通过构造函数实例出对象 => constructorToUse.newInstance(args)
return BeanUtils.instantiateClass(constructorToUse);
}else {
// Must generate CGLIB subclass. 使用CGlib生成beanClass的子类，返回的是子类的对象
// 这里逻辑和调用有参的构造函数创建cglib代理一致，只是传入的构造函数是一个null值
return instantiateWithMethodInjection(bd, beanName, owner);
}
}
至此，对象的实例化就完成了。
回调BeanPostProcessor（三）
当创建的非FactoryBean的对象创建完成之后，会返回一个BeanWrapper，这个类包装了bean对象。
// AbstractAutowireCapableBeanFactory#doCreateBean
if (instanceWrapper == null) {
// 说明不是FactoryBean，在这里实例化bean
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
// bean是真实的对象
final Object bean = instanceWrapper.getWrappedInstance();
Class beanType = instanceWrapper.getWrappedClass();
第三次后置处理器的回调：
实例化对象之后，仅仅只是完成了类的初始化工作，还未涉及到数据的填充，初始化方法的执行。这里的回调就是缓存bean中的生命周期函数，解析@Resource @Inject @Autowired等注解，为后续注入依赖，回调声明周期函数做准备
虽然会调用三个类的postProcessMergedBeanDefinition方法，但是主要看CommonAnnotationBeanPostProcessor#postProcessMergedBeanDefinition和AutowiredAnnotationBeanPostProcessor#postProcessMergedBeanDefinition
CommonAnnotationBeanPostProcessor：主要缓存bean的声明周期函数，bean内部的@Resource的注解
AutowiredAnnotationBeanPostProcessor：缓存一个类中所有@Autowired、@Value和@Inject注解的方法和字段。
applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
// AbstractAutowireCapableBeanFactory#applyMergedBeanDefinitionPostProcessors
protected void applyMergedBeanDefinitionPostProcessors(RootBeanDefinition mbd, Class beanType, String beanName) {
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof MergedBeanDefinitionPostProcessor) {
// CommonAnnotationBeanPostProcessor
// AutowiredAnnotationBeanPostProcessor
// ApplicationListenerDetector
MergedBeanDefinitionPostProcessor bdp = (MergedBeanDefinitionPostProcessor) bp;
bdp.postProcessMergedBeanDefinition(mbd, beanType, beanName);
}
}
}
CommonAnnotationBeanPostProcessor
public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class beanType, String beanName) {
// 检查@PostConstruct/@PreDestroy
super.postProcessMergedBeanDefinition(beanDefinition, beanType, beanName);
// 检查@Resource注解
InjectionMetadata metadata = findResourceMetadata(beanName, beanType, null);
metadata.checkConfigMembers(beanDefinition);
}
获取bean对象的中的生命周期回调函数
// 父类的postProcessMergedBeanDefinition方法
public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class beanType, String beanName) {
// 拿到 bd 对应的生命周期回调信息
LifecycleMetadata metadata = findLifecycleMetadata(beanType);
metadata.checkConfigMembers(beanDefinition);
}
private LifecycleMetadata findLifecycleMetadata(Class clazz) {
if (this.lifecycleMetadataCache == null) {
// 初始化缓存map对象
return buildLifecycleMetadata(clazz);
}
// 从Map获取生命周期回调的元数据，包括回调的类 初始方法集合 销毁方法集合
// 第一次获取肯定是没有的
LifecycleMetadata metadata = this.lifecycleMetadataCache.get(clazz);
if (metadata == null) {
synchronized (this.lifecycleMetadataCache) {
metadata = this.lifecycleMetadataCache.get(clazz);
if (metadata == null) {
// 没有就创建（检查类中的注解，核心方法），并放入map中
metadata = buildLifecycleMetadata(clazz);
// 获取到回调函数之后会缓存起来
this.lifecycleMetadataCache.put(clazz, metadata);
}
return metadata;
}
}
return metadata;
}
关键方法
- 在CommonAnnotationBeanPostProcessor对象创建时调用了父类的set方法， 设置了InitAnnotation和DestroyAnnotation
public CommonAnnotationBeanPostProcessor() {
setOrder(Ordered.LOWEST_PRECEDENCE - 3);
setInitAnnotationType(PostConstruct.class);
setDestroyAnnotationType(PreDestroy.class);
ignoreResourceType("javax.xml.ws.WebServiceContext");
}
- 遍历类中的所有方法，判断是否存在initAnnotationType或者destroyAnnotationType
do {
ReflectionUtils.doWithLocalMethods(targetClass, method -> {
if (this.initAnnotationType != null && method.isAnnotationPresent(this.initAnnotationType)) {
LifecycleElement element = new LifecycleElement(method);
currInitMethods.add(element);
}
if (this.destroyAnnotationType != null && method.isAnnotationPresent(this.destroyAnnotationType)) {
currDestroyMethods.add(new LifecycleElement(method));
}
});
initMethods.addAll(0, currInitMethods);
destroyMethods.addAll(currDestroyMethods);
}while (targetClass != null && targetClass != Object.class);
return new LifecycleMetadata(clazz, initMethods, destroyMethods);
- @Resource注解和@Autowired注解处理与上述过程类似，这两者解析的结果都被缓存在一个相同的Map(injectionMetadataCache)中。在下次依赖注入时直接从缓存中就可以获取到依赖信息。
回调BeanPostProcessor（四）
第四次回调的作用：在对象没有放入singletonObjects之前调用，返回一个提前暴露的对象，在这个后置处理器中可以对这个bean进行修改
// AbstractAutowireCapableBeanFactory#doCreateBean
boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
isSingletonCurrentlyInCreation(beanName));
if (earlySingletonExposure) {
// getEarlyBeanReference 后置处理器的第四次回调 => AutowiredAnnotationBeanPostProcessor
// SmartInstantiationAwareBeanPostProcessor 的 getEarlyBeanReference 方法
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}
关键在SmartInstantiationAwareBeanPostProcessor#getEarlyBeanReference
// SmartInstantiationAwareBeanPostProcessor#getEarlyBeanReference
public Object getEarlyBeanReference(Object bean, String beanName) throws BeansException {
return bean;
}
这里的addSingletonFactory方法非常的关键，主要是为了解决Spring中循环依赖的问题。
接下来就是解决Bean对象的属性装配和生命周期函数回调
// AbstractAutowireCapableBeanFactory#doCreateBean
Object exposedObject = bean;
// 解决属性装配
populateBean(beanName, mbd, instanceWrapper);
// 调用 BeanPostProcessor实现类的方法和自定义的初始化回调方法
exposedObject = initializeBean(beanName, exposedObject, mbd);
回调BeanPostProcessor（五）
第五次回调后置处理器，断定是否需要进行属性装配，当然默认的都是返回true，表示会自动装配。
// AbstractAutowireCapableBeanFactory#populateBean
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof InstantiationAwareBeanPostProcessor) {
// CommonAnnotationBeanPostProcessor.postProcessAfterInstantiation() => return true
// AutowiredAnnotationBeanPostProcessor.postProcessAfterInstantiation() => return true
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
continueWithPropertyPopulation = false;
break;
}
}
}
}
// 如果不自动注入，在这里就直接返回了
if (!continueWithPropertyPopulation) {
return;
}
选择Bean的装配模式
PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);
// 选择bd的装配模式，默认是 AUTOWIRE_NO
if (mbd.getResolvedAutowireMode() == AUTOWIRE_BY_NAME || mbd.getResolvedAutowireMode() == AUTOWIRE_BY_TYPE) {
MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
// Add property values based on autowire by name if applicable.
if (mbd.getResolvedAutowireMode() == AUTOWIRE_BY_NAME) {
autowireByName(beanName, mbd, bw, newPvs);
}
// Add property values based on autowire by type if applicable.
if (mbd.getResolvedAutowireMode() == AUTOWIRE_BY_TYPE) {
autowireByType(beanName, mbd, bw, newPvs);
}
pvs = newPvs;
}
回调BeanPostProcessor（六）
第六次回调正式进行属性的注入
// 检查是否存在 InstantiationAwareBeanPostProcessor 接口的实现类
boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
// 是否需要深度检查
boolean needsDepCheck = (mbd.getDependencyCheck() != AbstractBeanDefinition.DEPENDENCY_CHECK_NONE);
PropertyDescriptor[] filteredPds = null;
if (hasInstAwareBpps) {
if (pvs == null) {
pvs = mbd.getPropertyValues();
}
// 第六次后置处理器的回调 InstantiationAwareBeanPostProcessor 的 postProcessProperties 方法，处理属性
// CommonAnnotationBeanPostProcessor 处理 Resource 注解
// AutowiredAnnotationBeanPostProcessor 处理 Autowired Inject注解
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
PropertyValues pvsToUse = ibp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
if (pvsToUse == null) {
if (filteredPds == null) {
filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
}
pvsToUse = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
if (pvsToUse == null) {
return;
}
}
pvs = pvsToUse;
}
}
}
if (needsDepCheck) {
if (filteredPds == null) {
filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
}
// 深度检查依赖
checkDependencies(beanName, mbd, filteredPds, pvs);
}
if (pvs != null) {
applyPropertyValues(beanName, mbd, bw, pvs);
}
回调BeanPostProcessor（七、八）
第七次回调是在属性注入完成之后，执行BeanPostProcessor的 postProcessBeforeInitialization 方法，也就是init方法或者@PostConstruct方法。
第八次回调，执行BeanPostProcessor的postProcessAfterInitialization 方法，AOP的代理对象就是在这里生成的。
// AbstractAutowireCapableBeanFactory#initializeBean
protected Object initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd) {
// 回调 BeanNameAware/BeanClassLoaderAware/BeanFactoryAware 接口
invokeAwareMethods(beanName, bean);
Object wrappedBean = bean;
if (mbd == null || !mbd.isSynthetic()) {
// 第七次调用
// beanPostProcessor 的 beanPostProcessorsBeforeInitialization 方法
wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
}
// 调用init方法 @PostConstruct
invokeInitMethods(beanName, wrappedBean, mbd);
if (mbd == null || !mbd.isSynthetic()) {
// beanPostProcessor 的 beanPostProcessorsAfterInitialization 方法
// AOP的代理对象就是在这里生成的
// 第八次调用
wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
}
return wrappedBean;
}
回调BeanPostProcessor（九）
第九次回调，在bean销毁之前的回调，在容器关闭时调用(context.close())
// DisposableBeanAdapter#destroy
public void destroy() {
if (!CollectionUtils.isEmpty(this.beanPostProcessors)) {
// 处理系统中的 DestructionAwareBeanPostProcessor 接口 回调beanPostProcessor
for (DestructionAwareBeanPostProcessor processor : this.beanPostProcessors) {
processor.postProcessBeforeDestruction(this.bean, this.beanName);
}
}
if (this.destroyMethod != null) {
// 处理销毁方法回调 @PreDestroy
invokeCustomDestroyMethod(this.destroyMethod);
}
else if (this.destroyMethodName != null) {
// 调用指定的销毁回调方法
Method methodToInvoke = determineDestroyMethod(this.destroyMethodName);
if (methodToInvoke != null) {
invokeCustomDestroyMethod(ClassUtils.getInterfaceMethodIfPossible(methodToInvoke));
}
}
}
总结：在spring容器中，BeanPostProcessor一共回调了九次