Java SpringBoot

概述

先来了解一下 @SpringBootApplication 是什么，以及如何在一个简单的 Spring Boot 应用程序中使用它。先看看 Spring Team 在源码中对它的定义是什么？

Indicates a configuration class that declares one or more @Bean methods and also triggers auto-configuration and component scanning. This is a convenience annotation that is equivalent to declaring @Configuration, @EnableAutoConfiguration and @ComponentScan.

表示一个配置类，它声明了一个或多个@Bean方法，也触发了自动配置和组件扫描。这是一个方便的注解，相当于声明了@Configuration、@EnableAutoConfiguration和@ComponentScan。

从上面的定义可以看出，@SpringBootApplication 注解其实是一个组合注解。使用 @SpringBootApplication 相当于同时使用了 @Configuration、@EnableAutoConfiguration 和 @ComponentScan 。@SpringBootApplication 是在 Spring Boot 1.2.0 之后才开始有的，如果项目使用的 Spring Boot 1.2.0 之前的版本，那就不能使用这个注解，只能完整的使用那 3 个注解来代替它。
接下来看看，通过一个简单的示例来看看怎么使用的。

@SpringBootApplication 示例

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

  1. import org.springframework.boot.SpringApplication;
  2. import org.springframework.boot.autoconfigure.SpringBootApplication;
  4. @SpringBootApplication
  5. public class Application {
  6.     public static void main(String[] args) {
  7.         SpringApplication.run(Application.class, args);
  8.     }
  9. }

Spring Boot 项目的启动类非常的简洁，没有一行多余的代码。@SpringBootApplication 放在项目启动类上主要起到了自动化配置的作用。下面看看 @SpringBootApplication 具体的代码。

  1. @Target(ElementType.TYPE)
  2. @Retention(RetentionPolicy.RUNTIME)
  3. @Documented
  4. @Inherited
  5. @SpringBootConfiguration
  6. @EnableAutoConfiguration
  7. @ComponentScan(excludeFilters = { @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
  8.         @Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
  9. public @interface SpringBootApplication {
  10.     @AliasFor(annotation = EnableAutoConfiguration.class)
  11.     Class<?>[] exclude() default {};
  13.     @AliasFor(annotation = EnableAutoConfiguration.class)
  14.     String[] excludeName() default {};
  15.     @AliasFor(annotation = ComponentScan.class, attribute = "basePackages")
  16.     String[] scanBasePackages() default {};
  17.     @AliasFor(annotation = ComponentScan.class, attribute = "basePackageClasses")
  18.     Class<?>[] scanBasePackageClasses() default {};
  19.     @AliasFor(annotation = ComponentScan.class, attribute = "nameGenerator")
  20.     Class<? extends BeanNameGenerator> nameGenerator() default BeanNameGenerator.class;
  21.     @AliasFor(annotation = Configuration.class)
  22.     boolean proxyBeanMethods() default true;
  23. }

从 @SpringBootApplication 源码可以看出 @SpringBootApplication = @SpringBootConfiguration + @ComponentScan + @EnableAutoConfiguration 。
前面已经提过了，@SpringBootApplication 是3个注解的组合，下面分别介绍一下每个注解都有什么作用吧。

@SpringBootConfiguration

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

@ComponentScan

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

@EnableAutoConfiguration

这个注解可以启用 Spring Boot 自动配置功能。
如果仔细的话会发现和前面讲的不一样， @SpringBootConfiguration 是从那里冒出来的，不是应该是 @Configuration 吗？

@SpringBootConfiguration

  1. @Target(ElementType.TYPE)
  2. @Retention(RetentionPolicy.RUNTIME)
  3. @Documented
  4. @Configuration
  5. @Indexed
  6. public @interface SpringBootConfiguration {
  7.     @AliasFor(annotation = Configuration.class)
  8.     boolean proxyBeanMethods() default true;
  9. }

从源码可以看出，@SpringBootConfiguration 继承自 @Configuration，二者功能也一致，标注当前类是配置类，不过 @SpringBootConfiguration 是一个特殊的标记类，在项目中只能使用一次。

@ComponentScan

  1. @Retention(RetentionPolicy.RUNTIME)
  2. @Target(ElementType.TYPE)
  3. @Documented
  4. @Repeatable(ComponentScans.class)
  5. public @interface ComponentScan {
  6.     @AliasFor("basePackages")
  7.     String[] value() default {};
  8.     @AliasFor("value")
  9.     String[] basePackages() default {};
  10.     Class<?>[] basePackageClasses() default {};
  11.     Class<? extends BeanNameGenerator> nameGenerator() default BeanNameGenerator.class;
  12.     Class<? extends ScopeMetadataResolver> scopeResolver() default AnnotationScopeMetadataResolver.class;
  13.     ScopedProxyMode scopedProxy() default ScopedProxyMode.DEFAULT;
  14.     ...
  15. }

@ComponentScan 可以通过该注解指定扫描某些包下包含如下注解的均自动注册为 Spring beans：@Component、@Service、 @Repository、 @Controller 等等注释的类。Spring Boot 除了可以使用 @ComponentScan 注解来加载bean，还可以使用 @Import 指定该类。

@EnableAutoConfiguration

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

  1. @Target(ElementType.TYPE)
  2. @Retention(RetentionPolicy.RUNTIME)
  3. @Documented
  4. @Inherited
  5. @AutoConfigurationPackage
  6. @Import(AutoConfigurationImportSelector.class)
  7. public @interface EnableAutoConfiguration {
  8.     String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration";
  9.     Class<?>[] exclude() default {};
  10.     String[] excludeName() default {};
  11. }

从上述源码中可以看到 @Import 引入了 AutoConfigurationImportSelector 类。AutoConfigurationImportSelector 使用了 Spring Core 包的 SpringFactoriesLoader#loadFactoryNames() 方法。AutoConfigurationImportSelector 类实现了 DeferredImportSelector 接口，并实现了 selectImports 方法，用来导出 Configuration 类。

  1. public class AutoConfigurationImportSelector implements DeferredImportSelector, BeanClassLoaderAware,
  2.         ResourceLoaderAware, BeanFactoryAware, EnvironmentAware, Ordered {
  3.     @Override
  4.     public String[] selectImports(AnnotationMetadata annotationMetadata) {
  5.         if (!isEnabled(annotationMetadata)) {
  6.             return NO_IMPORTS;
  7.         }
  8.         AutoConfigurationEntry autoConfigurationEntry = getAutoConfigurationEntry(annotationMetadata);
  9.         return StringUtils.toStringArray(autoConfigurationEntry.getConfigurations());
  10.     }
  11.     protected AutoConfigurationEntry getAutoConfigurationEntry(AnnotationMetadata annotationMetadata) {
  12.         if (!isEnabled(annotationMetadata)) {
  13.             return EMPTY_ENTRY;
  14.         }
  15.         AnnotationAttributes attributes = getAttributes(annotationMetadata);
  16.         List<String> configurations = getCandidateConfigurations(annotationMetadata, attributes);
  17.         ...
  18.         return new AutoConfigurationEntry(configurations, exclusions);
  19.     }
  20.     protected boolean isEnabled(AnnotationMetadata metadata) {
  21.         if (getClass() == AutoConfigurationImportSelector.class) {
  22.             return getEnvironment().getProperty(EnableAutoConfiguration.ENABLED_OVERRIDE_PROPERTY, Boolean.class, true);
  23.         }
  24.         return true;
  25.     }
  26.     protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
  27.         List<String> configurations = SpringFactoriesLoader.loadFactoryNames(getSpringFactoriesLoaderFactoryClass(),
  28.                 getBeanClassLoader());
  29.         Assert.notEmpty(configurations, "No auto configuration classes found in META-INF/spring.factories. If you "
  30.                 + "are using a custom packaging, make sure that file is correct.");
  31.         return configurations;
  32.     }
  33. }

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

  1. public final class SpringFactoriesLoader {
  2.     public static final String FACTORIES_RESOURCE_LOCATION = "META-INF/spring.factories";
  3.     public static List<String> loadFactoryNames(Class<?> factoryType, @Nullable ClassLoader classLoader) {
  4.         ClassLoader classLoaderToUse = classLoader;
  5.         if (classLoaderToUse == null) {
  6.             classLoaderToUse = SpringFactoriesLoader.class.getClassLoader();
  7.         }
  8.         String factoryTypeName = factoryType.getName();
  9.         return loadSpringFactories(classLoaderToUse).getOrDefault(factoryTypeName, Collections.emptyList());
  10.     }
  11.     private static Map<String, List<String>> loadSpringFactories(ClassLoader classLoader) {
  12.         Map<String, List<String>> result = cache.get(classLoader);
  13.         if (result != null) {
  14.             return result;
  15.         }
  16.         result = new HashMap<>();
  17.         try {
  18.             Enumeration<URL> urls = classLoader.getResources(FACTORIES_RESOURCE_LOCATION);
  19.             while (urls.hasMoreElements()) {
  20.                 URL url = urls.nextElement();
  21.                 UrlResource resource = new UrlResource(url);
  22.                 Properties properties = PropertiesLoaderUtils.loadProperties(resource);
  23.                 for (Map.Entry<?, ?> entry : properties.entrySet()) {
  24.                     String factoryTypeName = ((String) entry.getKey()).trim();
  25.                     String[] factoryImplementationNames =
  26.                             StringUtils.commaDelimitedListToStringArray((String) entry.getValue());
  27.                     for (String factoryImplementationName : factoryImplementationNames) {
  28.                         result.computeIfAbsent(factoryTypeName, key -> new ArrayList<>())
  29.                                 .add(factoryImplementationName.trim());
  30.                     }
  31.                 }
  32.             }
  33.             // Replace all lists with unmodifiable lists containing unique elements
  34.             result.replaceAll((factoryType, implementations) -> implementations.stream().distinct()
  35.                     .collect(Collectors.collectingAndThen(Collectors.toList(), Collections::unmodifiableList)));
  36.             cache.put(classLoader, result);
  37.         }
  38.         catch (IOException ex) {
  39.             throw new IllegalArgumentException("Unable to load factories from location [" +
  40.                     FACTORIES_RESOURCE_LOCATION + "]", ex);
  41.         }
  42.         return result;
  43.     }
  44. }

META-INF/spring.factories 文件中一部分自动配置的内容：

  1. # Auto Configure
  2. org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
  3. org.springframework.boot.autoconfigure.admin.SpringApplicationAdminJmxAutoConfiguration,\
  4. org.springframework.boot.autoconfigure.aop.AopAutoConfiguration,\
  5. org.springframework.boot.autoconfigure.amqp.RabbitAutoConfiguration,\
  6. org.springframework.boot.autoconfigure.batch.BatchAutoConfiguration,\
  7. org.springframework.boot.autoconfigure.cache.CacheAutoConfiguration,\
  8. org.springframework.boot.autoconfigure.cassandra.CassandraAutoConfiguration,\
  9. org.springframework.boot.autoconfigure.context.ConfigurationPropertiesAutoConfiguration,\
  10. org.springframework.boot.autoconfigure.context.LifecycleAutoConfiguration,\
  11. org.springframework.boot.autoconfigure.context.MessageSourceAutoConfiguration,\
  12. org.springframework.boot.autoconfigure.context.PropertyPlaceholderAutoConfiguration,\
  13. org.springframework.boot.autoconfigure.couchbase.CouchbaseAutoConfiguration,\
  14. org.springframework.boot.autoconfigure.dao.PersistenceExceptionTranslationAutoConfiguration,\
  15. org.springframework.boot.autoconfigure.data.cassandra.CassandraDataAutoConfiguration,\
  16. org.springframework.boot.autoconfigure.data.cassandra.CassandraReactiveDataAutoConfiguration,\
  17. org.springframework.boot.autoconfigure.data.cassandra.CassandraReactiveRepositoriesAutoConfiguration,\

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

  1. @EnableAutoConfiguration(exclude  = {DataSourceAutoConfiguration.class})

这也是一种为 Spring Boot 项目瘦身的方法。可以看到网上一些为项目瘦身的方法都是通过这个注解来操作的。

@AutoConfigurationPackage

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

  1. @Import(AutoConfigurationPackages.Registrar.class)
  2. public @interface AutoConfigurationPackage {
  3.     String[] basePackages() default {};
  4.     Class<?>[] basePackageClasses() default {};
  5. }
  6. static class Registrar implements ImportBeanDefinitionRegistrar, DeterminableImports {
  7.     @Override
  8.     public void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
  9.         register(registry, new PackageImports(metadata).getPackageNames().toArray(new String[0]));
  10.     }
  11.     @Override
  12.     public Set<Object> determineImports(AnnotationMetadata metadata) {
  13.         return Collections.singleton(new PackageImports(metadata));
  14.     }
  15. }

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