SpringBoot

Posted 2021-07-19 思想累积

1、SpringBoot 是什么

SpringBoot 是一个服务于框架的的框架，简化了 spring 众多框架中大量且繁琐的配置文件，可以快速开启一个 web 容器进行开发。

2、SpringBoot 原理

2.1 pom.xml

• spring-boot-dependencies：核心依赖在父工程中，在引入一些 SpringBoot 依赖的时候不需要指定版本

  <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-dependencies</artifactId>
      <version>2.5.0-SNAPSHOT</version>
  </parent>
  

2.2 启动器

• springboot 会将所有的功能场景变为一个个启动器，在需要使用的时候找到对应的启动器即可

  <dependency>
  	<groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter</artifactId>
  </dependency>
  

2.3 自动装配原理

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

// 程序主入口，标注这个类是一个 springboot 应用
@SpringBootApplication
public class DemoApplication {

    public static void main(String[] args) {
        // 将 springboot 应用启动
        SpringApplication.run(DemoApplication.class, args);
    }

}

@SpringBootApplication 注解：

@SpringBootConfiguration：springboot 配置
	@Configuration：spring 配置
	@Component：spring 的组件
	
@EnableAutoConfiguration：自动配置
	@AutoConfigurationPackage：自动配置包
		@Import(AutoConfigurationPackages.Registrar.class)：自动注册包
    @Import(AutoConfigurationImportSelector.class)

// 获取所有的配置
List<String> configurations = 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;
}

1. SpringBoot 在启动的时候从类路径下的 META-INF/spring.factories 中获取 EnableAutoConfiguration 指定的值
2. 将这些值作为自动配置类导入容器，自动配置类就生效，帮我们进行自动配置工作
3. springboot 启动会加载大量的自动配置类（XXXXAutoConfiguration），给容器中添加组件
4. 只要我们需要的组件在其中，我们就不需要再手动配置了，给容器中自动配置类添加组件的时候，会从 properties 中获取某些属性，我们只需要在配置文件中指定这些属性的值即可。

可以在配置文件中 debug: true 查看哪些自动配置类生效，哪些未生效

主启动类

SpringApplication 类主要作用

1. 推断应用的类型是普通项目还是 web 项目
2. 查找并加载所有可用初始化器，设置到 initialize 属性中
3. 找出所有的应用程序监听器，设置到 listeners 属性中
4. 推断并设置 main 方法的定义类，找到运行的主类

3、SpringBoot 配置

application.properties 配置文件

# properties 文件只能以键值对形式
server.port=8081
name=sqdkk
age=21

YAML 标记语言，application.yml 配置文件，yml 可以直接给实体类赋值

# key - value
name: sqdkk
# 对象
student:
  name: sqdkk
  age: 21
# 行内写法
student2: {name: sqdkk,age: 21}
# 数组
persons1:
  - 小明
  - 小红
  - 小白
persons2: [小明,小红,小白]

@ConfigurationProperties(prefix = “XXX”) 作用：

将配置文件中配置的每个属性的值，映射到这个组件中

告诉 springboot 将本类中的所有属性和配置文件中相关的配置进行绑定

参数 prefix = “XXX” 和配置文件中 XXX 下的所有属性一一对应

@ConfigurationProperties(prefix = "XXX")

@PropertySource(value = “classpath:XXX.properties”) 加载指定的配置文件：

@PropertySource(value = "classpath:application.properties")
public class Person {
    @Value("${name}")
    private String name;
    @Value("${age}")
    private String age;
}

多环境配置及配置文件位置

springboot 默认会使用 application.properties 主配置文件

# 使用 properties 配置文件，springboot 多环境配置，可选择激活哪个配置文件
# 文件名 application-dev.properties
spring.profiles.actice=dev

# 使用 yaml 配置文件
server:
	port: 8081
# 选择要激活哪个环境
spring:
	profiles:
    	active: prod

---
server:
	port: 8082
spring:
	profiles: dev

---
server:
	port: 8083
spring:
	profiles: test

外部指定文件启动配置文件

java -jar spring-boot-config.jar --spring.config.location=F:/application.properties

多配置文件优先级别（高 → 低）：

properties > yml > yaml

file:./config/ 项目路径下 config 文件夹配置文件

file:./ 项目路径下配置文件

classpath:/config/ 资源路径下的 config 文件夹配置文件

classpath:/ 资源路径下的配置文件

SpringBoot 中的延迟加载（懒加载）
yml 文件配置

spring:
  main:
	lazy-initialization: true # true 为开启

项目启动日志管理

spring:
  main:
  	log-startup-info: false; # false：关闭启动日志

banner 图

• 在 resource 文件夹下创建一个 banner.txt 文件，里面的内容会作为项目启动时的信息

设置 banner 图的显示模式，默认在控制台

# log：输出在日志
# console：输出在控制台
# off：不显示 banner 图
spring:
  main:
  	banner-mode: log

4、JSR 303 校验

导入 validation 依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-validation</artifactId>
</dependency>

import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Repository;
import org.springframework.validation.annotation.Validated;

import javax.validation.constraints.Email;

@Repository
@Data
@ConfigurationProperties(prefix = "person")
@Validated
public class Person {
    @NotBlank(message = "名字不能为空")
    private String name;
    @Max(value = 120, message = "年龄最大值为 120")
    private String age;
    private Dog dog;
}

5、SpringBoot web 开发

5.1 静态资源

protected void addResourceHandlers(ResourceHandlerRegistry registry) {
    super.addResourceHandlers(registry);
    if (!this.resourceProperties.isAddMappings()) {
        logger.debug("Default resource handling disabled");
    } else {
        ServletContext servletContext = this.getServletContext();
        this.addResourceHandler(registry, "/webjars/**", "classpath:/META-INF/resources/webjars/");
        this.addResourceHandler(registry, this.mvcProperties.getStaticPathPattern(), (registration) -> {
            registration.addResourceLocations(this.resourceProperties.getStaticLocations());
            if (servletContext != null) {
                registration.addResourceLocations(new Resource[]{new ServletContextResource(servletContext, "/")});
            }

        });
    }
}

private void addResourceHandler(ResourceHandlerRegistry registry, String pattern, String... locations) {
    this.addResourceHandler(registry, pattern, (registration) -> {
        registration.addResourceLocations(locations);
    });
}

private void addResourceHandler(ResourceHandlerRegistry registry, String pattern, Consumer<ResourceHandlerRegistration> customizer) {
    if (!registry.hasMappingForPattern(pattern)) {
        ResourceHandlerRegistration registration = registry.addResourceHandler(new String[]{pattern});
        customizer.accept(registration);
        registration.setCachePeriod(this.getSeconds(this.resourceProperties.getCache().getPeriod()));
        registration.setCacheControl(this.resourceProperties.getCache().getCachecontrol().toHttpCacheControl());
        registration.setUseLastModified(this.resourceProperties.getCache().isUseLastModified());
        this.customizeResourceHandlerRegistration(registration);
    }
}

在 springboot 中，可以使用以下方式处理静态资源

• webjars localhost:8080/webjars
• resources，static（默认），public，/** localhost:8080/

5.2 首页

private Resource getWelcomePage() {
    String[] var1 = this.resourceProperties.getStaticLocations();
    int var2 = var1.length;

    for(int var3 = 0; var3 < var2; ++var3) {
        String location = var1[var3];
        Resource indexhtml = this.getIndexHtml(location);
        if (indexHtml != null) {
            return indexHtml;
        }
    }

    ServletContext servletContext = this.getServletContext();
    if (servletContext != null) {
        return this.getIndexHtml((Resource)(new ServletContextResource(servletContext, "/")));
    } else {
        return null;
    }
}

private Resource getIndexHtml(String location) {
    return this.getIndexHtml(this.resourceLoader.getResource(location));
}

private Resource getIndexHtml(Resource location) {
    try {
        Resource resource = location.createRelative("index.html");
        if (resource.exists() && resource.getURL() != null) {
            return resource;
        }
    } catch (Exception var3) {
    }

    return null;
}