关于Spring Boot启动类的启动原理及源码分析

关于Spring Boot启动类的启动原理及源码分析

①启动原理

使用springboot创建项目，首先说明，springboot是时候一种简化开发的一种框架，是基于spring基础的一种框架。
springboot项目通过主方法的方式来启动，并且试过@SpringBootApplication注解来标记当前类为主启动类

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

以上代码，就可以完成springboot项目的启动（说明：如果说是maven，在此之前需要配置pom.xml，将spring-boot-starter和spring-boot-starter-web两个依赖配置，这样才是一个真正的web项目）

②注解解析

@SpringBootApplication注解：标记当前类为一个springboot应用，并且启动类下的所有资源都被导入（是一个自动配置的过程）。通过ctrl点击进去@SpringBootApplication注解，

@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}
)}
)

@SpringBootConfiguration

这里面有几个很重要的注解，我们一一解析，通过@SpringBootApplication注解点进来之后，可以看到有七个注解，我就挑几个很重要的注解讲解。

@SpringBootConfiguration：通过名字可以知道是一个Springboot的一个配置类，我们再往里面追

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Configuration

看最后一个注解@Configuration：说明是spring的配置类(这个注解在学spring的时候就已经出现过了，所以很好说明，springboot是通过spring再整合得出的结果)。我们再次追加

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Component

看到这里就明白了，原来这是一个组件，也就是说我们启动类也就是一个组件，回忆刚才说的主启动类追源码的 时候，@SpringBootApplication—>@SpringBootConfiguration—>Configuration—>@Component。

@EnableAutoConfiguration

追源码进去

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage
@Import({AutoConfigurationImportSelector.class})

@AutoConfigurationPackage：自动配置包

@AutoConfigurationPackage注解的作用是将 添加该注解的类所在的package 作为 自动配置package 进行管理。如果说有迷惑的，典型的像MyBatis的@Mapper注解类扫描就是基于自动配置package进行的	。

```java
@Import({Registrar.class})
```
追进入之后，@Import({Registrar.class})这个是一个自动配置包注册

@Import({AutoConfigurationImportSelector.class})：引入自动配置选择器

 AutoConfigurationImportSelector.AutoConfigurationEntry autoConfigurationEntry = this.getAutoConfigurationEntry(autoConfigurationMetadata, annotationMetadata);

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

以上为源码分享，其中List configurations = this.getCandidateConfigurations(annotationMetadata, attributes);获取候选的配置，点开getCandidateConfigurations方法之后可以看到，需要返回一个List集合

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;
    }

this.getSpringFactoriesLoaderFactoryClass()这个方法最终就是为了获取一个标注了EnableAutoConfiguration注解的类

protected Class<?> getSpringFactoriesLoaderFactoryClass() {
        return EnableAutoConfiguration.class;
    }

this.getBeanClassLoader()获取bean实体

protected ClassLoader getBeanClassLoader() {
        return this.beanClassLoader;
    }

再进入loadFactoryNames()方法

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

获取工厂名字；继续追加loadSpringFactories()方法

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 factoryClassName = ((String)entry.getKey()).trim();
                        String[] var9 = StringUtils.commaDelimitedListToStringArray((String)entry.getValue());
                        int var10 = var9.length;

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

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

首先说明Enumeration urls = classLoader != null ? classLoader.getResources(“META-INF/spring.factories”) : ClassLoader.getSystemResources(“META-INF/spring.factories”);这行代码的作用：是用来获取当前项目和系统项目在spirng.factories配置文件中的项目注解，从这个配置文件中获取到所有的Element(自动配置)，然后再通过while循环来遍历这个枚举类，再封装到Properties配置类中，供我们使用。
一般spring.factories这个配置类在我们导入的jar包中的spring-boot-autoconfigure/META-INF/spring.factories

@ComponentScan

扫描与主启动类同级的包，所以有一个坑大家得注意，主启动类要创建在与其他同级的目录下

原理就写这么多了，如果有什么意见，请评论下方，我会尽快修改