相关文章 Spring 中 bean 注册的源码解析 前言 在上一篇文件Spring 中 bean 注册的源码解析中分析了 Spring 中 bean 的注册过程，就是把配置文件中配置的 bean 的
相关文章
Spring 中 bean 注册的源码解析
前言
在上一篇文件 Spring 中 bean 注册的源码解析 中分析了 Spring 中 bean 的注册过程，就是把配置文件中配置的 bean 的信息加载到内存中，以 BeanDefinition 对象的形式存放，该对象中存放了 bean 的相关属性，下面就以 debug 的形式一步步来看下 bean 是如何创建的。
Spring 中 bean 的创建可以说是非常的复杂，方法嵌套很多，为了更好的理清创建过程，画了下面的 UML 图：
从上述 UML 图中，可以看出 bean 的创建主要分为以下几步：
1. 根据 bean 的 name 解析对应的 class
2. 处理 lookup-metod 和 replace-method 子标签
3. 处理初始化前的后置处理器
4. 真正的创建 bean
4.1 创建 bean 实例
4.1.1 工厂方法创建
4.1.2 带参数的构造方法创建
4.1.3 默认的构造方法创建
4.2
4.3 添加单例对象的工厂缓存
4.4 填充对象的各种属性
4.4.1 名称注入
4.4.2 类型注入
4.5 处理 init-method 方法
4.5.1 处理 bean 的前置处理器
4.5.2 执行 init-method 方法
4.5.3 处理 bean 的后置处理器
创建过程
创建 bean 的代码是在 AbstractAutowireCapableBeanFactory 类中开始创建的，在分析的过程中，会把一些代码省略掉，如异常处理等：
@Overrideprotected Object createBean(String beanName, RootBeanDefinition mbd, Object[] args) throws BeanCreationException { // 表示 <bean> 标签，里面有各种属性 RootBeanDefinition mbdToUse = mbd; // 根据设置的 class 属性或 className 来解析 class， Class<?> resolvedClass = resolveBeanClass(mbd, beanName); if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) { mbdToUse = new RootBeanDefinition(mbd); mbdToUse.setBeanClass(resolvedClass); } // 处理 lookup-method 和 replace-method 子标签 mbdToUse.prepareMethodOverrides(); // 给 BeanPostProcessors 机会返回一个代理来代替bean的实例 // 即在初始化前，应用后置处理器，解析指定的bean是否存在初始化前的短路操作 Object bean = resolveBeforeInstantiation(beanName, mbdToUse); if (bean != null) { return bean; } // 创建 bean Object beanInstance = doCreateBean(beanName, mbdToUse, args); return beanInstance;}处理 lookup-method 和 replace-method 子标签
这两个标签虽然不常用，但是是很有用的，这里不再细说；在 Spring 中 bean 注册的源码解析 中 这两个标签会被解析放到 BeanDefinition 对象的 methodOverrides 属性中，表示需要覆盖的方法；所以在创建bean之前需要解析这两个标签，但是只是预处理：
public void prepareMethodOverrides() throws BeanDefinitionValidationException { // Check that lookup methods exists. MethodOverrides methodOverrides = getMethodOverrides(); if (!methodOverrides.isEmpty()) { Set<MethodOverride> overrides = methodOverrides.getOverrides(); synchronized (overrides) { for (MethodOverride mo : overrides) { prepareMethodOverride(mo); } } }}protected void prepareMethodOverride(MethodOverride mo) throws BeanDefinitionValidationException { // 获取对应类的方法的个数 int count = ClassUtils.getMethodCountForName(getBeanClass(), mo.getMethodName()); if (count == 0) { throw new BeanDefinitionValidationException("..."); } // 标记 MethodOverride 未被覆盖，避免了后面参数类型检查的开销 else if (count == 1) { mo.setOverloaded(false); }}在处理 prepareMethodOverride(MethodOverride mo) 方法为什么只处理方法个数为 1 的情况呢？如果一个类中有多个重载的方法，则调用或增强的时候，还需要进行参数类型的解析才能确定调用的是哪个方法，Spring 把部分功能放在这里提前进行预处理，如果方法只有一个，即没有重载的方法，在后面调用的时候，直接找到该方法调用，不用再去解析参数来确定方法了，这样就可以避免的一些参数类型检查的开销。
实例化的前置处理
如果经过前置处理后的结果不为空，则直接返回，不再进行bean的创建过程，AOP功能就是在这里判断的：
Object bean = resolveBeforeInstantiation(beanName, mbdToUse);if (bean != null) { return bean;}protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) { Object bean = null; if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) { if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) { Class<?> targetType = determineTargetType(beanName, mbd); if (targetType != null) { // bean 的前置处理器 bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName); if (bean != null) { // bean 的后置处理器 bean = applyBeanPostProcessorsAfterInitialization(bean, beanName); } } } mbd.beforeInstantiationResolved = (bean != null); } return bean;}创建 bean
当经过 resolveBeforeInstantiation 方法后，如果程序创建了代理，或者执行了 applyBeanPostProcessorsBeforeInstantiation 和 applyBeanPostProcessorsAfterInitialization 方法后，bean 被改变了，则直接返回，否则，会进行创建bean操作：
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args)throws BeanCreationException { // 最终返回的 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); mbd.resolvedTargetType = beanType; // Allow post-processors to modify the merged bean definition. synchronized (mbd.postProcessingLock) { if (!mbd.postProcessed) { // 应用 MergedBeanDefinitionPostProcessors applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName); mbd.postProcessed = true; } } // 检查循环依赖：是否是单例 && 是否允许循环依赖 && 当前bean是否正在创建中 boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences && isSingletonCurrentlyInCreation(beanName)); if (earlySingletonExposure) { // 为了避免后期的循环依赖，在bean初始化完成前，将创建bean的工厂添加到缓存中，如果其他的bean依赖该bean，直接从缓存中获取对应的工厂创建集合，解决循环依赖，注意是只有单例情况才能这么做 addSingletonFactory(beanName, new ObjectFactory<Object>() { public Object getObject() throws BeansException { return getEarlyBeanReference(beanName, mbd, bean); } }); } // 初始化 bean Object exposedObject = bean; // 填充属性 populateBean(beanName, mbd, instanceWrapper); if (exposedObject != null) { // 执行初始化方法，如 init-method exposedObject = initializeBean(beanName, exposedObject, mbd); } if (earlySingletonExposure) { // 只有在检测到循环依赖时才不会为空 Object earlySingletonReference = getSingleton(beanName, false); // 存在循环依赖 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还没有创建完，即存在循环依赖 if (!actualDependentBeans.isEmpty()) { throw new BeanCurrentlyInCreationException(""); } } } } // 根据 score 注册 bean registerDisposableBeanIfNecessary(beanName, bean, mbd); return exposedObject;}上面创建 bean 的过程很复杂，分为很多步骤，下面再来看看这些步骤：
创建bean实例
创建 bean 的实例，会根据策略使用不同的创建方法，比如说 构造方法创建， 工厂方法创建，默认的构造方法创建等：
protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, Object[] args) { // 获取 bean 对应的 class Class<?> beanClass = resolveBeanClass(mbd, beanName); // 如果工厂方法不为空，则使用工厂方法创建 if (mbd.getFactoryMethodName() != null) { return instantiateUsingFactoryMethod(beanName, mbd, args); } 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); } } // 解析构造方法 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);}参数的构造方法注入
先来看下带参数的构造方法自动注入,
public BeanWrapper autowireConstructor(final String beanName, final RootBeanDefinition mbd, Constructor<?>[] chosenCtors, final Object[] explicitArgs) { BeanWrapperImpl bw = new BeanWrapperImpl(); this.beanFactory.initBeanWrapper(bw); Constructor<?> constructorToUse = null; ArgumentsHolder argsHolderToUse = null; Object[] argsToUse = null; // explicitArgs 参数通过 getBean() 方法传入，Object getBean(String name, Object... args) if (explicitArgs != null) { // 如果 getBean 方法传入了参数，则直接使用 argsToUse = explicitArgs; } else { // 如果 getBean 方法没有传入参数，则从配置文件进行解析 Object[] argsToResolve = null; // 从缓存中获取 synchronized (mbd.constructorArgumentLock) { constructorToUse = (Constructor<?>) mbd.resolvedConstructorOrFactoryMethod; if (constructorToUse != null && mbd.constructorArgumentsResolved) { argsToUse = mbd.resolvedConstructorArguments; if (argsToUse == null) { argsToResolve = mbd.preparedConstructorArguments; } } } if (argsToResolve != null) { // 配置的构造方法参数 argsToUse = resolvePreparedArguments(beanName, mbd, bw, constructorToUse, argsToResolve); } } // 该构造没有被缓存，则需要进行解析 if (constructorToUse == null) { 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, mbd, bw, cargs, resolvedValues); } Constructor<?>[] candidates = chosenCtors; if (candidates == null) { Class<?> beanClass = mbd.getBeanClass(); candidates = (mbd.isNonPublicAccessAllowed() ? beanClass.getDeclaredConstructors() : beanClass.getConstructors()); } // 排序构造方法，按照参数个数进行排序 AutowireUtils.sortConstructors(candidates); int minTypeDiffWeight = Integer.MAX_VALUE; Set<Constructor<?>> ambiguousConstructors = null; for (Constructor<?> candidate : candidates) { Class<?>[] paramTypes = candidate.getParameterTypes(); if (constructorToUse != null && argsToUse.length > paramTypes.length) { // 如果已经找到满足条件的构造方法，则终止 break; } if (paramTypes.length < minNrOfArgs) { continue; } ArgumentsHolder argsHolder; if (resolvedValues != null) { // 构造方法参数的名字 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); } else { // 构造方法没有参数 argsHolder = new ArgumentsHolder(explicitArgs); } // 检查是否有不确定性构造方法的存在，如参数为父子关系 int typeDiffWeight = (mbd.isLenientConstructorResolution() ?argsHolder.getTypeDifferenceWeight(paramTypes) : argsHolder.getAssignabilityWeight(paramTypes)); 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) { throw new BeanCreationException("...") } // 将解析的构造方法加入缓存 if (explicitArgs == null) { argsHolderToUse.storeCache(mbd, constructorToUse); } } // 实例化 Object beanInstance; if (System.getSecurityManager() != null) { final Constructor<?> ctorToUse = constructorToUse; final Object[] argumentsToUse = argsToUse; beanInstance = AccessController.doPrivileged(new PrivilegedAction<Object>() { public Object run() { return beanFactory.getInstantiationStrategy().instantiate( mbd, beanName, beanFactory, ctorToUse, argumentsToUse); } }, beanFactory.getAccessControlContext()); } else { beanInstance = this.beanFactory.getInstantiationStrategy().instantiate( mbd, beanName, this.beanFactory, constructorToUse, argsToUse); } bw.setBeanInstance(beanInstance); return bw;}上面的方法就是使用构造方法进行实例化bean的过程，很复杂，也有很多的辅助方法，下面来看下实例化的过程：
实例化有两种方式，CGLIB 和 反射：
beanFactory.getInstantiationStrategy().instantiate(mbd, beanName, beanFactory, ctorToUse);先来看下 getInstantiationStrategy 方法返回什么？
protected InstantiationStrategy getInstantiationStrategy() { return this.instantiationStrategy;}private InstantiationStrategy instantiationStrategy = new CglibSubclassingInstantiationStrategy();它返回的是 InstantiationStrategy 接口，而接口由两个实现类：
public Object instantiate(RootBeanDefinition bd, String beanName, BeanFactory owner, final Constructor<?> ctor, Object... args) { // 如果没有需要动态改变的方法，则直接使用反射进行实例化 if (bd.getMethodOverrides().isEmpty()) { if (System.getSecurityManager() != null) { AccessController.doPrivileged(new PrivilegedAction<Object>() { @Override public Object run() { ReflectionUtils.makeAccessible(ctor); return null; } }); } // 使用 反射 实例化 return BeanUtils.instantiateClass(ctor, args); } else { // 如果需要覆盖或者动态替换的方法，则需要使用 CGLIB 来动态代理，在创建代理的时候，可以增强植入我们的代码 return instantiateWithMethodInjection(bd, beanName, owner, ctor, args); }}使用工厂方法创建实例和构造方法参不多，使用默认的构造方法实例化比较简单，这里就不列出来了。
属性填充
在上面分析 doCreateBean 方法的时候，当通过 工厂方法，带参数的构造方法或默认的构造方法创建了 bean 实例后，需要对 bean 的属性进行设置
protected void populateBean(String beanName, RootBeanDefinition mbd, BeanWrapper bw) { PropertyValues pvs = mbd.getPropertyValues(); // 给 InstantiationAwareBeanPostProcessor 最后一次机会在属性设置前来改变 bean boolean continueWithPropertyPopulation = true; if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) { for (BeanPostProcessor bp : getBeanPostProcessors()) { if (bp instanceof InstantiationAwareBeanPostProcessor) { InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp; // postProcessAfterInstantiation 返回值为是否继续填充 bean if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) { continueWithPropertyPopulation = false; break; } } } } if (!continueWithPropertyPopulation) { return; } if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME || mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) { MutablePropertyValues newPvs = new MutablePropertyValues(pvs); // 名称注入 if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME) { autowireByName(beanName, mbd, bw, newPvs); } // 类型注入 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; // 对所有需要依赖检查的属性进行后置处理 pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(),beanName); if (pvs == null) { return; } } } } if (needsDepCheck) { checkDependencies(beanName, mbd, filteredPds, pvs); } } // 将属性应用到 bean 中 applyPropertyValues(beanName, mbd, bw, pvs);}关于 名称 注入和类型注入，后面单独分析
将属性应用到 bean 中：
到这里，已经完成了对注入属性的获取，但是获取的是 PropereyValues 的形式存在，现在将他们应用到 bean 中去:
protected void applyPropertyValues(String beanName, BeanDefinition mbd, BeanWrapper bw, PropertyValues pvs) { if (pvs == null || pvs.isEmpty()) { return; } if (System.getSecurityManager() != null && bw instanceof BeanWrapperImpl) { ((BeanWrapperImpl) bw).setSecurityContext(getAccessControlContext()); } MutablePropertyValues mpvs = null; List<PropertyValue> original; if (pvs instanceof MutablePropertyValues) { // 如果 mpvs 中的值已经被转换为对应的类型，则可以直接设置到 beanWapper 中 mpvs = (MutablePropertyValues) pvs; if (mpvs.isConverted()) { bw.setPropertyValues(mpvs); return; } original = mpvs.getPropertyValueList(); } else { // 如果 pvs 不是 MutablePropertyValues 封装的类，则直接使用原始的属性获取方法 original = Arrays.asList(pvs.getPropertyValues()); } // 获取用户自定义的类型转换器 TypeConverter converter = getCustomTypeConverter(); if (converter == null) { converter = bw; } / 获取对应的解析器 BeanDefinitionValueResolver valueResolver = new BeanDefinitionValueResolver(this, beanName, mbd, converter); List<PropertyValue> deepCopy = new ArrayList<PropertyValue>(original.size()); boolean resolveNecessary = false; // 遍历属性，将属性转换为对应类的对应属性的类型 for (PropertyValue pv : original) { if (pv.isConverted()) { deepCopy.add(pv); } else { String propertyName = pv.getName(); Object originalValue = pv.getValue(); Object resolvedValue = valueResolver.resolveValueIfNecessary(pv, originalValue); Object convertedValue = resolvedValue; boolean convertible = bw.isWritableProperty(propertyName) && !PropertyAccessorUtils.isNestedOrIndexedProperty(propertyName); if (convertible) { convertedValue = convertForProperty(resolvedValue, propertyName, bw, converter); } if (resolvedValue == originalValue) { if (convertible) { pv.setConvertedValue(convertedValue); } deepCopy.add(pv); } else if (convertible && originalValue instanceof TypedStringValue && !((TypedStringValue) originalValue).isDynamic() && !(convertedValue instanceof Collection || ObjectUtils.isArray(convertedValue))) { pv.setConvertedValue(convertedValue); deepCopy.add(pv); } else { resolveNecessary = true; deepCopy.add(new PropertyValue(pv, convertedValue)); } } } if (mpvs != null && !resolveNecessary) { mpvs.setConverted(); } bw.setPropertyValues(new MutablePropertyValues(deepCopy));}执行初始化方法
protected Object initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd) { // 执行用户自定义的各种 aware 方法 invokeAwareMethods(beanName, bean); Object wrappedBean = bean; if (mbd == null || !mbd.isSynthetic()) { // 在执行 init 方法之前，先执行 前置处理器 applyBeanPostProcessorsBeforeInitialization wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName); } // 执行初始化方法 invokeInitMethods(beanName, wrappedBean, mbd); // 执行后置处理器 applyBeanPostProcessorsAfterInitialization if (mbd == null || !mbd.isSynthetic()) { wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName); } return wrappedBean;}// 执行用户自定义的各种 aware 方法 private void invokeAwareMethods(final String beanName, final Object bean) { if (bean instanceof Aware) { if (bean instanceof BeanNameAware) { ((BeanNameAware) bean).setBeanName(beanName); } if (bean instanceof BeanClassLoaderAware) { ((BeanClassLoaderAware) bean).setBeanClassLoader(getBeanClassLoader()); } if (bean instanceof BeanFactoryAware) { ((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this); } }}到这里，bean 创建的大致过程就结束了
