SpringBoot自动配置的全面理解（面试核心）

发布于：2024-09-18 ⋅ 阅读:(162) ⋅ 点赞:(0)

Spring Boot 的自动配置（Auto-Configuration）是其核心特性之一，它极大地简化了 Spring 应用的初始搭建以及开发过程。自动配置让开发者能够快速启动和运行 Spring 应用，而无需进行大量的配置。

什么是自动配置？

Spring Boot 的自动配置是在应用启动时根据添加的 jar 依赖自动配置 Spring 框架的行为。例如，如果 spring-boot-starter-web 依赖被添加到项目中，Spring Boot 会自动配置 Tomcat 和 Spring MVC。

自动配置的工作原理

  1. @EnableAutoConfiguration：这是自动配置的入口，它告诉 Spring Boot 基于classpath中的 jar 依赖为你的应用进行自动配置。@EnableAutoConfiguration 实际上是 @AutoConfigurationPackage 和 @Import(AutoConfigurationImportSelector.class) 的组合。

  2. @Conditional 注解*：Spring Boot 提供了一系列的 @Conditional* 注解，这些注解用来决定一个配置类是否应该被注册。例如，@ConditionalOnClass 会检查某个类是否在 classpath 中，如果是，则条件匹配，配置类会被注册。

  3. SpringFactoriesLoader：这个类位于 org.springframework.core.io.support 包下，它会在应用启动时加载 META-INF/spring.factories 文件中指定的配置。这个文件中可以指定多个自动配置类，这些类会被 Spring Boot 加载。

  4. 自动配置类：这些类通常以 AutoConfiguration 结尾，它们使用 @Configuration 注解。自动配置类可以定义 beans，也可以通过 @Import 引入其他配置类。

  5. 自动配置报告：Spring Boot 还提供了自动配置报告，可以通过 application.properties 或 application.yml 文件中的 spring.boot.show-banner=false 来控制是否显示启动时的自动配置报告。

自动配置的自定义

虽然自动配置极大地简化了配置，但在某些情况下，开发者可能需要自定义自动配置的行为。Spring Boot 允许通过以下几种方式来自定义自动配置：

  1. 通过 application.properties 或 application.yml 文件：通过这些配置文件，可以覆盖自动配置的默认值。

  2. 通过创建自己的配置类：可以创建带有 @Configuration 注解的类，并使用 @Conditional 注解来覆盖或添加新的配置。

  3. 通过 @Enable* 注解：可以使用 Spring Boot 提供的各种 @Enable* 注解来启用或禁用特定的自动配置。

  4. 通过 exclude 属性：在 @SpringBootApplication 注解中，可以使用 exclude 属性来排除某些自动配置类。

深入理解

要深入理解 Spring Boot 的自动配置，需要查看 Spring Boot 的源码，特别是 org.springframework.boot.autoconfigure 包下的类。此外，了解 Spring Framework 的核心概念，如 IoC 容器、依赖注入、Java Config、Profile 等，也是非常重要的。

自动配置是 Spring Boot 快速开发的关键，但它也可能导致一些难以调试的问题，因为很多配置都是隐式的。因此，理解自动配置的工作原理对于开发和维护 Spring Boot 应用至关重要。
Spring Boot 的自动配置原理可以通过分析其源码来进一步理解。以下是一些关键的类和接口，以及它们在自动配置中的作用：

1. @EnableAutoConfiguration

这个注解是自动配置的入口点，它通过 @Import 导入了 AutoConfigurationImportSelector 类。

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

    /**
     * Exclude specific auto-configuration classes such that they will not be
     * considered for registration.
     * @return the classes to exclude
     */
    Class<?>[] exclude() default {};
}

2. AutoConfigurationImportSelector

这个类实现了 DeferredImportSelector 接口，它负责根据条件选择要导入的自动配置类。

public class AutoConfigurationImportSelector
        implements DeferredImportSelector, BeanFactoryAware, EnvironmentAware, ResourceLoaderAware, ConfigurationClassParser.DeferredConfiguration {

    private static final String[] EMPTY_CONDITION_CLASS_ARRAY = new String[0];

    private final AutoConfigurationMetadata autoConfigurationMetadata =
            new AutoConfigurationMetadata();

    @Override
    public String[] selectImports(AnnotationMetadata annotationMetadata) {
        if (!isEnabled(annotationMetadata)) {
            return NO_IMPORTS;
        }

        AutoConfigurationEntry autoConfigurationEntry = getAutoConfigurationEntry(annotationMetadata);
        return autoConfigurationEntry.getConfigurations();
    }

    private boolean isEnabled(AnnotationMetadata metadata) {
        Map<String, Object> attributes = metadata.getAnnotationAttributes(
                EnableAutoConfiguration.class.getName(), true, true);
        ...
    }

    private AutoConfigurationEntry getAutoConfigurationEntry(AnnotationMetadata metadata) {
        List<String> configurations = getCandidateConfigurations(metadata, attributes);
        configurations = removeDuplicates(configurations);
        configurations = sort(configurations, metadata);
        Set<String> exclusions = getExclusions(metadata, attributes);
        checkExcludedClasses(configurations, exclusions);
        fireAutoConfigurationImportEvents(configurations, exclusions);
        return new AutoConfigurationEntry(configurations, exclusions);
    }

    ...
}

3. SpringFactoriesLoader

这个类负责从 META-INF/spring.factories 文件中加载自动配置类。

public abstract class SpringFactoriesLoader {

    public static List<String> loadFactoryNames(Class<?> factoryType, ClassLoader classLoader) {
        String factoryClassNames = loadSpringFactories(classLoader);
        return (factoryClassNames != null ? Arrays.asList(factoryType.cast(
                StringUtils.commaDelimitedListToStringArray(factoryClassNames)) : Collections.emptyList());
    }

    private static String loadSpringFactories(ClassLoader classLoader) {
        ...
        try {
            Enumeration<URL> urls = (classLoader != null ? classLoader.getResources("META-INF/spring.factories") :
                   ClassLoader.getSystemResources("META-INF/spring.factories"));
            while (urls.hasMoreElements()) {
                URL url = urls.nextElement();
                Properties properties = new Properties();
                InputStream is = url.openStream();
                try {
                    properties.load(is);
                }
                finally {
                    is.close();
                }
                String factoryClassNames = properties.getProperty(factoryType.getName());
                if (factoryClassNames != null) {
                    return factoryClassNames;
                }
            }
        }
        catch (IOException ex) {
            throw new IllegalArgumentException("Unable to load [META-INF/spring.factories] from the classpath.", ex);
        }
        return null;
    }

    ...
}

4. 条件注解

Spring Boot 提供了一系列的条件注解，如 @ConditionalOnClass、@ConditionalOnBean、@ConditionalOnMissingBean、@ConditionalOnProperty 等，这些注解用于控制自动配置类是否应该被注册。

@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Conditional(OnClassCondition.class)
public @interface ConditionalOnClass {
    Class<?>[] value() default {};
    String name() default "";
}

5. 自动配置类

自动配置类通常以 AutoConfiguration 结尾，并且使用 @Configuration 注解。这些类中定义了根据条件创建的 beans。

@Configuration
@ConditionalOnClass({Servlet.class, DispatcherServlet.class})
@ConditionalOnWebApplication
public class DispatcherServletAutoConfiguration {
    ...
}

6. 自动配置报告

Spring Boot 还提供了自动配置报告，它显示了哪些自动配置类被加载，以及为什么被加载或不被加载。

@Configuration
public class AutoConfigurationReportConfiguration {

    private final EnableAutoConfigurationImportListener enableAutoConfigurationImportListener;

    public AutoConfigurationReportConfiguration(EnableAutoConfigurationImportListener enableAutoConfigurationImportListener) {
        this.enableAutoConfigurationImportListener = enableAutoConfigurationImportListener;
    }

    @Bean
    @Order(Ordered.HIGHEST_PRECEDENCE)
    public AutoConfigurationReport autoConfigurationReport() {
        return new AutoConfigurationReport(this.enableAutoConfigurationImportListener.getAutoConfigurationEntry());
    }

    ...
}

通过分析这些关键的类和接口，我们可以更深入地理解 Spring Boot 的自动配置是如何工作的。自动配置通过条件注解来决定哪些配置应该被加载，并且可以通过 spring.factories 文件来扩展或自定义。这些机制共同工作，使得 Spring Boot 应用的配置变得非常灵活和强大。

网站公告

今日签到

点亮在社区的每一天
去签到

热门文章

最新发布