Spring IoC（Inversion of Control，控制反转）容器是Spring框架的核心组件之一，用于管理和组织应用中的Java对象（也称为Bean）。IoC容器负责创建、配置、组装并管理Bean的生命周期。
配置代码：
public static void main(String[] args) {
AnnotationConfigApplicationContext context=new AnnotationConfigApplicationContext(MainConfig.class);
var employee=context.getBean("employee", Employee.class);
System.out.println(employee.getName());
} AnnotationConfigApplicationContext context=new AnnotationConfigApplicationContext(MainConfig.class); 创建AnnotationConfigApplicationContext对象构造对象，首先回调用父类的构造方法：
GenericApplicationContext
public GenericApplicationContext() {
//父类的构造函数里面就是初始化DefaultListableBeanFactory，并且赋值给beanFactory
this.beanFactory = new DefaultListableBeanFactory();
}接下来调用
public AnnotationConfigApplicationContext(Class<?>... componentClasses) {
this();
register(componentClasses);
refresh();
}?一下是关于this的源码解读
/**
Spring IoC 容器初始化过程中启动了与注解驱动的 Bean 定义读取和扫描相关的步骤
**/
public AnnotationConfigApplicationContext() {
//这行代码创建了一个名为 "spring.context.annotated-bean-reader.create" 的启动步骤。StartupStep 是 Spring 用于跟踪应用程序启动过程的一种机制。
StartupStep createAnnotatedBeanDefReader = this.getApplicationStartup().start("spring.context.annotated-bean-reader.create");
//这一行代码创建了一个 AnnotatedBeanDefinitionReader 对象。AnnotatedBeanDefinitionReader 负责处理带有注解的类，并根据注解生成相应的 Bean 定义。通常，它用于处理类级别的注解，例如 @Component、@Service、@Repository 和 @Controller。
this.reader = new AnnotatedBeanDefinitionReader(this);
createAnnotatedBeanDefReader.end();
//这一行代码创建了一个 ClassPathBeanDefinitionScanner 对象。ClassPathBeanDefinitionScanner 负责在类路径下扫描带有特定注解的组件，并将它们注册为 Spring Bean。
this.scanner = new ClassPathBeanDefinitionScanner(this);
}实例化建BeanDefinition读取器： AnnotatedBeanDefinitionReader：
public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(
BeanDefinitionRegistry registry, @Nullable Object source) {
Set<BeanDefinitionHolder> beanDefs = new LinkedHashSet<>(8);
//判断是否有ConfigurationClassPostProcessor Bean
if (!registry.containsBeanDefinition(CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME)) {
//就通过RootBeanDefinition的构造方法获得
//ConfigurationClassPostProcessor的BeanDefinition，RootBeanDefinition是BeanDefinition的子类
RootBeanDefinition def = new RootBeanDefinition(ConfigurationClassPostProcessor.class);
def.setSource(source);
//执行registerPostProcessor方法，registerPostProcessor方法内部就是注册Bean，当然这里注册
//其他Bean也是一样的流程。
beanDefs.add(registerPostProcessor(registry, def, CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME));
}
return beanDefs;
}register(componentClasses);org.springframework.context.annotation.AnnotatedBeanDefinitionReader#doRegisterBean
private <T> void doRegisterBean(Class<T> beanClass, @Nullable String name,
@Nullable Class<? extends Annotation>[] qualifiers, @Nullable Supplier<T> supplier,
@Nullable BeanDefinitionCustomizer[] customizers) {
//拿到类上的注解
AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(beanClass);
//判断是否需要注解
if (this.conditionEvaluator.shouldSkip(abd.getMetadata())) {
return;
}
abd.setInstanceSupplier(supplier);
//判断bean的作用域，如果没有默认为单列
ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(abd);
abd.setScope(scopeMetadata.getScopeName());
String beanName = (name != null ? name : this.beanNameGenerator.generateBeanName(abd, this.registry));
AnnotationConfigUtils.processCommonDefinitionAnnotations(abd);
if (qualifiers != null) {
for (Class<? extends Annotation> qualifier : qualifiers) {
if (Primary.class == qualifier) {
abd.setPrimary(true);
}
else if (Lazy.class == qualifier) {
abd.setLazyInit(true);
}
else {
abd.addQualifier(new AutowireCandidateQualifier(qualifier));
}
}
}
if (customizers != null) {
for (BeanDefinitionCustomizer customizer : customizers) {
customizer.customize(abd);
}
}
BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd, beanName);
definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry);
}org.springframework.beans.factory.support.BeanDefinitionReaderUtils#registerBeanDefinition
public static void registerBeanDefinition(BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry) throws BeanDefinitionStoreException {
//获取注册的bean的名称
String beanName = definitionHolder.getBeanName();
//将 Bean 定义注册到容器中。这个步骤将 Bean 的定义信息加入到容器的 BeanDefinitionMap 中。
registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());
String[] aliases = definitionHolder.getAliases();
if (aliases != null) {
String[] var4 = aliases;
int var5 = aliases.length;
for(int var6 = 0; var6 < var5; ++var6) {
String alias = var4[var6];
registry.registerAlias(beanName, alias);
}
}
}org.springframework.beans.factory.support.DefaultListableBeanFactory#registerBeanDefinition
/**
向容器注册一个 Bean 定义，包括了处理同名 BeanDefinition 的情况，验证 AbstractBeanDefinition，更新 BeanDefinitionMap 和 BeanDefinitionNames 等步骤。它是 Spring IoC 容器中注册 Bean 定义的核心逻辑。
**/
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");
//如果 BeanDefinition 是 AbstractBeanDefinition 的实例，则进行验证
if (beanDefinition instanceof AbstractBeanDefinition) {
try {
((AbstractBeanDefinition)beanDefinition).validate();
} catch (BeanDefinitionValidationException var8) {
throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName, "Validation of bean definition failed", var8);
}
}
BeanDefinition existingDefinition = (BeanDefinition)this.beanDefinitionMap.get(beanName);
if (existingDefinition != null) {
//判断是否存在同名
处理存在同名 BeanDefinition 的情况
if (!this.isAllowBeanDefinitionOverriding()) {
throw new BeanDefinitionOverrideException(beanName, beanDefinition, existingDefinition);
}
//
if (existingDefinition.getRole() < beanDefinition.getRole()) {
if (this.logger.isInfoEnabled()) {
this.logger.info("Overriding user-defined bean definition for bean '" + beanName + "' with a framework-generated bean definition: replacing [" + existingDefinition + "] with [" + beanDefinition + "]");
}
} else if (!beanDefinition.equals(existingDefinition)) {
if (this.logger.isDebugEnabled()) {
this.logger.debug("Overriding bean definition for bean '" + beanName + "' with a different definition: replacing [" + existingDefinition + "] with [" + beanDefinition + "]");
}
} else if (this.logger.isTraceEnabled()) {
this.logger.trace("Overriding bean definition for bean '" + beanName + "' with an equivalent definition: replacing [" + existingDefinition + "] with [" + beanDefinition + "]");
}
this.beanDefinitionMap.put(beanName, beanDefinition);
} else {
if (this.hasBeanCreationStarted()) {
synchronized(this.beanDefinitionMap) {
this.beanDefinitionMap.put(beanName, beanDefinition);
List<String> updatedDefinitions = new ArrayList(this.beanDefinitionNames.size() + 1);
updatedDefinitions.addAll(this.beanDefinitionNames);
updatedDefinitions.add(beanName);
this.beanDefinitionNames = updatedDefinitions;
this.removeManualSingletonName(beanName);
}
} else {
this.beanDefinitionMap.put(beanName, beanDefinition);
this.beanDefinitionNames.add(beanName);
this.removeManualSingletonName(beanName);
}
this.frozenBeanDefinitionNames = null;
}
if (existingDefinition == null && !this.containsSingleton(beanName)) {
if (this.isConfigurationFrozen()) {
this.clearByTypeCache();
}
} else {
this.resetBeanDefinition(beanName);
}
}