Spring Boot启动流程简要分析

       在学习玩SSM三大框架之后,深刻的认识到了框架的伟大,以及使用起来的快捷以及方便,近期开始学习Spring Boot框架,在Spring Boot的框架中,它更是将框架的使用精简到了另一中地步,今天我们来简要分析一下Spring Boot的启动流程.

以下是Spring Boot一个最简单的程序:

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

1.由@SpringBootApplication注解开始.

   在@SpringBootApplication注解中,含有@EnableAutoConfiguration注解

   大家看到EnableAuto这几个字样肯定不会陌生,字面上的意思就是指开启自动配置.

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(
    excludeFilters = {@Filter(
    type = FilterType.CUSTOM,
    classes = {TypeExcludeFilter.class}
), @Filter(
    type = FilterType.CUSTOM,
    classes = {AutoConfigurationExcludeFilter.class}
)}
)

2.随即我们进入@EnableAutoConfiguration中

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage
@Import({AutoConfigurationImportSelector.class})
public @interface EnableAutoConfiguration {
    String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration";

    Class<?>[] exclude() default {};

    String[] excludeName() default {};
}

  在进入到该类以后,我们看到了一个在以前Spring框架中经常使用到的一个注解@Import注解.

  在@EnableAutoConfiguration中用@Import注解导入了AutoConfigurationImportSelector选择器这个类.

  进入到AutoConfigurationImportSelector类中.

public String[] selectImports(AnnotationMetadata annotationMetadata) {
    if (!this.isEnabled(annotationMetadata)) {
        return NO_IMPORTS;
    } else {
        AutoConfigurationMetadata autoConfigurationMetadata = AutoConfigurationMetadataLoader.loadMetadata(this.beanClassLoader);
        AutoConfigurationImportSelector.AutoConfigurationEntry autoConfigurationEntry = this.getAutoConfigurationEntry(autoConfigurationMetadata, annotationMetadata);
        return StringUtils.toStringArray(autoConfigurationEntry.getConfigurations());
    }
}

    在AutoConfigurationImportSelector中有一个selectImports方法,改方法调用了一个名为getAutoConfigurationEntry的方法

 

protected AutoConfigurationImportSelector.AutoConfigurationEntry getAutoConfigurationEntry(AutoConfigurationMetadata autoConfigurationMetadata, AnnotationMetadata annotationMetadata) {
    if (!this.isEnabled(annotationMetadata)) {
        return EMPTY_ENTRY;
    } else {
        AnnotationAttributes attributes = this.getAttributes(annotationMetadata);
        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);
    }
}

        我们注意到,在getAutoConfigurationEntry方法中,调用了一个名为getCandidateConfigurations的方法用于获取configurations的配置文件.进入到getCandidateConfigurations方法中

protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
    List<String> configurations = SpringFactoriesLoader.loadFactoryNames(this.getSpringFactoriesLoaderFactoryClass(), this.getBeanClassLoader());
    Assert.notEmpty(configurations, "No auto configuration classes found in META-INF/spring.factories. If you are using a custom packaging, make sure that file is correct.");
    return configurations;
}

 

        在该方法中调用了一个名为loadFactoryNames方法,进入该方法中.

public static List<String> loadFactoryNames(Class<?> factoryType, @Nullable ClassLoader classLoader) {
    String factoryTypeName = factoryType.getName();
    return (List)loadSpringFactories(classLoader).getOrDefault(factoryTypeName, Collections.emptyList());
}

 

        方法调用loadSpringfacotries方法,最后在这个方法中加载到了所有jar中META-INF路径下的spring.facoties资源.

private static Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader) {
    MultiValueMap<String, String> result = (MultiValueMap)cache.get(classLoader);
    if (result != null) {
        return result;
    } else {
        try {
            Enumeration<URL> urls = classLoader != null ? classLoader.getResources("META-INF/spring.factories") : ClassLoader.getSystemResources("META-INF/spring.factories");
            LinkedMultiValueMap result = new LinkedMultiValueMap();

            while(urls.hasMoreElements()) {
                URL url = (URL)urls.nextElement();
                UrlResource resource = new UrlResource(url);
                Properties properties = PropertiesLoaderUtils.loadProperties(resource);
                Iterator var6 = properties.entrySet().iterator();

                while(var6.hasNext()) {
                    Entry<?, ?> entry = (Entry)var6.next();
                    String factoryTypeName = ((String)entry.getKey()).trim();
                    String[] var9 = StringUtils.commaDelimitedListToStringArray((String)entry.getValue());
                    int var10 = var9.length;

                    for(int var11 = 0; var11 < var10; ++var11) {
                        String factoryImplementationName = var9[var11];
                        result.add(factoryTypeName, factoryImplementationName.trim());
                    }
                }
            }

            cache.put(classLoader, result);
            return result;
        } catch (IOException var13) {
            throw new IllegalArgumentException("Unable to load factories from location [META-INF/spring.factories]", var13);
        }
    }
}

 

        当我们随机进入到一个jar包中的META-INF路径下的spring.factories配置文件中.

        可以发现Spring Boot会将所有带有AutoConfiguration的全限定类名加载进configurations中,然后通过获得到的configurations开始自动加载组件到IOC容器中.

       如HttpEncodingAutoConfiguration类,就将用于解码的拦截器自动配置并加入了IOC容器.