Skip to content

Latest commit

 

History

History
699 lines (567 loc) · 38.3 KB

File metadata and controls

699 lines (567 loc) · 38.3 KB

AutowireCapableBeanFactory

一、基本信息

✒️ 作者 - Lex 📝 博客 - 掘金 📚 源码地址 - github

二、基本描述

AutowireCapableBeanFactory接口是Spring框架中位于org.springframework.beans.factory.config包下的关键接口,扩展自BeanFactory,主要提供了在运行时进行Bean自动装配和创建的高级功能。其核心方法createBean允许动态创建Bean实例,并进行自动装配,解决了Bean之间的依赖关系,而其他方法如autowireBeanapplyBeanPostProcessorsBeforeInitialization则提供了更细粒度的控制和定制点,使我们能够在Bean生命周期的不同阶段进行干预,实现更灵活的Bean管理和配置。这一接口的存在增强了Spring IoC容器的功能,使其能够更好地适应复杂系统的需求。

三、主要功能

  1. Bean的创建和初始化

    • 通过createBean方法,可以创建一个新的Bean实例,并在创建过程中执行完整的初始化,包括所有适用的BeanPostProcessor的回调。
  2. 自动装配

    • 提供了不同的自动装配模式,包括按名称、按类型、按构造函数等,通过autowireautowireBeanProperties方法实现对Bean属性的自动注入。
  3. Bean配置和后处理器应用

    • 通过configureBean方法,可以配置已存在的Bean实例,应用属性值、工厂回调等,同时执行所有BeanPostProcessor的回调。
  4. 定制化初始化和销毁过程

    • 通过initializeBean方法,可以在Bean初始化过程中应用定制化的操作,例如执行初始化回调、应用后处理器等。还提供了destroyBean方法用于销毁Bean实例。
  5. 解析依赖

    • 通过resolveDependency方法,可以解析指定的依赖关系,支持字段、方法、构造函数等各种依赖注入方式。

四、接口源码

AutowireCapableBeanFactory接口源码中看出,它承担了创建、配置和生命周期管理Bean实例的任务。通过定义常量和方法,它提供了细粒度的控制,包括特定的自动装配策略、初始化过程、属性注入、后处理器应用以及销毁阶段。

/**
 * org.springframework.beans.factory.BeanFactory的扩展接口,由能够进行自动装配的Bean工厂实现,
 * 前提是它们希望为现有的Bean实例暴露此功能。
 *
 * 此子接口不应在正常应用代码中使用:请使用org.springframework.beans.factory.BeanFactory
 * 或org.springframework.beans.factory.ListableBeanFactory以供典型用例使用。
 *
 * 其他框架的集成代码可以利用此接口来连接和填充Spring不控制生命周期的现有Bean实例。
 * 这对于WebWork Actions和Tapestry Page对象等情况特别有用。
 *
 * 请注意,此接口不由org.springframework.context.ApplicationContext门面实现,
 * 因为它在应用代码中几乎不被使用。尽管如此,它仍可从应用程序上下文中访问,通过ApplicationContext的
 * org.springframework.context.ApplicationContext#getAutowireCapableBeanFactory()方法获得。
 *
 * 您还可以实现org.springframework.beans.factory.BeanFactoryAware接口,
 * 它在ApplicationContext中运行时公开内部BeanFactory,以便访问AutowireCapableBeanFactory:
 * 只需将传入的BeanFactory强制转换为AutowireCapableBeanFactory。
 *
 * @author Juergen Hoeller
 * @since 04.12.2003
 * @see org.springframework.beans.factory.BeanFactoryAware
 * @see org.springframework.beans.factory.config.ConfigurableListableBeanFactory
 * @see org.springframework.context.ApplicationContext#getAutowireCapableBeanFactory()
 */
public interface AutowireCapableBeanFactory extends BeanFactory {

    /**
     * 常量,表示没有外部定义的自动装配。请注意,仍将应用BeanFactoryAware等,并且将应用基于注释的注入。
     * @see #createBean
     * @see #autowire
     * @see #autowireBeanProperties
     */
    int AUTOWIRE_NO = 0;

    /**
     * 常量,表示按名称自动装配Bean属性(适用于所有Bean属性设置器)。
     * @see #createBean
     * @see #autowire
     * @see #autowireBeanProperties
     */
    int AUTOWIRE_BY_NAME = 1;

    /**
     * 常量,表示按类型自动装配Bean属性(适用于所有Bean属性设置器)。
     * @see #createBean
     * @see #autowire
     * @see #autowireBeanProperties
     */
    int AUTOWIRE_BY_TYPE = 2;

    /**
     * 常量,表示自动装配可以满足的最贪婪的构造函数(涉及解析适当的构造函数)。
     * @see #createBean
     * @see #autowire
     */
    int AUTOWIRE_CONSTRUCTOR = 3;

    /**
     * 常量,表示通过对Bean类进行内省来确定适当的自动装配策略。
     * @see #createBean
     * @see #autowire
     * @deprecated 自Spring 3.0起:如果使用了混合自动装配策略,请优先使用基于注释的自动装配,以清晰标记自动装配需求。
     */
    @Deprecated
    int AUTOWIRE_AUTODETECT = 4;

    /**
     * 初始化现有Bean实例时使用的后缀,以实现“原始实例”约定:附加到完全限定的Bean类名称,
     * 例如“com.mypackage.MyClass.ORIGINAL”,以强制返回给定实例,即没有代理等。
     * @since 5.1
     * @see #initializeBean(Object, String)
     * @see #applyBeanPostProcessorsBeforeInitialization(Object, String)
     * @see #applyBeanPostProcessorsAfterInitialization(Object, String)
     */
    String ORIGINAL_INSTANCE_SUFFIX = ".ORIGINAL";

    /**
     * 完全创建给定类的新Bean实例。
     * 执行Bean的完全初始化,包括所有适用的BeanPostProcessor BeanPostProcessors。
     * 注意:这用于创建一个新实例,填充带注释的字段和方法以及应用所有标准的Bean初始化回调。
     * 它不意味着传统的按名称或按类型自动装配属性;对于这些目的,请使用#createBean(Class, int, boolean)。
     * @param beanClass 要创建的Bean的类
     * @return 新的Bean实例
     * @throws BeansException 如果实例化或装配失败
     */
    <T> T createBean(Class<T> beanClass) throws BeansException;

    /**
     * 通过应用实例化后回调和Bean属性后处理(例如用于注释驱动的注入)来填充给定的Bean实例。
     * 注意:这主要用于(重新)填充带注释的字段和方法,无论是对于新实例还是对于反序列化的实例。
     * 它不意味着传统的按名称或按类型自动装配属性;对于这些目的,请使用#autowireBeanProperties。
     * @param existingBean 现有的Bean实例
     * @throws BeansException 如果装配失败
     */
    void autowireBean(Object existingBean) throws BeansException;

    /**
     * 配置给定的原始Bean:自动装配Bean属性,应用Bean属性值,
     * 应用工厂回调,如{@code setBeanName和{@code setBeanFactory,
     * 以及应用所有Bean后处理器(包括可能包装给定原始Bean的后处理器)。
     * 这实际上是#initializeBean提供的超集,完全应用相应Bean定义指定的配置。
     * 注意:此方法需要给定名称的Bean定义!
     * @param existingBean 现有的Bean实例
     * @param beanName Bean的名称,如果需要,将传递给它
     *                 (必须存在该名称的Bean定义)
     * @return 用于使用的Bean实例,原始或包装的其中之一
     * @throws org.springframework.beans.factory.NoSuchBeanDefinitionException
     * 如果没有给定名称的Bean定义
     * @throws BeansException 如果初始化失败
     * @see #initializeBean
     */
    Object configureBean(Object existingBean, String beanName) throws BeansException;

    /**
     * 以指定的自动装配策略完全创建给定类的新Bean实例。
     * 此接口支持此处定义的所有常量。
     * 执行Bean的完全初始化,包括所有适用的BeanPostProcessor BeanPostProcessors。
     * 这实际上是#autowire提供的超集,添加了#initializeBean的行为。
     * @param beanClass 要创建的Bean的类
     * @param autowireMode 按名称或类型,使用此接口中的常量
     * @param dependencyCheck 是否对对象执行依赖关系检查
     *                        (不适用于构造函数的自动装配,因此在这里被忽略)
     * @return 新的Bean实例
     * @throws BeansException 如果实例化或装配失败
     * @see #AUTOWIRE_NO
     * @see #AUTOWIRE_BY_NAME
     * @see #AUTOWIRE_BY_TYPE
     * @see #AUTOWIRE_CONSTRUCTOR
     */
    Object createBean(Class<?> beanClass, int autowireMode, boolean dependencyCheck) throws BeansException;

    /**
     * 使用指定的自动装配策略实例化给定类的新Bean实例。
     * 此处支持此接口中定义的所有常量。
     * 也可以使用{@code AUTOWIRE_NO调用,以便仅应用实例化前回调(例如用于注释驱动的注入)。
     * 不会应用标准的BeanPostProcessor BeanPostProcessors回调或对Bean的进一步初始化。
     * 此接口为这些目的提供了不同的、细粒度的操作,例如#initializeBean。
     * 然而,如果适用于实例的构建,将应用InstantiationAwareBeanPostProcessor回调。
     * @param beanClass 要实例化的Bean的类
     * @param autowireMode 按名称或类型,使用此接口中的常量
     * @param dependencyCheck 是否对Bean实例中的对象引用执行依赖关系检查
     *                        (不适用于构造函数的自动装配,因此在这里被忽略)
     * @return 新的Bean实例
     * @throws BeansException 如果实例化或装配失败
     * @see #AUTOWIRE_NO
     * @see #AUTOWIRE_BY_NAME
     * @see #AUTOWIRE_BY_TYPE
     * @see #AUTOWIRE_CONSTRUCTOR
     * @see #AUTOWIRE_AUTODETECT
     * @see #initializeBean
     * @see #applyBeanPostProcessorsBeforeInitialization
     * @see #applyBeanPostProcessorsAfterInitialization
     */
    Object autowire(Class<?> beanClass, int autowireMode, boolean dependencyCheck) throws BeansException;

    /**
     * 按名称或类型自动装配给定Bean实例的Bean属性。
     * 也可以使用{@code AUTOWIRE_NO调用,以便仅应用实例化后回调(例如用于注释驱动的注入)。
     * 不会应用标准的BeanPostProcessor BeanPostProcessors回调或对Bean的进一步初始化。
     * 此接口为这些目的提供了不同的、细粒度的操作,例如#initializeBean。
     * 然而,如果适用于实例的配置,将应用InstantiationAwareBeanPostProcessor回调。
     * @param existingBean 现有的Bean实例
     * @param autowireMode 按名称或类型,使用此接口中的常量
     * @param dependencyCheck 是否对Bean实例中的对象引用执行依赖关系检查
     * @throws BeansException 如果装配失败
     * @see #AUTOWIRE_BY_NAME
     * @see #AUTOWIRE_BY_TYPE
     * @see #AUTOWIRE_NO
     */
    void autowireBeanProperties(Object existingBean, int autowireMode, boolean dependencyCheck)
            throws BeansException;


    /**
     * 将给定bean定义名称的bean定义的属性值应用于给定的bean实例。
     * bean定义可以定义一个完全独立的bean,重用其属性值,或仅用于现有bean实例的属性值。
     * 此方法不会自动装配bean属性;它只应用显式定义的属性值。
     * 使用#autowireBeanProperties方法来自动装配现有的bean实例。
     * 注意:此方法需要给定名称的bean定义!
     * 不会应用标准的BeanPostProcessor BeanPostProcessors回调或对bean的进一步初始化。
     * 此接口为这些目的提供了不同的、细粒度的操作,例如#initializeBean。
     * 但是,如果适用于实例的配置,将应用InstantiationAwareBeanPostProcessor回调。
     * @param existingBean 现有的bean实例
     * @param beanName bean工厂中bean定义的名称
     *                 (必须存在该名称的bean定义)
     * @throws org.springframework.beans.factory.NoSuchBeanDefinitionException
     * 如果没有给定名称的bean定义
     * @throws BeansException 如果应用属性值失败
     * @see #autowireBeanProperties
     */
    void applyBeanPropertyValues(Object existingBean, String beanName) throws BeansException;

    /**
     * 初始化给定的原始bean,应用工厂回调,例如{@code setBeanName和{@code setBeanFactory,
     * 也应用所有bean后处理器(包括可能包装给定原始bean的后处理器)。
     * 请注意,给定名称的bean工厂不必存在bean定义。
     * 传入的bean名称将仅用于回调,但不会与已注册的bean定义进行检查。
     * @param existingBean 现有的bean实例
     * @param beanName bean的名称,如果需要,将传递给它
     *                 (仅传递给BeanPostProcessor BeanPostProcessors;
     *                  可以遵循#ORIGINAL_INSTANCE_SUFFIX约定,以强制返回给定的实例,
     *                  即没有代理等)
     * @return 要使用的bean实例,原始的或包装的其中之一
     * @throws BeansException 如果初始化失败
     * @see #ORIGINAL_INSTANCE_SUFFIX
     */
    Object initializeBean(Object existingBean, String beanName) throws BeansException;

    /**
     * 将BeanPostProcessor BeanPostProcessors应用于给定的现有bean实例,
     * 调用其{@code postProcessBeforeInitialization方法。返回的bean实例可能是原始bean的包装。
     * @param existingBean 现有的bean实例
     * @param beanName bean的名称,如果需要,将传递给它
     *                 (仅传递给BeanPostProcessor BeanPostProcessors;
     *                  可以遵循#ORIGINAL_INSTANCE_SUFFIX约定,以强制返回给定的实例,
     *                  即没有代理等)
     * @return 要使用的bean实例,原始的或包装的其中之一
     * @throws BeansException 如果任何后处理失败
     * @see BeanPostProcessor#postProcessBeforeInitialization
     * @see #ORIGINAL_INSTANCE_SUFFIX
     */
    Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
            throws BeansException;

    /**
     * 将BeanPostProcessor BeanPostProcessors应用于给定的现有bean实例,
     * 调用其{@code postProcessAfterInitialization方法。返回的bean实例可能是原始bean的包装。
     * @param existingBean 现有的bean实例
     * @param beanName bean的名称,如果需要,将传递给它
     *                 (仅传递给BeanPostProcessor BeanPostProcessors;
     *                  可以遵循#ORIGINAL_INSTANCE_SUFFIX约定,以强制返回给定的实例,
     *                  即没有代理等)
     * @return 要使用的bean实例,原始的或包装的其中之一
     * @throws BeansException 如果任何后处理失败
     * @see BeanPostProcessor#postProcessAfterInitialization
     * @see #ORIGINAL_INSTANCE_SUFFIX
     */
    Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
            throws BeansException;

    /**
     * 销毁给定的bean实例(通常来自#createBean),应用
     * org.springframework.beans.factory.DisposableBean合同以及注册的
     * DestructionAwareBeanPostProcessor DestructionAwareBeanPostProcessors。
     * 在销毁过程中出现的任何异常都应该被捕获并记录,而不是传播到此方法的调用方。
     * @param existingBean 要销毁的bean实例
     */
    void destroyBean(Object existingBean);

    /**
     * 解析唯一匹配给定对象类型的bean实例,如果有的话,包括其bean名称。
     * 这实际上是#getBean(Class)的一个变体,它保留匹配实例的bean名称。
     * @param requiredType bean必须匹配的类型;可以是接口或超类
     * @return bean名称加上bean实例
     * @throws NoSuchBeanDefinitionException 如果没有找到匹配的bean
     * @throws NoUniqueBeanDefinitionException 如果找到多个匹配的bean
     * @throws BeansException 如果无法创建bean
     * @since 4.3.3
     * @see #getBean(Class)
     */
    <T> NamedBeanHolder<T> resolveNamedBean(Class<T> requiredType) throws BeansException;

    /**
     * 为给定的bean名称解析bean实例,提供一个依赖项描述符,以供目标工厂方法使用。
     * 这实际上是#getBean(String, Class)的一个变体,支持具有
     * org.springframework.beans.factory.InjectionPoint参数的工厂方法。
     * @param name 要查找的bean的名称
     * @param descriptor 用于请求注入点的依赖项描述符
     * @return 相应的bean实例
     * @throws NoSuchBeanDefinitionException 如果没有指定名称的bean
     * @throws BeansException 如果无法创建bean
     * @since 5.1.5
     * @see #getBean(String, Class)
     */
    Object resolveBeanByName(String name, DependencyDescriptor descriptor) throws BeansException;

    /**
     * 解析针对此工厂中定义的bean的指定依赖项。
     * @param descriptor 依赖项的描述符(字段/方法/构造函数)
     * @param requestingBeanName 声明给定依赖项的bean的名称
     * @return 已解析的对象,如果找不到则返回{@code null
     * @throws NoSuchBeanDefinitionException 如果未找到匹配的bean
     * @throws NoUniqueBeanDefinitionException 如果找到多个匹配的bean
     * @throws BeansException 如果由于其他原因导致依赖项解析失败
     * @since 2.5
     * @see #resolveDependency(DependencyDescriptor, String, Set, TypeConverter)
     */
    @Nullable
    Object resolveDependency(DependencyDescriptor descriptor, @Nullable String requestingBeanName) throws BeansException;

    /**
     * 解析针对此工厂中定义的bean的指定依赖项。
     * @param descriptor 依赖项的描述符(字段/方法/构造函数)
     * @param requestingBeanName 声明给定依赖项的bean的名称
     * @param autowiredBeanNames 应将所有自动装配的bean的名称(用于解析给定依赖项)添加到的Set
     * @param typeConverter 用于填充数组和集合的TypeConverter
     * @return 已解析的对象,如果找不到则返回{@code null
     * @throws NoSuchBeanDefinitionException 如果未找到匹配的bean
     * @throws NoUniqueBeanDefinitionException 如果找到多个匹配的bean
     * @throws BeansException 如果由于其他原因导致依赖项解析失败
     * @since 2.5
     * @see DependencyDescriptor
     */
    @Nullable
    Object resolveDependency(DependencyDescriptor descriptor, @Nullable String requestingBeanName,
            @Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException;
			
}

五、主要实现

  • AbstractAutowireCapableBeanFactory
    • AbstractAutowireCapableBeanFactoryAutowireCapableBeanFactory接口的抽象实现,为Spring框架提供了核心的Bean创建、初始化和销毁功能。它实现了createBean方法,支持对Bean的依赖注入、属性值应用、后置处理器的应用,以及初始化和销毁阶段的生命周期管理。
classDiagram
    direction BT
    class BeanFactory {
    	<<interface>>
    }

    class AutowireCapableBeanFactory {
    	<<interface>>
    }

    class AbstractAutowireCapableBeanFactory {
    }

    AutowireCapableBeanFactory --|> BeanFactory
    AbstractAutowireCapableBeanFactory --|> AutowireCapableBeanFactory

Loading

五、最佳实践

使用AnnotationConfigApplicationContext创建了Spring应用程序上下文,手动注册了一个后置处理器(MyBeanPostProcessor)与一个单例Bean(MyRepository),最后获取了AutowireCapableBeanFactory

public static void main(String[] args) {
    // 创建 ApplicationContext
    AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MyConfiguration.class);

    // 配置一个后置处理器,用于验证Bean的初始化前后拦截信息打印
    applicationContext.getBeanFactory().addBeanPostProcessor(new MyBeanPostProcessor());
    // 注册一个MyRepository的Bean对象
    applicationContext.getBeanFactory().registerSingleton("myRepository", new MyRepository());

    // 获取 AutowireCapableBeanFactory
    AutowireCapableBeanFactory beanFactory = applicationContext.getAutowireCapableBeanFactory();
}

MyService是一个经典的Spring Bean类,通过@Autowired@Value实现了对其他Bean和配置属性的注入。它实现了BeanNameAwareInitializingBeanDisposableBean接口,分别在Bean分配名称、属性设置完成后和Bean销毁时执行相应的生命周期方法,最后通过调用toString()方法提供了方便的信息展示。

public class MyService implements BeanNameAware, InitializingBean, DisposableBean {

    @Autowired
    private MyRepository myRepository;

    @Value("${java.home}")
    private String javaHome;

    @Override
    public void setBeanName(String name) {
        System.out.println("MyService.setBeanName方法被调用了");
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("MyService.afterPropertiesSet方法被调用了");
    }

    @Override
    public void destroy() throws Exception {
        System.out.println("MyService.destroy方法被调用了");
    }

    @Override
    public String toString() {
        return "MyService{" +
                "myRepository=" + myRepository +
                ", javaHome='" + javaHome + '\'' +
                '}';
    }
}

MyBeanPostProcessor是一个自定义的Bean后置处理器,实现了Spring的BeanPostProcessor接口。在Bean的初始化前后,它分别调用postProcessBeforeInitializationpostProcessAfterInitialization方法,在这个具体的实现中,我们简单地输出了一条日志,显示了被处理的Bean的名称。

public class MyBeanPostProcessor implements BeanPostProcessor {

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("MyBeanPostProcessor#postProcessBeforeInitialization方法被调用了,Bean名称 = " + beanName);
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("MyBeanPostProcessor#postProcessBeforeInitialization方法被调用了,Bean名称 = " + beanName);
        return bean;
    }
}

createBean

通过AutowireCapableBeanFactorycreateBean方法,手动创建了一个MyService类型的Bean实例。

private static void createBean(AutowireCapableBeanFactory beanFactory) {
    MyService myService = beanFactory.createBean(MyService.class);
    System.out.println("调用createBean方法,创建Bean对象 = " + myService);
}

运行结果发现,在MyService的生命周期中,setBeanNameafterPropertiesSet等回调方法都被成功触发,说明Bean的初始化过程正常执行。同时,MyBeanPostProcessor的后置处理器也在初始化前后成功拦截,并输出了Bean的名称。最重要的是,MyService中的myRepository和通过@Value注解注入的javaHome属性都成功被注入,表明依赖注入的过程也正常进行。

MyService.setBeanName方法被调用了
MyBeanPostProcessor#postProcessBeforeInitialization方法被调用了,Bean名称 = com.xcs.spring.service.MyService
MyService.afterPropertiesSet方法被调用了
MyBeanPostProcessor#postProcessBeforeInitialization方法被调用了,Bean名称 = com.xcs.spring.service.MyService
调用createBean方法,创建Bean对象 = MyService{myRepository=com.xcs.spring.repository.MyRepository@5b03b9fe, javaHome='D:\install\jdk-11'}

configureBean

通过AutowireCapableBeanFactoryconfigureBean方法手动配置Bean。首先,通过registerBeanDefinition方法注册了一个名为 "myService" 的RootBeanDefinition,表示要配置的Bean的定义。接着,创建了一个新的MyService实例,并通过configureBean方法对该实例进行配置,指定了使用之前注册的 "myService" Bean 定义。在方法执行前后,分别输出了MyService的实例信息,观察是否成功进行了配置。

private static void configureBean(AutowireCapableBeanFactory beanFactory) {
    // 配置一个RootBeanDefinition
    ((DefaultListableBeanFactory) beanFactory).registerBeanDefinition("myService", new RootBeanDefinition(MyService.class));

    MyService myService = new MyService();
    System.out.println("调用configureBean前,MyService = " + myService);
    beanFactory.configureBean(myService, "myService");
    System.out.println("调用configureBean后,MyService = " + myService);
}

运行结果发现,通过configureBean方法配置MyService实例的过程与使用createBean方法创建实例的结果相似。在调用configureBean之前,MyService的实例信息显示属性都为null。然后,setBeanNamepostProcessBeforeInitializationafterPropertiesSet等回调方法依次被触发,表明Bean的初始化过程正常执行。最终,调用configureBean之后,MyService的实例信息显示成功注入了myRepository和通过@Value注解注入的javaHome属性。

调用configureBean前,MyService = MyService{myRepository=null, javaHome='null'}
MyService.setBeanName方法被调用了
MyBeanPostProcessor#postProcessBeforeInitialization方法被调用了,Bean名称 = myService
MyService.afterPropertiesSet方法被调用了
MyBeanPostProcessor#postProcessBeforeInitialization方法被调用了,Bean名称 = myService
调用configureBean后,MyService = MyService{myRepository=com.xcs.spring.repository.MyRepository@5b03b9fe, javaHome='D:\install\jdk-11'}

autowireBean

通过AutowireCapableBeanFactoryautowireBean方法手动进行Bean的自动装配。首先,创建了一个MyService实例,然后通过autowireBean方法对该实例进行自动装配。在方法执行前后,分别输出了MyService的实例信息,观察是否成功进行了自动装配。

private static void autowireBean(AutowireCapableBeanFactory beanFactory) {
    MyService myService = new MyService();
    System.out.println("调用autowireBean前,MyService = " + myService);
    beanFactory.autowireBean(myService);
    System.out.println("调用autowireBean后,MyService = " + myService);
}

运行结果发现,使用AutowireCapableBeanFactoryautowireBean方法对一个新创建的MyService实例进行手动的自动装配。在调用autowireBean之前,MyService的实例信息显示属性都为null。然后,调用autowireBean方法后,MyService的实例信息显示成功注入了myRepository属性,该属性引用了com.xcs.spring.repository.MyRepository的实例,以及通过@Value注解注入的javaHome属性,该属性的值为'D:\install\jdk-11'。

然而,需要注意的是,使用autowireBean方法并没有触发BeanNameAware接口中的setBeanName方法、InitializingBean接口中的afterPropertiesSet方法,以及自定义的MyBeanPostProcessor后置处理器的相应回调方法。这是因为autowireBean方法主要关注依赖注入,而不涉及到完整的Bean生命周期管理。

调用autowireBean前,MyService = MyService{myRepository=null, javaHome='null'}
调用autowireBean后,MyService = MyService{myRepository=com.xcs.spring.repository.MyRepository@5b03b9fe, javaHome='D:\install\jdk-11'}

autowire

使用AutowireCapableBeanFactoryautowire方法来创建并自动装配一个MyService类型的Bean。通过指定AutowireCapableBeanFactory.AUTOWIRE_BY_TYPE参数,表示使用类型自动装配。在方法执行后,输出了通过autowire方法创建的MyService实例的信息。

private static void autowire(AutowireCapableBeanFactory beanFactory) {
    Object myService = beanFactory.autowire(MyService.class, AutowireCapableBeanFactory.AUTOWIRE_BY_TYPE, false);
    System.out.println("调用autowire方法,创建Bean对象 =" + myService);
}

运行结果发现,通过autowire方法和autowireBean方法获得了相似的结果。

不过,需要注意的是,虽然结果相似,但是这两个方法的使用场景略有不同。autowireBean是直接对一个已有实例进行自动装配,而autowire方法则是根据指定的类型动态创建并自动装配一个Bean。因此,具体使用哪一种方法取决于实际的需求和场景。

调用autowire方法,创建Bean对象 =MyService{myRepository=com.xcs.spring.repository.MyRepository@4145bad8, javaHome='D:\install\jdk-11'}

autowireBeanProperties

使用AutowireCapableBeanFactoryautowireBeanProperties方法,对一个新创建的MyService实例进行自动属性装配。首先,创建了一个MyService实例,并输出了其初始状态。然后,通过autowireBeanProperties方法对该实例进行自动属性装配,使用的是AutowireCapableBeanFactory.AUTOWIRE_BY_TYPE规则。最后,输出了autowireBeanProperties后的MyService实例信息,观察是否成功进行了自动属性装配。

private static void autowireBeanProperties(AutowireCapableBeanFactory beanFactory) {
    MyService myService = new MyService();
    System.out.println("调用autowireBeanProperties前,MyService = " + myService);
    beanFactory.autowireBeanProperties(myService, AutowireCapableBeanFactory.AUTOWIRE_BY_TYPE, false);
    System.out.println("调用autowireBeanProperties后,MyService = " + myService);
}

运行结果发现,通过autowireBeanProperties方法与之前的autowireBeanautowire方法相比,得到了相似的结果。在调用autowireBeanProperties方法之前,MyService的实例信息显示属性都为null。然后,调用autowireBeanProperties方法后,MyService的实例信息显示成功注入了myRepository属性,该属性引用了com.xcs.spring.repository.MyRepository的实例,以及通过@Value注解注入的javaHome属性,该属性的值为'D:\install\jdk-11'。

调用autowireBeanProperties前,MyService = MyService{myRepository=null, javaHome='null'}
调用autowireBeanProperties后,MyService = MyService{myRepository=com.xcs.spring.repository.MyRepository@4145bad8, javaHome='D:\install\jdk-11'}

applyBeanPropertyValues

使用AutowireCapableBeanFactoryapplyBeanPropertyValues方法,手动为MyService类型的Bean配置自定义属性值。首先,创建了一个PropertyValue实例,表示要设置的属性名为"javaHome",属性值为"这里是我自定义的javaHome路径配置"。接着,通过MutablePropertyValues构建了属性值的集合,并将之前创建的PropertyValue添加到集合中。然后,创建了一个RootBeanDefinition,并将属性值集合设置到该Bean定义中。最后,通过registerBeanDefinition方法注册了一个名为 "myService" 的Bean定义。在调用applyBeanPropertyValues方法之前,创建了一个新的MyService实例,并输出了其初始状态。然后,调用applyBeanPropertyValues方法后,输出了applyBeanPropertyValues后的MyService实例信息,观察是否成功应用了自定义的属性值。

private static void applyBeanPropertyValues(AutowireCapableBeanFactory beanFactory) {
    PropertyValue propertyValue = new PropertyValue("javaHome", "这里是我自定义的javaHome路径配置");
    MutablePropertyValues propertyValues = new MutablePropertyValues();
    propertyValues.addPropertyValue(propertyValue);

    RootBeanDefinition rootBeanDefinition = new RootBeanDefinition(MyService.class);
    rootBeanDefinition.setPropertyValues(propertyValues);
    // 配置一个RootBeanDefinition
    ((DefaultListableBeanFactory) beanFactory).registerBeanDefinition("myService", rootBeanDefinition);

    MyService myService = new MyService();
    System.out.println("调用applyBeanPropertyValues前,MyService = " + myService);
    beanFactory.applyBeanPropertyValues(myService, "myService");
    System.out.println("调用applyBeanPropertyValues后,MyService = " + myService);
}

运行结果发现,调用applyBeanPropertyValues方法后,并没有触发BeanNameAware接口中的setBeanName方法、InitializingBean接口中的afterPropertiesSet方法,以及自定义的MyBeanPostProcessor后置处理器的相应回调方法。这是因为applyBeanPropertyValues方法主要专注于属性值的应用,而不涉及完整的Bean初始化和生命周期管理。最终的运行结果显示myRepository属性为null,表明applyBeanPropertyValues方法并没有进行依赖注入。

调用applyBeanPropertyValues前,MyService = MyService{myRepository=null, javaHome='null'}
调用applyBeanPropertyValues后,MyService = MyService{myRepository=null, javaHome='这里是我自定义的javaHome路径配置'}

initializeBean

使用AutowireCapableBeanFactoryinitializeBean方法,手动初始化MyService类型的Bean。首先,创建了一个新的MyService实例,并输出了其初始状态。然后,通过initializeBean方法对该实例进行初始化,指定了Bean的名称为 "myService"。在调用方法之后,输出了initializeBean后的MyService实例信息,观察是否成功进行了初始化。

private static void initializeBean(AutowireCapableBeanFactory beanFactory) {
    MyService myService = new MyService();
    System.out.println("调用initializeBean前,MyService = " + myService);
    beanFactory.initializeBean(myService, "myService");
    System.out.println("调用initializeBean前,MyService = " + myService);
}

运行结果发现,myRepositoryjavaHome的值都显示为null,这是因为在调用initializeBean方法时,并没有提供属性值的注入。initializeBean方法主要用于手动触发Bean的初始化阶段,包括调用afterPropertiesSet方法和应用Bean后置处理器,但它并不负责属性的注入。

调用initializeBean前,MyService = MyService{myRepository=null, javaHome='null'}
MyService.setBeanName方法被调用了
MyBeanPostProcessor#postProcessBeforeInitialization方法被调用了,Bean名称 = myService
MyService.afterPropertiesSet方法被调用了
MyBeanPostProcessor#postProcessBeforeInitialization方法被调用了,Bean名称 = myService
调用initializeBean前,MyService = MyService{myRepository=null, javaHome='null'}

destroyBean

使用AutowireCapableBeanFactorydestroyBean方法,手动销毁(destroy)一个MyService类型的Bean实例。通过传递新创建的MyService实例作为参数,调用了destroyBean方法。

private static void destroyBean(AutowireCapableBeanFactory beanFactory) {
    beanFactory.destroyBean(new MyService());
}

运行结果发现,在调用destroyBean方法后,MyService实例的销毁方法 destroy 被成功调用。这表明destroyBean方法有效地触发了Bean的销毁阶段,执行了实现了DisposableBean接口的destroy方法。

MyService.destroy方法被调用了

resolveDependency

使用AutowireCapableBeanFactoryresolveDependency方法,手动解析一个依赖关系。通过创建一个DependencyDescriptor对象,表示MyService类中的myRepository属性,然后调用resolveDependency方法,尝试解析这个依赖关系。最后,输出解析得到的依赖对象。

private static void resolveDependency(AutowireCapableBeanFactory beanFactory) {
    try {
        DependencyDescriptor dependencyDescriptor = new DependencyDescriptor(MyService.class.getDeclaredField("myRepository"), false);
        Object resolveDependency = beanFactory.resolveDependency(dependencyDescriptor, "myRepository");
        System.out.println("resolveDependency = " + resolveDependency);
    } catch (NoSuchFieldException e) {
        e.printStackTrace();
    }
}

运行结果发现,通过调用resolveDependency方法成功解析了依赖关系,将myRepository属性的依赖解析为MyRepository的实例。

resolveDependency = com.xcs.spring.repository.MyRepository@37654521

常见问题

  1. createBean() 和 configureBean()

    • createBean() 用于创建Bean的实例,即进行Bean的实例化。它是Bean创建过程中的第一步。
    • configureBean() 则是在Bean实例创建之后,进行进一步的配置,如应用BeanPostProcessors等。这是在Bean实例化后、初始化之前的阶段。
  2. autowireBean() 和 autowire()

    • autowireBean() 用于对现有的Bean实例进行自动装配,将依赖注入到Bean中。
    • autowire() 是在创建Bean实例时使用指定的自动装配模式,用于生成新的Bean实例。
  3. autowireBeanProperties() 和 applyBeanPropertyValues()

    • autowireBeanProperties() 主要用于对Bean实例的属性进行自动装配。
    • applyBeanPropertyValues() 则是将属性值应用到Bean实例,包括在XML或注解中配置的属性值。
  4. initializeBean()、applyBeanPostProcessorsBeforeInitialization() 和 applyBeanPostProcessorsAfterInitialization()

    • initializeBean() 是Bean生命周期中的最后一步,包括初始化和应用BeanPostProcessors等。
    • applyBeanPostProcessorsBeforeInitialization() 用于在初始化之前应用BeanPostProcessors。
    • applyBeanPostProcessorsAfterInitialization() 用于在初始化之后应用BeanPostProcessors。
  5. destroyBean()

    • destroyBean() 用于销毁给定的Bean实例,释放资源等。通常在容器关闭时调用。
  6. resolveNamedBean() 和 resolveBeanByName()

    • resolveNamedBean() 主要用于解析指定名称的Bean并返回Bean实例。
    • resolveBeanByName() 则是解析指定名称的Bean定义,而不是直接返回Bean实例。
  7. resolveDependency()

    • resolveDependency() 主要用于解析Bean之间的依赖关系,特别是在自动装配时。在AbstractAutowireCapableBeanFactorydoResolveDependency()方法中调用。