一、基本概念介绍

// 通常一个SpringBoot工程会含有这样一个主配置类,它位于我们项目的根包下,通过启动这个main方法就可以启动我们的项目// 下面我们先分析@SpringBootApplication注解有哪些作用,在第二节中分析run方法,在run方法中会进行配置类的解析@SpringBootApplicationpublic class SpringbootApplication {    public static void main(String[] args) {       SpringApplication.run(SpringbootApplication.class, args);    }}

// 点击@SpringBootApplication进去发现它其实是由三个核心注解构成的,下面分别讲解这三个注解@SpringBootConfiguration@EnableAutoConfiguration@ComponentScan(excludeFilters = { @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),                      @Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })public @interface SpringBootApplication {

// 点进去发现它其实就是一个@Configuration注解,SpringBoot解析到就会知道这是一个配置类,会给容器中引入一些bean// 一个被@Configuration标注的类,相当于一个applicationContext.xml文件// @Configuration点进去发现其实就是一个@Component注解@Configurationpublic @interface SpringBootConfiguration {
}

// 结合下面@AutoConfigurationPackage注解,发现@EnableAutoConfiguration注解就是通过@Import注解给容器中引入了两个bean,// 分别是AutoConfigurationImportSelector和AutoConfigurationPackages.Registrar,通过这两个类可以给容器中引入更多的类// 下面先介绍下@Import注解的使用@AutoConfigurationPackage@Import(AutoConfigurationImportSelector.class)public @interface EnableAutoConfiguration {}
@Import(AutoConfigurationPackages.Registrar.class)public @interface AutoConfigurationPackage {}

// 步骤1) // 创建几个动物的实体类,如Cat、Bird、Chicken、Dog、Duck、Pig、Sheep、Snake、Tiger// 接下来会通过@Import的各种用法将这些bean注入到容器中@Datapublic class Cat {    private String name;}

// 步骤2) 在主配置类上加上我们自定义的@EnableAnimal注解,含义就是通过@EnableAnimal会给容器中导入上述的那些动物Bean// @EnableAnimal就可以类比我们上面说的@EnableAutoConfiguration注解,两者功能类似@SpringBootApplication@EnableAnimalpublic class SpringbootApplication {    public static void main(String[] args) {       SpringApplication.run(SpringbootApplication.class, args);    }}

// 步骤3) // @EnableAnimal如下所示,这是我们自定义的注解,这个注解的核心是是在上面声明了@Import注解// @Import注解可以传入四种类型,普通类、配置类、ImportSelector的实现类、ImportBeanDefinitionRegistar的实现类// 下面分别讲解@Import注解导入四种类型的用法@Documented@Retention(RetentionPolicy.RUNTIME)@Target(ElementType.TYPE)@Import({Dog.class, AnimalRegisterConfiguration.class, AnimalImportSelector.class,                                                        AnimalImportBeanDefinitionRegistar.class})public @interface EnableAnimal {}

// 1) 直接@Import({Dog.class}),则容器启动完成之后容器中就有Dog这个bean,注意Dog这个类我们并没有通过@Component方式注入

// 2) @Import ({AnimalRegisterConfiguration.class}),通过这种Import配置类形式也可以导入
@Configurationpublic class AnimalRegisterConfiguration {
    @Bean    public Cat cat(){        return new Cat("cat");    }}

// 3) @Import({AnimalImportSelector.class}),通过返回一个Spring数组的方式,数组中可以方便的指定多个Bean// 我们上面说的AutoConfigurationImportSelector就是这种方式,SpringBoot给容器中导入MybatisAutoConfiguration// 等自动配置类就是通过这种方式导入的,第二节配置类解析会讲这个public class AnimalImportSelector implements ImportSelector {
    @Override    public String[] selectImports(AnnotationMetadata importingClassMetadata) {        return new String[] {Tiger.class.getName()};    }}

// 4) @Import({AnimalImportBeanDefinitionRegistar.class}),通过手动编码方式向registry注入Bean// 我们上面说的AutoConfigurationPackages.Registrar就是这种方式
public class AnimalImportBeanDefinitionRegistar implements ImportBeanDefinitionRegistrar {
    @Override    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {        registry.registerBeanDefinition("snake", new RootBeanDefinition(Snake.class));    }}

// 我们可以看到这个@ComponentScan注解上显示指定了两个Filter过滤条件,它是SpringBoot提供的一种扩展机制,能让我们// 向IOC容器中注册一些自定义的组件过滤器,以便在包扫描的过程中过滤一些Bean@ComponentScan(excludeFilters = { @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),                      @Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })

// 这是TypeExcludeFilter的方法,可以看到它是获取容器中所有的TypeExcludeFilter,并遍历它们去过滤一些不想要的Beanpublic boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory) throws IOException {    if (this.beanFactory instanceof ListableBeanFactory && getClass() == TypeExcludeFilter.class) {  Collection<typeexcludefilter> delegates                    = ((ListableBeanFactory) this.beanFactory).getBeansOfType(TypeExcludeFilter.class).values();  for (TypeExcludeFilter delegate : delegates) {      if (delegate.match(metadataReader, metadataReaderFactory)) {    return true;      }  }    }    return false;}

// 我们可以自定义一个TypeExcludeFilter,它的功能就是过滤掉User这个bean,不让它注入到容器中@Componentpublic class MyTypeExcludeFilter extends TypeExcludeFilter {
    @Override    public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory) throws IOException {        return User.class.getName().equals(metadataReader.getClassMetadata().getClassName());    }}
@Componentpublic class User {    private String name;}

// 可以看到AutoConfigurationExcludeFilter就是将自动配置类给过滤掉了，因为自动配置类xxxAutoConfiguration是通过// 上面说的AutoConfigurationImportSelector方式导入的,没必要导入两次public class AutoConfigurationExcludeFilter implements TypeFilter, BeanClassLoaderAware {    public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory) throws IOException {        return isConfiguration(metadataReader) && isAutoConfiguration(metadataReader);    }}

// @ConditionalOnMissingBean是通过@Conditional注解和Condition接口的实现类(OnBeanCondition.class)来实现这个效果的@Bean@ConditionalOnMissingBeanpublic InternalResourceViewResolver defaultViewResolver() {

@Conditional(OnBeanCondition.class)public @interface ConditionalOnMissingBean {

@FunctionalInterfacepublic interface Condition {    boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata);}

// 自定义一个Condition接口的实现类MyCondition,通过其matches方法来判断是否符合指定条件public class MyCondition implements Condition {    @Override    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {        // 获取注解MyConditionAnotation注解上指定value对应的值,如果没有这个值,则不符合条件        String[] value = (String[]) metadata.getAnnotationAttributes(MyConditionAnotation.class.getName()).get("value");        for (String property : value){            if(StringUtils.isEmpty(context.getEnvironment().getProperty(property))){                return false;            }        }        return true;    }}

@Retention(RetentionPolicy.RUNTIME)@Target({ ElementType.TYPE, ElementType.METHOD })@Documented@Conditional(MyCondition.class)public @interface MyConditionAnotation {    String[] value() default {};}

// 通过@Component给容器中注入一个A类型Bean,条件是@MyConditionAnotation注解指定的key1、key2对应的值有配置@Component@MyConditionAnotation({"key1", "key2"})public class A {}

// 我们先来看下上面讲解@Import注解讲到的AutoConfigurationImportSelector,我们说通过它就可以导入SpringBoot提供那些// 自动配置类. 下面是Import注解讲到的AutoConfigurationImportSelector的selectImport方法@Overridepublic String[] selectImports(AnnotationMetadata annotationMetadata) {     // 忽略一些其他代码     // 这里的含义就是通过SpringFactoriesLoader去加载META-INF/spring.factories中配置的那些xxxAutoConfiguration     // 并放入String数组返回     AutoConfigurationEntry autoConfigurationEntry = getAutoConfigurationEntry(autoConfigurationMetadata,                                                       annotationMetadata);     return StringUtils.toStringArray(autoConfigurationEntry.getConfigurations());}
// 忽略中间过程调用,后面会分析，接下来就走到这里通过SpringFactoriesLoader去加载自动配置类protected List<string> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {     // 具体调用看下面分析     List<string> configurations = SpringFactoriesLoader.loadFactoryNames(getSpringFactoriesLoaderFactoryClass(),                                                                    getBeanClassLoader());     return configurations;}
protected Class<?> getSpringFactoriesLoaderFactoryClass() {     return EnableAutoConfiguration.class;}

public static List<string> loadFactoryNames(Class<?> factoryClass, @Nullable ClassLoader classLoader) {    // org.springframework.boot.autoconfigure.EnableAutoConfiguration    String factoryClassName = factoryClass.getName();    // 获得一个Map,map形如<key,List<String>&gt;形式,后面getOrDefault是获取    // org.springframework.boot.autoconfigure.EnableAutoConfiguration对应的实现类集合    // 注意这里面不仅仅是加载自动配置类,也会加载监听器、初始化器那些容器配置的实现类,这里统一一次加载之后放到缓存中    return loadSpringFactories(classLoader).getOrDefault(factoryClassName, Collections.emptyList());}
// 带缓存功能,从各个jar包的META-INF/spring.factories文件中加载实现类,一个key可能包含多个实现private static Map<String, List<String>> loadSpringFactories(ClassLoader classLoader) {    MultiValueMap<String, String> result = cache.get(classLoader);    if (result != null) {        // 缓存中有直接返回        return result;    }
    try {        // FACTORIES_RESOURCE_LOCATION值是META-INF/spring.factories        Enumeration<url> urls = (classLoader != null ? classLoader.getResources(FACTORIES_RESOURCE_LOCATION) :                                                       ClassLoader.getSystemResources(FACTORIES_RESOURCE_LOCATION));        result = new LinkedMultiValueMap<>();        while (urls.hasMoreElements()) {            URL url = urls.nextElement();            UrlResource resource = new UrlResource(url);            Properties properties = PropertiesLoaderUtils.loadProperties(resource);            for (Map.Entry<?, ?> entry : properties.entrySet()) {                // 获取key                String factoryClassName = ((String) entry.getKey()).trim();                // 将value逗号分隔,获得各个具体的实现类                for (String factoryName : StringUtils.commaDelimitedListToStringArray((String) entry.getValue())) {                    // 放入result中                    result.add(factoryClassName, factoryName.trim());                }            }        }        cache.put(classLoader, result);        // 返回的result见下图        return result;    }}

@Componentpublic class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
    @Override    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {        BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
        // 往容器中新增BeanDefinition        GenericBeanDefinition beanDefinition = new GenericBeanDefinition();        beanDefinition.setBeanClass(Chicken.class);        registry.registerBeanDefinition("beanFactoryPostProcessor-Chicken", beanDefinition);
        // 修改容器中原有的BeanDefinition        BeanDefinition snake = registry.getBeanDefinition("snake");        snake.setLazyInit(true);    }}

@Componentpublic class CatBeanPostProcessor implements BeanPostProcessor {
    @Override    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {        return bean;    }
    @Override    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {        if (bean instanceof Cat){            Cat cat = (Cat) bean;            cat.setName("changeNameCat");        }        return bean;    }}

二、SpringBoot启动流程概述

// 图中说的创建ConfigurableApplicationContext,默认创建的是普通的Servlet Web容器,就是下面这个// 通过反射创建会走到其默认的构造函数public AnnotationConfigServletWebServerApplicationContext() {    // 这里面进去会走到下面代码    this.reader = new AnnotatedBeanDefinitionReader(this);    this.scanner = new ClassPathBeanDefinitionScanner(this);}
// 走到这里registerAnnotationConfigProcessors(registry, null);
// 走到这里// 向容器中注入一个ConfigurationClassPostProcessor,它是BeanFactoryPostProcessorif (!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));}
// 向容器中注入一个AutowiredAnnotationBeanPostProcessor,它是BeanPostProcessor,用于解决依赖注入的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));}

三、配置类解析

@Override  public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {      // 删掉一些非关键代码    processConfigBeanDefinitions(registry);  }

public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {      List<beandefinitionholder> configCandidates = new ArrayList<>();     // 获取容器中已注册的bean名字,见下图,注意,这里容器中这些BeanDefinition都是容器初始化过程中容器添加进去的    // 不是我们业务代码的beanDefinition,这段代码其实是连贯的,为了注释图片方便才分开    String[] candidateNames = registry.getBeanDefinitionNames();  
    for (String beanName : candidateNames) {    // 获取BeanDefinition        BeanDefinition beanDef = registry.getBeanDefinition(beanName);    // 判断这个BeanDefinition的configurationClass属性是不是full或者lite,如果是认为已经处理过了,第一次时默认为空,  // 走下面分支        if (ConfigurationClassUtils.isFullConfigurationClass(beanDef) ||              ConfigurationClassUtils.isLiteConfigurationClass(beanDef)) {              // 打印日志记录下        } else if (ConfigurationClassUtils.checkConfigurationClassCandidate(beanDef, this.metadataReaderFactory)) {      // 1) 下面先分析下这个checkConfigurationClassCandidate方法,这边看方法名也可以猜到是检测该类是不是配置类      // 是配置类的意思就是它会给容器中引入bean,这个方法判断主要就是看这个类的元信息中有没有@Configuration注解      // 有没有@Component注解、有没有@ComponentScan、@Import、@ImportResource注解,有没有@Bean方法      // 构造一个BeanDefinitionHolder,放入configCandidates中            configCandidates.add(new BeanDefinitionHolder(beanDef, beanName));          }      }        // Return immediately if no @Configuration classes were found      // 上图中容易默认已经引入了7个BeanDefinition,经过上面检测发现默认就一个符合条件的配置类,即我们的主配置类    // 这里面configCandidates就一个,就是SpringBootApplication    if (configCandidates.isEmpty()) {          return;      }        // Sort by previously determined @Order value, if applicable     // 排序    configCandidates.sort((bd1, bd2) -> {          int i1 = ConfigurationClassUtils.getOrder(bd1.getBeanDefinition());          int i2 = ConfigurationClassUtils.getOrder(bd2.getBeanDefinition());          return Integer.compare(i1, i2);      });        // 删掉部分代码      // Parse each @Configuration class      // 配置类解析工具    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());      // 循环处理直到candidates.isEmpty()    do {    // 这边开始解析,对应步骤4        parser.parse(candidates);          parser.validate();          // 取出第四步解析得到的一些configurationClasses集合        Set<configurationclass> configClasses = new LinkedHashSet<>(parser.getConfigurationClasses());          configClasses.removeAll(alreadyParsed);            // 删除一部分代码  // 这边也会去加载BeanDefinition,对应图中步骤五        this.reader.loadBeanDefinitions(configClasses);          alreadyParsed.addAll(configClasses);     }     while (!candidates.isEmpty());  }

ConfigurationClassUtils.checkConfigurationClassCandidate(beanDef, this.metadataReaderFactory);
public static boolean checkConfigurationClassCandidate(BeanDefinition beanDef,                                                        MetadataReaderFactory metadataReaderFactory) {        String className = beanDef.getBeanClassName();      // 获取下类名,如果类名为空或者该类为工厂类    if (className == null || beanDef.getFactoryMethodName() != null) {          return false;      }        // 获取类的元数据信息    AnnotationMetadata metadata;     // 上图的7个candidateNames中只有一个springbootApplication是AnnotatedBeanDefinition,其余全返回false    if (beanDef instanceof AnnotatedBeanDefinition &&                  className.equals(((AnnotatedBeanDefinition) beanDef).getMetadata().getClassName())) {          // Can reuse the pre-parsed metadata from the given BeanDefinition...   // springbootApplication走到这里        metadata = ((AnnotatedBeanDefinition) beanDef).getMetadata();      }      else if (beanDef instanceof AbstractBeanDefinition && ((AbstractBeanDefinition) beanDef).hasBeanClass()) {          // Check already loaded Class if present...          // since we possibly can't even load the class file for this Class.    Class<?> beanClass = ((AbstractBeanDefinition) beanDef).getBeanClass();          metadata = new StandardAnnotationMetadata(beanClass, true);      }      else {          try {              MetadataReader metadataReader = metadataReaderFactory.getMetadataReader(className);        // 读取类的元数据信息,这里面包括注解等信息            metadata = metadataReader.getAnnotationMetadata();          }          catch (IOException ex) {              return false;          }      }        // metadata.isAnnotated(Configuration.class.getName()),这个就是判断类上面有没有@Configuration注解    if (isFullConfigurationCandidate(metadata)) {    // 如果true的话设置下这个属性,那么就标记为处理过了        beanDef.setAttribute(CONFIGURATION_CLASS_ATTRIBUTE, CONFIGURATION_CLASS_FULL);      } else if (isLiteConfigurationCandidate(metadata)) {          beanDef.setAttribute(CONFIGURATION_CLASS_ATTRIBUTE, CONFIGURATION_CLASS_LITE);      }      else {    // 其余6个返回false        return false;      }        // It's a full or lite configuration candidate... Let's determine the order value, if any.      Integer order = getOrder(metadata);      if (order != null) {        // 获取下类上的@Order信息       beanDef.setAttribute(ORDER_ATTRIBUTE, order);      }      return true;  }

public static boolean isLiteConfigurationCandidate(AnnotationMetadata metadata) {      // Do not consider an interface or an annotation...      if (metadata.isInterface()) {          return false;      }        // Any of the typical annotations found?      for (String indicator : candidateIndicators) {    // 判断下类上面有没有这几个注解        if (metadata.isAnnotated(indicator)) {             return true;          }      }        // Finally, let's look for @Bean methods...      try {          // 判断有没有@Bean的方法        return metadata.hasAnnotatedMethods(Bean.class.getName());      }      return false;    }  }
private static final Set<string> candidateIndicators = new HashSet<>();    static {      candidateIndicators.add(Component.class.getName());      candidateIndicators.add(ComponentScan.class.getName());      candidateIndicators.add(Import.class.getName());      candidateIndicators.add(ImportResource.class.getName());  }

public void parse(Set<beandefinitionholder> configCandidates) {      // 删除部分代码，实际执行时这里的configCandidates就一个springBootApplication代表的主配置类    for (BeanDefinitionHolder holder : configCandidates) {        // 获取BeanDefinition        BeanDefinition bd = holder.getBeanDefinition();          // 我们的SpringBootApplication会走到这边,下面先分析这边        parse(((AnnotatedBeanDefinition) bd).getMetadata(), holder.getBeanName());     }      // (**)处这边也要留意下,这边会处理DeferredImportSelector,我们前面说的AutoConfigurationImportSelector就是在这边处理    // 给容器中导入xxxAutoConfiguration    this.deferredImportSelectorHandler.process();  }
protected final void parse(AnnotationMetadata metadata, String beanName) throws IOException {       processConfigurationClass(new ConfigurationClass(metadata, beanName));  }
protected void processConfigurationClass(ConfigurationClass configClass) throws IOException {       // 根据当前类上面的@Conditional注解标注的条件判断是否要解析这个配置类     if (this.conditionEvaluator.shouldSkip(configClass.getMetadata(), ConfigurationPhase.PARSE_CONFIGURATION)) {          return;       }       // 以configClass作为key去获取,第一次来肯定是获取不到的,走下面逻辑     ConfigurationClass existingClass = this.configurationClasses.get(configClass);       if (existingClass != null) {           if (configClass.isImported()) {               if (existingClass.isImported()) {                   existingClass.mergeImportedBy(configClass);               }               // Otherwise ignore new imported config class; existing non-imported class overrides it.               return;           }           else {               // Explicit bean definition found, probably replacing an import.               // Let's remove the old one and go with the new one.  this.configurationClasses.remove(configClass);               this.knownSuperclasses.values().removeIf(configClass::equals);            }        }          // Recursively process the configuration class and its superclass hierarchy.      // 这一步其实没有做啥,重点还是看下一步骤      SourceClass sourceClass = asSourceClass(configClass);        do {      // 这里是重点,里面具体分为8大步骤,单独拿一小节分析    // b) doProcessConfigurationClass          sourceClass = doProcessConfigurationClass(configClass, sourceClass);        }        while (sourceClass != null);       // 放入configurationClasses中      this.configurationClasses.put(configClass, configClass);  }

// 上面的asSourceClass最终其实就是封装了一个SourceClass对象public SourceClass(Object source) {      this.source = source;      if (source instanceof Class) {          this.metadata = new StandardAnnotationMetadata((Class<?>) source, true);      }      else {          this.metadata = ((MetadataReader) source).getAnnotationMetadata();      }  }

protected final SourceClass doProcessConfigurationClass(ConfigurationClass configClass, SourceClass sourceClass)        throws IOException {      // 判断这个类上面有没有@Component注解     if (configClass.getMetadata().isAnnotated(Component.class.getName())) {          // Recursively process any member (nested) classes first    // 如果有的话,遍历其内部类,然后也是调用doProcessConfigurationClass递归处理        processMemberClasses(configClass, sourceClass);      }        // Process any @PropertySource annotations    // 处理PropertySource注解,之前讲解属性配置也分析过,就是将该注解对应的属性文件加载到Environment中    for (AnnotationAttributes propertySource : AnnotationConfigUtils.attributesForRepeatable(                                                 sourceClass.getMetadata(), PropertySources.class,                                                 org.springframework.context.annotation.PropertySource.class)) {          if (this.environment instanceof ConfigurableEnvironment) {              processPropertySource(propertySource);          }      }        // Process any @ComponentScan annotations     // 处理@ComponentScan注解,将其指定的包下的bean注册到框架中    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) {              // The config class is annotated with @ComponentScan -&gt; perform the scan immediately              Set<beandefinitionholder> scannedBeanDefinitions =                           this.componentScanParser.parse(componentScan, sourceClass.getMetadata().getClassName());              // Check the set of scanned definitions for any further config classes and parse recursively if needed              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());                   }              }          }      }        // Process any @Import annotations      // 处理Import注解    processImports(configClass, sourceClass, getImports(sourceClass), true);        // Process any @ImportResource annotations      // 处理@ImportResource注解,可以通过它来指定xml文件,BeanFactory就会读取这个xml文件将bean注册进去    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);          }      }        // Process individual @Bean methods      // 处理我们的类中使用@Bean注解的方法,添加到configClass的beanMethod中    Set<methodmetadata> beanMethods = retrieveBeanMethodMetadata(sourceClass);      for (MethodMetadata methodMetadata : beanMethods) {          configClass.addBeanMethod(new BeanMethod(methodMetadata, configClass));      }        // Process default methods on interfaces      // 处理接口的默认方法,遍历这个类的接口,判断有没有使用@Bean注解的非抽象方法,添加到configClass的beanMethod中    processInterfaces(configClass, sourceClass);        // Process superclass, if any      // 递归处理父类,这边返回父类上层方法会递归处理    if (sourceClass.getMetadata().hasSuperClass()) {         // 判断父类不为null且不在knownSuperclasses中且不以Java开头       String superclass = sourceClass.getMetadata().getSuperClassName();         if (superclass != null && !superclass.startsWith("java") &&                                              !this.knownSuperclasses.containsKey(superclass)) {             this.knownSuperclasses.put(superclass, configClass);             // Superclass found, return its annotation metadata and recurse             return sourceClass.getSuperClass();         }      }        // No superclass -&gt; processing is complete      return null;  }

if (configClass.getMetadata().isAnnotated(Component.class.getName())) {      // Recursively process any member (nested) classes first      processMemberClasses(configClass, sourceClass);  }

 // Register member (nested) classes that happen to be configuration classes themselves. private void processMemberClasses(ConfigurationClass configClass, SourceClass sourceClass) throws IOException {       Collection<SourceClass> memberClasses = sourceClass.getMemberClasses();      // 判断是否有内部类,没有的话直接不处理     if (!memberClasses.isEmpty()) {           List<SourceClass> candidates = new ArrayList<>(memberClasses.size());           for (SourceClass memberClass : memberClasses) {         // 判断是否是配置类,判断也很简单,之前分析过,判断类上面有没有@Configuration注解、@Import、@ImportResource       // @Component、@ComponentScan以及@Bean标注的方法             if (ConfigurationClassUtils.isConfigurationCandidate(memberClass.getMetadata()) &&                       !memberClass.getMetadata().getClassName().equals(configClass.getMetadata().getClassName())) {        // 加入到candidates中然后排个序                  candidates.add(memberClass);               }           }           OrderComparator.sort(candidates);           for (SourceClass candidate : candidates) {            // 防止A引入防止A引入B,B引入A             if (this.importStack.contains(configClass)) {                  this.problemReporter.error(new CircularImportProblem(configClass, this.importStack));               }               else {                  this.importStack.push(configClass);                  try {          // 放入栈中并遍历处理这些配置类,也是递归处理,调用之前的doProcessConfigurationClass处理这个配置类                    processConfigurationClass(candidate.asConfigClass(configClass));                  }                  finally {                      this.importStack.pop();                  }               }           }      }  }

@SpringBootApplication  @PropertySource({"demo.properties"})  public class Springboot2Application {

for (AnnotationAttributes propertySource : AnnotationConfigUtils.attributesForRepeatable(                                                  sourceClass.getMetadata(), PropertySources.class,                                                  org.springframework.context.annotation.PropertySource.class)) {      if (this.environment instanceof ConfigurableEnvironment) {    // 这边就不进去看了,主要是读取@PropertySource注解指定的文件,将其封装成一个属性集放入到环境中        processPropertySource(propertySource);      }  }

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) {          // The config class is annotated with @ComponentScan -> perform the scan immediately    // 下面先分析这个parse方法        Set<BeanDefinitionHolder> scannedBeanDefinitions =                       this.componentScanParser.parse(componentScan, sourceClass.getMetadata().getClassName());          // Check the set of scanned definitions for any further config classes and parse recursively if needed          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());              }          }      }  }

public Set<BeanDefinitionHolder> parse(AnnotationAttributes componentScan, final String declaringClass) {      ClassPathBeanDefinitionScanner scanner = new ClassPathBeanDefinitionScanner(this.registry,                             componentScan.getBoolean("useDefaultFilters"), this.environment, this.resourceLoader);        Class<? extends BeanNameGenerator> generatorClass = componentScan.getClass("nameGenerator");      boolean useInheritedGenerator = (BeanNameGenerator.class == generatorClass);     // 设置一个bean名字生成器,默认就是使用org.springframework.beans.factory.support.BeanNameGenerator    scanner.setBeanNameGenerator(useInheritedGenerator ? this.beanNameGenerator :                                                                        BeanUtils.instantiateClass(generatorClass));        // 就是默认的    ScopedProxyMode scopedProxyMode = componentScan.getEnum("scopedProxy");      if (scopedProxyMode != ScopedProxyMode.DEFAULT) {          scanner.setScopedProxyMode(scopedProxyMode);      }      else {          Class<? extends ScopeMetadataResolver> resolverClass = componentScan.getClass("scopeResolver");    // 理解是元数据解析器        scanner.setScopeMetadataResolver(BeanUtils.instantiateClass(resolverClass));      }        // 设置下扫描的资源模式,是**/*.class    scanner.setResourcePattern(componentScan.getString("resourcePattern"));        // 添加IncludeFilter和ExcludeFilter    for (AnnotationAttributes filter : componentScan.getAnnotationArray("includeFilters")) {          for (TypeFilter typeFilter : typeFiltersFor(filter)) {              scanner.addIncludeFilter(typeFilter);          }      }      for (AnnotationAttributes filter : componentScan.getAnnotationArray("excludeFilters")) {          for (TypeFilter typeFilter : typeFiltersFor(filter)) {              scanner.addExcludeFilter(typeFilter);          }      }      // 设置是否懒加载    boolean lazyInit = componentScan.getBoolean("lazyInit");      if (lazyInit) {          scanner.getBeanDefinitionDefaults().setLazyInit(true);      }        // 解析扫描的包路径加入到basePackages中    Set<String> basePackages = new LinkedHashSet<>();      String[] basePackagesArray = componentScan.getStringArray("basePackages");      for (String pkg : basePackagesArray) {          String[] tokenized = StringUtils.tokenizeToStringArray(this.environment.resolvePlaceholders(pkg),                                                   ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS);          Collections.addAll(basePackages, tokenized);      }      for (Class<?> clazz : componentScan.getClassArray("basePackageClasses")) {    // 解析basePackageClasses所在的包并加入到basePackages        basePackages.add(ClassUtils.getPackageName(clazz));      }       // 如果是空的,将声明该注解所在的类的包加入到basePackages    if (basePackages.isEmpty()) {    // 通常我们的主配置类是没有声明包扫描的路径的,所以这里会将主配置类所在的包加到这里面        basePackages.add(ClassUtils.getPackageName(declaringClass));      }        // 添加一个ExcludeFilter,跳过声明该注解的类    scanner.addExcludeFilter(new AbstractTypeHierarchyTraversingFilter(false, false) {         @Override         protected boolean matchClassName(String className) {             return declaringClass.equals(className);         }      });      return scanner.doScan(StringUtils.toStringArray(basePackages));  }

protected Set<BeanDefinitionHolder> doScan(String... basePackages) {       Assert.notEmpty(basePackages, "At least one base package must be specified");       Set<BeanDefinitionHolder> beanDefinitions = new LinkedHashSet<>();       // 遍历所有的包路径     for (String basePackage : basePackages) {     // 获取该包下面所有符合条件的BeanDefinition,然后遍历处理,下面会分析         Set<BeanDefinition> candidates = findCandidateComponents(basePackage);           for (BeanDefinition candidate : candidates) {               ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate);               candidate.setScope(scopeMetadata.getScopeName());         // 通过beanNameGenerator生成beanName             String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);       // 这两个if判断逻辑比较简单,就是设置一些Lazy、DependsOn属性             if (candidate instanceof AbstractBeanDefinition) {                  postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);               }               if (candidate instanceof AnnotatedBeanDefinition) {                  AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);               }         // 这边是检查下有没有之前定义过这个BeanDefinition             if (checkCandidate(beanName, candidate)) {                  BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);                  definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata,                                                       definitionHolder, this.registry);                  // 将该beanDefinition加入到集合中,并注册到容器中                beanDefinitions.add(definitionHolder);                  registerBeanDefinition(definitionHolder, this.registry);               }          }      }      return beanDefinitions;  }

private Set<BeanDefinition> scanCandidateComponents(String basePackage) {       Set<BeanDefinition> candidates = new LinkedHashSet<>();       try {           // 扫描指定包路径及其子包下面的class文件,将其封装成Resource对象   // classpath*:com/lwh/springboot/**/*.class   String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX +                                            resolveBasePackage(basePackage) + '/' + this.resourcePattern;           Resource[] resources = getResourcePatternResolver().getResources(packageSearchPath);              for (Resource resource : resources) {               if (resource.isReadable()) {                  try {                      MetadataReader metadataReader = getMetadataReaderFactory().getMetadataReader(resource);                      if (isCandidateComponent(metadataReader)) {                           ScannedGenericBeanDefinition sbd = new ScannedGenericBeanDefinition(metadataReader);                           sbd.setResource(resource);                           sbd.setSource(resource);                           if (isCandidateComponent(sbd)) {                               candidates.add(sbd);                           }                      }                  }              }           }    }    return candidates;  }

// 通过之前设置的几个filter进行过滤protected boolean isCandidateComponent(MetadataReader metadataReader) throws IOException {      for (TypeFilter tf : this.excludeFilters) {          if (tf.match(metadataReader, getMetadataReaderFactory())) {              return false;          }      }      for (TypeFilter tf : this.includeFilters) {          if (tf.match(metadataReader, getMetadataReaderFactory())) {              return isConditionMatch(metadataReader);          }      }      return false;  }

// Process any @Import annotations  // getImports方法就是去递归扫描configClass上面所有的注解,将@Import注解标注的值放入importCandidates中,见下图processImports(configClass, sourceClass, getImports(sourceClass), true);

private void processImports(ConfigurationClass configClass, SourceClass currentSourceClass,                                       Collection<SourceClass> importCandidates, boolean checkForCircularImports) {        if (importCandidates.isEmpty()) {          return;      }        if (checkForCircularImports && isChainedImportOnStack(configClass)) {          this.problemReporter.error(new CircularImportProblem(configClass, this.importStack));      }      else {          this.importStack.push(configClass);          try {              for (SourceClass candidate : importCandidates) {      // 依次遍历判断类型    // 其中有一个是这个类型,@Import(AutoConfigurationImportSelector.class)    // 这个就是自动配置原理,导入xxxAutoConfiguration这些类                if (candidate.isAssignable(ImportSelector.class)) {                      // Candidate class is an ImportSelector -> delegate to it to determine imports                      Class<?> candidateClass = candidate.loadClass();          // 实例化并调用xxxAware的方法并注入相关属性                    ImportSelector selector = BeanUtils.instantiateClass(candidateClass, ImportSelector.class);                      ParserStrategyUtils.invokeAwareMethods(                                              selector, this.environment, this.resourceLoader, this.registry);         // 它是DeferredImportSelector类型的                    if (selector instanceof DeferredImportSelector) {                    // deferredImportSelectors = new ArrayList<>()      // 这边会将两个参数封装下加入到deferredImportSelectors中,后面处理      // 加入到deferredImportSelectors中后,具体的处理是this.deferredImportSelectorHandler.process();                        this.deferredImportSelectorHandler.handle(configClass, (DeferredImportSelector) selector);                      }                      else {        // 不是的话获取@Import导入的类名数组                        String[] importClassNames = selector.selectImports(currentSourceClass.getMetadata());                          Collection<SourceClass> importSourceClasses = asSourceClasses(importClassNames);       // 然后再递归处理                        processImports(configClass, currentSourceClass, importSourceClasses, false);                      }                  }      // @Import(AutoConfigurationPackages.Registrar.class),我们的主配置类上面的注解就是这个类型    // 这个是用于导入主配置类所在包及其子包下的BeanDefinition                else if (candidate.isAssignable(ImportBeanDefinitionRegistrar.class)) {                       // Candidate class is an ImportBeanDefinitionRegistrar ->                       // delegate to it to register additional bean definitions                       Class<?> candidateClass = candidate.loadClass();                       ImportBeanDefinitionRegistrar registrar =                                  BeanUtils.instantiateClass(candidateClass, ImportBeanDefinitionRegistrar.class);                       ParserStrategyUtils.invokeAwareMethods(                                                 registrar, this.environment, this.resourceLoader, this.registry);           // 这边就是将这两个参数作为key,value放入了一个map中               // this.importBeanDefinitionRegistrars.put(registrar, importingClassMetadata);                     configClass.addImportBeanDefinitionRegistrar(registrar, currentSourceClass.getMetadata());                  }                  else {                       // Candidate class not an ImportSelector or ImportBeanDefinitionRegistrar ->                       // process it as an @Configuration class                 this.importStack.registerImport(                                       currentSourceClass.getMetadata(), candidate.getMetadata().getClassName());           // 当做一个普通类处理,判断是不是配置类,递归处理                     processConfigurationClass(candidate.asConfigClass(configClass));                  }           }        }        finally {           this.importStack.pop();        }     }  }

// 这种就是Spring中常用的通过XML形式注入的方式@SpringBootApplication  @ImportResource("test.xml")  public class Springboot2Application {

// Process any @ImportResource annotations// 可以使用@ImportResource注解指定xml文件,导入BeanDefinitionAnnotationAttributes 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) {     // 就是test.xml         String resolvedResource = this.environment.resolveRequiredPlaceholders(resource);           configClass.addImportedResource(resolvedResource, readerClass);       }  }
public void addImportedResource(String importedResource, Class<? extends BeanDefinitionReader> readerClass) {       // 这边就是放入到了map中,这边是先统一存放起来,在步骤五的4)在真正进行导入BeanDefinition     this.importedResources.put(importedResource, readerClass);  }
private final Map<String, Class<? extends BeanDefinitionReader>> importedResources = new LinkedHashMap<>();

// Process individual @Bean methods  // 获取当前类中的Bean方法Set<MethodMetadata> beanMethods = retrieveBeanMethodMetadata(sourceClass);  for (MethodMetadata methodMetadata : beanMethods) {       // 这边也是加入到set中,见下面代码,也是在步骤五的3)中进行处理     configClass.addBeanMethod(new BeanMethod(methodMetadata, configClass));  }
private final Set<BeanMethod> beanMethods = new LinkedHashSet<>();

// 默认方法举例,主配置类实现这个接口就可以public interface ConfigurationInterface {
    @Bean    default Pig pig(){        return new Pig();    }}

 // Process default methods on interfaces   processInterfaces(configClass, sourceClass);
 // Register default methods on interfaces implemented by the configuration class. // 这边也是递归处理其父接口,判断父接口中默认方法是不是@Bean方法 private void processInterfaces(ConfigurationClass configClass, SourceClass sourceClass) throws IOException {       for (SourceClass ifc : sourceClass.getInterfaces()) {           Set<MethodMetadata> beanMethods = retrieveBeanMethodMetadata(ifc);           for (MethodMetadata methodMetadata : beanMethods) {               if (!methodMetadata.isAbstract()) {                   // 也是在步骤五的3)中进行处理                 configClass.addBeanMethod(new BeanMethod(methodMetadata, configClass));               }           }           processInterfaces(configClass, ifc);       }  }

// Process superclass, if any  if (sourceClass.getMetadata().hasSuperClass()) {      String superclass = sourceClass.getMetadata().getSuperClassName();      if (superclass != null && !superclass.startsWith("java") &&                                !this.knownSuperclasses.containsKey(superclass)) {          this.knownSuperclasses.put(superclass, configClass);          // Superclass found, return its annotation metadata and recurse          return sourceClass.getSuperClass();      }  }

// 在解析@Import注解时，我们的AutoConfigurationImportSelector就是DeferredImportSelector类型的，它的意思是延迟导// 入. 为啥要延迟导入? 因为AutoConfigurationImportSelector是给容器中导入一些默认的组件，如果容器中已经有这种类型// 的组件了，那么就不再导入. 因此，它是故意先等SpringBoot容器去解析那些用户自定义的Bean,最后发现没有才来导入这// 些默认的组件if (selector instanceof DeferredImportSelector) {     // deferredImportSelectors = new ArrayList<>()   // 这边会将两个参数封装下加入到deferredImportSelectors中,后面处理   // 加入到deferredImportSelectors中后,具体的处理是this.deferredImportSelectorHandler.process();   this.deferredImportSelectorHandler.handle(configClass, (DeferredImportSelector) selector);  }

// 步骤四就是从这里开始分析的public void parse(Set<beandefinitionholder> configCandidates) {      // 删除部分代码，实际执行时这里的configCandidates就一个springBootApplication代表的主配置类    for (BeanDefinitionHolder holder : configCandidates) {        // 获取BeanDefinition        BeanDefinition bd = holder.getBeanDefinition();          // 我们的SpringBootApplication会走到这边,下面先分析这边        parse(((AnnotatedBeanDefinition) bd).getMetadata(), holder.getBeanName());     }        // 给容器中导入xxxAutoConfiguration,我们现在分析这边    this.deferredImportSelectorHandler.process();  }

// 上面方法会走到这里public void processGroupImports() {      for (DeferredImportSelectorGrouping grouping : this.groupings.values()) {     // 下面先分析这个getImports方法         grouping.getImports().forEach(entry -> {               ConfigurationClass configurationClass = this.configurationClasses.get(entry.getMetadata());               try {                   processImports(configurationClass, asSourceClass(configurationClass),                   asSourceClasses(entry.getImportClassName()), false);               }           });      }  }
public Iterable<group.entry> getImports() {      // 这边的deferredImports是通过grouping.add(deferredImport)添加进去的    for (DeferredImportSelectorHolder deferredImport : this.deferredImports) {          this.group.process(deferredImport.getConfigurationClass().getMetadata(),                                                                         deferredImport.getImportSelector());      }      return this.group.selectImports();  }
public void process(AnnotationMetadata annotationMetadata, DeferredImportSelector deferredImportSelector) {      // 下面先分析下这个getAutoConfigurationEntry方法     AutoConfigurationEntry autoConfigurationEntry = ((AutoConfigurationImportSelector) deferredImportSelector)                       .getAutoConfigurationEntry(getAutoConfigurationMetadata(), annotationMetadata);       // 加入到这个autoConfigurationEntries中     this.autoConfigurationEntries.add(autoConfigurationEntry);       for (String importClassName : autoConfigurationEntry.getConfigurations()) {     // 接着依次遍历放入到这个map中,Map<string, annotationmetadata> entries = new LinkedHashMap<>()         this.entries.putIfAbsent(importClassName, annotationMetadata);       }  }

// 这边就到了AutoConfigurationImportSelector类的方法中protected AutoConfigurationEntry getAutoConfigurationEntry(AutoConfigurationMetadata autoConfigurationMetadata,                                                             AnnotationMetadata annotationMetadata) {      // 判断是否支持自动配置    if (!isEnabled(annotationMetadata)) {          return EMPTY_ENTRY;      }      // 这个attributes属性就是上图中显示的,用来过滤自动配置类的    AnnotationAttributes attributes = getAttributes(annotationMetadata);      // 下面分析这个方法,这个就是加载容器中的自动配置类    List<string> configurations = getCandidateConfigurations(annotationMetadata, attributes);      // 去除重复的,方法就是放入set再放入list中    configurations = removeDuplicates(configurations);      // 去除掉应该被排除的    Set<string> exclusions = getExclusions(annotationMetadata, attributes);      checkExcludedClasses(configurations, exclusions);      configurations.removeAll(exclusions);       // 通过filter过滤,下面分析,过滤完发现只有22个了    configurations = filter(configurations, autoConfigurationMetadata);      // 发布一个事件,好像没有做啥关键的    fireAutoConfigurationImportEvents(configurations, exclusions);      // 将configurations封装成AutoConfigurationEntry返回    return new AutoConfigurationEntry(configurations, exclusions);  }
protected boolean isEnabled(AnnotationMetadata metadata) {      if (getClass() == AutoConfigurationImportSelector.class) {    // 判断有没有配置这个属性,没有的话默认为true,  // String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration";        return getEnvironment().getProperty(EnableAutoConfiguration.ENABLED_OVERRIDE_PROPERTY, Boolean.class, true);      }      return true;  }

protected List<string> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {     // getSpringFactoriesLoaderFactoryClass()返回EnableAutoConfiguration.class,那么这边就是获取容器中所有的字段配置类    List<string> configurations = SpringFactoriesLoader.loadFactoryNames(getSpringFactoriesLoaderFactoryClass(),                                                                                  getBeanClassLoader());      return configurations;  }

protected List<autoconfigurationimportfilter> getAutoConfigurationImportFilters() {      return SpringFactoriesLoader.loadFactories(AutoConfigurationImportFilter.class, this.beanClassLoader);  }

// 上面分析的是配置类解析的步骤四parser.parse(candidates);
// 下面来看第五步,步骤四中解析得到的配置类会放在configurationClasses中Set<ConfigurationClass> configClasses = new LinkedHashSet<>(parser.getConfigurationClasses());configClasses.removeAll(alreadyParsed);this.reader.loadBeanDefinitions(configClasses);

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

private void loadBeanDefinitionsForConfigurationClass(  ConfigurationClass configClass, TrackedConditionEvaluator trackedConditionEvaluator) {     // 判断是否应该跳过     if (trackedConditionEvaluator.shouldSkip(configClass)) {  return;     }
     // 向容器中注入这个配置类所代表的的BeanDefinition     if (configClass.isImported()) {  registerBeanDefinitionForImportedConfigurationClass(configClass);     }     // 遍历这个配置类的所有的Bean方法,注入这些@Bean标注的方法要引入的BeanDefinition     for (BeanMethod beanMethod : configClass.getBeanMethods()) {  loadBeanDefinitionsForBeanMethod(beanMethod);     }
     // 处理该配置类上的@ImportResource指定的配置文件,就是Spring中常用的XML配置方式     // 这边会通过解析该XML文件给容器中注入BeanDefinition,SpringBoot中不推荐这种方式,具体就不往下分析了     loadBeanDefinitionsFromImportedResources(configClass.getImportedResources());        // 处理步骤四中D解析@Import注解时获得的importBeanDefinitionRegistrars,调用其registerBeanDefinitions     // 方法给容器中注入BeanDefinition,这在前面讲解@Import方式时已经讲过了     loadBeanDefinitionsFromRegistrars(configClass.getImportBeanDefinitionRegistrars());}

private void loadBeanDefinitionsFromRegistrars(Map<ImportBeanDefinitionRegistrar, AnnotationMetadata> registrars) {     registrars.forEach((registrar, metadata) -> registrar.registerBeanDefinitions(metadata, this.registry));}

四、总结