springBoot自动配置原理

最新推荐文章于 2023-03-28 10:12:07 发布
最新推荐文章于 2023-03-28 10:12:07 发布
阅读量190 收藏
点赞数
分类专栏： spring 文章标签： springBoot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36528311/article/details/100156380
版权

1.springboot02Application：启动类

@SpringBootApplication
public class Springboot02Application {    
    public static void main(String[] args) {        SpringApplication.run(Springboot02Application.class, args);
     }}

@SpringBootApplication：表示这是一个springBoot的根启动器，启动全部从这里开始

2.进入@SpringBootApplication

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

@Configuration：表示这是一个配置类，跟spring里面的xml是一样的概念，声明为配置类后，容器启动的时候就会将配置类中的组件@Bean加入容器中

@SpringBootConfiguration：springBoot的根配置文件

@ComponentScan：springBoot默认会扫描启动器所在包下面的所以文件，所以，我们需要把我们的业务都放在启动器的包的下面，才能被扫描到

3.进入@EnableAutoConfiguration：自动配置类

@Import({AutoConfigurationImportSelector.class})
public @interface EnableAutoConfiguration {    
    String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration";    
    Class<?>[] exclude() default {};    
    tring[] excludeName() default {};}

@Import({AutoConfigurationImportSelector.class}):表示引入哪个类，括号中的类就是具体想引入的类

4.进入AutoConfigurationImportSelector.class：自动配置类选择器

public String[] selectImports(AnnotationMetadata annotationMetadata) {
        if (!this.isEnabled(annotationMetadata)) {
            return NO_IMPORTS;
        } else {
            /**下面这代码：加载配置文件数据，即spring-autoconfigure-metadata.properties
            该文件的功能在于，当配置类在实例化的时候，需要加载properties文件中的内容
            对自身进行实例，然后加入到容器中
            **/
            AutoConfigurationMetadata autoConfigurationMetadata = AutoConfigurationMetadataLoader.loadMetadata(this.beanClassLoader);
            /**
            下面这段代码：加载配置工厂文件，即spring.factories
            该文件的功能在于加载需要配置的具体配置类，在我们选择我们需要的开发环境的时候，
            开发环境中需要的架包和架包的自动配置文件就会被加入到EnableAutoConfiguration中，
            而EnableAutoConfiguration就被存放在spring.factories文件中
            **/
            AutoConfigurationImportSelector.AutoConfigurationEntry autoConfigurationEntry = this.getAutoConfigurationEntry(autoConfigurationMetadata, annotationMetadata);
            return StringUtils.toStringArray(autoConfigurationEntry.getConfigurations());
        }
    }
​
    protected AutoConfigurationImportSelector.AutoConfigurationEntry getAutoConfigurationEntry(AutoConfigurationMetadata autoConfigurationMetadata, 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.filter(configurations, autoConfigurationMetadata);
            this.fireAutoConfigurationImportEvents(configurations, exclusions);
            return new AutoConfigurationImportSelector.AutoConfigurationEntry(configurations, exclusions);
        }
    }

在这个类中，主要说明了如何去加载到配置类，并如何去初始化：

5.进入到this.getCandidateConfigurations(annotationMetadata, attributes);方法:获取候选的配置

protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
    //通过工厂加载到所以需要配置的配置类
        List<String> configurations = SpringFactoriesLoader.loadFactoryNames(this.getSpringFactoriesLoaderFactoryClass(), this.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;
    }

 

6.进SpringFactoriesLoader.loadFactoryNames(this.getSpringFactoriesLoaderFactoryClass(), this.getBeanClassLoader());

public static List<String> loadFactoryNames(Class<?> factoryClass, @Nullable ClassLoader classLoader) {
        String factoryClassName = factoryClass.getName();
        return (List)loadSpringFactories(classLoader).getOrDefault(factoryClassName, Collections.emptyList());
    }
​
    private static Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader) {
        MultiValueMap<String, String> result = (MultiValueMap)cache.get(classLoader);
        if (result != null) {
            return result;
        } else {
            try {
                /**
                1.声明配置工厂文件存放位置，就在META-INF下，并通过类加载器进行加载
                并将每一个url放入到枚举中
                **/
                Enumeration<URL> urls = classLoader != null ? classLoader.getResources("META-INF/spring.factories") : ClassLoader.getSystemResources("META-INF/spring.factories");
                LinkedMultiValueMap result = new LinkedMultiValueMap();
​
                while(urls.hasMoreElements()) {
                    URL url = (URL)urls.nextElement();
                    UrlResource resource = new UrlResource(url);
                    //将url资源封装到Perperties对象中
                    Properties properties = PropertiesLoaderUtils.loadProperties(resource);
                    Iterator var6 = properties.entrySet().iterator();
​
                    while(var6.hasNext()) {
                        Entry<?, ?> entry = (Entry)var6.next();
                        String factoryClassName = ((String)entry.getKey()).trim();
                        String[] var9 = StringUtils.commaDelimitedListToStringArray((String)entry.getValue());
                        int var10 = var9.length;
​
                        for(int var11 = 0; var11 < var10; ++var11) {
                            String factoryName = var9[var11];
                            result.add(factoryClassName, factoryName.trim());
                        }
                    }
                }
​
                cache.put(classLoader, result);
                return result;
            } catch (IOException var13) {
                throw new IllegalArgumentException("Unable to load factories from location [META-INF/spring.factories]", var13);
            }
        }
    }
​

这段代码功能主要是加载spring.factories文件，并且文件中的特定的类加载进来

特定的类？

看这行：

String factoryClassName = factoryClass.getName();

这个factoryClass到底是什么呢，其实这个就是需要在factories中加载进来的类

我们看到第5点的这段代码：

 List<String> configurations = SpringFactoriesLoader.loadFactoryNames(this.getSpringFactoriesLoaderFactoryClass(), this.getBeanClassLoader());

进入getSpringFactoriesLoaderFactoryClass()方法

protected Class<?> getSpringFactoriesLoaderFactoryClass() {
        return EnableAutoConfiguration.class;
    }

这时候我们就知道了，原来就是想加载到spring.factories文件中的EnableAutoConfiguration类

好了，那我们就来看看这个spring.factories是什么东西吧

7.进入spring.factories

找到spring-boot-autoconfigure-2.1.7.RELEASE.jar/META-INF/

找到 Auto Configureorg.springframework.boot.autoconfigure.EnableAutoConfiguration=\

# 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.cloud.CloudServiceConnectorsAutoConfiguration,\
org.springframework.boot.autoconfigure.context.ConfigurationPropertiesAutoConfiguration,\
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.ElasticsearchAutoConfiguration,\
org.springframework.boot.autoconfigure.data.elasticsearch.ElasticsearchDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.elasticsearch.ElasticsearchRepositoriesAutoConfiguration,\
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.Neo4jRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.solr.SolrRepositoriesAutoConfiguration,\
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.jest.JestAutoConfiguration,\
org.springframework.boot.autoconfigure.elasticsearch.rest.RestClientAutoConfiguration,\
org.springframework.boot.autoconfigure.flyway.FlywayAutoConfiguration,\
org.springframework.boot.autoconfigure.freemarker.FreeMarkerAutoConfiguration,\
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.groovy.template.GroovyTemplateAutoConfiguration,\
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.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.orm.jpa.HibernateJpaAutoConfiguration,\
org.springframework.boot.autoconfigure.quartz.QuartzAutoConfiguration,\
org.springframework.boot.autoconfigure.reactor.core.ReactorCoreAutoConfiguration,\
org.springframework.boot.autoconfigure.security.servlet.SecurityAutoConfiguration,\
org.springframework.boot.autoconfigure.security.servlet.SecurityRequestMatcherProviderAutoConfiguration,\
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.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.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.ReactiveWebServerFactoryAutoConfiguration,\
org.springframework.boot.autoconfigure.web.reactive.WebFluxAutoConfiguration,\
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

这里就是我们自动配置的所有配置类了

我们挑个简单的来分析下，这个配置类到底怎么自动配置，又怎么被加载进容器的

8.选择字符编码自动配置类分析：

org.springframework.boot.autoconfigure.web.servlet.HttpEncodingAutoConfiguration,\

进入HttpEncodingAutoConfiguration：

@Configuration
@EnableConfigurationProperties({HttpProperties.class})
@ConditionalOnWebApplication(
    type = Type.SERVLET
)
@ConditionalOnClass({CharacterEncodingFilter.class})
@ConditionalOnProperty(
    prefix = "spring.http.encoding",
    value = {"enabled"},
    matchIfMissing = true
)
public class HttpEncodingAutoConfiguration {
    private final Encoding properties;
​
    public HttpEncodingAutoConfiguration(HttpProperties properties) {
        this.properties = properties.getEncoding();
    }
​
    @Bean
    @ConditionalOnMissingBean
    public CharacterEncodingFilter characterEncodingFilter() {
        CharacterEncodingFilter filter = new OrderedCharacterEncodingFilter();
        filter.setEncoding(this.properties.getCharset().name());
        filter.setForceRequestEncoding(this.properties.shouldForce(org.springframework.boot.autoconfigure.http.HttpProperties.Encoding.Type.REQUEST));
        filter.setForceResponseEncoding(this.properties.shouldForce(org.springframework.boot.autoconfigure.http.HttpProperties.Encoding.Type.RESPONSE));
        return filter;
    }
​
    @Bean
    public HttpEncodingAutoConfiguration.LocaleCharsetMappingsCustomizer localeCharsetMappingsCustomizer() {
        return new HttpEncodingAutoConfiguration.LocaleCharsetMappingsCustomizer(this.properties);
    }

@Configuration：表示这是一个配置类，该配置类在满足条件之后就会生效，其中的组件@Bean就会被加载进容器

@EnableConfigurationProperties({HttpProperties.class})：//启动指定类的ConfigurationProperties功能；将配置文件中对应的值和HttpProperties绑定起来；并把HttpProperties加入到ioc容器中

@ConditionalOnClass({CharacterEncodingFilter.class})：类似@ConditionalOnxxxx的注解都是条件，作为当前配置类是否生效的条件，其中这个注解意思是，判断是否加载了CharacterEncodingFilter.class，如果加载了就为true，如果没有加载就为false

@Bean:容器组件,在该配置文件生效后，该组件就会被加载到容器中

其中

 public HttpEncodingAutoConfiguration(HttpProperties properties) {
        this.properties = properties.getEncoding();
    }

这段代码，是将容器中的HttpProperties注入了进来，在当前配置类中进行使用

9.接下来进入HttpProperties,看看这到底是什么

@ConfigurationProperties(
    prefix = "spring.http"//加载配置文件中的spring.http中配置的属性，并注入
)
public class HttpProperties {
    private boolean logRequestDetails;
    private final HttpProperties.Encoding encoding = new HttpProperties.Encoding();
​
    public HttpProperties() {
    }
​
    public boolean isLogRequestDetails() {
        return this.logRequestDetails;
    }
​
    public void setLogRequestDetails(boolean logRequestDetails) {
        this.logRequestDetails = logRequestDetails;
    }
​
    public HttpProperties.Encoding getEncoding() {
        return this.encoding;
    }
​
    public static class Encoding {
        public static final Charset DEFAULT_CHARSET;
        private Charset charset;
        private Boolean force;
        private Boolean forceRequest;
        private Boolean forceResponse;
        private Map<Locale, Charset> mapping;
​
        public Encoding() {
            this.charset = DEFAULT_CHARSET;
        }
​
        public Charset getCharset() {
            return this.charset;
        }
​
        public void setCharset(Charset charset) {
            this.charset = charset;
        }
​
        public boolean isForce() {
            return Boolean.TRUE.equals(this.force);
        }
​
        public void setForce(boolean force) {
            this.force = force;
        }
​
        public boolean isForceRequest() {
            return Boolean.TRUE.equals(this.forceRequest);
        }
​
        public void setForceRequest(boolean forceRequest) {
            this.forceRequest = forceRequest;
        }
​
        public boolean isForceResponse() {
            return Boolean.TRUE.equals(this.forceResponse);
        }
​
        public void setForceResponse(boolean forceResponse) {
            this.forceResponse = forceResponse;
        }
​
        public Map<Locale, Charset> getMapping() {
            return this.mapping;
        }
​
        public void setMapping(Map<Locale, Charset> mapping) {
            this.mapping = mapping;
        }
​
        public boolean shouldForce(HttpProperties.Encoding.Type type) {
            Boolean force = type != HttpProperties.Encoding.Type.REQUEST ? this.forceResponse : this.forceRequest;
            if (force == null) {
                force = this.force;
            }
​
            if (force == null) {
                force = type == HttpProperties.Encoding.Type.REQUEST;
            }
​
            return force;
        }
​
        static {
            DEFAULT_CHARSET = StandardCharsets.UTF_8;
        }
​
        public static enum Type {
            REQUEST,
            RESPONSE;
​
            private Type() {
            }
        }
    }
}
​

@ConfigurationProperties：表明该类为配置属性类，该类需要依赖properties中配置的值，默认使用

spring-boot-autoconfigure-2.1.7.RELEASE.jar/META-INF/spring-autoconfigure-metadata.properties配置文件

，如果我们对于自动配置的不满意，可以在application.properties或者application.yml文件，或者通过@**PropertySource指定的文件中重新配置你想修改的属性，具体有什么属性？

那就是跟这个HttpProperties类有关了，这个类有什么属性，你就可以配置什么属性

总结一下：就是说，通过属性文件，将值注入到propeties类中，configure类在从容器中引入properties的实例对象，从而达到实例化自身，将自身的bean加入到容器中

至此，springboot的自动配置完成

孤傲的小狼
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SpringBoot入门（四）——自动配置
网易数帆社区博客
08-24 242
本文来自网易云社区SpringBoot之所以能够快速构建项目，得益于它的2个新特性，一个是起步依赖前面已经介绍过，另外一个则是自动配置。起步依赖用于降低项目依赖的复杂度，自动配置负责减少人工配置的工作量。@EnableAutoConfiguration前一篇留了一个注解没介绍，@EnableAutoConfiguration注解是开启自动配置的入口。其定义如下：@Target(ElementTyp...
（4）Spring Boot 的自动配置原理
My_Deng_Peng的博客
04-26 338
Spring Boot 的自动配置原理 前言：配置过ssm的IT同行们都知道，搭建这个框架就需要大量的配置，什么视图解析器呀，什么包扫描呀，扫描方言呀等等，但是用过Spring Boot的同行都知道，创建好的项目就可以进行运行Holle World ，刚开始我也觉得很神奇，但是后来才知道，原来Spring团队在maven依赖里面做了手脚，并且内部就已经设置好了依赖。 1.POM文件的解析 我们看了...
关于springboot的自动配置原理理解
xlstudent的博客
07-07 384
现在企业后端很多都是用springboot。 springboot比传统我们使用的SSM框架开发便捷很多。 我们在理解springboot的时候，不要把它当成一个新的框架，它其实是默认了很多框架的使用方式，就像Maven整合了所有的Jar包，springboot整合了所有的框架。我们需要使用哪一个框架，只需要在Maven中导入相应的starter（启动器）即可。 所以我们得出springboot的优点在于： （1）它为所有spring开发者更快的入门 （2）开箱即用，提供各种默认配置来简化项目配置 （3）内
spring-cloud 2020.0.0以上版本无法连接nacos解决办法
weixin_45718351的博客
01-30 3830
今天使用spring-cloud+nacos无法连接。报各种错误，错误如下： Exception encountered during context initialization - cancelling refresh attempt: org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'configurationPropertiesBeans' defined in class
浅谈springboot自动配置原理
08-25
浅谈SpringBoot自动配置原理 SpringBoot自动配置原理是SpringBoot框架的核心机制之一，它使得开发者可以更方便、更快速地构建应用程序。自动配置原理的核心是通过@EnableAutoConfiguration注解开启自动配置功能，...
SpringBoot自动配置原理.docx
11-14
3. **SpringBoot自动配置原理** 自动配置的实现主要基于以下机制： - **条件注解（@Conditional）**：Spring Boot的自动配置类通常会包含@Conditional注解，它允许配置类仅在满足特定条件时生效。例如，如果某个...
SpringBoot自动配置原理分析
最新发布
06-12
学SpringBoot 最重要的是学它的自动配置原理，不然到了后面项目实战就会发现与其他人的差距在哪里，只知其一不知其二。SpringBoot的自动配置原理是其核心特性之一，其重要性主要体现在简化应用程序的开发和部署过程...
01.SpringBoot自动配置原理.pdf
04-22
SpringBoot自动配置原理 SpringBoot自动配置原理是指SpringBoot框架中的一种机制，该机制可以自动配置应用程序所需的各种Bean和依赖项，使得开发者无需手动配置繁多的配置文件和pom坐标。下面将详细介绍SpringBoot...
SpringBoot自动配置的实现原理
08-26
SpringBoot 自动配置的实现原理 Spring Boot 框架中的自动配置机制是其核心组件之一，主要负责将应用程序的配置信息自动加载到 Spring 应用程序上下文中。在本文中，我们将详细介绍 Spring Boot 自动配置的实现原理...
Eureka引入依赖后无法启动，Error processing condition on org.springframework.cloud.client.CommonsClientAutoCon
weixin_44973078的博客
03-28 1461
importpom
学习spring cloud alibaba nacos配置中心的时候，从nacos读取不到配置文件，仍然的读取的本地文件，也不报错，
myStyle的博客
03-08 2479
打印日志如下，只是提示，并没错误信息 Bean 'org.springframework.cloud.autoconfigure.ConfigurationPropertiesRebinderAutoConfiguration' of type [org.springframework.cloud.autoconfigure.ConfigurationPropertiesRebinderAutoConfiguration$$EnhancerBySpringCGLIB$$3f6b7452] is not e
SpringBoot整合MyBatis踩过版本问题的坑Error creating bean with name ‘stuController‘: Unsatisfied dependency exp
George_huhu的博客
09-25 5933
SpringBoot整合MyBatis踩过版本问题的坑Error creating bean with name ‘stuController’: Unsatisfied dependency expressed through field ‘stuService’; nested exception is org.springframework.beans.factory： 版本新旧不知该怎么用，简单搭建一个maven工程却不可以运行： 报错信息： 问题描述： 提示：报错信息如图 org.springf
Springboot自动装配之spring-autoconfigure-metadata.properties和spring.factories（SPI机制核心）
万物皆字节
07-29 1万+
SpringBoot启动源码分析
org/springframework/boot/autoconfigure/web/ServerPropertiesAutoConfiguration.class
热门推荐
poem_2010的博客
03-27 2万+
"C:\Program Files\Java\jdk1.8.0_201\bin\java.exe" -agentlib:jdwp=transport=dt_socket,address=127.0.0.1:64445,suspend=y,server=n -javaagent:C:\Users\Administrator\.IntelliJIdea2018.3\system\captureAge...
spring-boot创建项目遇到配置问题
qq_34756209的博客
12-25 1万+
今天在创建spring-boot时遇到一个读取不到application.properties的问题，正常是将此文件放在src/main/resouces的子目录下，但是有时候为了方便管理所以需要将位置转移。 如下图所示： 此图中我是将文件放在src/main/resouces的propertiesConfig目录下，所以直接运行项目会找不到该文件，此时会报以下错误： org.spring
SpringBoot排除不需要的自动配置类
lzhfdxhxm的博客
06-24 9220
SpringBoot排除不需要的自动配置类，以及根据配置文件的属性，自动加载需要的自动配置类
spring boot 自动配置功能解剖
it帝国的博客-辉
08-22 2439
    说起spring boot和spring的区别，大家第一反应就是spring boot 少了很多配置，但不是说少了很多配置很多功能就没有了，或者比spring就少了很多功能，而是spring boot 自己约定了很多默认配置，让大家感觉不到其中的一些信息   问题来了，spring boot的自动配置怎么实现的？今天我将自己这2天学习到的东西分享一下，有不对的地方可以说出来一起讨论 ...
Spring Boot 自动装配原理
林心涯的博客
01-20 3599
Spring Boot 自动装配原理 每次问到 Spring Boot， 面试官非常喜欢问这个问题：“讲述一下 SpringBoot 自动装配原理？”。 我觉得我们可以从以下几个方面回答： 什么是 SpringBoot 自动装配？ SpringBoot 是如何实现自动装配的？如何实现按需加载？ 如何实现一个 Starter？ 前言 使用过 Spring 的小伙伴，一定有被 XML 配置统治的恐惧。即使 Spring 后面引入了基于注解的配置，我们在开启某些 Spring
SpringBoot 自动配置原理
03-28
SpringBoot自动配置原理简述 SpringBoot自动配置是SpringBoot的一大特色，它提供了一种简洁的方式来配置应用程序。在SpringBoot中，我们可以通过添加特定的依赖来自动配置应用程序的各种组件，例如数据源、日志、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值