Spring Boot（6）：spring boot自动配置原理入门，源码剖析

已于 2022-10-13 15:20:52 修改
阅读量1k 收藏 1
点赞数 1
分类专栏： # SpringBoot开发入门与实战 文章标签： spring boot java spring
于 2022-10-12 00:10:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43745578/article/details/127271427
版权

目录

学习前面几章大致了解一些注解的作用，下面看下spring boot如何实现自动配置的。

所谓的自动配置就是根据添加的jar包依赖，会自动将一些配置类的bean注册进ioc容器。

原理源码剖析过程

首先看下spring boot的核心注解：启动类上的SpringBootApplication注解。

看下源码：

package org.springframework.boot.autoconfigure;

import ...

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

这个注解主要集成了以下3个注解。

SpringBootConfiguration

源码如下：

package org.springframework.boot;

import ...

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

这个注解其实就是一个@Configuration，其实就代表当前类时一个配置类。也就是说我们的主程序类也是spring boot的一个配置类。

ComponentScan

用来指定扫描哪些，有自己的扫描器。

具体的源码这里先不了解。

EnableAutoConfiguration

最重要的注解。

源码如下：

package org.springframework.boot.autoconfigure;

import ...

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

其中又包含两个主要注解：

AutoConfigurationPackage

再看下源码：

package org.springframework.boot.autoconfigure;

import ...

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@Import({Registrar.class})
public @interface AutoConfigurationPackage {
    String[] basePackages() default {};

    Class<?>[] basePackageClasses() default {};
}

可以看到这个注解其实也是一个Import注解。他用来给容器导入一个AutoConfigurationPackages.Registrar。

这个Registrar的源码如下：

static class Registrar implements ImportBeanDefinitionRegistrar, DeterminableImports {
        Registrar() {
        }
		
		// 下面这个方法是核心方法
		// 用于导入一系列组件
		// 其中new AutoConfigurationPackages.PackageImports(metadata)).getPackageNames()是获取到了当前主程序所在包名。
        public void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
            AutoConfigurationPackages.register(registry, (String[])(new AutoConfigurationPackages.PackageImports(metadata)).getPackageNames().toArray(new String[0]));
        }

        public Set<Object> determineImports(AnnotationMetadata metadata) {
            return Collections.singleton(new AutoConfigurationPackages.PackageImports(metadata));
        }
    }

这个Registrar用于给容器中导入一系列组件。
其中new AutoConfigurationPackages.PackageImports(metadata)).getPackageNames()是获取到了当前主程序所在包名。所以spring boot默认才会扫描当前主程序所在包下所有配置注入Bean。

Import

这个注解导入了AutoConfigurationImportSelector组件。

看下这个组件源码，其中有三个主要方法如下：

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

首先是selectImports方法，主要目的是获取要导入的组件，返回一个字符串数组。

其中核心方法是this.getAutoConfigurationEntry方法。

其中这个方法又是主要通过this.getCandidateConfigurations方法来获取所有的要导入的候选组件。

然后其中又两个重要的方法，SpringFactoriesLoader.loadFactoryNames和 ImportCandidates.load方法。

注意：在spring boot 2.7.3以后已经弃用SpringFactoriesLoader.loadFactoryNames方法了，这里有只是为了兼容。

ImportCandidates.load源码如下：

public static ImportCandidates load(Class<?> annotation, ClassLoader classLoader) {
    Assert.notNull(annotation, "'annotation' must not be null");
    ClassLoader classLoaderToUse = decideClassloader(classLoader);
    String location = String.format("META-INF/spring/%s.imports", annotation.getName());
    Enumeration<URL> urls = findUrlsInClasspath(classLoaderToUse, location);
    ArrayList autoConfigurations = new ArrayList();

    while(urls.hasMoreElements()) {
        URL url = (URL)urls.nextElement();
        autoConfigurations.addAll(readAutoConfigurations(url));
    }

    return new ImportCandidates(autoConfigurations);
}

这个方法主要使用来找文件META-INF/spring/%s.imports中的组件。最后返回找到的组件数组。

在spring boot 2.7.3之前使用的SpringFactoriesLoader.loadFactoryNames方法是找文件META-INF/spring.properties中的组件。
是寻找

其中在依赖查看，比如，查看org.springframework.boot:spring-boot-autoconfigure包。如下：
在这里插入图片描述

打开文件spring\org.springframework.boot.autoconfigure.AutoConfiguration.imports，如下：

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
org.springframework.boot.autoconfigure.data.cassandra.CassandraRepositoriesAutoConfiguration
org.springframework.boot.autoconfigure.data.couchbase.CouchbaseDataAutoConfiguration
org.springframework.boot.autoconfigure.data.couchbase.CouchbaseReactiveDataAutoConfiguration
org.springframework.boot.autoconfigure.data.couchbase.CouchbaseReactiveRepositoriesAutoConfiguration
org.springframework.boot.autoconfigure.data.couchbase.CouchbaseRepositoriesAutoConfiguration
org.springframework.boot.autoconfigure.data.elasticsearch.ElasticsearchDataAutoConfiguration
org.springframework.boot.autoconfigure.data.elasticsearch.ElasticsearchRepositoriesAutoConfiguration
org.springframework.boot.autoconfigure.data.elasticsearch.ReactiveElasticsearchRepositoriesAutoConfiguration
org.springframework.boot.autoconfigure.data.elasticsearch.ReactiveElasticsearchRestClientAutoConfiguration
org.springframework.boot.autoconfigure.data.jdbc.JdbcRepositoriesAutoConfiguration
org.springframework.boot.autoconfigure.data.jpa.JpaRepositoriesAutoConfiguration
org.springframework.boot.autoconfigure.data.ldap.LdapRepositoriesAutoConfiguration
org.springframework.boot.autoconfigure.data.mongo.MongoDataAutoConfiguration
org.springframework.boot.autoconfigure.data.mongo.MongoReactiveDataAutoConfiguration
org.springframework.boot.autoconfigure.data.mongo.MongoReactiveRepositoriesAutoConfiguration
org.springframework.boot.autoconfigure.data.mongo.MongoRepositoriesAutoConfiguration
org.springframework.boot.autoconfigure.data.neo4j.Neo4jDataAutoConfiguration
org.springframework.boot.autoconfigure.data.neo4j.Neo4jReactiveDataAutoConfiguration
org.springframework.boot.autoconfigure.data.neo4j.Neo4jReactiveRepositoriesAutoConfiguration
org.springframework.boot.autoconfigure.data.neo4j.Neo4jRepositoriesAutoConfiguration
org.springframework.boot.autoconfigure.data.r2dbc.R2dbcDataAutoConfiguration
org.springframework.boot.autoconfigure.data.r2dbc.R2dbcRepositoriesAutoConfiguration
org.springframework.boot.autoconfigure.data.redis.RedisAutoConfiguration
org.springframework.boot.autoconfigure.data.redis.RedisReactiveAutoConfiguration
org.springframework.boot.autoconfigure.data.redis.RedisRepositoriesAutoConfiguration
org.springframework.boot.autoconfigure.data.rest.RepositoryRestMvcAutoConfiguration
org.springframework.boot.autoconfigure.data.web.SpringDataWebAutoConfiguration
org.springframework.boot.autoconfigure.elasticsearch.ElasticsearchRestClientAutoConfiguration
org.springframework.boot.autoconfigure.flyway.FlywayAutoConfiguration
org.springframework.boot.autoconfigure.freemarker.FreeMarkerAutoConfiguration
org.springframework.boot.autoconfigure.graphql.GraphQlAutoConfiguration
org.springframework.boot.autoconfigure.graphql.data.GraphQlReactiveQueryByExampleAutoConfiguration
org.springframework.boot.autoconfigure.graphql.data.GraphQlReactiveQuerydslAutoConfiguration
org.springframework.boot.autoconfigure.graphql.data.GraphQlQueryByExampleAutoConfiguration
org.springframework.boot.autoconfigure.graphql.data.GraphQlQuerydslAutoConfiguration
org.springframework.boot.autoconfigure.graphql.reactive.GraphQlWebFluxAutoConfiguration
org.springframework.boot.autoconfigure.graphql.rsocket.GraphQlRSocketAutoConfiguration
org.springframework.boot.autoconfigure.graphql.rsocket.RSocketGraphQlClientAutoConfiguration
org.springframework.boot.autoconfigure.graphql.security.GraphQlWebFluxSecurityAutoConfiguration
org.springframework.boot.autoconfigure.graphql.security.GraphQlWebMvcSecurityAutoConfiguration
org.springframework.boot.autoconfigure.graphql.servlet.GraphQlWebMvcAutoConfiguration
org.springframework.boot.autoconfigure.groovy.template.GroovyTemplateAutoConfiguration
org.springframework.boot.autoconfigure.gson.GsonAutoConfiguration
org.springframework.boot.autoconfigure.h2.H2ConsoleAutoConfiguration
org.springframework.boot.autoconfigure.hateoas.HypermediaAutoConfiguration
org.springframework.boot.autoconfigure.hazelcast.HazelcastAutoConfiguration
org.springframework.boot.autoconfigure.hazelcast.HazelcastJpaDependencyAutoConfiguration
org.springframework.boot.autoconfigure.http.HttpMessageConvertersAutoConfiguration
org.springframework.boot.autoconfigure.http.codec.CodecsAutoConfiguration
org.springframework.boot.autoconfigure.influx.InfluxDbAutoConfiguration
org.springframework.boot.autoconfigure.info.ProjectInfoAutoConfiguration
org.springframework.boot.autoconfigure.integration.IntegrationAutoConfiguration
org.springframework.boot.autoconfigure.jackson.JacksonAutoConfiguration
org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration
org.springframework.boot.autoconfigure.jdbc.JdbcTemplateAutoConfiguration
org.springframework.boot.autoconfigure.jdbc.JndiDataSourceAutoConfiguration
org.springframework.boot.autoconfigure.jdbc.XADataSourceAutoConfiguration
org.springframework.boot.autoconfigure.jdbc.DataSourceTransactionManagerAutoConfiguration
org.springframework.boot.autoconfigure.jms.JmsAutoConfiguration
org.springframework.boot.autoconfigure.jmx.JmxAutoConfiguration
org.springframework.boot.autoconfigure.jms.JndiConnectionFactoryAutoConfiguration
org.springframework.boot.autoconfigure.jms.activemq.ActiveMQAutoConfiguration
org.springframework.boot.autoconfigure.jms.artemis.ArtemisAutoConfiguration
org.springframework.boot.autoconfigure.jersey.JerseyAutoConfiguration
org.springframework.boot.autoconfigure.jooq.JooqAutoConfiguration
org.springframework.boot.autoconfigure.jsonb.JsonbAutoConfiguration
org.springframework.boot.autoconfigure.kafka.KafkaAutoConfiguration
org.springframework.boot.autoconfigure.availability.ApplicationAvailabilityAutoConfiguration
org.springframework.boot.autoconfigure.ldap.embedded.EmbeddedLdapAutoConfiguration
org.springframework.boot.autoconfigure.ldap.LdapAutoConfiguration
org.springframework.boot.autoconfigure.liquibase.LiquibaseAutoConfiguration
org.springframework.boot.autoconfigure.mail.MailSenderAutoConfiguration
org.springframework.boot.autoconfigure.mail.MailSenderValidatorAutoConfiguration
org.springframework.boot.autoconfigure.mongo.embedded.EmbeddedMongoAutoConfiguration
org.springframework.boot.autoconfigure.mongo.MongoAutoConfiguration
org.springframework.boot.autoconfigure.mongo.MongoReactiveAutoConfiguration
org.springframework.boot.autoconfigure.mustache.MustacheAutoConfiguration
org.springframework.boot.autoconfigure.neo4j.Neo4jAutoConfiguration
org.springframework.boot.autoconfigure.netty.NettyAutoConfiguration
org.springframework.boot.autoconfigure.orm.jpa.HibernateJpaAutoConfiguration
org.springframework.boot.autoconfigure.quartz.QuartzAutoConfiguration
org.springframework.boot.autoconfigure.r2dbc.R2dbcAutoConfiguration
org.springframework.boot.autoconfigure.r2dbc.R2dbcTransactionManagerAutoConfiguration
org.springframework.boot.autoconfigure.rsocket.RSocketMessagingAutoConfiguration
org.springframework.boot.autoconfigure.rsocket.RSocketRequesterAutoConfiguration
org.springframework.boot.autoconfigure.rsocket.RSocketServerAutoConfiguration
org.springframework.boot.autoconfigure.rsocket.RSocketStrategiesAutoConfiguration
org.springframework.boot.autoconfigure.security.servlet.SecurityAutoConfiguration
org.springframework.boot.autoconfigure.security.servlet.UserDetailsServiceAutoConfiguration
org.springframework.boot.autoconfigure.security.servlet.SecurityFilterAutoConfiguration
org.springframework.boot.autoconfigure.security.reactive.ReactiveSecurityAutoConfiguration
org.springframework.boot.autoconfigure.security.reactive.ReactiveUserDetailsServiceAutoConfiguration
org.springframework.boot.autoconfigure.security.rsocket.RSocketSecurityAutoConfiguration
org.springframework.boot.autoconfigure.security.saml2.Saml2RelyingPartyAutoConfiguration
org.springframework.boot.autoconfigure.sendgrid.SendGridAutoConfiguration
org.springframework.boot.autoconfigure.session.SessionAutoConfiguration
org.springframework.boot.autoconfigure.security.oauth2.client.servlet.OAuth2ClientAutoConfiguration
org.springframework.boot.autoconfigure.security.oauth2.client.reactive.ReactiveOAuth2ClientAutoConfiguration
org.springframework.boot.autoconfigure.security.oauth2.resource.servlet.OAuth2ResourceServerAutoConfiguration
org.springframework.boot.autoconfigure.security.oauth2.resource.reactive.ReactiveOAuth2ResourceServerAutoConfiguration
org.springframework.boot.autoconfigure.solr.SolrAutoConfiguration
org.springframework.boot.autoconfigure.sql.init.SqlInitializationAutoConfiguration
org.springframework.boot.autoconfigure.task.TaskExecutionAutoConfiguration
org.springframework.boot.autoconfigure.task.TaskSchedulingAutoConfiguration
org.springframework.boot.autoconfigure.thymeleaf.ThymeleafAutoConfiguration
org.springframework.boot.autoconfigure.transaction.TransactionAutoConfiguration
org.springframework.boot.autoconfigure.transaction.jta.JtaAutoConfiguration
org.springframework.boot.autoconfigure.validation.ValidationAutoConfiguration
org.springframework.boot.autoconfigure.web.client.RestTemplateAutoConfiguration
org.springframework.boot.autoconfigure.web.embedded.EmbeddedWebServerFactoryCustomizerAutoConfiguration
org.springframework.boot.autoconfigure.web.reactive.HttpHandlerAutoConfiguration
org.springframework.boot.autoconfigure.web.reactive.ReactiveMultipartAutoConfiguration
org.springframework.boot.autoconfigure.web.reactive.ReactiveWebServerFactoryAutoConfiguration
org.springframework.boot.autoconfigure.web.reactive.WebFluxAutoConfiguration
org.springframework.boot.autoconfigure.web.reactive.WebSessionIdResolverAutoConfiguration
org.springframework.boot.autoconfigure.web.reactive.error.ErrorWebFluxAutoConfiguration
org.springframework.boot.autoconfigure.web.reactive.function.client.ClientHttpConnectorAutoConfiguration
org.springframework.boot.autoconfigure.web.reactive.function.client.WebClientAutoConfiguration
org.springframework.boot.autoconfigure.web.servlet.DispatcherServletAutoConfiguration
org.springframework.boot.autoconfigure.web.servlet.ServletWebServerFactoryAutoConfiguration
org.springframework.boot.autoconfigure.web.servlet.error.ErrorMvcAutoConfiguration
org.springframework.boot.autoconfigure.web.servlet.HttpEncodingAutoConfiguration
org.springframework.boot.autoconfigure.web.servlet.MultipartAutoConfiguration
org.springframework.boot.autoconfigure.web.servlet.WebMvcAutoConfiguration
org.springframework.boot.autoconfigure.websocket.reactive.WebSocketReactiveAutoConfiguration
org.springframework.boot.autoconfigure.websocket.servlet.WebSocketServletAutoConfiguration
org.springframework.boot.autoconfigure.websocket.servlet.WebSocketMessagingAutoConfiguration
org.springframework.boot.autoconfigure.webservices.WebServicesAutoConfiguration
org.springframework.boot.autoconfigure.webservices.client.WebServiceTemplateAutoConfiguration

可以看到很多我们可以注入的组件。

这些组件的代码在org.springframework.boot.autoconfigure文件下，以aop为例，打开aop的源码如下：

在这里插入图片描述
看到AopAutoConfiguration类上有@ConditionalOnProperty注解。

所以：虽然这些场景的所有自动配置启动的时候默认全部加载。但是按照条件装配规则（@Conditional），最终会按需配置。

Spring Boot默认会在底层配好所有的组件。但是如果用户自己配置了以用户的优先。

依赖组件配置

依赖组件的一些配置可以通过我们的配置文件直接修改。

以batch依赖为例，源码如下：
在这里插入图片描述
可以看到有一个注解@EnableConfigurationProperties({BatchProperties.class})，这里就是指定了BatchAutoConfiguration自动配置时会使用哪些配置。

打开BatchProperties文件：

package org.springframework.boot.autoconfigure.batch;

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.sql.init.DatabaseInitializationMode;

@ConfigurationProperties(
    prefix = "spring.batch"
)
public class BatchProperties {
    private final BatchProperties.Job job = new BatchProperties.Job();
    private final BatchProperties.Jdbc jdbc = new BatchProperties.Jdbc();

    public BatchProperties() {
    }

    public BatchProperties.Job getJob() {
        return this.job;
    }

    public BatchProperties.Jdbc getJdbc() {
        return this.jdbc;
    }

    public static enum Isolation {
        DEFAULT,
        READ_UNCOMMITTED,
        READ_COMMITTED,
        REPEATABLE_READ,
        SERIALIZABLE;

        private static final String PREFIX = "ISOLATION_";

        private Isolation() {
        }

        String toIsolationName() {
            return "ISOLATION_" + this.name();
        }
    }

    public static class Jdbc {
        private static final String DEFAULT_SCHEMA_LOCATION = "classpath:org/springframework/batch/core/schema-@@platform@@.sql";
        private BatchProperties.Isolation isolationLevelForCreate;
        private String schema = "classpath:org/springframework/batch/core/schema-@@platform@@.sql";
        private String platform;
        private String tablePrefix;
        private DatabaseInitializationMode initializeSchema;

        public Jdbc() {
            this.initializeSchema = DatabaseInitializationMode.EMBEDDED;
        }

        public BatchProperties.Isolation getIsolationLevelForCreate() {
            return this.isolationLevelForCreate;
        }

        public void setIsolationLevelForCreate(BatchProperties.Isolation isolationLevelForCreate) {
            this.isolationLevelForCreate = isolationLevelForCreate;
        }

        public String getSchema() {
            return this.schema;
        }

        public void setSchema(String schema) {
            this.schema = schema;
        }

        public String getPlatform() {
            return this.platform;
        }

        public void setPlatform(String platform) {
            this.platform = platform;
        }

        public String getTablePrefix() {
            return this.tablePrefix;
        }

        public void setTablePrefix(String tablePrefix) {
            this.tablePrefix = tablePrefix;
        }

        public DatabaseInitializationMode getInitializeSchema() {
            return this.initializeSchema;
        }

        public void setInitializeSchema(DatabaseInitializationMode initializeSchema) {
            this.initializeSchema = initializeSchema;
        }
    }

    public static class Job {
        private String names = "";

        public Job() {
        }

        public String getNames() {
            return this.names;
        }

        public void setNames(String names) {
            this.names = names;
        }
    }
}

注解@ConfigurationProperties( prefix = "spring.batch")可以看到，BatchProperties配置类属性会使用我们配置文件里"spring.batch开头的配置。这样就可以使用配置文件来控制我们依赖的组件属性。

结论

下面总结下自动配置原理：

1.主程序上的SpringBootApplication注解里有个EnableAutoConfiguration注解。

2.EnableAutoConfiguration注解包含AutoConfigurationPackage和Import注解。其中AutoConfigurationPackage用于描当前主程序所在包下所有配置注入Bean；Import用于导入依赖组件。

3.上面的.Import注解导入了AutoConfigurationImportSelector组件，这个选择器组件最终会找到依赖里的META-INF/spring/%s.imports文件，加载需要的依赖。

4.默认加载所有的依赖，但是按照条件装配规则（@Conditional），最终会按需配置。

5.我们可以通过配置文件修改依赖组件注入容器时的属性。

Ethan-running
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
handlebars-spring-boot-starter：车把的Spring Boot自动配置
01-30
Spring Boot Starter把手 Spring Boot Starter对 （无逻辑模板）的支持。 用法 添加handlebars-spring-boot-starter作为依赖项： repositories { mavenCentral() } dependencies { compile ' pl.allegro.tech.boot:handlebars-spring-boot-starter:0.3.2 ' } 要求 由于版本0.3.0 handlebars-spring-boot-starter需要Spring Boot 2.0，Spring Framework 5和Java 8。 帮手 Spring Boot Starter Handlebars将根据项目依赖关系自动注册handlerbar帮助器。 将任何车把助手添加到依赖项，就可以开始使用它了。 dependencies { compile ' com.github.jknack:handlebars-helpers:4.2.0 ' , ' com.githu
源码角度解析SpringBoot 自动配置
HSQdePYZ的博客
09-04 471
Spring Boot 自动配置是 Spring Boot 的核心特性之一，它的目标是通过分析应用程序的类路径（classpath）和依赖关系，来自动配置 Spring 应用程序所需的 Bean、设置和组件。这意味着开发人员不需要手动配置大部分常见的 Spring 组件，Spring Boot 将根据环境和依赖来进行智能配置。这样，开发人员可以专注于编写业务逻辑，而不必过多关心底层配置细节。
org.springframework.boot.autoconfigure.autoconfiguration.imports 未生效
qq_34359327的博客
02-21 703
org.springframework.boot.autoconfigure.autoconfiguration.imports 未生效
【SpringBoot3.x教程03】SpringBoot自动配置详解
升仔聊编程的博客
03-06 1048
如何学习SpringBoot 自动配置对于后续自定义一个Starter尤为重要
SpringBoot自动装配原理及其Starter应用
weixin_73023473的博客
03-21 1755
我们知道在SpringBoot启动类上面有个一@SpringBootApplication启动类注解；他其实一个复合注解,包括:@SpringBootConfiguration、@EnableAutoConfiguration、以及@ComponentScan等注解; @SpringBootConfiguration里面封装的是@Configuration注解，所以在启动类中我们可以使用@Bean注解来声明我们的bean对象; @ComponentScan:是项目启动时包的扫描路径配置 @Enable
十年老架构亲自出品：Spring Boot 自动配置一篇概览
weixin_71690375的博客
05-31 484
自动配置类通过添加 @AutoConfiguration 注解实现。因为 @AutoConfiguration 注解本身是以 @Configuration 注解的，所以自动配置类可以算是一个标准的基于 @Configuration 注解的类。@Conditional 注解可以用于声明自动配置启用条件，通常，我们可以使用 @ConditionalOnClass、@ConditionalOnMissingBean 注解。
【Spring Boot】自动配置及重要注解解析
Decade0712的博客
06-19 9886
分析Spring boot中的底层注解、主启动类相关的注解以及spring boot是如何实现自动配置的
IDEA中使用org.springframework.boot.autoconfigure.AutoConfiguration.imports没有被识别
热门推荐
Zhangsama1的博客
02-24 1万+
在SpringBoot2.7.x版本之后，慢慢不支持META-INF/spring.factories文件了，需要导入的自动配置类可以放在/META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports文件中，可以看下spring-boot-autoconfigure-2.7.7.jar下的这个文件。所以正确的操作是先创建META-INF目录，然后在其下面创建spring目录，然后把这个文件放进去即可。
若依org.springframework.boot.autoconfigure.AutoConfiguration.imports
weixin_44079262的博客
10-10 7023
看了这两天若依代码，之前几天我还看了nacos原理和springboot源码，因为要了解微服务配置的拉取和更新，所以要看看springboot源码，果然，大家要多看源码才能有收获，否则蒙在鼓里。
springboot自动装配原理
weixin_43950558的博客
06-10 5212
springboot自动装配
Spring Boot自动配置讲解
aaaPostcard的博客
08-13 5006
springboot自动配置的详解，从run方法开始。
localstack-spring-boot:适用于LocalStack的Spring Boot自动配置
05-24
Smartup LocalStack Spring Boot自动配置 介绍 此自动配置库的范围是提供一种使用localstack配置AWS客户端的简单方法。 要求 要使用此自动配置，您需要JDK8 。 用法 首先，您必须在项目中包含localstack-spring-boot...
Spring Boot自动化配置原理
12-22
Spring Boot自动化配置原理依赖于 @Conditional 注解来实现： @Conditional是Spring4提供的一个新特性用于根据条件来控制Bean的创建行为。 我们从大家熟知的Spring Boot 的启动类开始 @SpringBootApplication public...
12Spring Boot Admin：微服务应用监控1
08-04
12Spring Boot Admin：微服务应用监控1
基于Spring Boot的Rabbit自动化测试平台服务端设计源码
最新发布
04-04
本设计源码提供了一个基于Spring Boot的Rabbit自动化测试平台服务端。项目包含451个文件，主要使用Java编程语言，并包含了JavaScript、CSS、HTML和Shell。文件类型包括347个Java源代码文件、50个XML配置文件、13个...
SpringBoot——》@EnableAutoConfiguration注解
小仙~
05-24 2769
推荐链接：     总结——》【Java】     总结——》【Mysql】     总结——》【Spring】 一、作用 开启自动配置 @EnableAutoConfiguration注解的定义中使用了@Import注解，导入AutoConfigurationImportSelector.class，作用等同于在Spring的xml文件中使用导入 二、自动配置过程 1、找到文.
Spring_boot之自动加载自己的AutoConfiguration
Harry的博客
06-27 3501
如果项目中要开发一个比较通用的组件，这个组件可以被其它springboot项目应用并且其它springboot项目在应用它时不要加入新的标注和代码，只要在pom.xml里加入它的依赖就可以了。怎么办呢假如：我们组件名字时spring_autoconfiguration,在我们的组件里加入META-INF/spring.factories文件 创建这个组件的MyEnableAutoConfiguration MyService pom.xml 2. 项目spring_boot_test这个是sp
[Java] Spring Boot Auto Configure（Spring Boot自动装配）的原理
ToraNe的博客
11-21 2441
Spring Boot能帮助我们Java开发者快速开发基于Spring框架的应用，除了其作为依赖管理好帮手的一众Spring-Boot-Starter之外，其自动装配（Auto Configure）特性也起到了非常重要的作用。那么Spring Boot是如何实现自动装配的呢？本文将结合源码去讲解其原理。
springboot 自动配置 autoConfig 全流程
weixin_40533111的博客
03-22 9918
目录 1.自动配置简介 2.实现方式 3.演示 摘要
Spring Boot自动配置原理
09-26
Spring Boot的自动配置原理是通过在类路径中搜索特定的类，并根据它们发现的内容自动配置应用程序。它使用@EnableAutoConfiguration注解和@Configuration注解将类路径中的类和jar文件与Spring应用程序上下文进行关联...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Ethan-running

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值