引言

Spring最核心的内容就是其ioc容器了，而目前来说常见的容器为AnnotationConfigApplicationContext，今天主要就是针对其初始化部分的源码进行分析。在实际工作中往往需要在容器的初始化过程中增加项目本身的业务代码，了解容器的初始化原理后，这项工作就会变得非常简单了。

IOC容器概念

ioc容器实际上就是一个spring bean的一个管理容器，包括了bean的初始化、配置、组件以及实例化功能。ioc容器在进行初始化时，就会根据配置文件对位置文件中包括的所有bean以及spring自带的bean进行加载、装配、实例化，其工作原理如下图：

spring容器工作原理

AnnotationConfigApplicationContext初始化

AnnotationConfigApplicationContext容器的初始化代码如下：

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

下面就具体的解释一下其背后的详细实现

• this()： 此步骤首先会调用父类GenericApplicationContext的无参构造函数，初始化一个DefaultListableBeanFactory对象，然后调用自身的无参构造函数，给容器初始化一个 注解bean定义读取器以及一个类路径扫描器。
• 注解bean定义读取器：即AnnotatedBeanDefinitionReader，此类初始化的时候会将Spring需要的系统级bean（包括Autowired注解解析器、配置类解析器等6个系统bean）初始化为BeanDefinition，并装载至容器中
• 类路径bean定义扫描器：即ClassPathBeanDefinitionScanner，此类初始化时会加载默认的bean扫描配置（如果使用的时默认扫描配置的化），即加载所有带有 @component 注解的类，然后设置环境运行信息以及资源加载器
• 关于this()这一部分的中文描述大概就这么多了，接下来上源码

 public AnnotationConfigApplicationContext() {
StartupStep createAnnotatedBeanDefReader = this.getApplicationStartup().start("spring.context.annotated-bean-reader.create");
this.reader = new AnnotatedBeanDefinitionReader(this);
createAnnotatedBeanDefReader.end();
this.scanner = new ClassPathBeanDefinitionScanner(this);
}

//AnnotatedBeanDefinitionReader构造函数模块----start
public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry, Environment environment) {
this.registry = registry;
    // 初始化condition计算器，用于@condition注解使用
this.conditionEvaluator = new ConditionEvaluator(registry, environment, null);
    //注册系统级bean至ioc容器中
AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);
}
//registerAnnotationConfigProcessors方法源码，因为源码较多，此处挑选部分重要的源码展示
public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(
BeanDefinitionRegistry registry, @Nullable Object source) {

DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(registry);
Set<BeanDefinitionHolder> beanDefs = new LinkedHashSet<>(8);
  //此处注册配置类解析器bean至容器中
if (!registry.containsBeanDefinition(CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME)) {
RootBeanDefinition def = new RootBeanDefinition(ConfigurationClassPostProcessor.class);
def.setSource(source);
beanDefs.add(registerPostProcessor(registry, def, CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME));
}
 //此处注册autowire注解解析器bean至容器中
if (!registry.containsBeanDefinition(AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME)) {
RootBeanDefinition def = new RootBeanDefinition(AutowiredAnnotationBeanPostProcessor.class);
def.setSource(source);
beanDefs.add(registerPostProcessor(registry, def, AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME));
}

// 此处注册JSR250解析器至容器中(如果支持)
if (jsr250Present && !registry.containsBeanDefinition(COMMON_ANNOTATION_PROCESSOR_BEAN_NAME)) {
RootBeanDefinition def = new RootBeanDefinition(CommonAnnotationBeanPostProcessor.class);
beanDefs.add(registerPostProcessor(registry, def, COMMON_ANNOTATION_PROCESSOR_BEAN_NAME));
}

// 此处注册JPA解析器至容器中(如果支持)
if (jpaPresent && !registry.containsBeanDefinition(PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME)) {
RootBeanDefinition def = new RootBeanDefinition();
def.setBeanClass(ClassUtils.forName(PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME,
AnnotationConfigUtils.class.getClassLoader()));
beanDefs.add(registerPostProcessor(registry, def, PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME));
}
   //此处注册用于解析@EventListener解析器至容器中
if (!registry.containsBeanDefinition(EVENT_LISTENER_PROCESSOR_BEAN_NAME)) {
RootBeanDefinition def = new RootBeanDefinition(EventListenerMethodProcessor.class);
beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_PROCESSOR_BEAN_NAME));
}
    //将EventListenerFactory的默认实现加载至容器中
if (!registry.containsBeanDefinition(EVENT_LISTENER_FACTORY_BEAN_NAME)) {
RootBeanDefinition def = new RootBeanDefinition(DefaultEventListenerFactory.class);
def.setSource(source);
beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_FACTORY_BEAN_NAME));
}

return beanDefs;
}
//AnnotatedBeanDefinitionReader构造函数模块----end

//ClassPathBeanDefinitionScanner构造函数模块----start
public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry, boolean useDefaultFilters,
Environment environment, @Nullable ResourceLoader resourceLoader) {
    //判断是否启动默认扫描规则
if (useDefaultFilters) {
registerDefaultFilters();
}
    //运行环境设置
setEnvironment(environment);
    //资源加载器设置
setResourceLoader(resourceLoader);
}
//registerDefaultFilters方法内容，JSR-250，JSP330的扫描规则一般用不上，所以此处只展示重要部分源码
protected void registerDefaultFilters() {
    //将@component注解作为bean的扫描规则
this.includeFilters.add(new AnnotationTypeFilter(Component.class));
}
//ClassPathBeanDefinitionScanner构造函数模块----end  

• register(componentClasses):此行代码的主要作用的将初始化AnnotationConfigApplicationContext对象时关联的配置类加载至springioc容器中，加载自定义配置类时会根据配置类的注解生成bean的名称和一些其他属性，这段比较简单，直接上源码

 //AnnotationConfigApplicationContext类中register方法
public void register(Class<?>... componentClasses) {
//去掉了非关键代码，此方法主要还是通过容器前期准备初始化的bean读取器对于配置类进行读取（AnnotatedBeanDefinitionReader）
this.reader.register(componentClasses);
}
//bean读取器中register方法，直接调用registerBean方法
public void register(Class<?>... componentClasses) {
for (Class<?> componentClass : componentClasses) {
registerBean(componentClass);
}
}
//bean读取器中register方法，直接调用doRegisterBean方法
public void registerBean(Class<?> beanClass) {
doRegisterBean(beanClass, null, null, null, null);
}
//将bean注册至容器的实际方法，去除了一些生成supplier、beanname等代码，目前只关心bean和ioc的初始化流程
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;
}
    //根据qualifier注解设置bean的属性
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));
}
}
}

        //将配置类包装为BeanDefinitionHolder，并通过BeanDefinitionReaderUtils.registerBeanDefinition方法注册至容器
BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd, beanName);
definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
        BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry);
}
//BeanDefinitionReaderUtils.registerBeanDefinition方法，同样省略部分非关键代码
public static void registerBeanDefinition(
BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)
throws BeanDefinitionStoreException {

String beanName = definitionHolder.getBeanName();
        /*此处如果直接看源码或者就跟不下去了，要想起容器准备阶段调用了GenericApplicationContext的
        无参构造函数，所以此时的registry对象对应类为DefaultListableBeanFactory
        */registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());
}

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");

if (beanDefinition instanceof AbstractBeanDefinition) {
try {
((AbstractBeanDefinition) beanDefinition).validate();
}
catch (BeanDefinitionValidationException ex) {
throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
"Validation of bean definition failed", ex);
}
}

BeanDefinition existingDefinition = this.beanDefinitionMap.get(beanName);
        //此时配置类对应的bean并没有初始化完成，并且放入beanDefinitionMap中，所以existingDefinition肯定为null
if (existingDefinition != null) {
}
else {
      //此处用于判断当前备案是否已经被创建，很明显没有，省略此段代码
if (hasBeanCreationStarted()) {

}
else {
//将配置类对应的beanDefinition放入对应的map对象中，以供最后的refresh步骤使用
this.beanDefinitionMap.put(beanName, beanDefinition);
this.beanDefinitionNames.add(beanName);
removeManualSingletonName(beanName);
}
this.frozenBeanDefinitionNames = null;
}
}  

• refresh()：调用你的是其父类AbstractApplicationContext的refresh方法，此方法的主要作用就是加载当前的配置信息，并将配置信息以及bean定义 刷新至容器中，内部内容较多，本篇文章主要介绍配置类以及自定义bean装配并加载至IOC容器的全过程，此过程主要是由refresh方法中的invokeBeanFactoryPostProcessors(beanFactory)实现，下面通过源码来具体分析一下其实现的具体过程

 public void refresh() throws BeansException, IllegalStateException {
synchronized (this.startupShutdownMonitor) {
StartupStep contextRefresh = this.applicationStartup.start("spring.context.refresh");

// Prepare this context for refreshing.
prepareRefresh();

// Tell the subclass to refresh the internal bean factory.
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

// Prepare the bean factory for use in this context.
prepareBeanFactory(beanFactory);

// Allows post-processing of the bean factory in context subclasses.
postProcessBeanFactory(beanFactory);

StartupStep beanPostProcess = this.applicationStartup.start("spring.context.beans.post-process");
// Invoke factory processors registered as beans in the context.
invokeBeanFactoryPostProcessors(beanFactory);

// Register bean processors that intercept bean creation.
registerBeanPostProcessors(beanFactory);
beanPostProcess.end();

// Initialize message source for this context.
initMessageSource();

// Initialize event multicaster for this context.
initApplicationEventMulticaster();

// Initialize other special beans in specific context subclasses.
onRefresh();

// Check for listener beans and register them.
registerListeners();

// Instantiate all remaining (non-lazy-init) singletons.
finishBeanFactoryInitialization(beanFactory);

// Last step: publish corresponding event.
finishRefresh();
}
}
//AbstractApplicationContext类invokeBeanFactoryPostProcessors方法
protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
    //此方法会对符合扫描规则的bean进行装配、实例化，并加载至ioc容器中
PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());
//设置容器的beanpostprocessor和templateclassloader，不影响主流程，内部代码省略
if (!NativeDetector.inNativeImage() && beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
}
}
//PostProcessorRegistrationDelegate类invokeBeanFactoryPostProcessors方法
public static void invokeBeanFactoryPostProcessors(
ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {

Set<String> processedBeans = new HashSet<>();
    //ioc容器初始bean为DefaultListableBeanFactory，实现了BeanDefinitionRegistry
if (beanFactory instanceof BeanDefinitionRegistry) {
BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();
List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();
     //很明显beanFactoryPostProcessors为空，所以内部不会执行，代码省略
for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {

}
     //用于存放当前需要注册的bean定义
List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();
      /* 获取所有容器中所有BeanDefinitionRegistryPostProcessor的实例对象，还记得容器准备阶段
      将ConfigurationClassPostProcessor类的beanDefinition加入容器中了吗？因此
      ConfigurationClassPostProcessor的实例对象也会被加载(●ˇ∀ˇ●)      */String[] postProcessorNames =
beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
for (String ppName : postProcessorNames) {
        //筛选实现了PriorityOrdered接口的BeanDefinitionRegistryPostProcessor的实例对象
if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
          //将实现了排序接口的BeanDefinitionRegistryPostProcessor的实例对象加入currentRegistryProcessors中，为了后面的排序
currentRegistryProcessors.addz(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
//记录正在加载的BeanDefinitionRegistryPostProcessor的实例对象
          processedBeans.add(ppName);
}
}
     //将 currentRegistryProcessors内对象进行排序
sortPostProcessors(currentRegistryProcessors, beanFactory);
     //currentRegistryProcessors所有的实例对象加入至 registryProcessors
registryProcessors.addAll(currentRegistryProcessors);
      /*currentRegistryProcessors所有的实例对象依次调用postProcessBeanDefinitionRegistry方法
      这里就会调用到  ConfigurationClassPostProcessor的postProcessBeanDefinitionRegistry方法了，
      spring从此处开始通过配置类对配置类需要的bean进行扫描、加载，下面会专门把这一块源码写出来*/invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry, beanFactory.getApplicationStartup());
currentRegistryProcessors.clear();

/*处理实现了Ordered的BeanDefinitionRegistryPostProcessor的实例对象,
      当然如果已经在实现 PriorityOrdered.class 处理过的实例对象不会处理*/      //Ordered关联实例对象处理逻辑和PriorityOrdered.class 关联实例对象处理逻辑一致，因此此处移除部分源码
postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
for (String ppName : postProcessorNames) {
if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
}
}
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry, beanFactory.getApplicationStartup());
currentRegistryProcessors.clear();
      //Ordered关联实例对象处理 --end
// 处理剩余BeanDefinitionRegistryPostProcessor的实例对象--start
boolean reiterate = true;
while (reiterate) {
reiterate = false;
postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
for (String ppName : postProcessorNames) {
if (!processedBeans.contains(ppName)) {
currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
processedBeans.add(ppName);
reiterate = true;
}
}
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry, beanFactory.getApplicationStartup());
}
     // 处理剩余BeanDefinitionRegistryPostProcessor的实例对象---end
      //registryProcessors,regularPostProcessors都为空，暂时忽略
invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
}


//开始执行BeanFactoryPostProcessor的实例对象，思路和BeanDefinitionRegistryPostProcessor类似，这里就不一一说明
//执行BeanFactoryPostProcessor的实例对象 --start，可忽略
  String[] postProcessorNames =
beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);
List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
List<String> orderedPostProcessorNames = new ArrayList<>();
List<String> nonOrderedPostProcessorNames = new ArrayList<>();
for (String ppName : postProcessorNames) {
if (processedBeans.contains(ppName)) {
}
else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
}
else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
orderedPostProcessorNames.add(ppName);
}
else {
nonOrderedPostProcessorNames.add(ppName);
}
}

// First, invoke the BeanFactoryPostProcessors that implement PriorityOrdered.
sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);

// Next, invoke the BeanFactoryPostProcessors that implement Ordered.
List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());
for (String postProcessorName : orderedPostProcessorNames) {
orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
}
sortPostProcessors(orderedPostProcessors, beanFactory);
invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);

// Finally, invoke all other BeanFactoryPostProcessors.
List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());
for (String postProcessorName : nonOrderedPostProcessorNames) {
nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
}
invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);

beanFactory.clearMetadataCache();
  //执行BeanFactoryPostProcessor的实例对象 --end
}  

 // ConfigurationClassPostProcessor的postProcessBeanDefinitionRegistry方法
public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {
  //只关注配置类加载流程，移除其他非关键源码
  //加载配置类实际方法
processConfigBeanDefinitions(registry);
}
//配置类注解加载方法，只保留常用注解的扫描源码，移除部分非关键代码
public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
List<BeanDefinitionHolder> configCandidates = new ArrayList<>();
  //此处获取的是容器准备阶段加载至ioc容器的系统级bean以及配置类bean
String[] candidateNames = registry.getBeanDefinitionNames();
   //筛选处配置类beanDefinition并添加至configCandidates中
for (String beanName : candidateNames) {
BeanDefinition beanDef = registry.getBeanDefinition(beanName);
if (ConfigurationClassUtils.checkConfigurationClassCandidate(beanDef, this.metadataReaderFactory)) {
configCandidates.add(new BeanDefinitionHolder(beanDef, beanName));
}
}

// 设置bean名称生成器，移除部分非关键代码移除
SingletonBeanRegistry sbr = null;
if (registry instanceof SingletonBeanRegistry) {
sbr = (SingletonBeanRegistry) registry;
if (!this.localBeanNameGeneratorSet) {
BeanNameGenerator generator = (BeanNameGenerator) sbr.getSingleton(
AnnotationConfigUtils.CONFIGURATION_BEAN_NAME_GENERATOR);
if (generator != null) {
this.componentScanBeanNameGenerator = generator;
this.importBeanNameGenerator = generator;
}
}
}

// 生成配置类解析器
ConfigurationClassParser parser = new ConfigurationClassParser(
this.metadataReaderFactory, this.problemReporter, this.environment,
this.resourceLoader, this.componentScanBeanNameGenerator, registry);

Set<BeanDefinitionHolder> candidates = new LinkedHashSet<>(configCandidates);
Set<ConfigurationClass> alreadyParsed = new HashSet<>(configCandidates.size());
do {
      /*解析配置类，通过调用ConfigurationClassParser类的doProcessConfigurationClass
      方法对配置类进行解析，doProcessConfigurationClass方法源码在下面会解析*/parser.parse(candidates);
parser.validate();
      //获取通过配置类扫描到的所有配置bean数据
Set<ConfigurationClass> configClasses = new LinkedHashSet<>(parser.getConfigurationClasses());
////@ComponentScan注解在parser.parse的时候已经注册至容器中，此处移除
      configClasses.removeAll(alreadyParsed);

// 创建配置类加载器
if (this.reader == null) {
this.reader = new ConfigurationClassBeanDefinitionReader(
registry, this.sourceExtractor, this.resourceLoader, this.environment,
this.importBeanNameGenerator, parser.getImportRegistry());
}
      /*因为只有@ComponentScan注解关联的配置类信息才会注册至容器中，
      此处是将@import等其他注解标记的配置类BeanDefintion加载至容器中，
      这个方法内部会调用registerBeanDefinition方法，将beanDefinition加载至容器中*/this.reader.loadBeanDefinitions(configClasses);
alreadyParsed.addAll(configClasses);


candidates.clear();
      //通过此if判断此次解析以及加载bean的过程是否给容器添加了新的beanDefinition，为true代表本次循环新加载了bean定义
if (registry.getBeanDefinitionCount() > candidateNames.length) {
          /*以下逻辑的意义是防止容器有需要加载的beanDefinition，却没有完成，
        通过newCandidateNames和oldCandidateNames作为参考依据，将没有加载完成的beanDefinition加入
        candidates中，在下次循环中继续加载*/String[] newCandidateNames = registry.getBeanDefinitionNames();
Set<String> oldCandidateNames = new HashSet<>(Arrays.asList(candidateNames));
Set<String> alreadyParsedClasses = new HashSet<>();
for (ConfigurationClass configurationClass : alreadyParsed) {
alreadyParsedClasses.add(configurationClass.getMetadata().getClassName());
}
      
for (String candidateName : newCandidateNames) {
if (!oldCandidateNames.contains(candidateName)) {
BeanDefinition bd = registry.getBeanDefinition(candidateName);
if (ConfigurationClassUtils.checkConfigurationClassCandidate(bd, this.metadataReaderFactory) &&
!alreadyParsedClasses.contains(bd.getBeanClassName())) {
candidates.add(new BeanDefinitionHolder(bd, candidateName));
}
}
}
candidateNames = newCandidateNames;
}
}
while (!candidates.isEmpty());
}  

 //ConfigurationClassParser.parse方法
protected final void parse(AnnotationMetadata metadata, String beanName) throws IOException {
processConfigurationClass(new ConfigurationClass(metadata, beanName), DEFAULT_EXCLUSION_FILTER);
}
//ConfigurationClassParser.processConfigurationClass方法，移除部分非关键源码，保留bean加载核心代码
protected void processConfigurationClass(ConfigurationClass configClass, Predicate<String> filter) throws IOException {

SourceClass sourceClass = asSourceClass(configClass, filter);
do {
      //解析配置类的真正方法
sourceClass = doProcessConfigurationClass(configClass, sourceClass, filter);
}
while (sourceClass != null);

this.configurationClasses.put(configClass, configClass);
}
//ConfigurationClassParser类的doProcessConfigurationClass
protected final SourceClass doProcessConfigurationClass(
ConfigurationClass configClass, SourceClass sourceClass, Predicate<String> filter)
throws IOException {

        //对字类进行递归处理
if (configClass.getMetadata().isAnnotated(Component.class.getName())) {
processMemberClasses(configClass, sourceClass, filter);
}

//处理@propertySource注解
for (AnnotationAttributes propertySource : AnnotationConfigUtils.attributesForRepeatable(
sourceClass.getMetadata(), PropertySources.class,
org.springframework.context.annotation.PropertySource.class)) {
if (this.environment instanceof ConfigurableEnvironment) {
processPropertySource(propertySource);
}
else {
logger.info("Ignoring @PropertySource annotation on [" + sourceClass.getMetadata().getClassName() +
"]. Reason: Environment must implement ConfigurableEnvironment");
}
}

// 处理 @ComponentScan 注解
Set<AnnotationAttributes> componentScans = AnnotationConfigUtils.attributesForRepeatable(
sourceClass.getMetadata(), ComponentScans.class, ComponentScan.class);
if (!componentScans.isEmpty() &&
!this.conditionEvaluator.shouldSkip(sourceClass.getMetadata(), ConfigurationPhase.REGISTER_BEAN)) {
for (AnnotationAttributes componentScan : componentScans) {
  /*利用camponentScan专门的扫描器，对ComponentScan标注的对象进行扫描，
        同时内部会将扫描到的类定制包装为beanDefinition，并且注册至容器中*/Set<BeanDefinitionHolder> scannedBeanDefinitions =
this.componentScanParser.parse(componentScan, sourceClass.getMetadata().getClassName());
     //以下的逻辑主要是针对@ComponentScan扫描出来的类也使用了@ComponentScan，如果使用了此注解，则进行递归扫描
        for (BeanDefinitionHolder holder : scannedBeanDefinitions) {
BeanDefinition bdCand = holder.getBeanDefinition().getOriginatingBeanDefinition();
if (bdCand == null) {
bdCand = holder.getBeanDefinition();
}
if (ConfigurationClassUtils.checkConfigurationClassCandidate(bdCand, this.metadataReaderFactory)) {
parse(bdCand.getBeanClassName(), holder.getBeanName());
}
}
}
}

// 处理 @Import 注解，并将扫描到的配置类加入至configClass中
processImports(configClass, sourceClass, getImports(sourceClass), filter, true);

// 处理 @ ImportResource 注解，并将扫描到的配置类加入至configClass中
AnnotationAttributes importResource =
AnnotationConfigUtils.attributesFor(sourceClass.getMetadata(), ImportResource.class);
if (importResource != null) {
String[] resources = importResource.getStringArray("locations");
Class<? extends BeanDefinitionReader> readerClass = importResource.getClass("reader");
for (String resource : resources) {
String resolvedResource = this.environment.resolveRequiredPlaceholders(resource);
configClass.addImportedResource(resolvedResource, readerClass);
}
}

// 处理 @ bean 注解，并将扫描到的配置类加入至configClass中
Set<MethodMetadata> beanMethods = retrieveBeanMethodMetadata(sourceClass);
for (MethodMetadata methodMetadata : beanMethods) {
configClass.addBeanMethod(new BeanMethod(methodMetadata, configClass));
}

//处理接口中所有添加@Bean注解的方法，内部通过遍历所有接口，解析得到@Bean注解方法，并加入至configClass中
processInterfaces(configClass, sourceClass);

return null;
}  

以上就是关于spring ioc容器初始化过程中关于bean初始化的详细过程（只占整个ioc容器初始化的一部分），下一篇会针对spring ioc容器初始化的其他部分进行分析。