- 抽象bean工厂是一个用于创建和管理bean的类。它提供了创建bean的标准功能，并按照RootBeanDefinition类的规范实现了完整的功能。此外，它还实现了AutowireCapableBeanFactory接口，该接口定义了用于自动装配bean的方法。
- 抽象bean工厂提供了bean的创建（包括构造函数解析）、属性注入、装配（包括自动装配）和初始化等功能。它处理运行时的bean引用，解析管理的集合，调用初始化方法等操作。它支持通过构造函数进行自动装配、按名称进行属性注入以及按类型进行属性注入。
- 抽象bean工厂中的关键模板方法是
resolveDependency，用于解析依赖关系并进行自动装配。子类需要根据具体的实现方式，实现这个方法以支持按类型进行自动装配。对于那些能够搜索其bean定义的工厂，通常会通过搜索匹配的bean。而对于其他类型的工厂，可以实现简化的匹配算法来找到合适的依赖对象。 - 抽象bean工厂只提供了基本的bean创建、属性注入和初始化等功能，并没有具体实现bean定义的注册操作。如果需要在工厂中注册和管理bean定义，可以使用DefaultListableBeanFactory类来实现。
public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory
implements AutowireCapableBeanFactory {}-
factoryBeanInstanceCache用于缓存未完成的FactoryBean实例，其中键是FactoryBean的名称，值是与该FactoryBean相关联的BeanWrapper对象。 - 在Spring框架中，
FactoryBean是一种特殊的Bean，它负责创建和管理其他Bean的实例。每当使用getBean方法获取FactoryBean的实例时，Spring容器会检查缓存中是否存在该FactoryBean的实例，在缓存中找到对应的BeanWrapper对象后，可以直接返回已经创建的实例，从而避免重复创建。 - 需要注意的是，
factoryBeanInstanceCache仅用于缓存未完成的FactoryBean实例，即那些处于创建过程中但还未完成的实例。一旦FactoryBean实例完成创建，它将不再存在于该缓存中。
/** Cache of unfinished FactoryBean instances: FactoryBean name to BeanWrapper. */
private final ConcurrentMap<String, BeanWrapper> factoryBeanInstanceCache = new ConcurrentHashMap<>();
-
AbstractAutowireCapableBeanFactory()
这段代码是创建一个新的
AbstractAutowireCapableBeanFactory的构造函数。在构造函数中，做了一些初始化操作。首先，调用了父类的无参构造函数
super()进行初始化。然后，通过
ignoreDependencyInterface方法忽略了一些特定接口的依赖关系。在这个例子中，忽略了BeanNameAware、BeanFactoryAware和BeanClassLoaderAware接口的依赖关系。这意味着如果某个Bean实现了这些接口，Spring容器将不会自动处理这些接口的依赖注入。接下来，通过判断当前应用是否运行在Native Image环境下（通过调用
NativeDetector.inNativeImage()），来确定使用哪种实例化策略。如果当前应用运行在Native Image环境下，使用
SimpleInstantiationStrategy作为实例化策略。如果不是运行在Native Image环境下，则使用
CglibSubclassingInstantiationStrategy作为实例化策略。通过不同的实例化策略，可以选择使用不同的方式来创建Bean的实例。
SimpleInstantiationStrategy 是一种简单的实例化策略，主要使用Java的反射机制来实现实例化，而CglibSubclassingInstantiationStrategy 则是使用CGLIB库来创建Bean的子类来实现实例化。
public AbstractAutowireCapableBeanFactory() {
super();
ignoreDependencyInterface(BeanNameAware.class);
ignoreDependencyInterface(BeanFactoryAware.class);
ignoreDependencyInterface(BeanClassLoaderAware.class);
if (NativeDetector.inNativeImage()) {
this.instantiationStrategy = new SimpleInstantiationStrategy();
}
else {
this.instantiationStrategy = new CglibSubclassingInstantiationStrategy();
}
}- createBean(Class<T> beanClass)
在这个方法中，首先创建一个 RootBeanDefinition对象，并传入指定的 beanClass来定义一个原型（prototype）作用域的Bean定义。
然后，设置该Bean定义的作用域为原型作用域（SCOPE_PROTOTYPE），表示每次获取该Bean时都会创建一个新的实例。
接下来，根据 beanClass是否是缓存安全（cache-safe）的类型，设置Bean定义的 allowCaching属性。如果 beanClass是缓存安全的，则可以允许缓存Bean实例。否则，不允许缓存。
最后，调用重载的 createBean方法，传入 beanClass.getName()作为Bean的名称，创建Bean实例并返回。
@Override
@SuppressWarnings("unchecked")
public <T> T createBean(Class<T> beanClass) throws BeansException {
// Use prototype bean definition, to avoid registering bean as dependent bean.
RootBeanDefinition bd = new RootBeanDefinition(beanClass);
bd.setScope(SCOPE_PROTOTYPE);
bd.allowCaching = ClassUtils.isCacheSafe(beanClass, getBeanClassLoader());
return (T) createBean(beanClass.getName(), bd, null);
}- autowireBean(Object existingBean)
在这个方法中，首先创建一个 RootBeanDefinition对象，并使用 ClassUtils.getUserClass(existingBean)获取现有Bean实例的用户类。用户类是指具体类，而不是代理类或者CGLIB生成的子类。
然后，设置该Bean定义的作用域为原型作用域（SCOPE_PROTOTYPE），表示每次获取该Bean时都会创建一个新的实例。
接下来，根据Bean定义的类是否是缓存安全的，设置Bean定义的 allowCaching属性。如果Bean定义的类是缓存安全的，则允许缓存Bean实例。否则，不允许缓存。
之后，创建一个 BeanWrapperImpl对象，将现有的Bean对象包装起来，以便进行属性的注入和赋值操作。
调用 initBeanWrapper方法对 BeanWrapperImpl进行初始化，以确保其内部状态正确设置，以便进行属性注入和赋值。
最后，调用 populateBean方法，传入Bean名称、Bean定义和 BeanWrapper对象，进行属性的自动注入。
@Override
public void autowireBean(Object existingBean) {
// Use non-singleton bean definition, to avoid registering bean as dependent bean.
RootBeanDefinition bd = new RootBeanDefinition(ClassUtils.getUserClass(existingBean));
bd.setScope(SCOPE_PROTOTYPE);
bd.allowCaching = ClassUtils.isCacheSafe(bd.getBeanClass(), getBeanClassLoader());
BeanWrapper bw = new BeanWrapperImpl(existingBean);
initBeanWrapper(bw);
populateBean(bd.getBeanClass().getName(), bd, bw);
}-
configureBean(Object existingBean, String beanName)
configureBean方法的功能是对已存在的Bean对象进行配置，包括标记为已创建状态、获取合并的Bean定义、设置作用域和缓存属性、进行属性注入和初始化等操作，以确保现有Bean对象的正确配置和初始化。
@Override
public Object configureBean(Object existingBean, String beanName) throws BeansException {
markBeanAsCreated(beanName);
BeanDefinition mbd = getMergedBeanDefinition(beanName);
RootBeanDefinition bd = null;
if (mbd instanceof RootBeanDefinition) {
RootBeanDefinition rbd = (RootBeanDefinition) mbd;
bd = (rbd.isPrototype() ? rbd : rbd.cloneBeanDefinition());
}
if (bd == null) {
bd = new RootBeanDefinition(mbd);
}
if (!bd.isPrototype()) {
bd.setScope(SCOPE_PROTOTYPE);
bd.allowCaching = ClassUtils.isCacheSafe(ClassUtils.getUserClass(existingBean), getBeanClassLoader());
}
BeanWrapper bw = new BeanWrapperImpl(existingBean);
initBeanWrapper(bw);
populateBean(beanName, bd, bw);
return initializeBean(beanName, existingBean, bd);
}-
autowire(Class<?> beanClass, int autowireMode, boolean dependencyCheck)
autowire方法用于自动装配指定类型的Bean对象，根据自动装配模式和依赖检查的设置，创建一个非单例、原型作用域的Bean定义，并通过适当的方式实例化Bean对象。然后，对该Bean对象进行属性的自动注入。最终返回创建的Bean对象或通过构造器注入后的实例对象。注意，该方法使用的是原型作用域的Bean定义，以避免将该Bean注册为其他Bean的依赖关系。
@Override
public Object autowire(Class<?> beanClass, int autowireMode, boolean dependencyCheck) throws BeansException {
// Use non-singleton bean definition, to avoid registering bean as dependent bean.
RootBeanDefinition bd = new RootBeanDefinition(beanClass, autowireMode, dependencyCheck);
bd.setScope(SCOPE_PROTOTYPE);
if (bd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR) {
return autowireConstructor(beanClass.getName(), bd, null, null).getWrappedInstance();
}
else {
Object bean;
if (System.getSecurityManager() != null) {
bean = AccessController.doPrivileged(
(PrivilegedAction<Object>) () -> getInstantiationStrategy().instantiate(bd, null, this),
getAccessControlContext());
}
else {
bean = getInstantiationStrategy().instantiate(bd, null, this);
}
populateBean(beanClass.getName(), bd, new BeanWrapperImpl(bean));
return bean;
}
}- applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
这个方法的功能是在Bean对象初始化之前，依次应用注册的Bean后置处理器对Bean对象进行处理，并返回处理后的最终结果。可以在这里添加一些自定义的逻辑来对Bean对象进行进一步的处理。
@Override
public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
throws BeansException {
Object result = existingBean;
for (BeanPostProcessor processor : getBeanPostProcessors()) {
Object current = processor.postProcessBeforeInitialization(result, beanName);
if (current == null) {
return result;
}
result = current;
}
return result;
}- createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
核心方法。该方法负责创建Bean实例、填充Bean实例、应用后置处理器等操作 。
@Override
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
throws BeanCreationException {
if (logger.isTraceEnabled()) {
logger.trace("Creating instance of bean '" + beanName + "'");
}
RootBeanDefinition mbdToUse = mbd;
// Make sure bean class is actually resolved at this point, and
// clone the bean definition in case of a dynamically resolved Class
// which cannot be stored in the shared merged bean definition.
Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
mbdToUse = new RootBeanDefinition(mbd);
mbdToUse.setBeanClass(resolvedClass);
}
// Prepare method overrides.
try {
mbdToUse.prepareMethodOverrides();
}
catch (BeanDefinitionValidationException ex) {
throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
beanName, "Validation of method overrides failed", ex);
}
try {
// Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
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);
}
try {
Object beanInstance = doCreateBean(beanName, mbdToUse, args);
if (logger.isTraceEnabled()) {
logger.trace("Finished creating instance of bean '" + beanName + "'");
}
return beanInstance;
}
catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
// A previously detected exception with proper bean creation context already,
// or illegal singleton state to be communicated up to DefaultSingletonBeanRegistry.
throw ex;
}
catch (Throwable ex) {
throw new BeanCreationException(
mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);
}
}-
doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
这个核心方法的功能是实际上创建Bean实例，并在创建过程中进行属性填充、初始化和后置处理等操作。它还负责处理循环引用和Bean的销毁等相关逻辑。
-
首先，根据Bean定义的作用域确定是否从工厂缓存中获取Bean实例的包装器（
instanceWrapper）对象。如果Bean是单例作用域且缓存中存在，则从缓存中移除并将其赋值给instanceWrapper，否则调用createBeanInstance方法创建新的实例包装器。 -
然后，通过实例包装器获取Bean实例和Bean类型，并将Bean类型设置到Bean定义中。这一步主要是为了记录解析后的目标类型。
-
接下来，使用
synchronized关键字对mbd.postProcessingLock进行加锁，确保在后续的处理中只有一个线程能够执行。在加锁的情况下，将会应用所有注册的Bean定义后置处理器，并在处理完成后将mbd.postProcessed标志设置为true，以避免重复处理。 -
如果Bean是单例作用域且允许循环引用，并且当前正在创建的Bean是一个单例Bean，则会将该Bean提前暴露给其他Bean，以解决潜在的循环引用问题。如果启用了跟踪日志，则会记录相应的日志信息。
-
接着，调用
populateBean方法填充Bean的属性值，这包括属性注入和依赖处理等操作。 -
然后，调用
initializeBean方法对Bean进行初始化。这一步会应用所有注册的Bean后置处理器，并执行初始化回调方法（例如InitializingBean接口的afterPropertiesSet方法）。 -
如果之前提前暴露了单例Bean，并且在初始化过程中创建了其他Bean的原始引用，并且配置禁止原始注入嵌套包装，则会抛出
BeanCurrentlyInCreationException异常，以防止原始引用的使用。 -
接下来，根据需要将Bean注册为可销毁的Bean对象，以确保在容器关闭时能够正确地销毁Bean实例。
-
最后，返回经过初始化处理后的Bean实例。
protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
throws BeanCreationException {
// Instantiate the bean.
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
if (instanceWrapper == null) {
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
Object bean = instanceWrapper.getWrappedInstance();
Class<?> beanType = instanceWrapper.getWrappedClass();
if (beanType != NullBean.class) {
mbd.resolvedTargetType = beanType;
}
// Allow post-processors to modify the merged bean definition.
synchronized (mbd.postProcessingLock) {
if (!mbd.postProcessed) {
try {
applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
}
catch (Throwable ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Post-processing of merged bean definition failed", ex);
}
mbd.postProcessed = true;
}
}
// Eagerly cache singletons to be able to resolve circular references
// even when triggered by lifecycle interfaces like BeanFactoryAware.
boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
isSingletonCurrentlyInCreation(beanName));
if (earlySingletonExposure) {
if (logger.isTraceEnabled()) {
logger.trace("Eagerly caching bean '" + beanName +
"' to allow for resolving potential circular references");
}
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}
// Initialize the bean instance.
Object exposedObject = bean;
try {
populateBean(beanName, mbd, instanceWrapper);
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);
if (earlySingletonReference != null) {
if (exposedObject == bean) {
exposedObject = earlySingletonReference;
}
else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
String[] dependentBeans = getDependentBeans(beanName);
Set<String> actualDependentBeans = new LinkedHashSet<>(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 " +
"'getBeanNamesForType' 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(), beanName, "Invalid destruction signature", ex);
}
return exposedObject;
}- getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean)
这个方法的功能是在bean实例化过程中提前获取对特定bean的引用。通常用于解决循环依赖的问题。通过提前获取一个依赖bean的引用，可以将该引用注入到依赖它的其他bean中。
这个方法的主要作用是通过执行已注册的SmartInstantiationAwareBeanPostProcessor实现类的getEarlyBeanReference方法来处理实例化前的逻辑。
protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {
Object exposedObject = bean;
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
for (SmartInstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().smartInstantiationAware) {
exposedObject = bp.getEarlyBeanReference(exposedObject, beanName);
}
}
return exposedObject;
}-
getSingletonFactoryBeanForTypeCheck(String beanName, RootBeanDefinition mbd)
这个方法用于获取用于类型检查的单例FactoryBean实例。
首先，它在同步块中检查了factoryBeanInstanceCache（FactoryBean实例缓存）是否存在指定beanName对应的BeanWrapper（Bean包装器），如果存在，则获取并返回其中的FactoryBean实例。
如果factoryBeanInstanceCache中不存在指定beanName对应的BeanWrapper，则通过getSingleton方法获取该bean的实例。如果该实例是FactoryBean的实现类，则将其强制转换为FactoryBean实例并返回；否则，继续进行后续处理。
接下来，它检查了当前是否正在创建指定beanName或其工厂bean的实例，如果是，则直接返回null。
然后，它开始创建bean的实例。在创建之前，它调用了beforeSingletonCreation方法将该bean标记为正在创建中。然后，它尝试调用resolveBeforeInstantiation方法解析实例化前的逻辑，如果返回的实例为空，则调用createBeanInstance方法创建bean的实例。
在创建bean实例过程中，如果出现了UnsatisfiedDependencyException或BeanCreationException等异常，则会抛出这些异常，不会被捕获，以保证正常的异常处理。
最后，它通过getFactoryBean方法获取FactoryBean实例，并将其返回。如果在之前已经获取到了BeanWrapper，则将BeanWrapper存储到factoryBeanInstanceCache中。
@Nullable
private FactoryBean<?> getSingletonFactoryBeanForTypeCheck(String beanName, RootBeanDefinition mbd) {
synchronized (getSingletonMutex()) {
BeanWrapper bw = this.factoryBeanInstanceCache.get(beanName);
if (bw != null) {
return (FactoryBean<?>) bw.getWrappedInstance();
}
Object beanInstance = getSingleton(beanName, false);
if (beanInstance instanceof FactoryBean) {
return (FactoryBean<?>) beanInstance;
}
if (isSingletonCurrentlyInCreation(beanName) ||
(mbd.getFactoryBeanName() != null && isSingletonCurrentlyInCreation(mbd.getFactoryBeanName()))) {
return null;
}
Object instance;
try {
// Mark this bean as currently in creation, even if just partially.
beforeSingletonCreation(beanName);
// Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
instance = resolveBeforeInstantiation(beanName, mbd);
if (instance == null) {
bw = createBeanInstance(beanName, mbd, null);
instance = bw.getWrappedInstance();
}
}
catch (UnsatisfiedDependencyException ex) {
// Don't swallow, probably misconfiguration...
throw ex;
}
catch (BeanCreationException ex) {
// Don't swallow a linkage error since it contains a full stacktrace on
// first occurrence... and just a plain NoClassDefFoundError afterwards.
if (ex.contains(LinkageError.class)) {
throw ex;
}
// Instantiation failure, maybe too early...
if (logger.isDebugEnabled()) {
logger.debug("Bean creation exception on singleton FactoryBean type check: " + ex);
}
onSuppressedException(ex);
return null;
}
finally {
// Finished partial creation of this bean.
afterSingletonCreation(beanName);
}
FactoryBean<?> fb = getFactoryBean(beanName, instance);
if (bw != null) {
this.factoryBeanInstanceCache.put(beanName, bw);
}
return fb;
}
}- resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd)
该方法接受bean的名称（beanName）和Bean定义（mbd）作为参数。
首先，它初始化了一个名为"bean"的null对象。然后，它检查mbd中的beforeInstantiationResolved属性是否为false或null。
如果beforeInstantiationResolved不等于false，则继续执行下面的逻辑。它首先确保此时Bean的类已经解析成功（非合成的，并且存在实例化Aware类型的BeanPostProcessor）。
随后，它调用determineTargetType方法确定Bean的目标类型。如果确定了目标类型，则调用applyBeanPostProcessorsBeforeInstantiation方法，在实例化之前应用BeanPostProcessor的前置处理器，并将目标类型和Bean名称作为参数传递进去。
如果通过前置处理器成功获取到了bean实例，则调用applyBeanPostProcessorsAfterInitialization方法，在初始化之后再次应用BeanPostProcessor的处理器，并将bean实例和bean名称作为参数传递进去。
最后，通过设置mbd的beforeInstantiationResolved属性，表示是否已解析出"实例化前快捷方式"。
最终，返回解析出的bean实例。
@Nullable
protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
Object bean = null;
if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
// Make sure bean class is actually resolved at this point.
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
Class<?> targetType = determineTargetType(beanName, mbd);
if (targetType != null) {
bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
if (bean != null) {
bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
}
}
}
mbd.beforeInstantiationResolved = (bean != null);
}
return bean;
}- createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
该方法接受bean的名称（beanName）、bean定义（mbd）和用于构造函数或工厂方法调用的显式参数（args）作为参数。
在方法内部，首先通过resolveBeanClass方法解析出bean的类。如果bean类不为null且不是public修饰的，并且bean定义中不允许使用非公开访问，则会抛出BeanCreationException异常。
接下来，它检查bean定义中是否指定了instanceSupplier，如果有，则通过obtainFromSupplier方法从supplier获取bean实例。
然后，它检查bean定义中是否指定了factoryMethodName，如果有，则调用instantiateUsingFactoryMethod方法使用工厂方法来实例化bean。
如果没有工厂方法，则进入下面的逻辑。根据提供的参数args是否为null，如果为null，则使用synchronized块来确保线程安全地获得已解析的构造函数或工厂方法。
如果已解析，则根据是否需要自动装配来返回相应的实例。如果需要自动装配，则调用autowireConstructor方法进行自动装配，否则调用instantiateBean方法来创建实例。
如果没有解析构造函数，则继续执行下面的逻辑。它尝试从BeanPostProcessor中确定自动装配的候选构造函数。如果存在候选构造函数，或者bean定义中指定了AUTOWIRE_CONSTRUCTOR自动装配模式，或者bean定义中已经设置了构造函数参数值，或者提供了显式的args参数，则调用autowireConstructor方法进行自动装配。
如果没有候选构造函数，则继续执行下面的逻辑。它尝试从bean定义中获取优选的构造函数，并调用autowireConstructor方法进行自动装配。
最后，如果没有进行特殊处理，则使用无参构造函数来实例化bean并返回。
protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
// Make sure bean class is actually resolved at this point.
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());
}
Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
if (instanceSupplier != null) {
return obtainFromSupplier(instanceSupplier, beanName);
}
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);
}
}
// Candidate constructors for autowiring?
Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
return autowireConstructor(beanName, mbd, ctors, args);
}
// Preferred constructors for default construction?
ctors = mbd.getPreferredConstructors();
if (ctors != null) {
return autowireConstructor(beanName, mbd, ctors, null);
}
// No special handling: simply use no-arg constructor.
return instantiateBean(beanName, mbd);
}- instantiateBean(String beanName, RootBeanDefinition mbd)
该方法接受bean的名称（beanName）和bean定义（mbd）作为参数。
在方法内部，首先声明一个名为"beanInstance"的变量。
然后，它检查当前是否存在安全管理器（System.getSecurityManager() != null）。如果存在安全管理器，则使用AccessController.doPrivileged方法来执行获取实例化策略的实例化操作。这是为了确保在有安全管理器的情况下，可以以特权方式执行实例化操作。
接着，通过调用getInstantiationStrategy().instantiate(mbd, beanName, this)方法来实例化bean。getInstantiationStrategy()方法是从容器中获取相应的实例化策略对象。
接下来，使用实例化的bean创建一个BeanWrapper，并初始化BeanWrapper的相关属性。
最后，返回创建的BeanWrapper。
/**
* Instantiate the given bean using its default constructor.
* @param beanName the name of the bean
* @param mbd the bean definition for the bean
* @return a BeanWrapper for the new instance
*/
protected BeanWrapper instantiateBean(String beanName, RootBeanDefinition mbd) {
try {
Object beanInstance;
if (System.getSecurityManager() != null) {
beanInstance = AccessController.doPrivileged(
(PrivilegedAction<Object>) () -> getInstantiationStrategy().instantiate(mbd, beanName, this),
getAccessControlContext());
}
else {
beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, this);
}
BeanWrapper bw = new BeanWrapperImpl(beanInstance);
initBeanWrapper(bw);
return bw;
}
catch (Throwable ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Instantiation of bean failed", ex);
}
}- populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw)
这个方法是Spring框架中的一个核心方法，其主要功能是根据给定的bean定义，将属性值填充到BeanWrapper的bean实例中。
具体而言，它执行以下操作：
-
首先，检查传入的BeanWrapper是否为null。如果为null，并且bean定义中有属性值需要设置，将抛出异常。否则，直接跳过对null实例的属性填充阶段。
-
如果BeanWrapper不为null，将进行属性填充的逻辑。
-
如果bean定义不是合成的（非代理对象），并且存在InstantiationAwareBeanPostProcessor的后处理器，在设置属性之前，会调用这些后处理器的postProcessAfterInstantiation()方法，给它们在属性设置之前修改bean状态的机会。
-
获取bean定义中的属性值（PropertyValues）。如果bean定义没有属性值，那么会得到一个null。
-
检查bean定义中是否已解析了自动装配模式。如果是按名称自动装配，将创建一个新的MutablePropertyValues对象，根据bean的名称进行属性自动装配；如果是按类型自动装配，也会创建一个新的MutablePropertyValues对象，根据bean的类型进行属性自动装配。最终得到更新后的PropertyValues。
-
检查是否存在InstantiationAwareBeanPostProcessor的后处理器，然后依次调用它们的postProcessProperties()和postProcessPropertyValues()方法，对PropertyValues进行后处理。通过这些后处理器，可以对属性值进行修改或添加新的属性值。
-
根据bean定义中的依赖检查模式，检查bean的属性和依赖是否匹配。如果需要进行依赖检查，会执行检查逻辑，确保所有依赖的属性都已设置。
-
最后，将得到的PropertyValues应用于BeanWrapper的bean实例，完成属性的填充。
/**
* Populate the bean instance in the given BeanWrapper with the property values
* from the bean definition.
* @param beanName the name of the bean
* @param mbd the bean definition for the bean
* @param bw the BeanWrapper with bean instance
*/
@SuppressWarnings("deprecation") // for postProcessPropertyValues
protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
if (bw == null) {
if (mbd.hasPropertyValues()) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");
}
else {
// Skip property population phase for null instance.
return;
}
}
// Give any InstantiationAwareBeanPostProcessors the opportunity to modify the
// state of the bean before properties are set. This can be used, for example,
// to support styles of field injection.
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
for (InstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().instantiationAware) {
if (!bp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
return;
}
}
}
PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);
int resolvedAutowireMode = mbd.getResolvedAutowireMode();
if (resolvedAutowireMode == AUTOWIRE_BY_NAME || resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
// Add property values based on autowire by name if applicable.
if (resolvedAutowireMode == AUTOWIRE_BY_NAME) {
autowireByName(beanName, mbd, bw, newPvs);
}
// Add property values based on autowire by type if applicable.
if (resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
autowireByType(beanName, mbd, bw, newPvs);
}
pvs = newPvs;
}
boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
boolean needsDepCheck = (mbd.getDependencyCheck() != AbstractBeanDefinition.DEPENDENCY_CHECK_NONE);
PropertyDescriptor[] filteredPds = null;
if (hasInstAwareBpps) {
if (pvs == null) {
pvs = mbd.getPropertyValues();
}
for (InstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().instantiationAware) {
PropertyValues pvsToUse = bp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
if (pvsToUse == null) {
if (filteredPds == null) {
filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
}
pvsToUse = bp.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);
}
}- autowireByName(
String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs)
这个方法的功能是根据bean定义中的属性依赖，查找容器中对应名称的其他bean，并将它们填充到目标bean的属性中。具体而言，它执行以下操作：
-
首先，获取未满足依赖且非简单属性的名称列表。这些属性是需要进行自动装配的属性。
-
遍历属性名称列表，对于每个属性名称，判断容器中是否存在对应名称的其他bean。
-
如果存在对应名称的其他bean，则获取该bean，并将其添加到目标bean的PropertyValues中，完成属性的自动装配。
-
同时，将当前属性作为依赖关系注册到容器中，以表明它依赖于其他bean。
-
如果日志级别为跟踪（Trace），则打印相关的跟踪日志，记录完成了按名称自动装配的操作。
/**
* Fill in any missing property values with references to
* other beans in this factory if autowire is set to "byName".
* @param beanName the name of the bean we're wiring up.
* Useful for debugging messages; not used functionally.
* @param mbd bean definition to update through autowiring
* @param bw the BeanWrapper from which we can obtain information about the bean
* @param pvs the PropertyValues to register wired objects with
*/
protected void autowireByName(
String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) {
String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);
for (String propertyName : propertyNames) {
if (containsBean(propertyName)) {
Object bean = getBean(propertyName);
pvs.add(propertyName, bean);
registerDependentBean(propertyName, beanName);
if (logger.isTraceEnabled()) {
logger.trace("Added autowiring by name from bean name '" + beanName +
"' via property '" + propertyName + "' to bean named '" + propertyName + "'");
}
}
else {
if (logger.isTraceEnabled()) {
logger.trace("Not autowiring property '" + propertyName + "' of bean '" + beanName +
"' by name: no matching bean found");
}
}
}
}- autowireByType(
String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs)
这个方法的功能是根据bean定义中的属性依赖，通过类型匹配的方式，查找容器中与属性类型匹配的其他bean，并将它们填充到目标bean的属性中。具体而言，它执行以下操作：
-
首先，获取未满足依赖且非简单属性的名称列表。这些属性是需要进行自动装配的属性。
-
遍历属性名称列表，对于每个属性名称，获取BeanWrapper中关联属性的PropertyDescriptor。
-
判断属性类型是否为Object类。如果不是Object类，则创建一个描述依赖的DependencyDescriptor，并指定是否立即初始化相关bean。
-
调用resolveDependency()方法，解决依赖并获取依赖的实例。该方法会根据属性的类型，匹配容器中对应的bean，并返回实例。
-
如果获取到了依赖的实例，将其添加到目标bean的PropertyValues中，完成属性的自动装配。
-
同时，将被自动装配的依赖的bean名称注册为当前bean的依赖关系。
-
如果日志级别为跟踪（Trace），则打印相关的跟踪日志，记录完成了按类型自动装配的操作。
/**
* Abstract method defining "autowire by type" (bean properties by type) behavior.
* <p>This is like PicoContainer default, in which there must be exactly one bean
* of the property type in the bean factory. This makes bean factories simple to
* configure for small namespaces, but doesn't work as well as standard Spring
* behavior for bigger applications.
* @param beanName the name of the bean to autowire by type
* @param mbd the merged bean definition to update through autowiring
* @param bw the BeanWrapper from which we can obtain information about the bean
* @param pvs the PropertyValues to register wired objects with
*/
protected void autowireByType(
String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) {
TypeConverter converter = getCustomTypeConverter();
if (converter == null) {
converter = bw;
}
Set<String> autowiredBeanNames = new LinkedHashSet<>(4);
String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);
for (String propertyName : propertyNames) {
try {
PropertyDescriptor pd = bw.getPropertyDescriptor(propertyName);
// Don't try autowiring by type for type Object: never makes sense,
// even if it technically is a unsatisfied, non-simple property.
if (Object.class != pd.getPropertyType()) {
MethodParameter methodParam = BeanUtils.getWriteMethodParameter(pd);
// Do not allow eager init for type matching in case of a prioritized post-processor.
boolean eager = !(bw.getWrappedInstance() instanceof PriorityOrdered);
DependencyDescriptor desc = new AutowireByTypeDependencyDescriptor(methodParam, eager);
Object autowiredArgument = resolveDependency(desc, beanName, autowiredBeanNames, converter);
if (autowiredArgument != null) {
pvs.add(propertyName, autowiredArgument);
}
for (String autowiredBeanName : autowiredBeanNames) {
registerDependentBean(autowiredBeanName, beanName);
if (logger.isTraceEnabled()) {
logger.trace("Autowiring by type from bean name '" + beanName + "' via property '" +
propertyName + "' to bean named '" + autowiredBeanName + "'");
}
}
autowiredBeanNames.clear();
}
}
catch (BeansException ex) {
throw new UnsatisfiedDependencyException(mbd.getResourceDescription(), beanName, propertyName, ex);
}
}
}- applyPropertyValues(String beanName, BeanDefinition mbd, BeanWrapper bw, PropertyValues pvs)
这个方法的目的是在创建bean并将属性值应用于目标对象时，解析并应用属性值中对其他bean的引用。
该方法在Spring框架中的功能如下：
-
首先，检查传入的属性值是否为空，如果为空，则直接返回。
-
如果存在安全管理器，并且BeanWrapper是BeanWrapperImpl类型的，则设置安全上下文。
-
检查属性值是否是MutablePropertyValues类型的实例。如果是，则转换为MutablePropertyValues，并检查是否已经转换过。
-
如果存在自定义的TypeConverter，则使用自定义的TypeConverter；否则，使用BeanWrapper作为TypeConverter。
-
创建一个BeanDefinitionValueResolver对象，用于解析属性值中对其他bean的引用。
-
创建一个深拷贝的属性值列表，用于存储解析后的属性值。
-
遍历原始的属性值列表，并对每个属性值进行处理：
- 如果属性值已经转换过，则直接添加到深拷贝列表中。
- 如果属性值是AutowiredPropertyMarker的实例，表示要进行自动装配，将其替换为对应属性的DependencyDescriptor对象。
- 否则，使用BeanDefinitionValueResolver解析属性值中的引用，并进行相应的转换。如果属性可读写且不是嵌套或索引属性，则进行转换。
- 如果转换后的值与原始值相同，则将转换后的值存储在属性值中，并将其添加到深拷贝列表中。
- 否则，将解析后的属性值添加到深拷贝列表中，并标记需要进一步解析。
-
如果原始的属性值是MutablePropertyValues类型的实例，并且不需要进一步解析，则将其标记为已转换。
-
最后，使用深拷贝的属性值列表设置BeanWrapper的属性值。
/**
* Apply the given property values, resolving any runtime references
* to other beans in this bean factory. Must use deep copy, so we
* don't permanently modify this property.
* @param beanName the bean name passed for better exception information
* @param mbd the merged bean definition
* @param bw the BeanWrapper wrapping the target object
* @param pvs the new property values
*/
protected void applyPropertyValues(String beanName, BeanDefinition mbd, BeanWrapper bw, PropertyValues pvs) {
if (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 = (MutablePropertyValues) pvs;
if (mpvs.isConverted()) {
// Shortcut: use the pre-converted values as-is.
try {
bw.setPropertyValues(mpvs);
return;
}
catch (BeansException ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Error setting property values", ex);
}
}
original = mpvs.getPropertyValueList();
}
else {
original = Arrays.asList(pvs.getPropertyValues());
}
TypeConverter converter = getCustomTypeConverter();
if (converter == null) {
converter = bw;
}
BeanDefinitionValueResolver valueResolver = new BeanDefinitionValueResolver(this, beanName, mbd, converter);
// Create a deep copy, resolving any references for values.
List<PropertyValue> deepCopy = new ArrayList<>(original.size());
boolean resolveNecessary = false;
for (PropertyValue pv : original) {
if (pv.isConverted()) {
deepCopy.add(pv);
}
else {
String propertyName = pv.getName();
Object originalValue = pv.getValue();
if (originalValue == AutowiredPropertyMarker.INSTANCE) {
Method writeMethod = bw.getPropertyDescriptor(propertyName).getWriteMethod();
if (writeMethod == null) {
throw new IllegalArgumentException("Autowire marker for property without write method: " + pv);
}
originalValue = new DependencyDescriptor(new MethodParameter(writeMethod, 0), true);
}
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);
}
// Possibly store converted value in merged bean definition,
// in order to avoid re-conversion for every created bean instance.
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();
}
// Set our (possibly massaged) deep copy.
try {
bw.setPropertyValues(new MutablePropertyValues(deepCopy));
}
catch (BeansException ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Error setting property values", ex);
}
}-
initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd)
这个方法的目的是初始化给定的bean实例，包括应用工厂回调函数、初始化方法和bean后置处理器。
该方法在Spring框架中的功能如下：
-
首先，检查是否存在安全管理器。如果存在，则使用特权访问方式调用invokeAwareMethods方法，应用感知接口回调方法（比如BeanNameAware、BeanClassLoaderAware、BeanFactoryAware）。否则，直接调用invokeAwareMethods方法。
-
调用applyBeanPostProcessorsBeforeInitialization方法，对bean进行初始化之前的处理。该方法会依次调用注册的所有BeanPostProcessor的postProcessBeforeInitialization方法，并返回处理后的bean实例。
-
调用invokeInitMethods方法，执行bean的初始化方法。该方法会根据给定的bean名称、bean实例以及对应的RootBeanDefinition，调用bean的初始化方法。如果初始化方法抛出异常，则将其封装为BeanCreationException并抛出。
-
如果存在RootBeanDefinition，并且不是合成定义的bean，则调用applyBeanPostProcessorsAfterInitialization方法，对bean进行初始化之后的处理。该方法会依次调用注册的所有BeanPostProcessor的postProcessAfterInitialization方法，并返回处理后的bean实例。
-
返回经过初始化处理后的bean实例。
/**
* Initialize the given bean instance, applying factory callbacks
* as well as init methods and bean post processors.
* <p>Called from {@link #createBean} for traditionally defined beans,
* and from {@link #initializeBean} for existing bean instances.
* @param beanName the bean name in the factory (for debugging purposes)
* @param bean the new bean instance we may need to initialize
* @param mbd the bean definition that the bean was created with
* (can also be {@code null}, if given an existing bean instance)
* @return the initialized bean instance (potentially wrapped)
* @see BeanNameAware
* @see BeanClassLoaderAware
* @see BeanFactoryAware
* @see #applyBeanPostProcessorsBeforeInitialization
* @see #invokeInitMethods
* @see #applyBeanPostProcessorsAfterInitialization
*/
protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
if (System.getSecurityManager() != null) {
AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
invokeAwareMethods(beanName, bean);
return null;
}, getAccessControlContext());
}
else {
invokeAwareMethods(beanName, bean);
}
Object wrappedBean = bean;
if (mbd == null || !mbd.isSynthetic()) {
wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
}
try {
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()) {
wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
}
return wrappedBean;
}- invokeAwareMethods(String beanName, Object bean)
这个方法的功能是在bean初始化过程中，检查并调用可能存在的Aware接口回调方法。通过这些回调方法，bean可以感知并获取与容器相关的信息，比如自己的名称、类加载器和所属的BeanFactory。这样设计的目的是为了给bean提供更多的自定义和扩展能力，在初始化阶段可以灵活地与容器进行交互。
该方法在Spring框架中的功能如下：
-
首先，判断bean是否实现了Aware接口。Aware接口是一组特殊的接口，用于提供对容器或其他资源的感知能力。
-
如果bean实现了BeanNameAware接口，表示它需要被通知自己在容器中的名字。在这种情况下，将bean的名称作为参数，调用setBeanName方法，将bean的名称传递给它。
-
如果bean实现了BeanClassLoaderAware接口，表示它需要被通知所使用的类加载器。在这种情况下，获取当前容器的类加载器，并调用setBeanClassLoader方法，将类加载器传递给它。
-
如果bean实现了BeanFactoryAware接口，表示它需要被通知所属的BeanFactory（即AbstractAutowireCapableBeanFactory）。在这种情况下，调用setBeanFactory方法，将当前的BeanFactory实例传递给它。
private void invokeAwareMethods(String beanName, Object bean) {
if (bean instanceof Aware) {
if (bean instanceof BeanNameAware) {
((BeanNameAware) bean).setBeanName(beanName);
}
if (bean instanceof BeanClassLoaderAware) {
ClassLoader bcl = getBeanClassLoader();
if (bcl != null) {
((BeanClassLoaderAware) bean).setBeanClassLoader(bcl);
}
}
if (bean instanceof BeanFactoryAware) {
((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);
}
}
}- invokeInitMethods(String beanName, Object bean, @Nullable RootBeanDefinition mbd)
这个方法的功能是在bean初始化过程中，检查并调用可能存在的初始化回调方法。首先检查bean是否实现了InitializingBean接口，并执行其中的初始化逻辑。然后检查是否有自定义的初始化方法，并执行该方法。通过这些回调方法，bean可以在初始化时执行特定的操作，以确保它们处于正确的状态。这样设计的目的是为了扩展bean的初始化能力，并提供一种统一的初始化机制。
该方法在Spring框架中的功能如下：
-
首先，判断bean是否实现了InitializingBean接口，该接口定义了一个方法afterPropertiesSet()，用于在属性设置完成后执行任意的初始化逻辑。如果bean实现了InitializingBean接口，并且没有自定义的外部管理的初始化方法（即在bean定义中指定了其他init方法），则调用afterPropertiesSet()方法来执行初始化逻辑。
-
如果bean定义中指定了自定义的初始化方法，并且不是因为继承InitializingBean而导致的默认的afterPropertiesSet()方法，则调用invokeCustomInitMethod方法来执行自定义的初始化方法。
/**
* Give a bean a chance to react now all its properties are set,
* and a chance to know about its owning bean factory (this object).
* This means checking whether the bean implements InitializingBean or defines
* a custom init method, and invoking the necessary callback(s) if it does.
* @param beanName the bean name in the factory (for debugging purposes)
* @param bean the new bean instance we may need to initialize
* @param mbd the merged bean definition that the bean was created with
* (can also be {@code null}, if given an existing bean instance)
* @throws Throwable if thrown by init methods or by the invocation process
* @see #invokeCustomInitMethod
*/
protected void invokeInitMethods(String beanName, Object bean, @Nullable RootBeanDefinition mbd)
throws Throwable {
boolean isInitializingBean = (bean instanceof InitializingBean);
if (isInitializingBean && (mbd == null || !mbd.hasAnyExternallyManagedInitMethod("afterPropertiesSet"))) {
if (logger.isTraceEnabled()) {
logger.trace("Invoking afterPropertiesSet() on bean with name '" + beanName + "'");
}
if (System.getSecurityManager() != null) {
try {
AccessController.doPrivileged((PrivilegedExceptionAction<Object>) () -> {
((InitializingBean) bean).afterPropertiesSet();
return null;
}, getAccessControlContext());
}
catch (PrivilegedActionException pae) {
throw pae.getException();
}
}
else {
((InitializingBean) bean).afterPropertiesSet();
}
}
if (mbd != null && bean.getClass() != NullBean.class) {
String initMethodName = mbd.getInitMethodName();
if (StringUtils.hasLength(initMethodName) &&
!(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) &&
!mbd.hasAnyExternallyManagedInitMethod(initMethodName)) {
invokeCustomInitMethod(beanName, bean, mbd);
}
}
}-
invokeCustomInitMethod(String beanName, Object bean, RootBeanDefinition mbd)
这个方法的功能是在给定的bean上调用指定的自定义初始化方法。它通过反射查找并调用初始化方法，以确保bean在初始化过程中执行特定的自定义逻辑。
该方法在Spring框架中的功能如下：
-
首先，获取bean定义中指定的初始化方法的名称。
-
如果找不到指定名称的初始化方法，则根据是否强制要求存在初始化方法进行相应的处理。如果强制要求存在初始化方法，则抛出BeanDefinitionValidationException异常；否则，忽略不存在的初始化方法，并返回。
-
如果找到了指定名称的初始化方法，则根据非公共访问被允许的标志以及bean的类型，通过反射查找方法对象。
-
如果找到了方法对象，则执行相应的初始化方法。
-
在执行方法前，通过ReflectionUtils.makeAccessible方法设置方法的可访问性，并调用methodToInvoke.invoke(bean)来执行初始化方法。
/**
* Invoke the specified custom init method on the given bean.
* Called by invokeInitMethods.
* <p>Can be overridden in subclasses for custom resolution of init
* methods with arguments.
* @see #invokeInitMethods
*/
protected void invokeCustomInitMethod(String beanName, Object bean, RootBeanDefinition mbd)
throws Throwable {
String initMethodName = mbd.getInitMethodName();
Assert.state(initMethodName != null, "No init method set");
Method initMethod = (mbd.isNonPublicAccessAllowed() ?
BeanUtils.findMethod(bean.getClass(), initMethodName) :
ClassUtils.getMethodIfAvailable(bean.getClass(), initMethodName));
if (initMethod == null) {
if (mbd.isEnforceInitMethod()) {
throw new BeanDefinitionValidationException("Could not find an init method named '" +
initMethodName + "' on bean with name '" + beanName + "'");
}
else {
if (logger.isTraceEnabled()) {
logger.trace("No default init method named '" + initMethodName +
"' found on bean with name '" + beanName + "'");
}
// Ignore non-existent default lifecycle methods.
return;
}
}
if (logger.isTraceEnabled()) {
logger.trace("Invoking init method '" + initMethodName + "' on bean with name '" + beanName + "'");
}
Method methodToInvoke = ClassUtils.getInterfaceMethodIfPossible(initMethod, bean.getClass());
if (System.getSecurityManager() != null) {
AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
ReflectionUtils.makeAccessible(methodToInvoke);
return null;
});
try {
AccessController.doPrivileged((PrivilegedExceptionAction<Object>)
() -> methodToInvoke.invoke(bean), getAccessControlContext());
}
catch (PrivilegedActionException pae) {
InvocationTargetException ex = (InvocationTargetException) pae.getException();
throw ex.getTargetException();
}
}
else {
try {
ReflectionUtils.makeAccessible(methodToInvoke);
methodToInvoke.invoke(bean);
}
catch (InvocationTargetException ex) {
throw ex.getTargetException();
}
}
}-
postProcessObjectFromFactoryBean(Object object, String beanName)
这个方法的功能是应用所有注册的BeanPostProcessor的postProcessAfterInitialization回调方法，以实现对从FactoryBean获取的对象进行后处理的能力。通过这些回调方法，可以对bean做进一步的定制化处理，以满足特定的业务需求。
该方法在Spring框架中的功能如下：
-
首先，获取从FactoryBean获取到的对象和bean的名称。
-
在容器启动过程中，Spring会扫描并实例化所有的BeanPostProcessor。BeanPostProcessor是一个特殊的接口，它定义了两个回调方法：postProcessBeforeInitialization和postProcessAfterInitialization。通过实现BeanPostProcessor接口，可以在bean初始化前后对其进行自定义的操作。
-
applyBeanPostProcessorsAfterInitialization方法调用所有注册的BeanPostProcessor的postProcessAfterInitialization回调方法，这样它们就有机会对从FactoryBean获取的对象进行后处理操作。
-
postProcessAfterInitialization方法允许BeanPostProcessor在bean的所有初始化工作完成之后对bean进行定制化的处理。这个回调方法可以被用来对bean进行增强，例如自动代理、修改属性值等。
-
最后，返回经过所有BeanPostProcessor后处理后的对象。
/**
* Applies the {@code postProcessAfterInitialization} callback of all
* registered BeanPostProcessors, giving them a chance to post-process the
* object obtained from FactoryBeans (for example, to auto-proxy them).
* @see #applyBeanPostProcessorsAfterInitialization
*/
@Override
protected Object postProcessObjectFromFactoryBean(Object object, String beanName) {
return applyBeanPostProcessorsAfterInitialization(object, beanName);
}
888
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
