2021-08-25 springBoot2 学习笔记(自动配置的底层原理)

最新推荐文章于 2025-12-04 10:15:57 发布
原创 最新推荐文章于 2025-12-04 10:15:57 发布 · 179 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#spring boot #java

自动配置原理入门

引导加载自动配置类

  • @SpringBootConfiguration
    该注解里有一个@Configuration，表示类为配置类
  • @ComponentScan
    指定扫描路径
  • @EnableAutoConfiguration
    该注解里有@AutoConfigurationPackage；@Import({AutoConfigurationImportSelector.class})
    点开@AutoConfigurationPackage，会发现有一个@Import({Registrar.class})
    利用Register给容器导入一系列组件
        public void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
            AutoConfigurationPackages.register(registry, (String[])(new AutoConfigurationPackages.PackageImports(metadata)).getPackageNames().toArray(new String[0]));
        }

上面的方法就是Registrar里的，将被注解修饰的类的包名取到，将整个包下的所有组件注册，这也就解释了之前提到的：在主类添加注解之后，会将主类所在包下所有的组件都注册

接下来看一下@Import({AutoConfigurationImportSelector.class})。
导入包的核心方法：this.getAutoConfigurationEntry(annotationMetadata)

    public String[] selectImports(AnnotationMetadata annotationMetadata) {
        if (!this.isEnabled(annotationMetadata)) {
            return NO_IMPORTS;
        } else {
            AutoConfigurationImportSelector.AutoConfigurationEntry autoConfigurationEntry = this.getAutoConfigurationEntry(annotationMetadata);
            return StringUtils.toStringArray(autoConfigurationEntry.getConfigurations());
        }
    }

getAutoConfigurationEntry里核心方法是 this.getCandidateConfigurations(annotationMetadata, attributes)

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

继续进入到getCandidateConfigurations方法里之后，一直找到最基础的方法loadSpringFactories，可以看到spring boot在启动的时候，会读取所有包中的META-INF/spring.factories文件

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();

                    while(var6.hasNext()) {
                        Entry<?, ?> entry = (Entry)var6.next();
                        String factoryTypeName = ((String)entry.getKey()).trim();
                        String[] factoryImplementationNames = StringUtils.commaDelimitedListToStringArray((String)entry.getValue());
                        String[] var10 = factoryImplementationNames;
                        int var11 = factoryImplementationNames.length;

                        for(int var12 = 0; var12 < var11; ++var12) {
                            String factoryImplementationName = var10[var12];
                            ((List)result.computeIfAbsent(factoryTypeName, (key) -> {
                                return new ArrayList();
                            })).add(factoryImplementationName.trim());
                        }
                    }
                }

                result.replaceAll((factoryType, implementations) -> {
                    return (List)implementations.stream().distinct().collect(Collectors.collectingAndThen(Collectors.toList(), Collections::unmodifiableList));
                });
                cache.put(classLoader, result);
                return result;
            } catch (IOException var14) {
                throw new IllegalArgumentException("Unable to load factories from location [META-INF/spring.factories]", var14);
            }
        }
    }

最核心的包是spring-boot-autoconfigure-2.5.4.jar，里面的spring.factories里定义了启动时要加载的哪些配置类：

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.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.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.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

但是所有的类并不会一开始就被注册，因为这些类里用到了@ConditionalOnClass或其他类型的注解实现了按需装配

@Configuration(
    proxyBeanMethods = false
)
@ConditionalOnClass({CacheManager.class})
@ConditionalOnBean({CacheAspectSupport.class})
@ConditionalOnMissingBean(
    value = {CacheManager.class},
    name = {"cacheResolver"}
)
@EnableConfigurationProperties({CacheProperties.class})
@AutoConfigureAfter({CouchbaseDataAutoConfiguration.class, HazelcastAutoConfiguration.class, HibernateJpaAutoConfiguration.class, RedisAutoConfiguration.class})
@Import({CacheAutoConfiguration.CacheConfigurationImportSelector.class, CacheAutoConfiguration.CacheManagerEntityManagerFactoryDependsOnPostProcessor.class})
public class CacheAutoConfiguration {
    public CacheAutoConfiguration() {
    }

    @Bean
    @ConditionalOnMissingBean
    public CacheManagerCustomizers cacheManagerCustomizers(ObjectProvider<CacheManagerCustomizer<?>> customizers) {
        return new CacheManagerCustomizers((List)customizers.orderedStream().collect(Collectors.toList()));
    }

    @Bean
    public CacheAutoConfiguration.CacheManagerValidator cacheAutoConfigurationValidator(CacheProperties cacheProperties, ObjectProvider<CacheManager> cacheManager) {
        return new CacheAutoConfiguration.CacheManagerValidator(cacheProperties, cacheManager);
    }

    static class CacheConfigurationImportSelector implements ImportSelector {
        CacheConfigurationImportSelector() {
        }

        public String[] selectImports(AnnotationMetadata importingClassMetadata) {
            CacheType[] types = CacheType.values();
            String[] imports = new String[types.length];

            for(int i = 0; i < types.length; ++i) {
                imports[i] = CacheConfigurations.getConfigurationClass(types[i]);
            }

            return imports;
        }
    }

    static class CacheManagerValidator implements InitializingBean {
        private final CacheProperties cacheProperties;
        private final ObjectProvider<CacheManager> cacheManager;

        CacheManagerValidator(CacheProperties cacheProperties, ObjectProvider<CacheManager> cacheManager) {
            this.cacheProperties = cacheProperties;
            this.cacheManager = cacheManager;
        }

        public void afterPropertiesSet() {
            Assert.notNull(this.cacheManager.getIfAvailable(), () -> {
                return "No cache manager could be auto-configured, check your configuration (caching type is '" + this.cacheProperties.getType() + "')";
            });
        }
    }

    @ConditionalOnClass({LocalContainerEntityManagerFactoryBean.class})
    @ConditionalOnBean({AbstractEntityManagerFactoryBean.class})
    static class CacheManagerEntityManagerFactoryDependsOnPostProcessor extends EntityManagerFactoryDependsOnPostProcessor {
        CacheManagerEntityManagerFactoryDependsOnPostProcessor() {
            super(new String[]{"cacheManager"});
        }
    }
}

按需开启自动配置

总结：

  • SpringBoot先加载所有的自动配置类 xxxxxAutoConfiguration
  • 每个自动配置类按照条件进行生效，默认都会绑定配置文件指定的值。值从xxxProperties里获取，xxxProperties和配置文件进行绑定
  • 生效的配置类就会给容器中装配很多组件
  • 只要容器中有这些组件，相当于功能就有了
  • 定制化配置：
    • 用户直接自己创建一个组件，用@Bean修饰之后就会替换了底层的组件
    • 用户如果想修改组件的某些配置，就去看这些配置获取了配置文件的哪些值，自己在application.properties里进行修改即可

查看自动配置了哪些？
在配置文件中debug=true开启自动配置报告。Nagative就是不生效的配置，Positive是生效的配置。

开发工具

lombok

先引入依赖

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>

下载插件：idea --> settings --> plugins --> 搜索lombok后安装

应用举例

package com.study.springboot2.bean;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.ToString;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

//@Component
@ConfigurationProperties(prefix = "cat")
@Data //自动生成get set方法
@ToString
@AllArgsConstructor	//全参构造器
@NoArgsConstructor	//无参构造器
public class Pet {
    private String name;
}

@RestController
@Slf4j  //引入slf4j日志，引入完之后可以直接使用log打印日志
public class HelloWordController {

    @RequestMapping("/hello")
    public String hello(){
        log.info("hello world");
        return "hello world";

    }
}

devtools

引入依赖

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <version>2.5.4</version>
        </dependency>

引入完之后，每次修改文件就不用重新启动，使用ctrl+f9，可以使改动后的文件生效

yaml

package com.study.springboot2.bean;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.ToString;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.Set;

@Data
@NoArgsConstructor
@AllArgsConstructor
@ToString
@Component
@ConfigurationProperties(prefix = "user")
public class User {
    private String name;
    private Boolean boss;
    private Date birth;
    private Integer age;
    private Pet pet;
    private String[] interests;
    private List<String> animal;
    private Map<String, Object> score;
    private Set<Double> salarys;
    private Map<String, List<Pet>> allPets;
}


user:
  name: lucy
  boss: true
  birth: 1995/08/09
  age: 26
  pet:
    name: dog
    weight: 220
  interests:
    - 足球
    - 篮球
  animal: [猫，狗]
  score: {english:100, math:99}
  salarys:
    - 1000
    - 20000
  allPets:
    sick:
      - {name: maomao, weights: 110}
      - {name: mao1, weights: 222}
    health:
      - name: dog
        weights: 222
      - name: dog1
        weights: 333
SpringBoot源码学习系列之自动配置原理简介
Nicky's blog
11-02 5266
ok，本博客尝试跟一下Springboot的自动配置源码，做一下笔记记录，自动配置是Springboot的一个很关键的特性，也容易被忽略的属性，因为这个属性被包括在`@SpringBootApplication`注解里，所以不去跟一下源码都不知道还有这个属性
SpringBoot2学习笔记02
xizheng2018的博客
04-14 776
十六、最佳实践-SpringBoot应用如何编写 1、引入场景依赖 2、查看自动配置了哪些（选做） 自己分析，引入场景对应的自动配置一般都生效了 配置文件中debug=true开启自动配置报告。Negative（不生效）\Positive（生效） 3、是否需要修改 参照文档修改配置项 application.properties 自己分析。xxxxProperties绑定了配置文件的哪...
springboot 初始加载自动配置类
sehnsucht
10-07 886
springboot 初始加载自动配置类 @SpringBootApplication --> @EnableAutoConfiguration @Target({ElementType.TYPE}) @Retention(RetentionPolicy.RUNTIME) @Documented @Inherited @SpringBootConfiguration @EnableAutoConfiguration @ComponentScan( excludeFilters = {@Filt
SpringBoot2学习笔记三--了解自动配置原理
木易进
08-05 255
**该文本笔记来源于尚硅谷：SpringBoot2文本教程(代码部分大多数为笔者个人实践所写)一方面为了缩短做笔记的时间，另一方面也为了后续巩固复习时方便。直接在尚硅谷官方笔记上进行标注个人认为需要关注的点。如需转载请务必注明笔记文本来源于尚硅谷教学课程。 《SpringBoot学习笔记三–了解自动配置原理》 1、SpringBoot特点 1.1、依赖管理 父项目做依赖管理 依赖管理 <parent> <groupId>org.springframewor
2021-11（java-springboot学习笔记二）
qq_45688193的博客
11-27 487
目录 自动配置一 自动配置二 容器功能 1、@Configuration和@Bean的基本使用与作用 主启动类的分析 web场景 1.静态资源规则 2.静态资源配置原理 自动配置一 1、父依赖 <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifac
SpringBoot学习--基于狂神说的springboot笔记
qq_57237780的博客
11-10 2762
基于狂神说的springboot笔记，有一些不完美，欢迎大家提出意见修改。一起交流，学习
狂神SpringBoot学习笔记12天-Day 03 自动装配原理
weixin_52613545的博客
08-02 430
自动装配原理！
SpringBoot学习笔记（上）——自动装配原理、自定义 springboot-starter、配置文件编写
weixin_47257473的博客
08-31 830
本文系统介绍了SpringBoot的核心知识，包括5种创建方式、自动配置原理、自定义starter实现、热部署和配置文件管理。重点解析了@SpringBootApplication注解的组成和自动配置流程，详细说明了通过AutoConfigurationImportSelector加载spring.factories配置类的机制。针对自定义starter开发，提供了完整的实现步骤和常见问题解决方案，特别强调了可执行JAR与普通JAR的区别。最后讲解了YAML语法、多环境配置和配置文件加载优先级，涵盖@Val
一、SpringBoot2基础入门--07-SpringBoot自动配置原理
2401_84413531的博客
04-20 880
1、自动配置原理1.1、springboot自动配置底层常用注解。
Springboot学习笔记（八）--自动装配原理
2401_85354273的博客
07-23 448
SpringBoot官方文档中有大量的配置，但这些配置文件到底能写什么？怎么写？1、分析自动装配原理我们以HttpEncodingAutoConfiguration（Http编码自动配置）为例解释自动配置原理；//表示这是一个配置类，和以前编写的配置文件一样，也可以给容器中添加组件；//启动指定类的ConfigurationProperties功能；//进入这个HttpProperties查看，将配置文件中对应的值和HttpProperties绑定起来；
SpringBoot2学习笔记
benben044的专栏
08-01 1412
springboot学习的教程
SpringBoot2学习笔记一--Spring与SpringBoot2
木易进
08-05 1434
该文本笔记 来源于尚硅谷：SpringBoot2文本教程 一方面为了缩短做笔记的时间，另一方面也为了后续巩固复习时方便。直接在尚硅谷官方笔记上进行标注个人认为需要关注的点。如需转载请务必注明笔记文本来源于尚硅谷教学课程。 一. Spring与SpringBoot 1、Spring能做什么 1.1、Spring的能力 1.2、Spring的生态 https://spring.io/projects/spring-boot 覆盖了： web开发 数据访问 安全控制 分布式 消息服务 移动开发 批处理 … 1.
倾情力作-一文读懂SpringBoot2源码-基础入门-自动配置原理
Fatter$hday的博客
03-26 1402
SpringBoot2核心技术-基础入门-自动配置原理 我们都知道SpringBoot自动给我们导入了许多的组件，那么这些组件是怎么导入的呢？是从哪里导入的？本文将带你一探究竟，彻底明白SpringBoot的自动配置原理。
SpringBoot2学习笔记06
xizheng2018的博客
03-21 297
1、Profile功能为了方便多环节适配，springboot简化了profile功能2、命令行激活3、配置文件分组。
Java面试实战：从Spring Boot到AI集成的技术深度挑战
weixin_49437670的博客
12-02 678
谢飞机同学，欢迎来到我们公司的技术面试。先简单介绍一下你对Spring Boot的理解吧。：(自信满满) Spring Boot啊，这我熟！就是那个"约定大于配置"的框架嘛，开箱即用，内置Tomcat，还能自动装配。我之前做项目的时候，就用它快速搭建过RESTful API，连XML配置都不用写，太方便了。：(点头) 不错，那你能具体说说Spring Boot的自动装配原理吗？
Spring Boot 全面指南从入门到精通构建高效Java应用的完整路径
最新发布
ztt123654的博客
12-04 785
本文深入探讨Spring Boot框架的核心概念、实践技巧和高级特性，旨在帮助开发者从零开始掌握这一强大的Java应用开发工具。文章涵盖Spring Boot的快速入门、自动配置原理、微服务架构集成、性能优化策略以及实际项目部署，提供从基础到精通的系统性学习路径，适合初学者和有经验的开发者参考。
Spring Boot 3.x 中使用 Jasypt 时加解密不生效
JGYBZX_G的博客
12-02 259
摘要：Spring Boot 3.x 使用 Jasypt 时出现数据库密码解密失败问题，原因是新版默认采用强加密算法 PBEWITHHMACSHA512ANDAES_256。解决方案需在配置中显式指定旧算法 PBEWithMD5AndDES，并配置对应的 IV 生成器为 org.jasypt.iv.NoIvGenerator，同时确保加密盐值正确设置。
【经验分享】基于Spring Boot 4.0快速实现最简版的OAuth2 Server和Client
泽济天下的专栏
12-03 816
本文主要介绍了基于springboot4实现的最简版的oauth2 server端和client端的过程，希望能帮助到大家。
Spring Boot自动配置原理
2301_80096362的博客
12-03 1195
Spring Boot的自动配置就是自动帮你把代码(依赖）变成对象（Bean）。
狂神SpringBoot学习笔记与配套源码分享
SpringBoot 是当前 Java 后端开发领域中最为核心和流行的框架之一，而“狂神SpringBoot笔记+源码”这一资源包正是围绕 SpringBoot 框架的系统性学习资料，结合了理论讲解与实际代码实践，适合初学者入门以及中高级...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值