一文读懂Spring Boot启动原理

概述

开发过Spring Boot项目的小伙伴都知道spring boot项目搭建简单,一个启动类就能运行起来项目,那么它是如何运行的?通过什么方式去实现自动装配呢,今天就一起看看spring boot启动时都做了哪些事情。

如果你已经使用 Spring Boot 很久了,那么你可能知道我们需要在 Application 类或 Main 类中注解相当多的注解才能开始使用,比如说

@Configuration,启用基于Java的配置。
@ComponentScan 来启用组件扫描。
@EnableAutoConfiguration启用Spring Boot的自动配置功能。

但现在你只需用 @SpringBootApplication 来注解你的 Application 类,就可以做到这一切。

顺便说一下,这个注解从 Spring Boot 1.2开始就有了,这意味着如果你运行在较低版本的 Spring Boot 上,那么如果你需要这些功能,你仍然需要使用@Configuration、@CompnentScan 和 @EnableAutoConfiguration。

@SpringBootApplication 示例

下面是一个简单的例子,说明如何使用 @SpringBootApplication 注解来编写 Spring Boot 应用程序。

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

在 Spring Boot 应用程序中,Application 类有两个用途:配置和引导。首先,它是主要的 Spring 配置类,其次,它可以实现 Spring Boot 应用程序的自动配置。

@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) })
public @interface SpringBootApplication {
    @AliasFor(annotation = EnableAutoConfiguration.class)
    Class<?>[] exclude() default {};
    
    @AliasFor(annotation = EnableAutoConfiguration.class)
    String[] excludeName() default {};
    @AliasFor(annotation = ComponentScan.class, attribute = "basePackages")
    String[] scanBasePackages() default {};
    @AliasFor(annotation = ComponentScan.class, attribute = "basePackageClasses")
    Class<?>[] scanBasePackageClasses() default {};
    @AliasFor(annotation = ComponentScan.class, attribute = "nameGenerator")
    Class<? extends BeanNameGenerator> nameGenerator() default BeanNameGenerator.class;
    @AliasFor(annotation = Configuration.class)
    boolean proxyBeanMethods() default true;
}

从 @SpringBootApplication 源码可以看出 @SpringBootApplication = @SpringBootConfiguration + @ComponentScan + @EnableAutoConfiguration 。

@SpringBootApplication注解是以下三个Spring注解的组合,只需一行代码就能提供所有三个注解的功能。

@SpringBootConfiguration

这个注解将一个类标记为基于Java配置的配置类。如果你喜欢基于Java的配置而不是基于XML的配置,这一点就特别重要。

@ComponentScan

该注解使组件扫描成为可能,这样你创建的Web控制器类和其他组件将被自动发现,并在Spring应用上下文中注册为Bean。你编写的所有@Controller类将被该注解发现。

@EnableAutoConfiguration

这个注解可以启用Spring Boot惊人的自动配置功能,它可以为你自动配置很多东西。

另外我们还可以关注一下几个方法

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

根据 class 来排除,排除特定的类加入 spring 容器,传入参数 value 类型是 class 类型。

String[] excludeName() default {}:

根据 class name 来排除,排除特定的类加入 spring 容器,传入参数 value 类型是 class 的全类名字符串数组。

String[] scanBasePackages() default {}:

指定扫描包,参数是包名的字符串数组。

Class<?>[] scanBasePackageClasses() default {}:

扫描特定的包,参数类似是 Class 类型数组。

就拿 scanBasePackages 来举个例子:

@SpringBootApplication(scanBasePackages  = {"com.javanorth.controller"})

@SpringBootConfiguration

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Configuration
@Indexed
public @interface SpringBootConfiguration {
    @AliasFor(annotation = Configuration.class)
    boolean proxyBeanMethods() default true;
}

@SpringBootConfiguration 继承自 @Configuration,二者功能也一致,标注当前类是配置类,并会将当前类内声明的一个或多个以@Bean注解标记的方法的实例纳入到 Spring 容器中,并且实例名就是方法名。

@ComponentScan

可以通过该注解指定扫描某些包下包含如下注解的均自动注册为 spring beans:@Component、@Service、 @Repository、 @Controller等等 。使用方式例如:

@ComponentScan(basePackages = {"com.javanorth.controller"})

除了可以使用 @ComponentScan 注解来加载我们的 bean,还可以在 Application 类中使用 @Import 指定该类。 例如:

@Import(JdbcRepositoriesRegistrar.class)

@EnableAutoConfiguration

@EnableAutoConfiguration 的作用启动自动的配置,@EnableAutoConfiguration 注解的意思就是 Spring Boot 根据你添加的 jar 包来配置你项目的默认配置,比如根据 spring-boot-starter-web ,来判断你的项目是否需要添加了web mvc 和 tomcat,就会自动的帮你配置 web 项目中所需要的默认配置。简单点说就是它会根据定义在 classpath 下的类,自动的给你生成一些 Bean,并加载到 Spring 的 Context 中。

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

可以看到 import 引入了 AutoConfigurationImportSelector 类。该类使用了 Spring Core 包的 SpringFactoriesLoader 类的 loadFactoryNames() 方法。AutoConfigurationImportSelector 类实现了 DeferredImportSelector 接口,并实现了 selectImports 方法,用来导出Configuration 类。

public class AutoConfigurationImportSelector implements DeferredImportSelector, BeanClassLoaderAware,
        ResourceLoaderAware, BeanFactoryAware, EnvironmentAware, Ordered {
    @Override
    public String[] selectImports(AnnotationMetadata annotationMetadata) {
        if (!isEnabled(annotationMetadata)) {
            return NO_IMPORTS;
        }
        AutoConfigurationEntry autoConfigurationEntry = getAutoConfigurationEntry(annotationMetadata);
        return StringUtils.toStringArray(autoConfigurationEntry.getConfigurations());
    }
    protected AutoConfigurationEntry getAutoConfigurationEntry(AnnotationMetadata annotationMetadata) {
        if (!isEnabled(annotationMetadata)) {
            return EMPTY_ENTRY;
        }
        AnnotationAttributes attributes = getAttributes(annotationMetadata);
        List<String> configurations = getCandidateConfigurations(annotationMetadata, attributes);
        ...
        return new AutoConfigurationEntry(configurations, exclusions);
    }
    protected boolean isEnabled(AnnotationMetadata metadata) {
        if (getClass() == AutoConfigurationImportSelector.class) {
            return getEnvironment().getProperty(EnableAutoConfiguration.ENABLED_OVERRIDE_PROPERTY, Boolean.class, true);
        }
        return true;
    }
    protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
        List<String> configurations = SpringFactoriesLoader.loadFactoryNames(getSpringFactoriesLoaderFactoryClass(),
                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;
    }
}

导出的类是通过 SpringFactoriesLoader.loadFactoryNames() 读取了 classpath 下面的 META-INF/spring.factories 文件。

public final class SpringFactoriesLoader {
    public static final String FACTORIES_RESOURCE_LOCATION = "META-INF/spring.factories";
    public static List<String> loadFactoryNames(Class<?> factoryType, @Nullable ClassLoader classLoader) {
        ClassLoader classLoaderToUse = classLoader;
        if (classLoaderToUse == null) {
            classLoaderToUse = SpringFactoriesLoader.class.getClassLoader();
        }
        String factoryTypeName = factoryType.getName();
        return loadSpringFactories(classLoaderToUse).getOrDefault(factoryTypeName, Collections.emptyList());
    }
    private static Map<String, List<String>> loadSpringFactories(ClassLoader classLoader) {
        Map<String, List<String>> result = cache.get(classLoader);
        if (result != null) {
            return result;
        }
        result = new HashMap<>();
        try {
            Enumeration<URL> urls = classLoader.getResources(FACTORIES_RESOURCE_LOCATION);
            while (urls.hasMoreElements()) {
                URL url = urls.nextElement();
                UrlResource resource = new UrlResource(url);
                Properties properties = PropertiesLoaderUtils.loadProperties(resource);
                for (Map.Entry<?, ?> entry : properties.entrySet()) {
                    String factoryTypeName = ((String) entry.getKey()).trim();
                    String[] factoryImplementationNames =
                            StringUtils.commaDelimitedListToStringArray((String) entry.getValue());
                    for (String factoryImplementationName : factoryImplementationNames) {
                        result.computeIfAbsent(factoryTypeName, key -> new ArrayList<>())
                                .add(factoryImplementationName.trim());
                    }
                }
            }
            // Replace all lists with unmodifiable lists containing unique elements
            result.replaceAll((factoryType, implementations) -> implementations.stream().distinct()
                    .collect(Collectors.collectingAndThen(Collectors.toList(), Collections::unmodifiableList)));
            cache.put(classLoader, result);
        }
        catch (IOException ex) {
            throw new IllegalArgumentException("Unable to load factories from location [" +
                    FACTORIES_RESOURCE_LOCATION + "]", ex);
        }
        return result;
    }
}

这里列出了一部分自动配置的内容:

# Auto Configure
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
org.springframework.boot.autoconfigure.admin.SpringApplicationAdminJmxAutoConfiguration,\
org.springframework.boot.autoconfigure.aop.AopAutoConfiguration,\
org.springframework.boot.autoconfigure.amqp.RabbitAutoConfiguration,\
org.springframework.boot.autoconfigure.batch.BatchAutoConfiguration,\
org.springframework.boot.autoconfigure.cache.CacheAutoConfiguration,\
org.springframework.boot.autoconfigure.cassandra.CassandraAutoConfiguration,\
org.springframework.boot.autoconfigure.context.ConfigurationPropertiesAutoConfiguration,\
org.springframework.boot.autoconfigure.context.LifecycleAutoConfiguration,\
org.springframework.boot.autoconfigure.context.MessageSourceAutoConfiguration,\
org.springframework.boot.autoconfigure.context.PropertyPlaceholderAutoConfiguration,\
org.springframework.boot.autoconfigure.couchbase.CouchbaseAutoConfiguration,\
org.springframework.boot.autoconfigure.dao.PersistenceExceptionTranslationAutoConfiguration,\
org.springframework.boot.autoconfigure.data.cassandra.CassandraDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.cassandra.CassandraReactiveDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.cassandra.CassandraReactiveRepositoriesAutoConfiguration,\

如果你发现自动装配的 Bean 不是你想要的,你也可以 disable 它。比如说,我不想要自动装配 Database 的那些Bean:

@EnableAutoConfiguration(exclude  = {DataSourceAutoConfiguration.class})

@AutoConfigurationPackage

@EnableAutoConfiguration 又继承了@AutoConfigurationPackage,@AutoConfigurationPackage 会引导类(@SpringBootApplication标注的类)所在的包及下面所有子包里面的所有组件扫描到Spring容器。具体怎么实现的呢,我们来看代码,原来它 import 了 AutoConfigurationPackages.Registrar.class, 我们来看看它做了什么?

@Import(AutoConfigurationPackages.Registrar.class)
public @interface AutoConfigurationPackage {
    String[] basePackages() default {};
    Class<?>[] basePackageClasses() default {};
}
static class Registrar implements ImportBeanDefinitionRegistrar, DeterminableImports {
    @Override
    public void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
        register(registry, new PackageImports(metadata).getPackageNames().toArray(new String[0]));
    }
    @Override
    public Set<Object> determineImports(AnnotationMetadata metadata) {
        return Collections.singleton(new PackageImports(metadata));
    }
}

看代码就很容易理解,把注解扫描进来的package 全部给注册到 spring bean中。这样 Spring Boot 的自动配置也就完成了。

总结

经过这样的一番折腾,相信大家已经对 @SpringBootApplication 注解,有了一定的了解。也知道了@SpringBootApplication 怎么实现的Spring Boot 的自动配置功能。你可以只写这一行代码来启用基于Java的配置、组件扫描,并启用Spring Boot的自动配置功能。它使你的代码更具可读性。

  • 1
    点赞
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值