万字SpringBoot学习笔记｜菜鸟版

开发运维 2023-07-14 三掌柜 手机阅读

Spring Boot是Pivotal团队在Spring的基础上提供的一套全新的开源框架，其目的是为了简化Spring应用的搭建和开发过程。Spring Boot去除了大量的XML配置文件，简化了复杂的依赖管理。

官网地址：spring.io/projects/sp…

Spring Boot入门

简介

Spring Boot是简化Spring应用开发的一个框架、整个Spring技术栈的一个大整合（Spring全家桶时代）、J2EE开发的一站式解决方案（Spring Cloud是分布式整体解决方案）。优点：– 快速创建独立运行的Spring项目以及与主流框架集成– 使用嵌入式的Servlet容器，应用无需打成WAR包– starters自动依赖与版本控制– 大量的自动配置，简化开发，也可修改默认值– 无需配置XML，无代码生成，开箱即用– 准生产环境的运行时应用监控– 与云计算的天然集成

单体应用与微服务

– 单体应用：ALL IN ONE（所有内容都在一个应用里面）– 微服务：每一个功能元素最终都是一个可独立替换和独立升级的软件单元微服务是一种架构风格(服务微化)，一个应用应该是一组小型服务，可以通过HTTP的方式进行互通

HelloWorld案例

工程创建及案例可以参考文章进行操作：在IDEA中创建SpringBoot项目

POM文件

父项目是Spring Boot的版本仲裁中心（他来真正管理Spring Boot应用里面的所有依赖版本），以后我们导入依赖默认是不需要写版本（没有在dependencies里面管理的依赖自然需要声明版本号）


    org.springframework.boot
    spring-boot-starter-parent
    2.7.11

启动器 spring-boot-starter（spring-boot场景启动器），spring-boot-starter-web 帮我们导入了web模块正常运行所依赖的组件。



        org.springframework.boot
        spring-boot-starter-web

        org.springframework.boot
        spring-boot-starter-test
        test

Spring Boot将所有的功能场景都抽取出来，做成一个个的starters(启动器)，只需要在项目里面引入这些starter相关场景的所有依赖都会导入进来。要用什么功能就导入什么场景的启动器。

主程序类

// 自动生成的
@SpringBootApplication
public class SpringBootDemo0Application {
    public static void main(String[] args) {
        SpringApplication.run(SpringBootDemo0Application.class, args);
    }
}

@SpringBootApplication: Spring Boot应用标注在某个类上说明这个类是SpringBoot的主配置类，SpringBoot 就应该运行这个类的main方法来启动SpringBoot应用。

Spring Boot配置

配置文件

SpringBoot使用一个全局的配置文件，配置文件名固定：application.properties 或者 application.yml。配置文件放在 src/main/resources目录 或者 类路径/config 下。作用是修改SpringBoot自动配置的默认值。

YAML

YAML(YAML Ain't Markup Language)，.yml为结尾，以数据为中心，比json、xml等更适合做配置文件。

YAML配置例子
server:
    port: 8081

等价于XML配置：

    8081

【语法】key: value(注意冒号后面有个空格)以空格的缩进来控制层级关系，只要是左对齐的一列数据，都是同一个层级

【值写法】

（1）字面量：普通的值(数字，字符串，布尔)

  • k: v，字面量直接写
  • 字符串默认不用加上单引号或者双引号
  • ""（双引号），name: "zhangsan n lisi" 会输出 zhangsan 换行 lisi
  • ''（单引号），name: 'zhangsan n lisi' 会输出 zhangsan n lisi

（2）对象、Map

  • k: v，在下一行来写对象的属性和值
friends:
    lastName: zhangsan
    age: 20
或者：
friends: {lastName:zhangsan,age:18}

（3）数组(List、Set)

  • 用- 值表示数组中的一个元素
pets:
    ‐ cat
    ‐ dog
    ‐ pig
pets: [cat,dog,pig]

配置文件值注入 🔥

@ConfigurationProperties

1）导入配置文件处理器



    org.springframework.boot
    spring-boot-configuration-processor
    true

2）javaBean对象 @ConfigurationProperties(prefix = "person") 会将配置文件和类进行绑定：

/**
 * 将配置文件中配置的每一个属性的值，映射到这个组件中
 * @ConfigurationProperties：告诉SpringBoot将本类中的所有属性和配置文件中相关的配置进行绑定;
 *      prefix = "person":配置文件中哪个下面的所有属性进行一一映射
 * 只有这个组件是容器中的组件，才能容器提供的@ConfigurationProperties功能;
 */
@Component
@ConfigurationProperties(prefix = "person")
public class Person {
    private String lastName;
    private Integer age;
    private Boolean boss;
    private Date birth;
    private Map maps;
    private List lists;
    private Dog dog;
    ....
}

3）配置文件 application.yml

person:
  lastName: haha
  age: 18
  boss: false
  birth: 2022/01/01
  maps: {k1: v1,k2: v2}
  lists:
    - lisi
    - wangwu
  dog:
    name: 芒果
    age: 1

或者配置文件application.properties

#解决乱码问题
spring.message.encoding=UTF-8
#person
person.last-name=haha
person.age=20
person.birth=2022/01/02
person.boss=true
person.maps.k1=v1
person.maps.k2=v2
person.lists=a,b,c
person.dog.name=丸子
person.dog.age=5

乱码问题还需要配置：image.png 4）单元测试，先将内容注入（@Autowired）然后使用image.png

与@Value的区别

@ConfigurationProperties 与 @Value 的区别：

  • @ConfigurationProperties 是批量注入配置文件中的属性，@Value 是一个个指定
  • @ConfigurationProperties 支持松散绑定(松散语法) 、不支持SpEL(表达式如#{2*4})、支持JSR303数据校验 、支持复杂类型封装(如map)
  • @Value 不支持松散绑定(松散语法) 、支持SpEL、不支持JSR303数据校验 、不支持复杂类型封装
@Component
// @ConfigurationProperties(prefix = "person")
public class Person {
    @Value("${person.last-name}")
    private String lastName;
    @Value("#{2*4}")
    private Integer age;
    @Value("true")
    private Boolean boss;
    @Value("${person.birth}")
    private Date birth;
    ...

松散绑定：– person.firstName：使用标准方式– person.first-name：大写用-– person.first_name：大写用_– PERSON_FIRST_NAME：推荐系统属性使用这种写法JSR303数据校验：image.png 使用规则：

  • 如果说，我们只是在某个业务逻辑中需要获取一下配置文件中的某项值，使用@Value
@Value("${febase.api.host}")
private String febaseHost;
  • 如果说，我们专门编写了一个javaBean来和配置文件进行映射，我们就直接使用@ConfigurationProperties

读取外部配置文件

@PropertySource：加载指定的配置文件

@PropertySource("classpath:person.properties")
@Component
@ConfigurationProperties(prefix = "person")
public class Person {
    private String lastName;
    private Integer age;
    private Boolean boss;
    ...
}

@ImportResource：导入Spring的配置文件，让配置文件里面的内容生效--标注在一个配置类上如下我们自己编写的配置文件：

我们可以标注在主配置类上：

@SpringBootApplication
// 导入Spring的配置文件让其生效
@ImportResource(locations = {"classpath:beans.xml"})
public class SpringBootDemo0Application {
    public static void main(String[] args) {
        SpringApplication.run(SpringBootDemo0Application.class, args);
    }
}

测试：

@SpringBootTest
class SpringBootDemo0ApplicationTests {
    @Autowired
    ApplicationContext ioc;

    @Test
    public void testHelloService(){
        boolean containsBean = ioc.containsBean("helloService");
        System.out.println(containsBean); 
        // 上一步没加@ImportResource之前返回false
        // 添加@ImportResource之后返回true
    }
}

SpringBoot推荐给容器中添加组件的方式，推荐使用全注解的方式 @Configuration

/**
 * @Configuration：指明当前类是一个配置类，就是来替代之前的Spring配置文件
 * 
 * 在配置文件中用标签添加组件。在配置类中使用@Bean注解
 */
@Configuration
public class MyAppConfig {
    // 将方法的返回值添加到容器中;容器中这个组件默认的id就是方法名
    @Bean
    public HelloService helloService(){
        System.out.println("配置类@Bean给容器中添加组件了");
        return new HelloService();
    }
}

配置文件占位符

随机数

${random.value}、${random.int}、${random.long}、${random.uuid}
${random.int(10)}、${random.int[1024,65536]}

占位符获取之前配置的值，如果没有可以是用:指定默认值

#person
person.last-name=haha${random.uuid}
person.age=${random.int}
person.birth=2222/02/02
person.boss=false
person.maps.k1=v11111
person.maps.k2=v22222
person.lists=a,b,c,d,e,f
person.dog.name=${person.hello:hello}_dog
person.dog.age=1

Profile 🔥

Profile是Spring对不同环境提供不同配置功能的支持，可以通过激活、指定参数等方式快速切换环境。 多profile文件形式格式如：application-{profile}.properties/yml，如 application-dev.properties、application-prod.properties

默认使用application.properties的配置

激活方式：

  • 命令行 --spring.profiles.active=dev
    • java -jar spring-boot-02-config-0.0.1-SNAPSHOT.jar --spring.profiles.active=dev;
  • 配置文件 spring.profiles.active=dev
  • jvm参数 –Dspring.profiles.active=dev

image.pngimage.pngyml支持多文档块方式：

server:
    port: 8081
spring:
    profiles:
    active: prod

‐‐‐
server:
    port: 8083
spring:
    profiles: dev

‐‐‐
server:
    port: 8084
spring:
    profiles: prod #指定属于哪个环境

配置文件加载位置

spring boot 启动会扫描以下位置的application.properties或者application.yml文件作为Spring boot的默认配置文件

  • file:./config/
  • file:./
  • classpath:/config/
  • classpath:/

    • 以上是按照优先级从高到低的顺序，所有位置的文件都会被加载，高优先级配置内容会覆盖低优先级配置内容。 可以通过配置spring.config.location来改变默认配置。项目打包好以后，可以使用命令行参数的形式，启动项目的时候来指定配置文件的新位置；指定配置文件和默认加载的这些配置文件共同起作用形成互补配置：java -jar spring-boot-02-config-02-0.0.1-SNAPSHOT.jar --spring.config.location=G:/application.properties

    外部配置加载顺序

    Spring Boot支持多种外部配置方式，优先级从高到低。高优先级的配置覆盖低优先级的配置，所有的配置会形成互补配置：

  • 命令行参数
  • 来自java:comp/env的JNDI属性
  • Java系统属性(System.getProperties())
  • 操作系统环境变量
  • RandomValuePropertySource配置的random.*属性值

    • 由jar包外向jar包内进行寻找。优先加载带profile：

  • jar包外部的application-{profile}.properties或application.yml(带spring.profile)配置文件
  • jar包内部的application-{profile}.properties或application.yml(带spring.profile)配置文件

    • 再来加载不带profile：

  • jar包外部的application.properties或application.yml(不带spring.profile)配置文件
  • jar包内部的application.properties或application.yml(不带spring.profile)配置文件
  • @Configuration注解类上的@PropertySource
  • 通过SpringApplication.setDefaultProperties指定的默认属性

    • 自动配置原理

    配置文件可以配置的属性：docs.spring.io/spring-boot…

    自动配置原理：1）Spring Boot启动时加载主配置类（带有@SpringBootApplication），其里面开启了自动配置功能@EnableAutoConfiguration2）@EnableAutoConfiguration利用@Import(AutoConfigurationImportSelector.class)给容器导入一些组件。导入的组件是通过List configurations = getCandidateConfigurations(annotationMetadata, attributes);获取到的。里面通过SpringFactoriesLoader.loadFactoryNames 扫描所有jar包类路径下"META-INF/spring.factories"，把扫描到的这些文件的内容包装成properties对象，从properties中获取到EnableAutoConfiguration.class类(类名)对应的值，然后把他们添加在容器中。其实就是将类路径下 META-INF/spring.factories 里面配置的所有EnableAutoConfiguration的值加入到了容器中。每一个这样的 xxxAutoConfiguration 类都是容器中的一个组件，都加入到容器中；用他们来做自动配置;3）每一个自动配置类进行自动配置功能 4）以HttpEncodingAutoConfiguration配置类进行分析：

    // 表示这是一个配置类，以前编写的配置文件一样，也可以给容器中添加组件
@AutoConfiguration
// 启动指定类的ConfigurationProperties功能，将配置文件中对应的值和xxxProperties绑定起来，并把xxxProperties加入到ioc容器中
@EnableConfigurationProperties(ServerProperties.class)
// Spring底层@Conditional注解(Spring注解版)，根据不同的条件，如果满足指定的条件，整个配置类里面的配置就会生效;
@ConditionalOnWebApplication(type = ConditionalOnWebApplication.Type.SERVLET)
// 判断当前项目有没有这个类CharacterEncodingFilter-SpringMVC中进行乱码解决的过滤器
@ConditionalOnClass(CharacterEncodingFilter.class)
// 判断配置文件中是否存在某个配置 spring.servlet.encoding.enabled;如果不存在，判断也是成立的
// 即使我们配置文件中不配置spring.servlet.encoding.enabled=true，也是默认生效的;
@ConditionalOnProperty(prefix = "server.servlet.encoding", value = "enabled", matchIfMissing = true)
public class HttpEncodingAutoConfiguration {

    // 他已经和SpringBoot的配置文件映射了
    private final Encoding properties;

    // 只有一个有参构造器的情况下，参数的值就会从容器中拿
    public HttpEncodingAutoConfiguration(ServerProperties properties) {
        this.properties = properties.getServlet().getEncoding();
    }

    @Bean  // 给容器中添加一个组件，这个组件的某些值需要从properties中获取
    @ConditionalOnMissingBean // 判断容器没有这个组件，就给配置一个
    public CharacterEncodingFilter characterEncodingFilter() {
        CharacterEncodingFilter filter = new OrderedCharacterEncodingFilter();
        filter.setEncoding(this.properties.getCharset().name());
        filter.setForceRequestEncoding(this.properties.shouldForce(Encoding.Type.REQUEST));
        filter.setForceResponseEncoding(this.properties.shouldForce(Encoding.Type.RESPONSE));
        return filter;
    }
    ...
}

    根据当前不同的条件判断，决定这个配置类是否生效一但这个配置类生效，这个配置类就会给容器中添加各种组件，这些组件的属性是从对应的properties类中获取的，这些类里面的每一个属性又是和配置文件绑定的 5)、所有在配置文件中能配置的属性都是在xxxxProperties类中封装着，配置文件能配置什么就可以参照某个功能对应的这个属性类

    使用精髓: 1)、SpringBoot启动会加载大量的自动配置类 ；2)、我们看我们需要的功能有没有SpringBoot默认写好的自动配置类；3)、我们再来看这个自动配置类中到底配置了哪些组件(只要我们要用的组件有，我们就不需要再来配置了) 4)、给容器中自动配置类添加组件的时候，会从properties类中获取某些属性。我们就可以在配置文件中指定这些属性的值; xxxxAutoConfigurartion：自动配置类; 给容器中添加组件xxxxProperties：封装配置文件中相关属性

    @Conditional注解

    作用：必须是@Conditional指定的条件成立，才给容器中添加组件，配置配里面的所有内容才生效也就是说，自动配置类必须在一定的条件下才能生效

    @Conditional扩展注解 作用（判断是否满足当前指定条件）
    @ConditionalOnJava 系统的java版本是否符合要求
    @ConditionalOnBean 容器中存在指定Bean
    @ConditionalOnMissingBean 容器中不存在指定Bean
    @ConditionalOnExpression 满足SpEL表达式指定
    @ConditionalOnClass 系统中有指定的类
    @ConditionalOnMissingClass 系统中没有指定的类
    @ConditionalOnSingleCandidate 容器中只有一个指定的Bean，或者这个Bean是首选Bean
    @ConditionalOnProperty 系统中指定的属性是否有指定的值
    @ConditionalOnResource 类路径下是否存在指定资源文件
    @ConditionalOnWebApplication 当前是web环境
    @ConditionalOnNotWebApplication 当前不是web环境
    @ConditionalOnJndi JNDI存在指定项

    想要查看生效的自动配置类，可以在配置文件中配置debug=true，positive为启动的，negative没启用的image.png

    Spring Boot与日志

    日志框架

    市场上存在非常多的日志框架：JUL(java.util.logging)，JCL(Apache Commons Logging)，Log4j，Log4j2，Logback、SLF4j、jboss-logging等。 Spring Boot在框架内容部使用JCL，spring-boot-starter-logging采用了 slf4j+logback的形式，Spring Boot也能自动适配(jul、log4j2、logback) 并简化配置 SpringBoot底层是Spring框架，Spring框架默认是用JCL。SpringBoot选用SLF4j（日志抽象层）和logback（日志实现）

    SLF4j

    开发时日志记录方法的调用，不应该来直接调用日志的实现类，而是调用日志抽象层里面的方法：

    import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class HelloWorld {

  public static void main(String[] args) {
    Logger logger = LoggerFactory.getLogger(HelloWorld.class);
    logger.info("Hello World");
  }
}

    每一个日志的实现框架都有自己的配置文件。使用slf4j以后，配置文件还是做成日志实现框架自己本身的配置文件。如何让系统中所有的日志都统一到slf4j：

  • 将系统中其他日志框架先排除出去
  • 用中间包来替换原有的日志框架
  • 我们导入slf4j其他的实现

    • SpringBoot日志关系

    添加依赖：

    
  org.springframework.boot
  spring-boot-starter-logging

    image.pngSpringBoot能自动适配所有的日志，而且底层使用slf4j+logback的方式记录日志，引入其他框架的时候，只需要把这个框架依赖的日志框架排除掉即可

    
    org.springframework
    spring‐core

            commons‐logging
            commons‐logging

    默认日志配置

    日志级别由低到高：trace