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

最新推荐文章于 2024-08-24 19:14:38 发布
最新推荐文章于 2024-08-24 19:14:38 发布
阅读量125 收藏
点赞数
分类专栏： spring学习笔记 文章标签： spring boot java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/getKonwledge/article/details/119917355
版权

自动配置原理入门

引导加载自动配置类

  • @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
getKonwledge
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
spring-boot-test_springboot学习笔记
01-17
Spring Boot简化了测试流程，通过自动配置和内嵌的Servlet容器，使得测试Java web应用变得更加简单。 一、Spring Boot测试基础 1. **Spring Boot测试支持**：Spring Boot为开发人员提供了全面的测试支持，包括单元...
springboot 初始加载自动配置类
sehnsucht
10-07 752
springboot 初始加载自动配置类 @SpringBootApplication --> @EnableAutoConfiguration @Target({ElementType.TYPE}) @Retention(RetentionPolicy.RUNTIME) @Documented @Inherited @SpringBootConfiguration @EnableAutoConfiguration @ComponentScan( excludeFilters = {@Filt
SpringBoot经典学习笔记_springboot_SpringBoot经典学习笔记_
09-30
SpringBoot经典学习笔记是针对Java开发者的宝贵资源，它涵盖了SpringBoot的核心概念、特性以及实践应用。SpringBoot是由Pivotal团队开发的框架，旨在简化Spring应用的初始搭建以及开发过程，通过“约定优于配置”的...
spring-boot-test:springboot学习笔记！
05-10
主要描述在Springboot的单元测试和项目启动时如何使用不同的配置文件，功能不多，搞清楚原理即可。 引入Mysql数据库，引入Jpa管理数据库，使用Hibernate自动建表。 使用Jpa对数据库进行增加、删除、修改和查询，全部...
Cadence学习笔记1-原理图.pdf
11-16
Cadence学习笔记1-原理图.pdf
JSP学习笔记-2.pdf
11-28
JSP学习笔记-2.pdf
苍穹外卖项目DAY01
qq_62892403的博客
08-12 2161
定位：专门为餐饮企业（餐厅、饭店）定制的一款软件产品功能架构：体现项目中的业务功能模块产品原型：用于展示项目的业务功能，一般由产品经理进行设计技术选型：展示项目中使用到的技术框架和中间件等使用Swagger你只需要按照它的规范去定义接口及接口相关的信息，就可以做到生成接口文档，以及在线接口调试页面。Knife4j是Java MVC框架集成Swagger生成Api文档的增强解决方案。
【Spring Boot】全局异常处理
2401_83045332的博客
08-16 1007
在Spring Boot中捕获全局异常是一种有效的方式，可以将应用程序中的所有异常集中处理，提供统一的错误响应，并且可以避免重复编写异常处理逻辑。实现全局异常处理通常使用@ControllerAdvice注解来定义一个全局的异常处理类。在类中编写异常处理方法，并使用@ExceptionHandler注解指定要处理的异常类型。以下是具体的步骤和示例。
Spring Boot 应用案例：打造股票价格自动通知平台
心猿意码
08-20 672
在本篇博文中，我们将构建一个简单的Spring Boot应用来演示如何创建一个股票价格更新系统，并在股票价格变动时自动通知订阅用户。这个示例将涵盖Spring Boot的核心功能，包括Web模块、数据持久化、消息队列以及简单的用户订阅机制。
以简单的例子从头开始建spring boot web多模块项目(四)-多模块工具类
lwprain的专栏
08-21 278
8、重启程序，访问http://localhost:8081/demo/str 即可看到效果。6、在webDemo1工程中，pom.xml中增加WebTool的引用。增加spring-boot-starter的依赖。同样为Maven Archetype，类型为。目的是为了验证主工程调用工具工程。1、新建模块，名称为WebTool。2、修改pom.xml。3、修改App启动程序。5、增加新的测试工具类。
以简单的例子从头开始建spring boot web多模块项目(三)-better mybatis generate的使用
lwprain的专栏
08-21 329
project folder、model folder、dao folder、xml folder都设置为D:/java/workspace/RParentDemo/Web。D:/java/workspace/RParentDemo 这个路径是父项目，web是子项目，具体根据情况设置。这里k3mdm为数据库名，点击Test Connection，成功就行。这个也是因为网上找了太多不太对头的文档，这里是验证过的。勾选mysql_8，点确定，即可。点击ok就能生成了。
以简单的例子从头开始建spring boot web多模块项目(二)-mybatis简单集成
lwprain的专栏
08-21 546
1、pom.xml文件中，增加相关的依赖包的引入，分别是mybatis-spring-boot-starter、lombok、mysql-connector-java。3、安装插件better-mybatis-generator之类的可以帮助生成mapper、entity、*mapper.xml等相关文件，也可以进行手工添加。新增相应的包及xml的目录entity、mapper、service、service\impl。服务实现类WarehouseServiceImpl。实体Warehouse 类。
Spring Boot 集成 JdbcTemplate（盘它！）
08-24 869
SpringBoot 整合 JdbcTemplate，看完还不会你别来打我。
Spring Boot 大数据处理实战：运用迭代器模式避免内存溢出
心猿意码
08-20 903
假设我们要处理一个包含数百万行记录的 CSV 文件，每行记录代表一个用户。我们定义一个简单的 User 类来映射这些记录。User.javajava深色版本1@Entity3 @Id810}
Spring Boot 与 Spring Security 的集成及 OAuth2 实现
最新发布
2202_76097976的博客
08-24 1841
本文介绍了如何在 Spring Boot 应用中集成 Spring Security 和 OAuth2 进行安全保护。首先，配置了 Spring Security 来控制访问权限，允许匿名访问部分资源并保护其他资源。接着，通过 OAuth2 客户端实现与 Google 的授权集成，使应用能够获取访问令牌并保护 API。最后，展示了前端如何使用访问令牌请求受保护的资源，从而增强应用的安全性和用户体验。
Spring Boot OAuth2.0应用
onePlus5T的博客
08-21 1584
展示Spring Boot中，新版本OAuth2.0的简单实现
Spring Boot中怎么使用Spring Statemachine状态机实现订单状态流转控制
冥胖胖9的博客
08-20 1223
Spring Statemachine是由Spring团队提供的一个轻量级状态机框架。它为开发者提供了一种简便且强大的方式来管理复杂的状态流转逻辑，尤其适用于订单处理、工作流引擎等需要状态管理的场景。灵活的状态配置：通过Java配置或外部配置文件定义状态和状态转换。支持并发状态和嵌套状态：可以管理复杂的状态图。与Spring生态系统的良好集成：易于与Spring Boot、Spring Security等集成。接下来，我们定义订单状态和事件。
【spring boot自动配置】深入探讨 Spring Boot 自动配置：实现与机制
weixin_55939638的博客
08-20 451
Spring Boot 是现代 Java 开发中的重要工具，它极大地简化了 Spring 应用的配置和管理。其核心特性之一——自动配置（Auto-Configuration），使得开发者能够以最少的配置迅速启动应用。在这篇文章中，我们将深入探讨 Spring Boot 的自动配置机制，介绍实现自动配置的不同方式，并结合实际代码示例，帮助你更好地理解这一强大功能。
Spring Boot 分库分表策略示例
print_helloword的博客
08-21 975
分库：将数据存储到多个数据库中，通过动态数据源选择和路由来决定当前使用的数据库。分表：将数据存储到多个表中，根据分表策略生成动态表名。实现：配置多个数据源，使用动态数据源路由，创建工具类生成表名，并在数据访问层应用这些策略。这种分库分表策略可以有效地提高系统的性能和可扩展性，尤其适用于大规模数据处理场景。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值