【spring源码分析】@Bean的使用以及分析

@Bean

• @Bean
  • 一、基本信息
  • 二、注解描述
  • 三、注解源码
  • 四、主要功能
  • 五、最佳实践
  • 六、时序图
    • @Bean注册时序图
    • @Bean初始化方法时序图
    • @Bean销毁方法时序图
  • 七、源码分析
    • @Bean注册源码分析
    • @Bean初始化源码分析
    • @Bean销毁源码分析
  • 八、注意事项
  • 九、总结
    • 最佳实践总结
    • 源码分析总结

一、基本信息

转载自github源码分析

二、注解描述

@Bean 是 Spring 框架的核心注解，用于标记一个方法，表明这个方法返回值应被注册为 Spring 容器中的一个对象（Bean）。与传统的 XML 配置方式相比，它提供了一种更加简洁和直观的方式来定义 Bean。通常，@Bean 与 @Configuration 注解一起使用，后者标记一个类为 Spring 的配置类。方法名默认作为 Bean 的 ID，但也可以通过 @Bean 的 name 属性自定义。这种声明式的 Bean 定义方式在 Java 代码中提供了强大的灵活性，允许我们利用 Java 的完整特性来配置和初始化对象。此外，结合其他 Spring 特性，如 @Autowired，可以轻松实现依赖注入，进一步简化了应用的配置和组件管理。总之，通过 @Bean 注解，Spring 为现代化的应用开发提供了强大的支持，使得代码更为整洁和易于维护。

三、注解源码

@Bean注解是 Spring 框架自 3.0 版本开始引入的一个核心注解，这个注解表明一个方法会返回一个对象，该对象应该被注册为 Spring 应用上下文中的一个 bean。

/**
 * 指示一个方法会产生一个由Spring容器管理的Bean。
 * @author Rod Johnson
 * @author Costin Leau
 * @author Chris Beams
 * @author Juergen Hoeller
 * @author Sam Brannen
 * @since 3.0
 * @see Configuration
 * @see Scope
 * @see DependsOn
 * @see Lazy
 * @see Primary
 * @see org.springframework.stereotype.Component
 * @see org.springframework.beans.factory.annotation.Autowired
 * @see org.springframework.beans.factory.annotation.Value
 */
@Target({ElementType.METHOD, ElementType.ANNOTATION_TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Bean {

    /**
     * {@link #name}的别名。
     * 当不需要其他属性时可以使用，例如：{@code @Bean("customBeanName")}。
     * @see #name
     */
    @AliasFor("name")
    String[] value() default {};

    /**
     * 这个bean的名称，或者如果有多个名称，则为主要的bean名称加上别名。
     * 如果未指定，bean的名称是注解方法的名称。
     * @see #value
     */
    @AliasFor("value")
    String[] name() default {};

    /**
     * 是否通过基于习惯的按名称或类型进行自动装配？
     * 注意，这种自动装配模式是基于按照习惯通过bean属性的setter方法进行的外部驱动的自动装配。
     * @deprecated ...
     */
    @Deprecated
    Autowire autowire() default Autowire.NO;

    /**
     * 这个bean是否可以作为其他bean的自动注入候选者？
     */
    boolean autowireCandidate() default true;

    /**
     * 在初始化时调用bean实例上的方法的可选名称。
     * 通常，可以在带有@Bean注解的方法的主体中直接以编程方式调用该方法。
     */
    String initMethod() default "";

    /**
     * 在关闭应用程序上下文时调用bean实例上的方法的可选名称。
     * 例如，一个JDBC DataSource的close()方法。
     */
    String destroyMethod() default AbstractBeanDefinition.INFER_METHOD;

}

四、主要功能

1. Bean 的创建与注册:

   • @Bean 注解用于标记一个方法，该方法返回的对象会被 Spring 容器管理。这意味着当应用上下文启动时，该方法会被调用，并且它的返回值会被添加到容器中作为一个 bean。

2. 自定义 Bean 名称

   • 虽然默认的 bean 名称是标注 @Bean 的方法的名称，但可以通过 @Bean 的 name 属性为 bean 指定一个或多个名称。

3. 生命周期管理

   • 通过 initMethod 和 destroyMethod 属性，可以为 bean 指定初始化和销毁的回调方法。当 bean 被创建或销毁时，这些方法会被调用。

4. 替代 XML 配置

   • 在早期的 Spring 版本中，bean 通常是在 XML 文件中定义的。使用 @Bean 注解可以完全用 Java 配置来替代 XML，从而使配置更为集中和类型安全。

5. 灵活的依赖注入

   • 在 @Bean 方法内部，可以直接调用其他 @Bean 方法，实现依赖的注入。这种方式保证了类型安全，并使得代码与配置紧密结合。

6. 与其他注解结合

   • @Bean 注解经常与其他 Spring 注解一起使用，如 @Scope（定义 bean 的范围，如单例或原型），@Lazy（延迟 bean 的初始化），@Primary（当存在多个相同类型的 bean 时，标记一个为首选）等，为 bean 提供更详细的配置。

7. 控制自动装配行为

   • 通过 autowireCandidate 属性，可以控制该 bean 是否应被视为自动装配的候选对象，当其他 bean 需要进行类型匹配的自动装配时。

五、最佳实践

首先来看看启动类入口，上下文环境使用AnnotationConfigApplicationContext（此类是使用Java注解来配置Spring容器的方式），构造参数我们给定了一个MyConfiguration组件类。然后从Spring上下文中获取一个MyBean类型的bean，最后调用context.close()方法关闭容器。

public class BeanApplication {

    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MyConfiguration.class);
        System.out.println(context.getBean(MyBean.class));
        context.close();
    }
}

在 MyConfiguration 配置类中，通过 @Bean 注解定义了一个名为 myBean 的 bean。这个 bean 是 MyBean 类的实例。当 Spring 容器初始化这个 bean 时，它会首先调用 MyBean 的 init 方法（由 initMethod 属性指定）。当这个 bean 在容器关闭时被销毁，它会调用 MyBean 的 destroy 方法（由 destroyMethod 属性指定）。

@Configuration
public class MyConfiguration {

    @Bean(initMethod = "init",destroyMethod = "destroy")
    public MyBean myBean(){
        return new MyBean();
    }
}

当 Spring 容器创建 MyBean 的实例时，init 方法会被自动调用，因此 “MyBean.init” 会被输出到控制台。同样地，当 Spring 容器准备销毁这个 bean 或关闭时，destroy 方法会被调用，于是 “MyBean.destroy” 会被输出到控制台。

public class MyBean {

    public void init(){
        System.out.println("MyBean.init");
    }

    public void destroy(){
        System.out.println("MyBean.destroy");
    }
}

运行结果发现，证明了在创建 bean 时 init 方法的调用以及在销毁 bean 时 destroy 方法的调用，从而展示了通过 @Bean 注解指定的生命周期方法在实际应用中的执行顺序。

MyBean.init
com.xcs.spring.bean.MyBean@2fb3536e
MyBean.destroy

六、时序图

@Bean注册时序图

@Bean初始化方法时序图

@Bean销毁方法时序图

七、源码分析

@Bean注册源码分析

首先来看看启动类入口，上下文环境使用AnnotationConfigApplicationContext（此类是使用Java注解来配置Spring容器的方式），构造参数我们给定了一个MyConfiguration组件类。然后从Spring上下文中获取一个MyBean类型的bean，最后调用context.close()方法关闭容器。

public class BeanApplication {

    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MyConfiguration.class);
        System.out.println(context.getBean(MyBean.class));
        context.close();
    }
}

在org.springframework.context.annotation.AnnotationConfigApplicationContext#AnnotationConfigApplicationContext构造函数中，执行了三个步骤，我们重点关注refresh()方法。

public AnnotationConfigApplicationContext(Class<?>... componentClasses) {
    this();
    register(componentClasses);
    refresh();
}

在org.springframework.context.support.AbstractApplicationContext#refresh方法中我们重点关注一下finishBeanFactoryInitialization(beanFactory)这方法会对实例化所有剩余非懒加载的单列Bean对象，其他方法不是本次源码阅读的重点暂时忽略。

@Override
public void refresh() throws BeansException, IllegalStateException {
     // ... [代码部分省略以简化]
     // 调用在上下文中注册为bean的工厂处理器
     invokeBeanFactoryPostProcessors(beanFactory);
     // ... [代码部分省略以简化]
}

在org.springframework.context.support.AbstractApplicationContext#invokeBeanFactoryPostProcessors方法中，又委托了PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors()进行调用。

protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
    PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());
    // ... [代码部分省略以简化]
}

在org.springframework.context.support.PostProcessorRegistrationDelegate#invokeBeanFactoryPostProcessors方法中，首先调用了 BeanDefinitionRegistryPostProcessor（这是 BeanFactoryPostProcessor 的子接口）。它专门用来在所有其他 bean 定义加载之前修改默认的 bean 定义。

public static void invokeBeanFactoryPostProcessors(
        ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
    // ... [代码部分省略以简化]
    invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry, beanFactory.getApplicationStartup());
	// ... [代码部分省略以简化]
}

在org.springframework.context.support.PostProcessorRegistrationDelegate#invokeBeanDefinitionRegistryPostProcessors方法中，循环调用了实现BeanDefinitionRegistryPostProcessor接口中的postProcessBeanDefinitionRegistry(registry)方法

private static void invokeBeanDefinitionRegistryPostProcessors(
			Collection<? extends BeanDefinitionRegistryPostProcessor> postProcessors, BeanDefinitionRegistry registry, ApplicationStartup applicationStartup) {

    for (BeanDefinitionRegistryPostProcessor postProcessor : postProcessors) {
        StartupStep postProcessBeanDefRegistry = applicationStartup.start("spring.context.beandef-registry.post-process")
            .tag("postProcessor", postProcessor::toString);
        postProcessor.postProcessBeanDefinitionRegistry(registry);
        postProcessBeanDefRegistry.end();
    }
}

在org.springframework.context.annotation.ConfigurationClassPostProcessor#postProcessBeanDefinitionRegistry方法中，调用了processConfigBeanDefinitions方法，该方法的主要目的是处理和注册配置类中定义的beans。

@Override
public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {
    // ... [代码部分省略以简化]
    processConfigBeanDefinitions(registry);
}

在org.springframework.context.annotation.ConfigurationClassPostProcessor#processConfigBeanDefinitions方法中，这个方法主要处理了配置类的解析和验证，并确保了所有在配置类中定义的beans都被正确地注册到Spring的bean定义注册表中。

public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
    // ... [代码部分省略以简化]

    // 步骤1：创建一个用于解析配置类的解析器
    ConfigurationClassParser parser = new ConfigurationClassParser(
            this.metadataReaderFactory, this.problemReporter, this.environment,
            this.resourceLoader, this.componentScanBeanNameGenerator, registry);

    // 步骤2：初始化候选配置类集合以及已解析配置类集合
    Set<BeanDefinitionHolder> candidates = new LinkedHashSet<>(configCandidates);
    Set<ConfigurationClass> alreadyParsed = new HashSet<>(configCandidates.size());

    // 步骤3：循环处理所有候选配置类，直至没有候选类为止
    do {
        // 步骤3.1 解析配置类
        parser.parse(candidates);
        // 步骤3.2 验证配置类
        parser.validate();

        // 获取解析后的配置类，并从中移除已经处理过的
        Set<ConfigurationClass> configClasses = new LinkedHashSet<>(parser.getConfigurationClasses());
        configClasses.removeAll(alreadyParsed);

        // 步骤4：如果reader为空，则创建一个新的Bean定义读取器
        if (this.reader == null) {
            this.reader = new ConfigurationClassBeanDefinitionReader(
                    registry, this.sourceExtractor, this.resourceLoader, this.environment,
                    this.importBeanNameGenerator, parser.getImportRegistry());
        }

        // 步骤5：使用读取器为解析的配置类加载Bean定义
        this.reader.loadBeanDefinitions(configClasses);

        // ... [代码部分省略以简化]
        
    } while (!candidates.isEmpty());

    // ... [代码部分省略以简化]
}

我们来到org.springframework.context.annotation.ConfigurationClassPostProcessor#processConfigBeanDefinitions方法中的步骤3.1。在org.springframework.context.annotation.ConfigurationClassParser#parse方法中，主要是遍历所有的配置类候选者，并对每一个带有注解的Bean定义进行解析。这通常涉及到查找该配置类中的@Bean方法、组件扫描指令等，并将这些信息注册到Spring容器中。

public void parse(Set<BeanDefinitionHolder> configCandidates) {
    // ... [代码部分省略以简化]
    parse(((AnnotatedBeanDefinition) bd).getMetadata(), holder.getBeanName());
    // ... [代码部分省略以简化]
}

在org.springframework.context.annotation.ConfigurationClassParser#parse(metadata, beanName)方法中，将注解元数据和Bean名称转化为一个配置类，然后对其进行处理。处理配置类是Spring配置驱动的核心，它涉及到许多关键操作，如解析@Bean方法、处理@ComponentScan注解、处理@Import注解等。

protected final void parse(AnnotationMetadata metadata, String beanName) throws IOException {
    processConfigurationClass(new ConfigurationClass(metadata, beanName), DEFAULT_EXCLUSION_FILTER);
}

在org.springframework.context.annotation.ConfigurationClassParser#processConfigurationClass方法中，处理一个给定的配置类。它首先递归地处理配置类及其父类，以确保所有相关的配置都被正确地读取并解析。在递归处理完所有相关配置后，它将配置类添加到已解析的配置类的映射中。

protected void processConfigurationClass(ConfigurationClass configClass, Predicate<String> filter) throws IOException {
    // ... [代码部分省略以简化]

    // 步骤1：递归地处理配置类及其超类层次结构
    SourceClass sourceClass = asSourceClass(configClass, filter);
    do {
        sourceClass = doProcessConfigurationClass(configClass, sourceClass, filter);
    } while (sourceClass != null);

    // 步骤2：将处理后的配置类放入映射中
    this.configurationClasses.put(configClass, configClass);
}

在org.springframework.context.annotation.ConfigurationClassParser#doProcessConfigurationClass方法中，进一步处理配置类。特别是，它处理配置类中所有带有@Bean注解的方法。这些方法定义了如何在Spring应用程序上下文中初始化bean。这里简化的注释重点放在@Bean方法上，但原方法可能还包含其他重要的处理逻辑。

@Nullable
protected final SourceClass doProcessConfigurationClass(
    ConfigurationClass configClass, SourceClass sourceClass, Predicate<String> filter)
    throws IOException {

    // ... [代码部分省略以简化]
    
    // 处理配置类中的每一个@Bean注解的方法
    // 这里的目标是识别和注册配置类中定义的所有@Bean方法。这些方法定义了如何初始化应用程序中的bean。
    Set<MethodMetadata> beanMethods = retrieveBeanMethodMetadata(sourceClass);
    for (MethodMetadata methodMetadata : beanMethods) {
        configClass.addBeanMethod(new BeanMethod(methodMetadata, configClass));
    }

    // ... [代码部分省略以简化]
    return null;
}

在org.springframework.context.annotation.ConfigurationClassParser#retrieveBeanMethodMetadata方法中，终于看到对@Bean注解的解析过程了，首先是尝试使用ASM获取确定的方法顺序，这一步是因为Java反射API返回的方法顺序是不确定的，但在某些场景下，方法的声明顺序可能是重要的。为了获得一个确定的顺序，我们尝试使用ASM（一个Java字节码处理框架）来读取类文件。其次是比较反射和ASM的结果，如果通过ASM获取到的方法数大于或等于通过反射获取的方法数，那么我们会进一步比较这两个集合。如果这两个集合的方法名相匹配，我们会更倾向于使用ASM的结果，因为它提供了确定的方法顺序。最后，方法返回一个Set<MethodMetadata>，表示找到的所有标注了@Bean的方法。

为什么要关心方法的顺序? 在某些情况下，我们可能期望@Bean方法按照它们在类中的声明顺序执行。虽然这种依赖通常应该避免，但Spring还是尽可能地根据我们声明的这种顺序，特别是在涉及生命周期回调和依赖注入时。

private Set<MethodMetadata> retrieveBeanMethodMetadata(SourceClass sourceClass) {
    // 从源类中获取其注解元数据
    AnnotationMetadata original = sourceClass.getMetadata();
    
    // 从注解元数据中获取所有带有@Bean注解的方法
    Set<MethodMetadata> beanMethods = original.getAnnotatedMethods(Bean.class.getName());

    // 如果发现多个@Bean方法，并且注解元数据是StandardAnnotationMetadata的实例，
    // 则尝试使用ASM库读取类文件，以获取确定的方法声明顺序。
    if (beanMethods.size() > 1 && original instanceof StandardAnnotationMetadata) {
        try {
            // 使用ASM读取类文件的元数据
            AnnotationMetadata asm =
                this.metadataReaderFactory.getMetadataReader(original.getClassName()).getAnnotationMetadata();
            Set<MethodMetadata> asmMethods = asm.getAnnotatedMethods(Bean.class.getName());

            // 检查ASM读取的方法集是否包含所有通过标准反射检测到的方法
            if (asmMethods.size() >= beanMethods.size()) {
                Set<MethodMetadata> selectedMethods = new LinkedHashSet<>(asmMethods.size());
                for (MethodMetadata asmMethod : asmMethods) {
                    for (MethodMetadata beanMethod : beanMethods) {
                        if (beanMethod.getMethodName().equals(asmMethod.getMethodName())) {
                            selectedMethods.add(beanMethod);
                            break;
                        }
                    }
                }
                if (selectedMethods.size() == beanMethods.size()) {
                    // 所有通过反射检测到的方法都在ASM方法集中，因此使用ASM方法集
                    beanMethods = selectedMethods;
                }
            }
        }
        catch (IOException ex) {
            // 如果使用ASM读取类文件时发生错误，记录错误信息，并继续使用反射元数据
            logger.debug("Failed to read class file via ASM for determining @Bean method order", ex);
        }
    }

    // 返回检索到的@Bean方法集
    return beanMethods;
}

上面是步骤3.1对@Bean方法进行扫描，并将扫描结果存储在ConfigurationClass类中的beanMethods字段中。

我们来到org.springframework.context.annotation.ConfigurationClassPostProcessor#processConfigBeanDefinitions方法中的步骤4。在org.springframework.context.annotation.ConfigurationClassBeanDefinitionReader#loadBeanDefinitions方法中，首先设置了一个跟踪条件评估的工具，然后遍历每一个配置类，为每一个配置类加载bean定义。这是Spring Java配置方式的核心过程，确保@Bean方法被正确地解析并在容器中注册为bean。

public void loadBeanDefinitions(Set<ConfigurationClass> configurationModel) {
    TrackedConditionEvaluator trackedConditionEvaluator = new TrackedConditionEvaluator();
    for (ConfigurationClass configClass : configurationModel) {
        loadBeanDefinitionsForConfigurationClass(configClass, trackedConditionEvaluator);
    }
}

在org.springframework.context.annotation.ConfigurationClassBeanDefinitionReader#loadBeanDefinitionsForConfigurationClass方法中，对于每一个BeanMethod，调用了loadBeanDefinitionsForBeanMethod方法。这个方法会针对单个@Bean方法进行解析，并将其转换为一个Spring IoC容器可以管理的Bean定义。

private void loadBeanDefinitionsForConfigurationClass(
			ConfigurationClass configClass, TrackedConditionEvaluator trackedConditionEvaluator) {

    // ... [代码部分省略以简化]
    for (BeanMethod beanMethod : configClass.getBeanMethods()) {
        loadBeanDefinitionsForBeanMethod(beanMethod);
    }
	// ... [代码部分省略以简化]
}

在org.springframework.context.annotation.ConfigurationClassBeanDefinitionReader#loadBeanDefinitionsForBeanMethod方法中，如果@Bean方法是静态的，那么它直接使用方法所在类作为bean的类。否则，它使用配置类的bean名称作为工厂bean名，并设置工厂方法名为当前@Bean方法的名字，然后尝试获取更详细的方法元数据，特别是如果元数据是StandardMethodMetadata类型的，它可以直接获取原始方法对象，然后还要处理autowire, autowireCandidate, initMethod, 和destroyMethod等属性，这些属性提供了有关如何处理bean生命周期和依赖注入的信息。然后如果@Bean方法有@Scope注解，它会处理这个注解的属性，如作用域名和代理模式，然后需要为这个bean创建一个代理，最后，使用registerBeanDefinition方法将Bean定义注册到IoC容器中。

private void loadBeanDefinitionsForBeanMethod(BeanMethod beanMethod) {
    // ... [代码部分省略以简化]

    // 创建一个新的Bean定义基于@Bean方法的元数据
    ConfigurationClassBeanDefinition beanDef = new ConfigurationClassBeanDefinition(configClass, metadata, beanName);

    // 设置Bean定义的来源信息
    beanDef.setSource(this.sourceExtractor.extractSource(metadata, configClass.getResource()));

    // 检查@Bean方法是否为静态方法
    if (metadata.isStatic()) {
        // 处理静态@Bean方法
        if (configClass.getMetadata() instanceof StandardAnnotationMetadata) {
            beanDef.setBeanClass(((StandardAnnotationMetadata) configClass.getMetadata()).getIntrospectedClass());
        }
        else {
            beanDef.setBeanClassName(configClass.getMetadata().getClassName());
        }
        beanDef.setUniqueFactoryMethodName(methodName);
    }
    else {
        // 处理实例@Bean方法
        beanDef.setFactoryBeanName(configClass.getBeanName());
        beanDef.setUniqueFactoryMethodName(methodName);
    }

    // 如果元数据是StandardMethodMetadata类型的，设置已解析的工厂方法
    if (metadata instanceof StandardMethodMetadata) {
        beanDef.setResolvedFactoryMethod(((StandardMethodMetadata) metadata).getIntrospectedMethod());
    }

    // 设置自动装配模式为构造器自动装配
    beanDef.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_CONSTRUCTOR);
    beanDef.setAttribute(org.springframework.beans.factory.annotation.RequiredAnnotationBeanPostProcessor.
                         SKIP_REQUIRED_CHECK_ATTRIBUTE, Boolean.TRUE);

    // 处理Bean定义的通用注解属性
    AnnotationConfigUtils.processCommonDefinitionAnnotations(beanDef, metadata);

    // 获取并设置autowire属性
    Autowire autowire = bean.getEnum("autowire");
    if (autowire.isAutowire()) {
        beanDef.setAutowireMode(autowire.value());
    }

    // 获取并设置autowireCandidate属性
    boolean autowireCandidate = bean.getBoolean("autowireCandidate");
    if (!autowireCandidate) {
        beanDef.setAutowireCandidate(false);
    }

    // 获取并设置初始化方法名
    String initMethodName = bean.getString("initMethod");
    if (StringUtils.hasText(initMethodName)) {
        beanDef.setInitMethodName(initMethodName);
    }

    // 获取并设置销毁方法名
    String destroyMethodName = bean.getString("destroyMethod");
    beanDef.setDestroyMethodName(destroyMethodName);

    // 根据@Scope注解处理Bean的作用域及其代理模式
    ScopedProxyMode proxyMode = ScopedProxyMode.NO;
    AnnotationAttributes attributes = AnnotationConfigUtils.attributesFor(metadata, Scope.class);
    if (attributes != null) {
        beanDef.setScope(attributes.getString("value"));
        proxyMode = attributes.getEnum("proxyMode");
        if (proxyMode == ScopedProxyMode.DEFAULT) {
            proxyMode = ScopedProxyMode.NO;
        }
    }

    // 如果需要，创建一个代理的Bean定义
    BeanDefinition beanDefToRegister = beanDef;
    if (proxyMode != ScopedProxyMode.NO) {
        BeanDefinitionHolder proxyDef = ScopedProxyCreator.createScopedProxy(
            new BeanDefinitionHolder(beanDef, beanName), this.registry,
            proxyMode == ScopedProxyMode.TARGET_CLASS);
        beanDefToRegister = new ConfigurationClassBeanDefinition(
            (RootBeanDefinition) proxyDef.getBeanDefinition(), configClass, metadata, beanName);
    }

    // 最终将@Bean方法对应的Bean定义注册到容器
    this.registry.registerBeanDefinition(beanName, beanDefToRegister);
}

@Bean初始化源码分析

首先来看看启动类入口，上下文环境使用AnnotationConfigApplicationContext（此类是使用Java注解来配置Spring容器的方式），构造参数我们给定了一个MyConfiguration组件类。然后从Spring上下文中获取一个MyBean类型的bean，最后调用context.close()方法关闭容器。

public class BeanApplication {

    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MyConfiguration.class);
        System.out.println(context.getBean(MyBean.class));
        context.close();
    }
}

在org.springframework.context.annotation.AnnotationConfigApplicationContext#AnnotationConfigApplicationContext构造函数中，执行了三个步骤，我们重点关注refresh()方法

public AnnotationConfigApplicationContext(Class<?>... componentClasses) {
    this();
    register(componentClasses);
    refresh();
}

在org.springframework.context.support.AbstractApplicationContext#refresh方法中我们重点关注一下finishBeanFactoryInitialization(beanFactory)这方法会对实例化所有剩余非懒加载的单列Bean对象，其他方法不是本次源码阅读的重点暂时忽略。

@Override
public void refresh() throws BeansException, IllegalStateException {
    // ... [代码部分省略以简化]
    // Instantiate all remaining (non-lazy-init) singletons.
    finishBeanFactoryInitialization(beanFactory);
    // ... [代码部分省略以简化]
}

在org.springframework.context.support.AbstractApplicationContext#finishBeanFactoryInitialization方法中，会继续调用DefaultListableBeanFactory类中的preInstantiateSingletons方法来完成所有剩余非懒加载的单列Bean对象。

/**
 * 完成此工厂的bean初始化，实例化所有剩余的非延迟初始化单例bean。
 * 
 * @param beanFactory 要初始化的bean工厂
 */
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
    // ... [代码部分省略以简化]
    // 完成所有剩余非懒加载的单列Bean对象。
    beanFactory.preInstantiateSingletons();
}

在org.springframework.beans.factory.support.DefaultListableBeanFactory#preInstantiateSingletons方法中，主要的核心目的是预先实例化所有非懒加载的单例bean。在Spring的上下文初始化完成后，该方法会被触发，以确保所有单例bean都被正确地创建并初始化。其中getBean(beanName)是此方法的核心操作。对于容器中定义的每一个单例bean，它都会调用getBean方法，这将触发bean的实例化、初始化及其依赖的注入。如果bean之前没有被创建过，那么这个调用会导致其被实例化和初始化。

public void preInstantiateSingletons() throws BeansException {
    // ... [代码部分省略以简化]
    // 循环遍历所有bean的名称
    for (String beanName : beanNames) {
        getBean(beanName);
    }
    // ... [代码部分省略以简化]
}

在org.springframework.beans.factory.support.AbstractBeanFactory#getBean()方法中，又调用了doGetBean方法来实际执行创建Bean的过程，传递给它bean的名称和一些其他默认的参数值。此处，doGetBean负责大部分工作，如查找bean定义、创建bean（如果尚未创建）、处理依赖关系等。

@Override
public Object getBean(String name) throws BeansException {
    return doGetBean(name, null, null, false);
}

在org.springframework.beans.factory.support.AbstractBeanFactory#doGetBean方法中，首先检查所请求的bean是否是一个单例并且已经创建。如果尚未创建，它将创建一个新的实例。在这个过程中，它处理可能的异常情况，如循环引用，并确保返回的bean是正确的类型。这是Spring容器bean生命周期管理的核心部分。

protected <T> T doGetBean(
        String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)
        throws BeansException {
    // ... [代码部分省略以简化]

    // 开始创建bean实例
    if (mbd.isSingleton()) {
        // 如果bean是单例的，我们会尝试从单例缓存中获取它
        // 如果不存在，则使用lambda创建一个新的实例
        sharedInstance = getSingleton(beanName, () -> {
            try {
                // 尝试创建bean实例
                return createBean(beanName, mbd, args);
            }
            catch (BeansException ex) {
                // ... [代码部分省略以简化]
            }
        });
        // 对于某些bean（例如FactoryBeans），可能需要进一步处理以获取真正的bean实例
        beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
    }
    // ... [代码部分省略以简化]

    // 确保返回的bean实例与请求的类型匹配
    return adaptBeanInstance(name, beanInstance, requiredType);
}

在org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#getSingleton()方法中，主要负责从单例缓存中获取一个已存在的bean实例，或者使用提供的ObjectFactory创建一个新的实例。这是确保bean在Spring容器中作为单例存在的关键部分。

public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
    // 断言bean名称不能为空
    Assert.notNull(beanName, "Bean name must not be null");

    // 同步访问单例对象缓存，确保线程安全
    synchronized (this.singletonObjects) {
        // 从缓存中获取单例对象
        Object singletonObject = this.singletonObjects.get(beanName);

        // 如果缓存中没有找到
        if (singletonObject == null) {
            // ... [代码部分省略以简化]

            try {
                // 使用工厂创建新的单例实例
                singletonObject = singletonFactory.getObject();
                newSingleton = true;
            }
            catch (IllegalStateException ex) {
                // ... [代码部分省略以简化]
            }
            catch (BeanCreationException ex) {
                // ... [代码部分省略以简化]
            }
            finally {
                // ... [代码部分省略以简化]
            }

            // ... [代码部分省略以简化]
        }

        // 返回单例对象
        return singletonObject;
    }
}

在org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#createBean()方法中，主要的逻辑是调用 doCreateBean，这是真正进行 bean 实例化、属性填充和初始化的地方。这个方法会返回新创建的 bean 实例。

@Override
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
    throws BeanCreationException {
    
    // ... [代码部分省略以简化]
    
    try {
        // 正常的bean实例化、属性注入和初始化。
        // 这里是真正进行bean创建的部分。
        Object beanInstance = doCreateBean(beanName, mbdToUse, args);
        // 记录bean成功创建的日志
        if (logger.isTraceEnabled()) {
            logger.trace("Finished creating instance of bean '" + beanName + "'");
        }
        return beanInstance;
    }
    catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
        // ... [代码部分省略以简化]
    }
    catch (Throwable ex) {
        // ... [代码部分省略以简化]
    }
}

在org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#doCreateBean方法中，initializeBean方法是bean初始化，确保bean是完全配置和准备好的。

protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
        throws BeanCreationException {

    // 声明一个对象，后续可能用于存放初始化后的bean或它的代理对象
    Object exposedObject = bean;

    // ... [代码部分省略以简化]
    
    try {
        // ... [代码部分省略以简化]
        
        // bean初始化
        exposedObject = initializeBean(beanName, exposedObject, mbd);
    } 
    catch (Throwable ex) {
        // ... [代码部分省略以简化]
    }

    // 返回创建和初始化后的bean
    return exposedObject;
}

在org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#initializeBean方法中，如果bean实现了InitializingBean接口，则它的afterPropertiesSet方法会在此处被调用。此外，如果bean配置中定义了自定义的初始化方法，spring会在这里被调用。

protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {

    // ... [代码部分省略以简化]
    
    try {
        invokeInitMethods(beanName, wrappedBean, mbd);
    }
    catch (Throwable ex) {
        // ... [代码部分省略以简化]
    }
    
    // ... [代码部分省略以简化]

    return wrappedBean;
}

在org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#invokeInitMethods方法中，afterPropertiesSet是InitializingBean接口中定义的一个特殊的初始化方法。如果bean实现了这个接口，这个方法会在bean的属性被注入之后自动被调用。在这里，为了避免重复调用，Spring会检查bean是否是InitializingBean的实例，以及其初始化方法名是否为afterPropertiesSet。

protected void invokeInitMethods(String beanName, Object bean, @Nullable RootBeanDefinition mbd)
			throws Throwable {
    // ... [代码部分省略以简化]
    
    // 检查Bean定义是否存在，且bean实例不是一个NullBean（Spring中用于标记占位bean的特殊类型）
    if (mbd != null && bean.getClass() != NullBean.class) {
        // 获取初始化方法名
        String initMethodName = mbd.getInitMethodName();
        // 检查是否有初始化方法需要被调用
        if (StringUtils.hasLength(initMethodName) &&
            // bean不是一个InitializingBean，或者初始化方法名不是"afterPropertiesSet"
            !(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) &&
            // 初始化方法没有被外部管理（例如，通过AspectJ的切面）
            !mbd.isExternallyManagedInitMethod(initMethodName)) {
            // 调用自定义的初始化方法
            invokeCustomInitMethod(beanName, bean, mbd);
        }
    }
}

在org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#invokeCustomInitMethod方法中，使用Java反射API来动态地调用Bean的初始化方法。

protected void invokeCustomInitMethod(String beanName, Object bean, RootBeanDefinition mbd)
			throws Throwable {
	// ... [代码部分省略以简化]

	// 使用反射来调用Bean的初始化方法
    try {
        // 确保要调用的方法是可访问的
        ReflectionUtils.makeAccessible(methodToInvoke);
        // 调用Bean的自定义初始化方法
        methodToInvoke.invoke(bean);
    }
    catch (InvocationTargetException ex) {
        // 如果初始化方法抛出了异常，这里会捕获到，并继续抛出该异常的目标异常
        throw ex.getTargetException();
    }
    // ... [代码部分省略以简化]
}

@Bean销毁源码分析

首先来看看启动类入口，上下文环境使用AnnotationConfigApplicationContext（此类是使用Java注解来配置Spring容器的方式），构造参数我们给定了一个MyConfiguration组件类。然后从Spring上下文中获取一个MyBean类型的bean，最后调用context.close()方法关闭容器。

public class BeanApplication {

    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MyConfiguration.class);
        System.out.println(context.getBean(MyBean.class));
        context.close();
    }
}

在org.springframework.context.support.AbstractApplicationContext#close方法中，首先是启动了一个同步块，它同步在 startupShutdownMonitor 对象上。这确保了在给定时刻只有一个线程可以执行这个块内的代码，防止多线程导致的资源竞争或数据不一致，然后是调用了 doClose 方法，最后是为 JVM 注册了一个关闭钩子。

@Override
public void close() {
    synchronized (this.startupShutdownMonitor) {
        doClose();
        // If we registered a JVM shutdown hook, we don't need it anymore now:
        // We've already explicitly closed the context.
        if (this.shutdownHook != null) {
            try {
                Runtime.getRuntime().removeShutdownHook(this.shutdownHook);
            }
            catch (IllegalStateException ex) {
                // ignore - VM is already shutting down
            }
        }
    }
}

在org.springframework.context.support.AbstractApplicationContext#doClose方法中，又调用了 destroyBeans 方法。

protected void doClose() {
    // ... [代码部分省略以简化]
    // Destroy all cached singletons in the context's BeanFactory.
    destroyBeans();
    // ... [代码部分省略以简化]
}

在org.springframework.context.support.AbstractApplicationContext#destroyBeans方法中，首先是调用了getBeanFactory()返回 Spring 的 BeanFactory ，然后在获得的 BeanFactory 上，调用了 destroySingletons 方法，这个方法的目的是销毁所有在 BeanFactory 中缓存的单例 beans。

protected void destroyBeans() {
    getBeanFactory().destroySingletons();
}

在org.springframework.beans.factory.support.DefaultListableBeanFactory#destroySingletons方法中，首先是调用了父类的 destroySingletons 方法，为了确保继承自父类的销毁逻辑得到了执行。

@Override
public void destroySingletons() {
    super.destroySingletons();
    updateManualSingletonNames(Set::clear, set -> !set.isEmpty());
    clearByTypeCache();
}

在org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#destroySingletons方法中，首先是在disposableBeans 字段上，从其键集合中获取所有的 bean 名称，并将它们转换为一个字符串数组。disposableBeans 可能包含了实现了 DisposableBean 接口的 beans，这些 beans 需要在容器销毁时特殊处理，最后倒序循环，从最后一个开始，销毁所有在 disposableBeans 列表中的 beans。这样做是为了确保依赖关系正确地处理，beans先被创建的应该后被销毁。

public void destroySingletons() {
    // ... [代码部分省略以简化]
    String[] disposableBeanNames;
    synchronized (this.disposableBeans) {
        disposableBeanNames = StringUtils.toStringArray(this.disposableBeans.keySet());
    }
    for (int i = disposableBeanNames.length - 1; i >= 0; i--) {
        destroySingleton(disposableBeanNames[i]);
    }
    // ... [代码部分省略以简化]
}

在org.springframework.beans.factory.support.DefaultListableBeanFactory#destroySingleton方法中，首先是调用了父类的 destroySingleton 方法，为了确保继承自父类的销毁逻辑得到了执行。

@Override
public void destroySingleton(String beanName) {
    super.destroySingleton(beanName);
    removeManualSingletonName(beanName);
    clearByTypeCache();
}

在org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#destroySingleton方法中，首先是使用 synchronized 关键字在 disposableBeans 对象上进行同步，以确保在多线程环境中安全地访问和修改它，从 disposableBeans 集合中移除指定名称的 bean，并将其转换为 DisposableBean 类型，最后调用destroyBean方法执行实际的销毁操作。

public void destroySingleton(String beanName) {
    // Remove a registered singleton of the given name, if any.
    removeSingleton(beanName);

    // Destroy the corresponding DisposableBean instance.
    DisposableBean disposableBean;
    synchronized (this.disposableBeans) {
        disposableBean = (DisposableBean) this.disposableBeans.remove(beanName);
    }
    destroyBean(beanName, disposableBean);
}

在org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#destroyBean方法中，直接调用 bean 的 destroy 方法。因为 bean 是一个 DisposableBean 类型的实例，所以它一定有一个 destroy 方法，该方法提供了 bean 的自定义销毁逻辑。

protected void destroyBean(String beanName, @Nullable DisposableBean bean) {
    // ... [代码部分省略以简化]
    // Actually destroy the bean now...
    if (bean != null) {
        try {
            bean.destroy();
        }
        catch (Throwable ex) {
            // ... [代码部分省略以简化]
        }
    }
    // ... [代码部分省略以简化]
}

在org.springframework.beans.factory.support.DisposableBeanAdapter#destroy方法中，此方法首先检查是否已经为bean指定了一个销毁方法(destroyMethod)。如果有，则直接调用invokeCustomDestroyMethod方法。如果没有提供具体的方法，但提供了方法的名称(destroyMethodName)，那么它会尝试根据这个名称找到对应的方法。一旦找到了方法，就会调用invokeCustomDestroyMethod方法。

@Override
public void destroy() {
    // ... [代码部分省略以简化]

    // 如果提供了销毁方法（destroyMethod），则直接调用它
    if (this.destroyMethod != null) {
        invokeCustomDestroyMethod(this.destroyMethod);
    }
    // 否则，如果提供了销毁方法的名称（destroyMethodName），则尝试找到对应的方法并调用它
    else if (this.destroyMethodName != null) {
        // 根据方法名确定要调用的销毁方法
        Method methodToInvoke = determineDestroyMethod(this.destroyMethodName);
        if (methodToInvoke != null) {
            // 如果找到了方法，则调用它，但确保使用的是方法的接口版本（如果可能的话）
            invokeCustomDestroyMethod(ClassUtils.getInterfaceMethodIfPossible(methodToInvoke));
        }
    }
}

在org.springframework.beans.factory.support.DisposableBeanAdapter#invokeCustomDestroyMethod方法中，用于执行自定义的销毁方法。自定义销毁方法是由我们在Spring配置中为bean定义的，用于在bean的生命周期结束时释放资源、清理等。

private void invokeCustomDestroyMethod(final Method destroyMethod) {
    // ... [代码部分省略以简化]
    try {
        if (System.getSecurityManager() != null) {
            // ... [代码部分省略以简化]
        }
        else {
            ReflectionUtils.makeAccessible(destroyMethod);
            destroyMethod.invoke(this.bean, args);
        }
    }
    catch (InvocationTargetException ex) {
        // ... [代码部分省略以简化]
    }
    catch (Throwable ex) {
        // ... [代码部分省略以简化]
    }
}

八、注意事项

1. 方法名称即Bean名称

   • 默认情况下，使用@Bean注解的方法名称将用作Bean的名称。如果需要自定义bean的名称，可以在@Bean注解中指定名称，如@Bean("customBeanName")。

2. 返回类型

   • 确保@Bean方法的返回类型与实际创建的bean对象匹配。

3. 调用其他@Bean方法

   • 在一个配置类中，可以调用一个@Bean方法来注入另一个@Bean方法的结果。这是因为@Bean方法在调用时是通过Spring代理进行的，这确保了单例beans的单一实例性。

4. 作用域

   • 使用@Scope注解与@Bean一起可以定义Bean的作用域，例如单例（默认）、原型、请求、会话等。

5. 生命周期回调

   • @Bean注解允许指定initMethod和destroyMethod，这些方法分别在bean初始化和销毁时被调用。

6. 避免重复定义

   • 确保不在XML和Java配置中同时定义同一个bean。如果必须这样做，确保bean的名称和定义相同，否则会出现不可预测的行为。

7. 慎用@Lazy

   • @Lazy注解使得bean在首次请求时才被初始化。如果一个bean需要在应用启动时就初始化，那么不应该标记为延迟初始化。

8. 参数化@Bean方法

   • @Bean方法可以接受参数，这些参数会从Spring容器中自动解析。这在创建一个bean依赖于另一个bean时特别有用。

9. 考虑线程安全性

   • 特别是对于原型作用域的bean，确保bean是线程安全的，或者不会在多个线程之间共享。

10. 使用条件注解

    • 配合@Conditional或其他相关注解，可以在满足某些条件时才创建bean。

11. @Bean与@Component的区别

    • 虽然两者都用于定义bean，但@Bean通常用于方法，特别是在Java配置类中，而@Component（及其特化：@Service、@Repository、@Controller等）用于类。

12. 注意潜在的循环依赖

    • 如果两个@Bean方法相互调用，可能会出现循环依赖。Spring可以解决单例作用域的bean之间的循环依赖，但不推荐这样做。

13. 配置类应被Spring管理

    • 确保包含@Bean方法的类由Spring管理，并标记为@Configuration。这确保@Bean方法由Spring的代理调用，从而支持上述提到的特性，如单例保证和循环引用。

九、总结

最佳实践总结

1. 应用启动

   • 使用AnnotationConfigApplicationContext可以基于Java注解来启动和配置Spring的上下文。在上述示例中，我们传递了一个Java配置类 MyConfiguration 作为参数来初始化这个上下文。

2. 配置类的使用

   • 使用 @Configuration 注解标记配置类，表明这个类包含Spring的bean定义。在配置类中，可以使用 @Bean 注解来定义bean。这个注解的方法的名称默认会作为bean的名称，返回的实例则为Spring容器管理的bean实例。

3. Bean的生命周期

   • 通过 @Bean 注解的 initMethod 和 destroyMethod 属性，可以为bean定义初始化和销毁时要调用的方法。这为bean提供了一种自定义的初始化和清理机制。当bean被Spring容器实例化时，指定的初始化方法会被调用；当bean被销毁或容器关闭时，指定的销毁方法会被调用。

源码分析总结

1. @Bean 注册源码分析总结

   • 启动及配置加载

     • 使用 AnnotationConfigApplicationContext 初始化Spring上下文，并传入 MyConfiguration 配置类。该上下文构造函数将执行 register() 和 refresh() 方法。

   • Bean定义的解析

     • refresh() 方法触发上下文的刷新，其中涉及到对bean定义的处理。调用 invokeBeanFactoryPostProcessors() 方法来处理bean工厂后置处理器。

   • 处理配置类

     • BeanDefinitionRegistryPostProcessor 是特殊的 BeanFactoryPostProcessor，它会在所有其他bean定义被加载之前运行。这个流程主要通过 ConfigurationClassPostProcessor 实现，该类负责处理标有 @Configuration 的类。

   • 解析 @Bean 方法

     • 对每个 @Configuration 类执行解析，将其中的 @Bean 方法解析为bean定义。这涉及读取方法元数据，并将其转化为一个Spring可以理解和管理的 BeanDefinition 对象。

   • 处理bean作用域与代理

     • 如果在 @Bean 方法上有 @Scope 注解，会根据其属性处理bean的作用域。根据需要，可能会为bean创建一个代理，这是通过 ScopedProxyCreator 来完成的。

   • bean定义的注册

     • 最终，解析出的bean定义会被注册到Spring的bean定义注册表中，这样在上下文启动后，这些定义的bean就可以被实例化和使用了。

2. @Bean初始化源码分析总结

   • 启动

     • 当使用AnnotationConfigApplicationContext并提供MyConfiguration类作为参数时，Spring容器开始初始化。

   • 刷新上下文

     • 通过调用refresh()方法，Spring上下文被刷新。这是在上下文中创建和初始化所有bean的关键阶段。

   • 初始化Bean工厂

     • 方法finishBeanFactoryInitialization会确保所有非懒加载的单例bean都被初始化。它调用DefaultListableBeanFactory中的preInstantiateSingletons方法，该方法循环遍历容器中定义的每一个单例bean并使用getBean方法进行初始化。

   • 获取Bean：

     • 在获取bean时，首先会检查是否已存在此单例bean。如果不存在，则会创建它。核心方法是doGetBean，它管理整个bean的生命周期，从查找bean定义到初始化bean。

   • 单例处理

     • getSingleton方法管理单例bean的缓存。它首先尝试从缓存中获取bean，如果未找到，则使用提供的ObjectFactory创建一个新的实例。

   • 创建Bean

     • 如果需要，createBean方法将负责实例化bean。最终，真正的bean创建工作是在doCreateBean方法中完成的。

   • 初始化Bean

     • 一旦bean被实例化，就需要进行初始化。如果bean实现了InitializingBean接口，那么它的afterPropertiesSet方法会被调用。此外，如果bean配置中定义了自定义的初始化方法，该方法也会在此时被调用。

   • 反射调用

     • 最终，如果定义了自定义的初始化方法，Spring会使用Java的反射API来调用它。

3. @Bean销毁源码分析总结

   • 启动和关闭

     • 通过AnnotationConfigApplicationContext，Spring容器初始化后，context.close()方法会被调用以关闭容器。

   • 关闭上下文

     • close()方法首先同步startupShutdownMonitor，确保在特定时刻只有一个线程能关闭上下文，接着调用doClose方法执行实际关闭操作。

   • 销毁Beans

     • 在doClose方法中，destroyBeans方法被调用以销毁所有缓存中的单例bean。

   • 销毁单例Beans

     • destroyBeans方法会调用BeanFactory的destroySingletons方法来销毁所有缓存的单例beans。

   • 遍历并销毁

     • 在destroySingletons中，所有缓存的单例bean都会被遍历。对于每一个bean，destroySingleton方法会被调用来执行销毁操作。

   • 实际的销毁操作

     • 在destroySingleton中，会从disposableBeans列表中移除对应的bean，并执行实际的销毁操作。

   • 自定义销毁逻辑

     • 如果bean实现了DisposableBean接口或者定义了自定义的销毁方法，Spring容器会确保在销毁bean时调用这些方法。销毁方法可以是定义在bean配置中的任何方法，不需要特定的方法签名。

   • 反射调用销毁方法

     • 最后，Spring使用Java反射API来动态地调用bean的自定义销毁方法。