@SpringBootApplication
@SpringBootApplication
public class DemoApplication {
public static void main(String[] args) {
SpringApplication.run(DemoApplication.class, args);
}
}
从启动类开始，springboot应用从标注有@SpringBootApplication注解的类开始启动，
该注解是一个组合注解。由@SpringBootConfiguration、@EnableAutoConfiguration和@ComponentScan三个子注解组成
.....
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(
excludeFilters = {@Filter(
type = FilterType.CUSTOM,
classes = {TypeExcludeFilter.class}
), @Filter(
type = FilterType.CUSTOM,
classes = {AutoConfigurationExcludeFilter.class}
)}
)
public @interface SpringBootApplication {
// .......
}
@SpringBootConfiguration
这个注解包含了@Configuration，@Configuration里面又包含了一个@Component注解，也就是说，这个注解标注在哪个类上，就表示当前这个类是一个配置类，而配置类也是Spring容器中的组件。
@ComponentScan
@ComponentScan：它的作用就是根据定义的扫描路径，把符合扫描规则的类装配到Spring容器中，以待后续使用（让其实例化）。
@EnableAutoConfiguration
根据名称，可以猜测它应该是开启自动配置的一个注解。
@EnableAutoConfiguration它里面又包含了两个注解，分别是
- @AutoConfigurationPackage
- @Import(AutoConfigurationImportSelector.class)
.....
@AutoConfigurationPackage
@Import({AutoConfigurationImportSelector.class})
public @interface EnableAutoConfiguration {
String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration";
Class<?>[] exclude() default {};
String[] excludeName() default {};
}
其中@AutoConfigurationPackage主要作用是标识自动配置的包，这样Spring Boot在启动时就可以自动扫描该包及其子包下的类，并将其纳入自动配置的范围。
而@Import(AutoConfigurationImportSelector.class)则是将配置类信息交给SpringFactory加载器进行一系列的容器创建过程。
@AutoConfigurationPackage
@AutoConfigurationPackage：该注解包含了@Import({Registrar.class})
@Import({Registrar.class})
public @interface AutoConfigurationPackage {
String[] basePackages() default {};
Class<?>[] basePackageClasses() default {};
}
它利用Registrar给容器中导入一系列组件，将指定的一个包下的所有组件导入进来，该指定包：即为该注解所在的包也就是@SpringBootApplication-启动类所在的包
以下是对应部分源码(AutoConfigurationPackages)的实现：
public static void register(BeanDefinitionRegistry registry, String... packageNames) {
if (registry.containsBeanDefinition(BEAN)) {
AutoConfigurationPackages.BasePackagesBeanDefinition beanDefinition = (AutoConfigurationPackages.BasePackagesBeanDefinition)registry.getBeanDefinition(BEAN);
beanDefinition.addBasePackages(packageNames);
} else {
registry.registerBeanDefinition(BEAN, new AutoConfigurationPackages.BasePackagesBeanDefinition(packageNames));
}
}
static final class BasePackagesBeanDefinition extends GenericBeanDefinition {
private final Set<String> basePackages = new LinkedHashSet();
BasePackagesBeanDefinition(String... basePackages) {
this.setBeanClass(AutoConfigurationPackages.BasePackages.class);
this.setRole(2);
this.addBasePackages(basePackages);
}
public Supplier<?> getInstanceSupplier() {
return () -> {
return new AutoConfigurationPackages.BasePackages(StringUtils.toStringArray(this.basePackages));
};
}
private void addBasePackages(String[] additionalBasePackages) {
this.basePackages.addAll(Arrays.asList(additionalBasePackages));
}
}
@Import({AutoConfigurationImportSelector.class})
AutoConfigurationImportSelector类通过selectImports方法，将配置类信息交给SpringFactory加载器进行一系列的容器创建。
- 利用getAutoConfigurationEntry(annotationMetadata);给容器中批量导入一些组件
- 调用List< String> configurations = getCandidateConfigurations(annotationMetadata, attributes)获取到所有需要导入到容器中的配置类
- 利用工厂加载 Map<String, List< String>> loadSpringFactories(@Nullable ClassLoader classLoader)；得到所有的组件
- 从META-INF/spring.factories位置来加载一个文件。 默认扫描我们当前系统里面所有META-INF/spring.factories位置的文件 spring-boot-autoconfigure-2.3.4.RELEASE.jar包里面也有META-INF/spring.factories
以下是对应的部分源码：
// AutoConfigurationImportSelector调用 selectImports
public String[] selectImports(AnnotationMetadata annotationMetadata) {
if (!this.isEnabled(annotationMetadata)) {
return NO_IMPORTS;
} else {
AutoConfigurationImportSelector.AutoConfigurationEntry autoConfigurationEntry = this.getAutoConfigurationEntry(annotationMetadata);
return StringUtils.toStringArray(autoConfigurationEntry.getConfigurations());
}
}
// ......
protected AutoConfigurationImportSelector.AutoConfigurationEntry getAutoConfigurationEntry(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.getConfigurationClassFilter().filter(configurations);
this.fireAutoConfigurationImportEvents(configurations, exclusions);
return new AutoConfigurationImportSelector.AutoConfigurationEntry(configurations, exclusions);
}
}
// 获取待用配置信息
protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
List<String> configurations = new ArrayList(SpringFactoriesLoader.loadFactoryNames(this.getSpringFactoriesLoaderFactoryClass(), this.getBeanClassLoader()));
ImportCandidates.load(AutoConfiguration.class, this.getBeanClassLoader()).forEach(configurations::add);
Assert.notEmpty(configurations, "No auto configuration classes found in META-INF/spring.factories nor in META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports. If you are using a custom packaging, make sure that file is correct.");
return configurations;
}
// 让springfactories 通过配置文件进行加载
public static List<String> loadFactoryNames(Class<?> factoryType, @Nullable ClassLoader classLoader) {
ClassLoader classLoaderToUse = classLoader;
if (classLoader == null) {
classLoaderToUse = SpringFactoriesLoader.class.getClassLoader();
}
String factoryTypeName = factoryType.getName();
return (List)loadSpringFactories(classLoaderToUse).getOrDefault(factoryTypeName, Collections.emptyList());
}
private static Map<String, List<String>> loadSpringFactories(ClassLoader classLoader) {
Map<String, List<String>> result = (Map)cache.get(classLoader);
if (result != null) {
return result;
} else {
HashMap result = new HashMap();
try {
Enumeration urls = classLoader.getResources("META-INF/spring.factories");
while(urls.hasMoreElements()) {
URL url = (URL)urls.nextElement();
UrlResource resource = new UrlResource(url);
Properties properties = PropertiesLoaderUtils.loadProperties(resource);
Iterator var6 = properties.entrySet().iterator();
//......
这里会加载一个名为META-INF/spring.factories的配置文件，该文件也是自定义starter的一个重要步骤
总结
虽然通过@EnableAutoConfiguration，会在容器中加载所有的bean
但实际确是只生效一部分，会按照条件装配规则（@Conditional），最终按需配置。
springboot中的自动装配流程:
- 启动 Spring Boot 应用：首先，你需要启动一个 Spring Boot 应用。这可以通过直接运行应用的主类（通常是一个带有
public static void main(String[] args)方法的类）来实现。当 Spring Boot 应用启动时，它会自动创建并初始化一个 Spring 应用上下文（ApplicationContext）。- 加载配置文件：Spring Boot 会加载应用类路径（classpath）下的配置文件。默认情况下，它会查找名为
application.properties或application.yml的文件。这些文件中包含了 Spring Boot 的配置信息，比如数据库连接、端口号等。- 创建 Bean：Spring Boot 会根据配置文件中的信息创建各种 Bean。例如，如果配置文件中指定了数据源的连接信息，Spring Boot 会自动创建一个数据源 Bean。这个过程是通过 Spring Boot 的自动配置特性实现的。
- 自动装配：在创建了各种 Bean 之后，Spring Boot 会根据这些 Bean 之间的关系进行自动装配。例如，如果一个类需要一个数据源，而 Spring Boot 已经创建了一个数据源 Bean，那么 Spring Boot 就会自动将这个数据源 Bean 注入到需要的类中。这个过程是通过 Spring 的依赖注入（DI）机制实现的。
- 应用启动：最后，当所有的 Bean 都已经被创建并装配好之后，Spring Boot 应用就可以正常运行了。
在整个过程中，Spring Boot 的
自动装配-autoConfigurationXXX特性发挥了很大的作用。它可以根据 Bean 的名称、类型、属性等信息来自动进行配置。
