那些年背过的题目：Spring ApplicationContext- IOC容器初始化过程Spring IOC（Inv

Spring IOC（Inversion of Control）容器的初始化过程分为几个主要步骤，从创建容器、定位资源、读取和解析配置文件，到最终实例化和初始化bean。

1. 创建IOC容器

根据配置类型选择适当的IOC容器实现。

XML 配置：

ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");

注解配置：

ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);

2. 资源定位

Spring通过ResourceLoader接口及其实现类来定位资源。通常情况下，XML配置使用ClassPathXmlApplicationContext进行资源定位，而注解配置使用AnnotationConfigApplicationContext。

3. 资源读取和解析

根据配置类型不同，Spring会采用不同的读取器来解析配置并生成BeanDefinition对象：

XML配置：使用XmlBeanDefinitionReader
注解配置：使用AnnotatedBeanDefinitionReader

这些读取器将配置文件或类解析成Spring内部的BeanDefinition对象，这些对象包含了bean的所有配置信息。

4. 注册BeanDefinition

将解析后的BeanDefinition对象注册到IOC容器中，通过BeanDefinitionRegistry接口来完成。

5. BeanFactory准备

Spring使用DefaultListableBeanFactory作为默认的BeanFactory实现。在这一步，Spring会初始化一些基础设施bean，如BeanPostProcessor和BeanFactoryPostProcessor。

6. 实例化和注入依赖关系

这是Spring IOC容器最核心的功能之一，涉及以下几个子步骤：

6.1 实例化Bean

IOC容器根据BeanDefinition中的信息实例化bean对象。这一步通常通过反射机制来完成。

6.2 设置Bean属性

在实例化bean之后，IOC容器会进行属性注入，将所需的依赖对象注入到bean中。这可以通过构造函数注入、setter方法注入或者字段注入（使用注解）。

6.3 初始化Bean

如果bean实现了InitializingBean接口，Spring会调用它的afterPropertiesSet方法。如果在配置文件中指定了init-method方法，也会被调用。

6.4 Bean的生命周期回调

Spring支持多种生命周期回调，如@PostConstruct注解的方法，这些方法会在依赖注入完成后调用。

6.5 AOP代理（可选）

如果bean配置了AOP（Aspect-Oriented Programming），在这个阶段Spring会为bean创建相应的代理对象。

示例代码

下面提供了XML配置方式和注解配置方式的完整示例代码。

XML配置方式

`applicationContext.xml`

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
                           http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="myService" class="com.example.MyService">
        <property name="name" value="Example Service"/>
    </bean>
</beans>

Java代码示例

Main.java

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Main {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        MyService myService = context.getBean(MyService.class);
        System.out.println(myService.getName());
    }
}

MyService.java

package com.example;

public class MyService {
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

注解配置方式

`AppConfig.java`

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class AppConfig {

    @Bean
    public MyService myService() {
        MyService myService = new MyService();
        myService.setName("Example Service");
        return myService;
    }
}

Java代码示例

Main.java

import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class Main {
    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        MyService myService = context.getBean(MyService.class);
        System.out.println(myService.getName());
    }
}

MyService.java

package com.example;

public class MyService {
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

关键步骤解析

创建IOC容器
- 使用ClassPathXmlApplicationContext或AnnotationConfigApplicationContext来加载配置文件或配置类。
资源定位
- Spring通过ResourceLoader接口及其实现类来找到配置文件或配置类的位置。
资源读取和解析
- 根据配置类型不同，Spring会采用不同的读取器（如XmlBeanDefinitionReader或AnnotatedBeanDefinitionReader）来解析配置并生成BeanDefinition对象。
注册BeanDefinition
- 将解析后的BeanDefinition对象注册到IOC容器中，通过BeanDefinitionRegistry接口来完成。
BeanFactory准备
- Spring使用DefaultListableBeanFactory作为默认的BeanFactory实现。在这一步，Spring会初始化一些基础设施bean，如BeanPostProcessor和BeanFactoryPostProcessor。
实例化和注入依赖关系
- 实例化Bean：根据BeanDefinition中的信息实例化bean对象。
- 设置Bean属性：进行属性注入，将所需的依赖对象注入到bean中。
- 初始化Bean：调用InitializingBean接口的afterPropertiesSet方法或指定的init-method方法。
- Bean的生命周期回调：调用@PostConstruct注解的方法。
- AOP代理（可选）：为bean创建AOP代理对象，如果有配置AOP。

通过以上步骤，Spring IOC容器能够成功初始化，并且所有bean都可以正确实例化和注入依赖关系。

资源读取和解析详细流程

XML 配置读取和解析

步骤：

创建XmlBeanDefinitionReader:

XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(beanFactory);

使用读取器加载和解析配置文件：

int beanCount = reader.loadBeanDefinitions("applicationContext.xml");

核心方法：

loadBeanDefinitions：负责从XML文件中读取bean定义。
doLoadBeanDefinitions：实际执行XML文件的解析。

示例代码：

public class XmlBeanDefinitionReader extends AbstractBeanDefinitionReader {

    public int loadBeanDefinitions(String location) throws BeanDefinitionStoreException {
        Resource resource = getResourceLoader().getResource(location);
        return loadBeanDefinitions(resource);
    }

    public int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException {
        try (InputStream inputStream = resource.getInputStream()) {
            return doLoadBeanDefinitions(inputStream, resource);
        } catch (IOException ex) {
            throw new BeanDefinitionStoreException("IOException parsing XML document from " + resource, ex);
        }
    }

    protected int doLoadBeanDefinitions(InputStream inputStream, Resource resource) throws BeanDefinitionStoreException {
        Document doc = doLoadDocument(inputStream, resource);
        return registerBeanDefinitions(doc, resource);
    }
    
    // 其他必要的方法...
}

解析XML配置的主要步骤：

使用ResourceLoader获取配置文件资源。
打开输入流读取XML文件内容。
将XML内容解析成Document对象。
遍历Document对象，提取bean定义信息并注册为BeanDefinition对象。

3.2 注解配置读取和解析

步骤：

创建AnnotatedBeanDefinitionReader:

AnnotatedBeanDefinitionReader reader = new AnnotatedBeanDefinitionReader(beanFactory);

注册配置类：
```
reader.register(AppConfig.class);
```

核心方法：

register：负责从配置类中读取bean定义。

示例代码：

public class AnnotatedBeanDefinitionReader {

    private final BeanDefinitionRegistry registry;

    public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry) {
        this.registry = registry;
    }

    public void register(Class<?>... annotatedClasses) {
        for (Class<?> annotatedClass : annotatedClasses) {
            registerBean(annotatedClass);
        }
    }

    private void registerBean(Class<?> annotatedClass) {
        BeanDefinition beanDefinition = new ScannedGenericBeanDefinition(annotatedClass);
        String beanName = determineBeanName(beanDefinition);
        registry.registerBeanDefinition(beanName, beanDefinition);
    }
    
    // 其他必要的方法...
}

解析注解配置的主要步骤：

遍历配置类中的所有bean定义。
为每个bean定义创建BeanDefinition对象。
将BeanDefinition对象注册到容器中。

注册BeanDefinition详细流程

无论是XML方式还是注解方式，最终都会生成BeanDefinition对象并注册到IOC容器中。这个过程通常由BeanDefinitionRegistry接口实现。

核心接口和类

BeanDefinitionRegistry：这是一个接口，定义了注册和获取 BeanDefinition 的基本操作方法。
DefaultListableBeanFactory：这是 BeanDefinitionRegistry 接口的主要实现类，也是 Spring IOC 容器的默认实现。
GenericApplicationContext：这是一个方便的应用上下文实现类，组合了 DefaultListableBeanFactory 和其他功能。

注册 BeanDefinition 的核心方法

在 BeanDefinitionRegistry 接口中，有几个关键方法：

void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)：注册一个新的 BeanDefinition。
boolean containsBeanDefinition(String beanName)：检查是否包含给定名称的 BeanDefinition。
BeanDefinition getBeanDefinition(String beanName)：获取指定名称的 BeanDefinition。

源码分析

`BeanDefinitionRegistry` 接口

public interface BeanDefinitionRegistry {

    void registerBeanDefinition(String beanName, BeanDefinition beanDefinition) throws BeanDefinitionStoreException;

    void removeBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;

    BeanDefinition getBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;

    boolean containsBeanDefinition(String beanName);

    String[] getBeanDefinitionNames();

    int getBeanDefinitionCount();
}

`DefaultListableBeanFactory` 类

DefaultListableBeanFactory 是 BeanDefinitionRegistry 的主要实现类，其内部通过一个 ConcurrentHashMap 来存储 BeanDefinition。

public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFactory
        implements ConfigurableListableBeanFactory, BeanDefinitionRegistry, Serializable {

    private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(256);

    @Override
    public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
            throws BeanDefinitionStoreException {
        
        Assert.hasText(beanName, "Bean name must not be empty");
        Assert.notNull(beanDefinition, "BeanDefinition must not be null");

        synchronized (this.beanDefinitionMap) {
            BeanDefinition oldBeanDefinition = this.beanDefinitionMap.get(beanName);
            if (oldBeanDefinition != null) {
                throw new BeanDefinitionStoreException(beanName,
                        "Cannot register bean definition [" + beanDefinition + "] for bean '" + beanName +
                        "': there is already [" + oldBeanDefinition + "] bound.");
            }
            this.beanDefinitionMap.put(beanName, beanDefinition);
        }

        // Other logic related to bean definition registration
    }

    @Override
    public BeanDefinition getBeanDefinition(String beanName) throws NoSuchBeanDefinitionException {
        BeanDefinition bd = this.beanDefinitionMap.get(beanName);
        if (bd == null) {
            throw new NoSuchBeanDefinitionException(beanName);
        }
        return bd;
    }

    @Override
    public boolean containsBeanDefinition(String beanName) {
        return this.beanDefinitionMap.containsKey(beanName);
    }

    @Override
    public int getBeanDefinitionCount() {
        return this.beanDefinitionMap.size();
    }

    @Override
    public String[] getBeanDefinitionNames() {
        return StringUtils.toStringArray(this.beanDefinitionMap.keySet());
    }
}

简要流程总结

registerBeanDefinition(String beanName, BeanDefinition beanDefinition) ：
- 检查 bean 名称和 BeanDefinition 是否为空。
- 使用 synchronized 块确保线程安全。
- 将 BeanDefinition 存入 beanDefinitionMap。
- 如果已经存在同名的 BeanDefinition，则抛出异常。
getBeanDefinition(String beanName) ：
- 从 beanDefinitionMap 获取指定名称的 BeanDefinition。
- 如果不存在，则抛出 NoSuchBeanDefinitionException。
containsBeanDefinition(String beanName) ：
- 检查 beanDefinitionMap 中是否包含指定名称的 BeanDefinition。
getBeanDefinitionCount() ：
- 返回 beanDefinitionMap 中的 BeanDefinition 数量。
getBeanDefinitionNames() ：
- 返回 beanDefinitionMap 中所有 BeanDefinition 的名称。

手动注册一个`BeanDefinition`流程

创建或者获取一个BeanDefinitionRegistry实例：通常情况下，BeanDefinitionRegistry由容器如DefaultListableBeanFactory或GenericApplicationContext提供。
```
BeanDefinitionRegistry registry = new GenericApplicationContext();
```

定义你的Bean：创建一个BeanDefinition实例，可以使用BeanDefinitionBuilder来简化这个过程。

BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(YourBeanClass.class);
builder.addPropertyValue("propertyName", "propertyValue");
BeanDefinition beanDefinition = builder.getBeanDefinition();

将BeanDefinition注册到BeanDefinitionRegistry：使用registerBeanDefinition方法，将创建好的BeanDefinition注册到BeanDefinitionRegistry中。
```
String beanName = "yourBeanName";
registry.registerBeanDefinition(beanName, beanDefinition);
```

使用ApplicationContext获取Bean（如果需要） ：注册完成后，如果你使用的是GenericApplicationContext，可以通过该上下文来获取bean实例。

if (registry instanceof GenericApplicationContext) {
    GenericApplicationContext context = (GenericApplicationContext) registry;
    YourBeanClass bean = context.getBean(beanName, YourBeanClass.class);
}

示例代码

以下是一个完整的示例代码，展示了上述步骤：

import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.support.GenericApplicationContext;

public class BeanDefinitionRegistryExample {

    public static void main(String[] args) {
        // Step 1: 创建一个ApplicationContext，它实现了BeanDefinitionRegistry接口
        GenericApplicationContext context = new AnnotationConfigApplicationContext();

        // Step 2: 定义一个Bean
        BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(MyBean.class);
        builder.addPropertyValue("name", "Test Bean");

        // 获取BeanDefinition
        BeanDefinition beanDefinition = builder.getBeanDefinition();

        // Step 3: 将BeanDefinition注册到BeanDefinitionRegistry
        String beanName = "myBean";
        context.registerBeanDefinition(beanName, beanDefinition);

        // 刷新上下文以应用注册的BeanDefinition
        context.refresh();

        // Step 4: 从ApplicationContext中获取Bean
        MyBean myBean = context.getBean(beanName, MyBean.class);
        System.out.println(myBean.getName());
    }

    public static class MyBean {
        private String name;

        public void setName(String name) {
            this.name = name;
        }

        public String getName() {
            return name;
        }
    }
}

思考题1:`BeanDefinition`存储结构

ConcurrentHashMap 来存储 BeanDefinition，具体参考上文。

`BeanPostProcessor`和`BeanFactoryPostProcessor`接口详细流程

BeanPostProcessor和BeanFactoryPostProcessor是两个非常重要的接口，它们允许开发者在bean实例化和初始化过程中插入自定义逻辑。下面是对这两个接口及其底层实现的详细分析。

一、BeanPostProcessor

1. `BeanPostProcessor`接口

BeanPostProcessor提供了两个回调方法，分别在bean初始化前后执行：

package org.springframework.beans.factory.config;

public interface BeanPostProcessor {

    // 在bean初始化之前执行
    @Nullable
    default Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }

    // 在bean初始化之后执行
    @Nullable
    default Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }
}

2. 使用示例

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;

public class MyBeanPostProcessor implements BeanPostProcessor {

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("Before Initialization : " + beanName);
        return bean; // 可以返回原始bean或者包装后的bean
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("After Initialization : " + beanName);
        return bean; // 可以返回原始bean或者包装后的bean
    }
}

3. 如何注册`BeanPostProcessor`

可以在Spring配置文件或Java配置类中注册BeanPostProcessor：

XML配置：

<bean class="com.example.MyBeanPostProcessor"/>

Java配置：

@Configuration
public class AppConfig {

    @Bean
    public MyBeanPostProcessor myBeanPostProcessor() {
        return new MyBeanPostProcessor();
    }
}

二、BeanFactoryPostProcessor

1. `BeanFactoryPostProcessor`接口

BeanFactoryPostProcessor用于在容器初始化后但在任何bean实例化之前修改bean定义。这使得它们能够修改应用程序上下文的内部bean工厂。

package org.springframework.beans.factory.config;

@FunctionalInterface
public interface BeanFactoryPostProcessor {

    void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException;
}

2. 使用示例

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;

public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        System.out.println("BeanFactoryPostProcessor is called");
        // 可以在这里修改bean定义或添加新的bean定义
    }
}

3. 如何注册`BeanFactoryPostProcessor`

可以在Spring配置文件或Java配置类中注册BeanFactoryPostProcessor：

XML配置：

<bean class="com.example.MyBeanFactoryPostProcessor"/>

Java配置：

@Configuration
public class AppConfig {

    @Bean
    public MyBeanFactoryPostProcessor myBeanFactoryPostProcessor() {
        return new MyBeanFactoryPostProcessor();
    }
}

两个接口的主要功能和实现细节如下：

BeanPostProcessor:
- 提供两个回调方法：postProcessBeforeInitialization和postProcessAfterInitialization。
- 在bean初始化前后分别进行处理。
- Spring容器通过调用applyBeanPostProcessorsBeforeInitialization和applyBeanPostProcessorsAfterInitialization方法来应用这些回调。
BeanFactoryPostProcessor:
- 提供postProcessBeanFactory方法，用于在Spring容器标准初始化之后修改应用上下文的内部bean工厂。

`InitializingBean`接口详细流程

InitializingBean接口用于在一个bean属性设置完毕并进行其他初始化操作之后需要执行的额外初始化逻辑。InitializingBean接口只定义了一个方法：afterPropertiesSet()。当Spring容器实例化一个bean并完成其依赖注入后，它会自动调用实现InitializingBean接口的bean的afterPropertiesSet()方法。

下面是InitializingBean接口的源码：

package org.springframework.beans.factory;

public interface InitializingBean {

    /**
     * 被所有bean属性设置后的回调函数。
     * @throws Exception 在初始化时抛出的异常
     */
    void afterPropertiesSet() throws Exception;
}

处理流程

当Spring容器创建并配置完一个bean后，会在以下几个阶段调用实现了InitializingBean接口的bean的afterPropertiesSet方法：

Bean实例化：Spring容器通过反射机制创建bean实例。
依赖注入：Spring容器根据配置对bean的属性进行依赖注入。
调用afterPropertiesSet方法：如果这个bean实现了InitializingBean接口，Spring容器会调用其afterPropertiesSet方法。

实现示例

下面是一个简单的实现示例：

import org.springframework.beans.factory.InitializingBean;

public class MyBean implements InitializingBean {

    private String name;

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        // 在这里进行初始化操作
        System.out.println("InitializingBean接口的afterPropertiesSet方法被调用，name属性为: " + name);
    }
}

如何触发`afterPropertiesSet`方法

为了看到afterPropertiesSet方法的执行，我们可以使用ApplicationContext来加载和管理我们的bean，如下所示：

import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Main {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");

        MyBean myBean = (MyBean) context.getBean("myBean");
        // 此时已经完成初始化，afterPropertiesSet方法已经被调用

        context.close();
    }
}

这里是beans.xml文件的内容：

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
                           http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="myBean" class="com.example.MyBean">
        <property name="name" value="Test Name"/>
    </bean>
</beans>

源码解析

Spring在处理bean初始化时，最终会调用到AbstractAutowireCapableBeanFactory类中的invokeInitMethods方法，该方法负责调用InitializingBean接口的方法。

protected void invokeInitMethods(String beanName, final Object bean, RootBeanDefinition mbd)
        throws Throwable {

    boolean isInitializingBean = (bean instanceof InitializingBean);
    if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {
        if (logger.isDebugEnabled()) {
            logger.debug("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.isExternallyManagedInitMethod(initMethodName)) {
            invokeCustomInitMethod(beanName, bean, mbd);
        }
    }
}

详细流程总结

检查是否实现InitializingBean接口：
- 首先，方法中使用instanceof关键字检查当前bean是否实现了InitializingBean接口。
调用afterPropertiesSet方法：
- 如果bean实现了InitializingBean接口，并且没有被外部管理的初始化方法覆盖，则通过反射机制（在有安全管理器时使用AccessController）调用afterPropertiesSet方法。
调用自定义初始化方法：
- 如果存在自定义初始化方法并且该方法不是afterPropertiesSet，则调用invokeCustomInitMethod来执行自定义的初始化逻辑。

`BeanDefinition`接口

在Spring的源码中，BeanDefinition接口及其实现类负责存储bean的各种元数据，如类名、作用域、构造函数参数、属性值等。

`BeanDefinition`接口

下面是BeanDefinition接口的部分代码及相关说明：

package org.springframework.beans.factory.config;

import org.springframework.beans.BeanMetadataElement;
import org.springframework.core.AttributeAccessor;

public interface BeanDefinition extends AttributeAccessor, BeanMetadataElement {

    String SCOPE_SINGLETON = ConfigurableBeanFactory.SCOPE_SINGLETON;
    String SCOPE_PROTOTYPE = ConfigurableBeanFactory.SCOPE_PROTOTYPE;

    int ROLE_APPLICATION = 0;
    int ROLE_SUPPORT = 1;
    int ROLE_INFRASTRUCTURE = 2;

    void setParentName(@Nullable String parentName);
    @Nullable
    String getParentName();

    void setBeanClassName(@Nullable String beanClassName);
    @Nullable
    String getBeanClassName();

    void setScope(@Nullable String scope);
    @Nullable
    String getScope();

    void setLazyInit(boolean lazyInit);
    boolean isLazyInit();

    void setDependsOn(@Nullable String... dependsOn);
    @Nullable
    String[] getDependsOn();

    void setAutowireCandidate(boolean autowireCandidate);
    boolean isAutowireCandidate();

    void setPrimary(boolean primary);
    boolean isPrimary();

    void setFactoryBeanName(@Nullable String factoryBeanName);
    @Nullable
    String getFactoryBeanName();

    void setFactoryMethodName(@Nullable String factoryMethodName);
    @Nullable
    String getFactoryMethodName();

    ConstructorArgumentValues getConstructorArgumentValues();
    MutablePropertyValues getPropertyValues();

    boolean isSingleton();
    boolean isPrototype();
    boolean isAbstract();

    int getRole();
    @Nullable
    String getDescription();

    @Nullable
    String getResourceDescription();

    @Nullable
    BeanDefinition getOriginatingBeanDefinition();
}

关键方法解析

setParentName 和 getParentName：
- 设置和获取该bean定义的父bean名称，用于bean继承。
setBeanClassName 和 getBeanClassName：
- 设置和获取bean的类名。
setScope 和 getScope：
- 设置和获取bean的作用域（如单例或原型）。
setLazyInit 和 isLazyInit：
- 设置和判断是否延迟初始化。
setDependsOn 和 getDependsOn：
- 设置和获取该bean所依赖的其他bean。
setAutowireCandidate 和 isAutowireCandidate：
- 设置和判断该bean是否可以被自动装配。
setPrimary 和 isPrimary：
- 设置和判断该bean是否为主要的候选者。
setFactoryBeanName 和 getFactoryBeanName：
- 设置和获取创建该bean实例的工厂bean的名称。
setFactoryMethodName 和 getFactoryMethodName：
- 设置和获取用于创建该bean实例的工厂方法的名称。
getConstructorArgumentValues：
- 获取构造函数参数值。
getPropertyValues：
- 获取属性值。
isSingleton、isPrototype 和 isAbstract：
- 判断该bean的作用域类型以及是否为抽象bean定义。
getRole：
- 获取bean定义的角色（应用程序、支持、基础设施）。
getDescription：
- 获取bean定义的描述。
getResourceDescription：
- 获取资源描述信息。

那些年背过的题目：Spring ApplicationContext- IOC容器初始化过程

1. 创建IOC容器

2. 资源定位

3. 资源读取和解析

4. 注册BeanDefinition

5. BeanFactory准备

6. 实例化和注入依赖关系

6.1 实例化Bean

6.2 设置Bean属性

6.3 初始化Bean

6.4 Bean的生命周期回调

6.5 AOP代理（可选）

示例代码

XML配置方式

applicationContext.xml

Java代码示例

注解配置方式

AppConfig.java

Java代码示例

关键步骤解析

资源读取和解析详细流程

XML 配置读取和解析

3.2 注解配置读取和解析

注册BeanDefinition详细流程

核心接口和类

注册 BeanDefinition 的核心方法

源码分析

BeanDefinitionRegistry 接口

DefaultListableBeanFactory 类

简要流程总结

手动注册一个BeanDefinition流程

示例代码

思考题1:BeanDefinition存储结构

BeanPostProcessor和BeanFactoryPostProcessor接口详细流程

一、BeanPostProcessor

1. BeanPostProcessor接口

2. 使用示例

3. 如何注册BeanPostProcessor

二、BeanFactoryPostProcessor

1. BeanFactoryPostProcessor接口

2. 使用示例

3. 如何注册BeanFactoryPostProcessor

InitializingBean接口详细流程

处理流程

实现示例

如何触发afterPropertiesSet方法

源码解析

详细流程总结

BeanDefinition接口

BeanDefinition接口

关键方法解析

`applicationContext.xml`

`AppConfig.java`

`BeanDefinitionRegistry` 接口

`DefaultListableBeanFactory` 类

手动注册一个`BeanDefinition`流程

思考题1:`BeanDefinition`存储结构

`BeanPostProcessor`和`BeanFactoryPostProcessor`接口详细流程

1. `BeanPostProcessor`接口

3. 如何注册`BeanPostProcessor`

1. `BeanFactoryPostProcessor`接口

3. 如何注册`BeanFactoryPostProcessor`

`InitializingBean`接口详细流程

如何触发`afterPropertiesSet`方法

`BeanDefinition`接口

`BeanDefinition`接口