1 文章说明

• springboot横行的时候，将一些功能抽出来给到不同的springboot的项目来说用，或者其他的一些场景，如果能定义成starter组件，也许是一个不错的选择。
• 弄清楚springboot自动装配的原理对开发者也是不错的选择。或许理解还有偏差，但是还是希望进行整理输出，为方便以后翻阅。

1.1本文目标:

• 实现start组件。
• 对Springboot如何实现自动装配进行说明。

1.2 前置知识说明

1.2.1 关于starter组件的命名规范

• 官方定义的starter组件命名一般为spring-boot-starter-xxx
• 自定义starter组件命名一般为xxx-spring-boot-starter

2.实现starter组件

• 引入依赖

 <dependencies>
     <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-autoconfigure</artifactId>
    </dependency>

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-configuration-processor</artifactId>
        <optional>true</optional>
    </dependency>
</dependencies>

• 项目结构

  
  项目结构
• hello-spring-boot-starter是基于条件装配来实现(在属性配置中让enable来提供开关)
• myenable-spring-boot-starter是基于@import来实现(实现@Enablexxx注解来使starter组件引入)

2.1 基于条件装配来实现

• 这种方式主要是通过springboot扫描spring.factories文件来实现
• 至于这么实现的原理是什么样，在后续实现介绍完会有说明

2.1.1 starter组件定义

• 定义需要使用的简单功能

public interface IHelloService {
    String sayHello(String  name);
}
public class HelloServiceImpl implements IHelloService {

    private HelloProperties helloProperties;

    public HelloServiceImpl(HelloProperties helloProperties) {
        this.helloProperties = helloProperties;
    }

    @Override
    public String sayHello(String name) {
        return helloProperties.getName()+"say hello "+name;
    }
}

• Properties属性定义

@ConfigurationProperties(prefix = "hello")
public class HelloProperties {

    private String name;

    private boolean enable;

    public String getName() {
        return name;
    }

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

    public boolean isEnable() {
        return enable;
    }

    public void setEnable(boolean enable) {
        this.enable = enable;
    }
}

• configuration定义

@Configuration
@EnableConfigurationProperties(value = HelloProperties.class)
public class HelloConfiguration {


    @Bean
    @ConditionalOnProperty("hello.enable")
    public IHelloService helloService(HelloProperties helloProperties){
        return new HelloServiceImpl(helloProperties);
    }
}

• 在resource下添加 /META-INF/spring.factories文件

org.springframework.boot.autoconfigure.EnableAutoConfiguration=com.pitaya.starter.hello.HelloConfiguration

2.1.2 starter组件引用

• maven 引入

<dependency>
    <groupId>org.example</groupId>
    <artifactId>hello-spring-boot-starter</artifactId>
    <version>1.0-SNAPSHOT</version>
</dependency>

• 配置文件application.yml
  enable定义为true即可使用

hello:
  name: 笑笑
  enable: true 

• 引用功能

@RestController
@RequestMapping("/hello")
public class HelloController {

    @Autowired
    private IHelloService helloService;

    @GetMapping("/say-hello")
    public String sayHello(String name){
        return helloService.sayHello(name);
    }
}

2.2 基于@import注解来实现

2.2.1 starter组件定义

• 定义功能

public interface IMyService {
    String getName();
}

public class MyServiceImpl implements IMyService {

    private MyEnableProperties myEnableProperties;

    public MyServiceImpl(MyEnableProperties myEnableProperties) {
        this.myEnableProperties = myEnableProperties;
    }

    @Override
    public String getName() {
        return myEnableProperties.getName();
    }
}

• 配置属性

@ConfigurationProperties(prefix = "myenable")
public class MyEnableProperties {

    private String name;

    public String getName() {
        return name;
    }

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

• configuration类

@Configuration
@EnableConfigurationProperties(value = MyEnableProperties.class)
public class MyEnableConfiguration {

    @Bean
    public IMyService myService(MyEnableProperties myEnableProperties){
        return new MyServiceImpl(myEnableProperties);
    }
}

• enable注解定义

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(MyEnableConfiguration.class)
public @interface EnableHello {
}

2.2.2 starter组件引用

• maven引入依赖

<dependency>
    <groupId>org.example</groupId>
    <artifactId>myenable-spring-boot-starter</artifactId>
    <version>1.0-SNAPSHOT</version>
</dependency>

• 启动类上增加注解

@EnableHello
@SpringBootApplication
public class MyEnableExampleApplication {

    public static void main(String[] args) {
        SpringApplication.run(MyEnableExampleApplication.class,args);
    }
}

• 配置文件application.yml

myenable:
  name: aa

3.原理

• 以上两种方式如果说从使用来看的话，看喜欢或者规范，或者项目情况来选择即可，但是从springboot加载的角度来看的话他们还是有一定的区别的。
• springboot的启动如何实现自动装配，其实如果要从每一个细节去说的话非常繁杂，但是说到底，我们要弄明白的事情只有一件事，那就是Spring如何把starter组件的bean加入Spring容器的即可.
• 要解释这个问题绝非以下几句话就可以忽悠面试官，也包括忽悠自己，你是否曾经如此推断过：
  • 步骤1:启动类上有一个@SpringBootApplication注解，它包含了@ConfigurationPropertiesScan注解
  • 步骤2:@ConfigurationPropertiesScan上又包含注解@Import({AutoConfigurationImportSelector.class})
  • 步骤3: AutoConfigurationImportSelector的selectImports()方法调用的时候，就回去查找所有jar包下的spring.factories文件，然后spring就可以加载到这个jar包上的bean，然后注入到Spring容器。
  • 这些回答无懈可击，然后世界和平，我啥都懂了，我给自己猛call 666。然而这些似乎。。。 似乎少了点什么，就像少了什么时候去 处理AutoConfigurationImportSelector，又怎样去加载到Spring容器的，然后随之而来的越来越的的怎样，为什么，什么时候的问题会出现。
• 所以一切的一切从入口main()函数开始吧，先解决掉一些笨笨的为什么再说。

3.1 启动前的准备工作

• main()函数入口

@SpringBootApplication
public class HelloExampleApplication {

    public static void main(String[] args) {
        SpringApplication.run(HelloExampleApplication.class,args);
    }
}

• 紧接着会调用SpringApplication.run()静态方法

public static ConfigurableApplicationContext run(Class<?>[] primarySources, String[] args) {
    return new SpringApplication(primarySources).run(args);
}

• 3.1.1 创建SpringApplication对象

• 总的来说这一步大概就是确定web应用类型，找到一些监听器之类的方便后续在启动过程中需要使用，大概就是做了一些初始化工作

public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
   
    // resourceLoader参数为空
   this.resourceLoader = resourceLoader;
        Assert.notNull(primarySources, "PrimarySources must not be null");
  
    // 将启动类放到Set结构的primarySources中
   this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));
  
    // 判断当前web环境，结果为Servlet环境
    this.webApplicationType = WebApplicationType.deduceFromClasspath();
  
    // 将结果存储到Application的属性initializers中，在后续需要的时候从这里读，获取到7个类的实例化
    setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));
  
    // 将结果存储到Application的属性listeners中，在后续需要的时候从这里读，获取到10个类的实例化
   setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
  
    //确定当前应用的启动类，就是你的springboot的main函数的入口
   this.mainApplicationClass = deduceMainApplicationClass();
}

• 3.1.2 SpringApplication中run(args)方法中的一些准备工作

• 方法定义如下，这个方法就是springboot启动的全过程，在本小节，refreshContext()太重要，在后续再说吧

public ConfigurableApplicationContext run(String... args) {

    //下面这两行代码就是为了记录启动停止时间之类的，和主流程没啥关系，所以不理它
    StopWatch stopWatch = new StopWatch();
    stopWatch.start();

    //定义spring的容器，只是定义一个变量而已
    ConfigurableApplicationContext context = null;
 
   //创建异常报告器
    Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList<>();

    // 主要设置java.awt.headless设置系统参数为true，用于运行xxx的图像处理，也是关系不大
    configureHeadlessProperty();

    // 创建了SpringApplicationRunListeners对象，里面包括一些监听器，例如EventPublishingRunListener 
    SpringApplicationRunListeners listeners = getRunListeners(args);

    //1.初始化EventPublishingRunListener
    //2.将application的11个监听器给当前对象
    // 上面只是简单的两个，其实还有一些东西的初始化，debug的时候如果某个对象不知道怎么来的，可以debug看看这些监听器 
   listeners.starting();
   try {
      //解析命令行参数
      ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);

      //准备环境    
      ConfigurableEnvironment environment = prepareEnvironment(listeners, applicationArguments);
      configureIgnoreBeanInfo(environment);

      // 打印banner图对象，没错，就是控制台的那个spring
      Banner printedBanner = printBanner(environment);
    
      // 创建spring环境，子类是AnnotationConfigServletWebServerApplicationContext，这一步也是至关重要，开始和Spring关联起来了
      context = createApplicationContext();
      
      //TODO 异常处理，先不管
      exceptionReporters = getSpringFactoriesInstances(SpringBootExceptionReporter.class,
                    new Class[] { ConfigurableApplicationContext.class }, context);

      /// 准备Spring上下文
      // 1.向Spring注册bean internalConfigurationBeanNameGenerator
      // 2.添加数据类型转换器
      prepareContext(context, environment, listeners, applicationArguments, printedBanner);

      // 重点要弄明白的，会调用到spring的refresh()方法里面去,全部的spring启动过程，在这个方法呈现在你的面前
      refreshContext(context);

      // 空实现
      afterRefresh(context, applicationArguments);

      // 停止及时，你看到springboot启动完后耗时多久就是它咯 
      stopWatch.stop();
    
      // log相关，不理会
      if (this.logStartupInfo) {
                new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), stopWatch);
      }
    
     listeners.started(context);

      // ApplicationRunner的执行，包括你自己定义的
      callRunners(context, applicationArguments);
  }catch (Throwable ex) {
      handleRunFailure(context, ex, exceptionReporters, listeners);
      throw new IllegalStateException(ex);
  }

  try {
      listeners.running(context);
   }catch (Throwable ex) {
      handleRunFailure(context, ex, exceptionReporters, null);
       throw new IllegalStateException(ex);
  }
  return context;
}

• 好像是挺简单，真的这么简单吗？没点进去吧，然后如果展开进去太多，这里对于不重要的步骤只大概说，对于和自动装配有关系的才会贴出相关代码，方便后续的Debug跟踪。

• prepareEnvironment()

private ConfigurableEnvironment prepareEnvironment(SpringApplicationRunListeners listeners,
            ApplicationArguments applicationArguments) {
        // Create and configure the environment
    // 创建环境
        ConfigurableEnvironment environment = getOrCreateEnvironment();
  
    //配置环境
        configureEnvironment(environment, applicationArguments.getSourceArgs());
        ConfigurationPropertySources.attach(environment);
  
    // 告诉所有监听器环境已经准备好，发布事件为ApplicationEnvironmentPreparedEvent，7个监听器会收到事件
        listeners.environmentPrepared(environment);
        bindToSpringApplication(environment);
        if (!this.isCustomEnvironment) {
            environment = new EnvironmentConverter(getClassLoader()).convertEnvironmentIfNecessary(environment,
                    deduceEnvironmentClass());
        }
        ConfigurationPropertySources.attach(environment);
        return environment;
    }

• congirureEnvironment()

protected void configureEnvironment(ConfigurableEnvironment environment, String[] args) {
        if (this.addConversionService) {
        
          // 加载所有的类型转换器
            ConversionService conversionService = ApplicationConversionService.getSharedInstance();
            
      // 设置数据类型转换器到当前环境         environment.setConversionService((ConfigurableConversionService) conversionService);
        }
        
        // 配置properties资源
        configurePropertySources(environment, args);
        
        // 将properties加载到环境变量
        configureProfiles(environment, args);
    }

• createApplicationContext()，创建了一个spring的Context对象返回

protected ConfigurableApplicationContext createApplicationContext() {
        Class<?> contextClass = this.applicationContextClass;
        if (contextClass == null) {
            try {
                // 在创建SpringApplication对象的时候就已经确定是SERVLET了
                switch (this.webApplicationType) { 
                case SERVLET:

                    // public static final String DEFAULT_SERVLET_WEB_CONTEXT_CLASS = "org.springframework.boot."+web.servlet.context.AnnotationConfigServletWebServerApplicationContext
                    // 可以知道Spring上下文就是AnnotationConfigServletWebServerApplicationContext
                    contextClass = Class.forName(DEFAULT_SERVLET_WEB_CONTEXT_CLASS);
                    break;
                case REACTIVE:
                    contextClass = Class.forName(DEFAULT_REACTIVE_WEB_CONTEXT_CLASS);
                    break;
                default:
                    contextClass = Class.forName(DEFAULT_CONTEXT_CLASS);
                }
            }
            catch (ClassNotFoundException ex) {
                throw new IllegalStateException(
                        "Unable create a default ApplicationContext, please specify an ApplicationContextClass", ex);
            }
        }
        return (ConfigurableApplicationContext) BeanUtils.instantiateClass(contextClass);
}

• 到目前为止，Spring的context有了，环境有了(StandardEnvironment),命令行参数解析了，启动类的也找到了，下面正式开始要执行Spring的refresh的12个方法了()

3.2 那个难懂的refresh()方法

• 调用refresh()方法之后会调用AbstractApplicationContext(其实AnnotationConfigServletWebServerApplicationContext继承的就是这个类)的refresh()方法

• 之后会调用一系列的方法，如下

  
  spring相关流程
• 也就是说在这个过程中其实需要加载springboot自己定义的bean以及starter组件中的bean，在spring加载bean的过程中，其实第一步先要获取到的是这些需要载入的bean的BeanDefinition，这就等价于说我们需要来获取springboot项目以及starter组件的需要载入的bean的BeanDefintion加载到spring容器中。
• 在spring这个过程中，留给我们很多扩展的地方，其中BeanFactoryPostProcessor就是允许我们来处理这些BeanDefintion的，所以，从上述图片和代码Debug过程中，我们很快可以定位到，最重要的是这个invokebeanFactoryPostProcessors()方法
• 上述可能有点跳跃，但是那么多的方法确实很难在文章中说清楚，我们还是需要直奔目标，说清楚和自动装配相关的东西。

3.2.1

• invokeBeanFactoryPostProcessors()方法

protected void  invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {

//beanFactory, getBeanFactoryPostProcessors()可以获取到以下三个类
//CachingMetadataReaderFactoryPostProcessor
//ConfigurationWarningsPostProcessor
//PropertySourceOrderingPostProcessor
PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());
             
        // Detect a LoadTimeWeaver and prepare for weaving, if found in the meantime
        // (e.g. through an @Bean method registered by ConfigurationClassPostProcessor)
  
        if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
            beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
            beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
        }
}

• ConfigurationClassParser的parser()方法

public void parse(Set<BeanDefinitionHolder> configCandidates) {
        for (BeanDefinitionHolder holder : configCandidates) {
            BeanDefinition bd = holder.getBeanDefinition();
            try {
                if (bd instanceof AnnotatedBeanDefinition) {
                    parse(((AnnotatedBeanDefinition) bd).getMetadata(), holder.getBeanName());
                }
                else if (bd instanceof AbstractBeanDefinition && ((AbstractBeanDefinition) bd).hasBeanClass()) {
                    parse(((AbstractBeanDefinition) bd).getBeanClass(), holder.getBeanName());
                }
                else {
                    parse(bd.getBeanClassName(), holder.getBeanName());
                }
            }
            catch (BeanDefinitionStoreException ex) {
                throw ex;
            }
            catch (Throwable ex) {
                throw new BeanDefinitionStoreException(
                        "Failed to parse configuration class [" + bd.getBeanClassName() + "]", ex);
            }
        }

        // 这里需要处理所有延迟处理的@import上的类，例如AutoConfigurationImportSelector，在解析道@import上的类之后，这里正式去调用扫描jar包的spring.factories文件了
        this.deferredImportSelectorHandler.process();
    }

• 循环处理配置类doProcessConfigurationClass

protected final SourceClass doProcessConfigurationClass(ConfigurationClass configClass, SourceClass sourceClass)
            throws IOException {

        //加载 compotent 注解的类
        if (configClass.getMetadata().isAnnotated(Component.class.getName())) {
            // Recursively process any member (nested) classes first
            processMemberClasses(configClass, sourceClass);
        }

        // Process any @PropertySource annotations
        // 加载属性文件
        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");
            }
        }

        // Process any @ComponentScan annotations
        //先找出类上的@ComponentScan和@ComponentScans注解的所有属性， 解析@ComponentScan和@ComponentScans配置的扫描的包所包含的类，如果没有就从启动类的包查找
        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
                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注解注册的bean，这一步只会将import注册的bean变为ConfigurationClass,不会变成BeanDefinition
        processImports(configClass, sourceClass, getImports(sourceClass), true);

        // Process any @ImportResource annotations
        //处理@ImportResource注解引入的配置文件
        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注解的方法
        Set<MethodMetadata> beanMethods = retrieveBeanMethodMetadata(sourceClass);
        for (MethodMetadata methodMetadata : beanMethods) {
            configClass.addBeanMethod(new BeanMethod(methodMetadata, configClass));
        }

        // Process default methods on interfaces
        processInterfaces(configClass, sourceClass);

        // 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();
            }
        }

        // No superclass -> processing is complete
        return null;
    }

    /**
     * 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) {
                if (ConfigurationClassUtils.isConfigurationCandidate(memberClass.getMetadata()) &&
                        !memberClass.getMetadata().getClassName().equals(configClass.getMetadata().getClassName())) {
                    candidates.add(memberClass);
                }
            }
            OrderComparator.sort(candidates);
            for (SourceClass candidate : candidates) {
                if (this.importStack.contains(configClass)) {
                    this.problemReporter.error(new CircularImportProblem(configClass, this.importStack));
                }
                else {
                    this.importStack.push(configClass);
                    try {
                        processConfigurationClass(candidate.asConfigClass(configClass));
                    }
                    finally {
                        this.importStack.pop();
                    }
                }
            }
        }
    }

• 这里特别需要关心的是@Import注解的处理，也就是processImports()方法,把这行代码单独拿出来

 processImports(configClass, sourceClass, getImports(sourceClass), true);

• 首先看参数getImports(sourceClass)

private Set<SourceClass> getImports(SourceClass sourceClass) throws IOException {
        Set<SourceClass> imports = new LinkedHashSet<>();
        Set<SourceClass> visited = new LinkedHashSet<>();

                // 收集当前类上所有的import载入的class
        collectImports(sourceClass, imports, visited);
        return imports;
    }

• 具体收集的方式就是采用递归来获取，例如@SpringBootApplication，会一层一层进去找，直到最后找到AutoConfigurationPackages$Registrar,AutoConfigurationImportSelector,EnableConfigurationPropertiesRegistrar和ConfigurationPropertiesScanRegistrar

private void collectImports(SourceClass sourceClass, Set<SourceClass> imports, Set<SourceClass> visited)
            throws IOException {

        if (visited.add(sourceClass)) {
            for (SourceClass annotation : sourceClass.getAnnotations()) {
                String annName = annotation.getMetadata().getClassName();
                if (!annName.equals(Import.class.getName())) {
                    collectImports(annotation, imports, visited);
                }
            }
            imports.addAll(sourceClass.getAnnotationAttributes(Import.class.getName(), "value"));
        }
    }

• processImports()去标记哪些import的类需要延迟加载，最后回到ConfigurationClassParser的parser()方法进行处理,在下面这句代码

this.deferredImportSelectorHandler.process();

• DeferredImportSelectorHandler的process()方法

public void process() {
            List<DeferredImportSelectorHolder> deferredImports = this.deferredImportSelectors;
            this.deferredImportSelectors = null;
            try {
                if (deferredImports != null) {
                    DeferredImportSelectorGroupingHandler handler = new DeferredImportSelectorGroupingHandler();
                    deferredImports.sort(DEFERRED_IMPORT_COMPARATOR);
                    deferredImports.forEach(handler::register);
                    handler.processGroupImports();
                }
            }
            finally {
                this.deferredImportSelectors = new ArrayList<>();
            }
        }

• DefaultDeferredImportSelectorGroup的processGroupImports()方法

public void processGroupImports() {
            for (DeferredImportSelectorGrouping grouping : this.groupings.values()) {
           //grouping.getImports()就会调用
                grouping.getImports().forEach(entry -> {
                    ConfigurationClass configurationClass = this.configurationClasses.get(
                            entry.getMetadata());
                    try {
                        processImports(configurationClass, asSourceClass(configurationClass),
                                asSourceClasses(entry.getImportClassName()), false);
                    }
                    catch (BeanDefinitionStoreException ex) {
                        throw ex;
                    }
                    catch (Throwable ex) {
                        throw new BeanDefinitionStoreException(
                                "Failed to process import candidates for configuration class [" +
                                        configurationClass.getMetadata().getClassName() + "]", ex);
                    }
                });
            }
        }

• DeferredImportSelectorGrouping 的getImports方法

public Iterable<Group.Entry> getImports() {
            for (DeferredImportSelectorHolder deferredImport : this.deferredImports) {
            
this.group.process(deferredImport.getConfigurationClass().getMetadata(),
                        deferredImport.getImportSelector());
            }
 //调用import的selectImports()方法
            return this.group.selectImports();
        }

• AutoConfigurationImportSelector的getAutoConfigurationEntry()方法

protected AutoConfigurationImportSelector.AutoConfigurationEntry getAutoConfigurationEntry(AutoConfigurationMetadata 
autoConfigurationMetadata, AnnotationMetadata annotationMetadata) {
        if (!this.isEnabled(annotationMetadata)) {
            return EMPTY_ENTRY;
        } else {
            AnnotationAttributes attributes = this.getAttributes(annotationMetadata);

            // 遍历jar包读取spring.factories文件中的所有的类
            List<String> configurations = this.getCandidateConfigurations(annotationMetadata, attributes);
            configurations = this.removeDuplicates(configurations);
            Set<String> exclusions = this.getExclusions(annotationMetadata, attributes);
           
            //处理一些相关的排除的不需要的类
            this.checkExcludedClasses(configurations, exclusions);
            configurations.removeAll(exclusions);
            configurations = this.filter(configurations, autoConfigurationMetadata);
            this.fireAutoConfigurationImportEvents(configurations, exclusions);
            return new AutoConfigurationImportSelector.AutoConfigurationEntry(configurations, exclusions);
        }
    }

• 最后就是注册BeanDefinition了，这个在完成

this.reader.loadBeanDefinitions(configClasses);

• 最后是方便debug的流程图

  
  自动装配流程图

总结

Spring到底如何完成自动装配？简单点，应该是以下几个步骤:

• 1.spring在构造SpringApplication对象的时候确定web应用类型为SERVLET，同时完成监听器等操作，为后续解析自动装配jar包，构建spring环境做准备。

• 2.执行SpringApplication对象执行run()方法，最重要的两个步骤为准备好Environment环境以及创建spring上下文AnnotationConfigServletWebServerApplicationContext

• 3.准备好Spring上下文后，开始调用prepareContext将启动类的BeanDefintion创建好，调用refresh()方法执行spring的启动过程，最重要的是在执行到invokeBeanFactoryPostProcessors()方法的时候，会查找所有@Configuration类，并完成相应的BeanDefintion注册工作，以及循环查找启动类上的@Import注解，最终确定到一个非常重要的类AutoConfigurationImportSelector，Springboot调用该类的getCandidateConfigurations()方法去查找jar包中所有的spring.factories文件，并且解析得到这些文件配置的类，排除掉一些不必要加载的后最终调用loadBeanDefintions()方法，完成bean描述信息的注册，随后，这些BeanDefintions会跟随spring一步一步完成实例化，初始化，aware接口调用，BeanPostProcessor的postProcessBeforeInitialization()方法，初始化方法,BeanPostProcessor的postProcessAfterInitialization()方法的生命周期而被Spring管理

• 好难写，写的手痛