Spring Boot从0开始学的个人笔记 2 -- 配置文件

其他 2021-04-01 10:33:24 阅读次数: 0

1、YAML文件配置属性

这个YAML呢，是一个配置的东西，刚开始没有的，要自己手动创建才可以，而且名字是固定的:application.yml在这里插入图片描述### 2、基本语法：##### ①普通的值v: 值空格必须要有，而且左边对齐的话，是同一个层级的，而且字符串默认不用加上单引号或者双引号；如果要用到""或者’'也可以- “” ： 不会转义字符，如\n输出换行- ‘’ :会转义字符，如输入\n输出\n##### ②对象、Map（属性和值）（键值对）k: v: 值在下一行来写对象的属性和值的关系；注意缩进.对象还是k: v的方式多行写法：yamlfriend: name: 张三 age: 20单行写法：yamlfriend: {name: 张三,age: 20}##### ③数组(List\Set)多行写法：yamlpets: - cat - dog - pig单行写法：yamlpets: [cat,dog,pig]### 3、配置文件中值的注入（设置值，可以让后台看到）在这里插入图片描述javapackage com.qiang.springbootfast.bean;public class Gril { private String name; private int age; @Override public String toString() { return "Gril{" + "name='" + name + '\'' + ", age=" + age + '}'; }}``````javapackage com.qiang.springbootfast.bean;import org.springframework.boot.context.properties.ConfigurationProperties;import org.springframework.stereotype.Component;import java.util.Date;import java.util.List;import java.util.Map;@Component//把这个类实例化到spring boot容器中，就是把这个类当作组件@ConfigurationProperties(prefix = "person")public class Person { private String name; private int age; private boolean boss; private Date birth; private Map<String,Object> maps; private List<Object> lists; private Gril gril; @Override public String toString() { return "Person{" + "name='" + name + '\'' + ", age=" + age + ", boss=" + boss + ", birth=" + birth + ", maps=" + maps + ", lists=" + lists + ", gril=" + gril + '}'; } }- @Component：把这个类实例化到spring boot容器中，就是把这个类当作组件- @ConfigurationProperties(prefix = "person")：这个注解呢，就是告诉spring将本类中所有的属性和配置文件都与yml文件进行绑定，(prefix = "person")：配置文件（yml）中的person下面的属性一一配对- 只有这个组件是容器中的组件，才能容器提供的@ConfigurationProperties功能；- 用到@ConfigurationProperties，需要导入jar包xml<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-configuration-processor</artifactId> <optional>true</optional></dependency>配置文件application.yml：ymlserver: port: 8081person: name: 小强 age: 22 boss: true birth: 2020/07/04 maps: {k1: v1,k2: v2} lists: - 对象1 - 对象2 gril: name: 相泽南 age: 25##### 在后台中查看然后在测试用例中javapackage com.qiang.springbootfast;import com.qiang.springbootfast.bean.Person;import org.junit.jupiter.api.Test;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.boot.test.context.SpringBootTest;@SpringBootTestclass SpringBootFastApplicationTests { @Autowired Person person; @Test void contextLoads() { System.out.println(person); } }- @SpringBootTest:spring的单元测试- @Autowired：创建的这个对象，自动获得与配置文件相对应的值点这个：在这里插入图片描述在这里插入图片描述可以看到，值已经传进来了##### 在网页端显示控制类javapackage com.qiang.springbootfast.controller;import com.qiang.springbootfast.bean.Person;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.stereotype.Controller;import org.springframework.web.bind.annotation.RequestMapping;import org.springframework.web.bind.annotation.ResponseBody;import org.springframework.web.bind.annotation.RestController;@RestControllerpublic class ControllerApplication { @Autowired Person person; @RequestMapping("/hello") //在服务器的哪里打开 public String hello(){ return person.toString(); }}在这里插入图片描述### 4、.properties文件配置属性在这里插入图片描述javaserver.port=8081person.name=小强person.age=22person.boss=trueperson.birth=2020/07/11person.maps.k1=v1person.maps.k2=v2person.lists=a,b,c,dperson.gril.name=相泽南person.gril.age=18在这里插入图片描述注意：这里的properties文件中的person，是要在Person类中用@ConfigurationProperties(prefix = "person")进行绑定的### 5、@Value赋值在上面，我们都是用注解@ConfigurationProperties(prefix = "xxxx")来进行赋值的，这个注解是在yml或者properties中写好然后全部赋值的。但是@Value是可以一个个地赋值的，可以只拿yml或者properties中的某些值，也可以在类中直接@Value("xxx")赋值yml:ymlserver: port: 8081person: name: 小强 age: 22 boss: true birth: 2020/07/04 maps: {k1: v1,k2: v2} lists: - 对象1 - 对象2 gril: name: 相泽南 age: 25Person类：javapackage com.qiang.springbootfast.bean;import org.springframework.beans.factory.annotation.Value;import org.springframework.boot.context.properties.ConfigurationProperties;import org.springframework.stereotype.Component;import java.util.Date;import java.util.List;import java.util.Map;@Component//把这个类实例化到spring boot容器中，就是把这个类当作组件//@ConfigurationProperties(prefix = "person")public class Person { @Value("${person.name}")//在yml写好，然后@Value拿person.name过来 private String name; @Value("#{11*2}")//进行计算 private int age; @Value("true")//直接赋值 private boolean boss; private Date birth; private Map<String,Object> maps; private List<Object> lists; private Gril gril; @Override public String toString() { return "Person{" + "name='" + name + '\'' + ", age=" + age + ", boss=" + boss + ", birth=" + birth + ", maps=" + maps + ", lists=" + lists + ", gril=" + gril + '}'; }在这里插入图片描述@Value有几种赋值方式1. @Value("xxx")直接赋值2. @Value(${xxx})xxx里写yml或者properties的对应值3. @Value(#{运算的结果})里面可以写#{11*2},的出来的就是@Value("22")，这个叫SpEL### 6、番外篇：注解@Validated，数据校验@Validated,这个注解是用来进行数据校验的，比如你在类上边写@Validated，那么在下面的属性前加上要校验的格式，就可以校验了，比如@Email，那么就会校验这个属性是不是邮箱格式，如果不是邮箱格式，那么会在控制台报错，如果是邮箱格式，那么就OK但是这个@Validated注解，@ConfigurationProperties可以识别，@Value不能识别需要导入jar包：xml<dependency> <groupId>org.hibernate</groupId> <artifactId>hibernate-validator</artifactId> <version>6.0.7.Final</version></dependency>``````java@Component//把这个类实例化到spring boot容器中，就是把这个类当作组件@Validated//数据校验public class Person { @Email//检查name是不是邮箱格式 @Value("小强") private String name; }在这里插入图片描述### 7、@Value与@ConfigurationProperties区别在这里插入图片描述SpEL是${获取对应的值}JSR303是@Validated数据校验### 8、@PropertySource：加载指定的配置文件上面的那些配置文件，都是配置在全局变量中的，但实际开发中，不会配置那么多在全局变量里面的，都是划分一堆文件，然后一个文件负责配置某几个类的赋值。那么要怎么获取那些分割开来的配置文件？用@PropertySource，把分割开来的放在resources中，内容的格式和properties的一样在这里插入图片描述javaperson.name=小明person.age=18person.boss=falseperson.birth=2020/07/11person.maps.k1=v1person.maps.k2=v2person.lists=a,b,c,dperson.gril.name=小芳person.gril.age=18Person类java@PropertySource(value = {"classpath:person.properties"})@Component//把这个类实例化到spring boot容器中，就是把这个类当作组件@ConfigurationProperties(prefix = "person")//优先级是yml和properties的public class Person { private String name; private int age; private boolean boss; private Date birth; private Map<String,Object> maps; private List<Object> lists; private Gril gril; @Override public String toString() { return "Person{" + "name='" + name + '\'' + ", age=" + age + ", boss=" + boss + ", birth=" + birth + ", maps=" + maps + ", lists=" + lists + ", gril=" + gril + '}'; }}测试类：java//单元测试@SpringBootTestclass SpringBootFastApplicationTests { @Autowired Person person; @Test void contextLoads() {// System.out.println(person); System.out.println(person); }}在这里插入图片描述- @PropertySource(value = {"classpath:指定的文件"})：这个指定的文件必须是resources下的文件- 配合@ConfigurationProperties(prefix = "xxxx")使用，xxx是指定文件下的对应值### 9、@ImportResource：导入Spring的配置文件，让配置文件里面的内容生效Spring Boot没有Spring的配置文件，我们自己写的配置文件呢，也没有办法识别，因为spring BOOT已经整合了，如果要加，那么就要用到@ImportResource注解格式：- @ImportResource(locations = {"classpath:配置文件.xml"})，该xml文件放在resource下但由于我没学过spring，所以没有办法演示，但是！！！看不懂没关系，继续往下面走### 10、@Configuration与@Beanspring boot推荐我们给容器中添加组件的方式，是使用全注解的方式，省事又不用麻烦====================================================##### 1）这里先说一个东西：番外篇ApplicationContext这是一个类，类中有一个方法containsBean(组件名)，判断该容器是否有该组件，有就返回true，没就返回false使用java@AutowiredApplicationContext ioc;可以自动获得值，这个包含很多东西，但是我们只要其中的一个ApplicationContext.containsBean方法而已依赖xml<dependency> <groupId>....org.springframework</groupId> <artifactId>spring-context</artifactId> <version>5.2.1.RELEASE</version> </dependency>1. 首先，创建一个配置类，用@Configuration标识该类，就像@SpringBootApplication和@RestController一样，标识了主程序类和容器类2. 在配置类中，用@Bean给容器中添加组件- 先创建一个类，内容为空，把他当作组件类/service类在这里插入图片描述- 写配置类java@Configurationpublic class MyAppConfig { //将方法的返回值添加到容器中；容器中这个组件默认的id就是方法名 @Bean//将返回值添加到容器中 public HelloService helloService(){ System.out.println("配置类@Bean给容器中添加组件了..."); return new HelloService(); }}注意，这个容器的名字，就是这个方法的名字，就是该容器id为helloService测试类：java//单元测试@SpringBootTestclass SpringBootFastApplicationTests { @Autowired ApplicationContext ioc; @Test public void test(){ boolean b = ioc.containsBean("helloService");//检查该对象是否已经添加到容器中了 System.out.println(b); }}在这里插入图片描述在这里插入图片描述可以看到，通过@Configuration设置配置类，用@Bean进行组件的添加，id为方法名，这样就可以把HelloService加到组件中了，这样，我们也不用写xml来进行配置了### 11、配置文件占位符在yml或者properties中，可以用到随机数，或者调用刚赋值的值，又或者创建不存在的东西ymlperson: name: ${random.uuid} age: ${random.int(100)} #100是最大值 boss: true birth: 2020/07/04 maps: {k1: v1,k2: v2} lists: - ${person.no1} - ${person.no5:不存在的对应属性} gril: name: ${person.name}的女朋友 age: 25输出的结果Person{name='36fff990-c76f-4a26-bf96-17a3a66c841a', age=79, boss=true, birth=Sat Jul 04 00:00:00 CST 2020, maps={k1=v1, k2=v2}, lists=[${person.no1}, 不存在的对应属性], gril=Gril{name='758b21da-011f-4f56-b843-69667ea30238的女朋友', age=25}}名字是随机生成的，年龄最大时100，然后lists,第一个person.no1不存在，所以直接输出${person.no1}，第二个person.no5虽然也不存在，但是:赋值了，所以值为不存在的对应属性，然后下面，还调用了person.name### 12、profile这个profile呢，是Spring对不同环境提供提供不同配置的支持，比如开发环境配置开发环境的东西，还有测试环境，生产环境和运行环境，每个环境都可以设置不同的环境，这样就方便程序员操作了这个profile的设置，有好几种方法profile文件的格式是application-profile的环境.properties或者是application-profile的环境.yml##### 1）多profile文件在application.properties下激活比如我们写了两个profile的文件，prod（生产环境）和dev（开发环境）分别对应不同的生产环境application-prod.properties:propertiesserver.port=8083application-dev.properties:propertiesserver.port=8082在这里插入图片描述这个时候，我们只是写好文件还没有激活，如果没激活的话，默认使用的是application.properties或者application.yml。要激活的话，在application.properties或者application.yml里面写spring.profiles.active=对应的生产环境比如在application.properties里面写propertiesspring.profiles.active=dev这里的dev对应了我们上面的application-dev.properties,对应的是dev这个profile环境名字这里主程序运行在这里插入图片描述可以看到，我们的dev环境设置的是8082端口，这里也改成了8082端口，就对应上了，除了端口设置，还有很多其他的变量赋值都是同样的道理##### 2）单文件在yml的多文档块方式使用番外篇yml还支持多文档块的方式，就加---，就可以划分文档块在这里插入图片描述鼠标移上去，可以看到这是第几部分=========注意，这个的yml可以用多文档块方式使用，也可以用单文档块使用，不过单文档块使用的话，要配合多profile文件一起使用使用单文件在yml的多文档块方式使用要把profile文件给注释掉了，因为多文件有优先权第一部分必须是配置选择的位置，剩下的是待选项ymlserver: port: 8081spring: profiles: active: prod #spring-profiles-active中选择配置的环境---server: port: 8085spring: profiles: dev #表明这个环境是dev环境的---server: port: 8086spring: profiles: prod #表明这个环境是prod环境的在这里插入图片描述##### 3）前两种方法的注意事项可以看到多profile文件与yml的多文档块方式是一样的，就是说，这两个取一种方法即可，不要两种都写##### 4）IDEA的自带命令行方式激活除了在properties和yml激活，IDEA还自带了激活的方式在这里插入图片描述在这里插入图片描述这里的激活格式为--spring.profiles.active=环境名，这个激活的方式优先于前边两个方式，即使你YML写的是prod，这里写了dev，会覆盖yml写的东西在这里插入图片描述##### 5）打包后在CMD中指定环境激活在CMD里面的指定方式，比前面的优先级都要高就，很上面的笔记，把项目打包成jar，然后cmd打开他，在 打开的时候，在最后面加上一句话，--spring.profiles.active=dev，就ok了##### 6）虚拟机参数激活-Dspring.profiles.active=环境名在这里插入图片描述在这里插入图片描述### 13、配置文件加载位置springboot 启动会扫描以下位置的application.properties或者application.yml文件作为Spring boot的默认配置文件–file:./config/–file:./–classpath:/config/–classpath:/优先级由高到底，高优先级的配置会覆盖低优先级的配置；SpringBoot会从这四个位置全部加载主配置文件；互补配置；在这里插入图片描述这里的classpath默认是resources，file就是这个项目##### 1）指定配置文件路径项目打包好以后，我们可以使用命令行参数的形式，启动项目的时候来指定配置文件的新位置；指定配置文件和默认加载的这些配置文件共同起作用形成互补配置；java -jar spring-boot-02-config-02-0.0.1-SNAPSHOT.jar --spring.config.location=G:/application.properties##### 2）番外篇在application.properties可以配置项目访问路径server.context-path=/boot02这样，我们就要localhost:8080/boot02/访问的东西如(hello)### 14、外部配置加载顺序参考官方文档，里面列举的加载顺序由高到低SpringBoot也可以从以下位置加载配置； 优先级从高到低；高优先级的配置覆盖低优先级的配置，所有的配置会形成互补配置1. 命令行参数2. 来自java:comp/env的JNDI属性3. Java系统属性（System.getProperties()）4. 操作系统环境变量5. RandomValuePropertySource配置的random.*属性值6. jar包外部的application-{profile}.properties或application.yml(带spring.profile)配置文件7. jar包内部的application-{profile}.properties或application.yml(带spring.profile)配置文件8. jar包外部的application.properties或application.yml(不带spring.profile)配置文件9. jar包内部的application.properties或application.yml(不带spring.profile)配置文件10. @Configuration注解类上的@PropertySource11. 通过SpringApplication.setDefaultProperties指定的默认属性##### 1）命令行参数比如用命令行来修改端口号可以在IDEA下面这里，直接变成了CMD窗口了在这里插入图片描述在这里插入图片描述java -jar spring-boot-fast-0.0.1-SNAPSHOT.jar --server.port=8000这个在CMD的时候，命令行修改参数配置多个参数的时候，用空格隔开--配置项=配置值##### 8）jar包外部的application.properties或application.yml(不带spring.profile)配置文件这是个啥东西？简单来说 ，就是，cmd中可以添加指定的配置参数，但是一个个打太麻烦。就，当打包成jar包的时候，把application.properties和jar包放在一个文件夹，这样，直接执行jar包的时候，会自动加载外部的application.properties在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述也不用打什么设置加载这个文件的，只要和这个jar包同一个文件夹名叫application.properties，他就会一起加载的##

1、YAML文件配置属性

这个YAML呢，是一个配置的东西，刚开始没有的，要自己手动创建才可以，而且名字是固定的:application.yml
在这里插入图片描述

2、基本语法：

①普通的值

v: 值
空格必须要有，而且左边对齐的话，是同一个层级的，而且字符串默认不用加上单引号或者双引号；
如果要用到""或者’'也可以

  • “” ： 不会转义字符，如\n输出换行
  • ‘’ :会转义字符，如输入\n输出\n
②对象、Map（属性和值）（键值对）

k: v: 值在下一行来写对象的属性和值的关系；注意缩进.对象还是k: v的方式
多行写法：

friend:
  name: 张三
  age: 20

单行写法：

friend: {
    
    name: 张三,age: 20}
③数组(List\Set)

多行写法：

pets:
  - cat
  - dog
  - pig

单行写法：

pets: [cat,dog,pig]

3、配置文件中值的注入（设置值，可以让后台看到）

在这里插入图片描述

package com.qiang.springbootfast.bean;

public class Gril {
    
    
    private String name;
    private int age;

    @Override
    public String toString() {
    
    
        return "Gril{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}


package com.qiang.springbootfast.bean;

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

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

@Component//把这个类实例化到spring boot容器中，就是把这个类当作组件
@ConfigurationProperties(prefix = "person")
public class Person {
    
    
    private String name;
    private int age;
    private boolean boss;
    private Date birth;

    private Map<String,Object> maps;
    private List<Object> lists;
    private Gril gril;

    @Override
    public String toString() {
    
    
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", boss=" + boss +
                ", birth=" + birth +
                ", maps=" + maps +
                ", lists=" + lists +
                ", gril=" + gril +
                '}';
    }

    
}
  • @Component：把这个类实例化到spring boot容器中，就是把这个类当作组件
  • @ConfigurationProperties(prefix = "person")：这个注解呢，就是告诉spring将本类中所有的属性和配置文件都与yml文件进行绑定，(prefix = "person")：配置文件（yml）中的person下面的属性一一配对
  • 只有这个组件是容器中的组件，才能容器提供的@ConfigurationProperties功能；
  • 用到@ConfigurationProperties，需要导入jar包
<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-configuration-processor</artifactId>
   <optional>true</optional>
</dependency>

配置文件application.yml：

server:
  port: 8081


person:
  name: 小强
  age: 22
  boss: true
  birth: 2020/07/04
  maps: {
    
    k1: v1,k2: v2}
  lists:
    - 对象1
    - 对象2
  gril:
    name: 相泽南
    age: 25
在后台中查看

然后在测试用例中

package com.qiang.springbootfast;

import com.qiang.springbootfast.bean.Person;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
class SpringBootFastApplicationTests {
    
    

    @Autowired
    Person person;

    @Test
    void contextLoads() {
    
    
        System.out.println(person);

    }
    
}
  • @SpringBootTest:spring的单元测试
  • @Autowired：创建的这个对象，自动获得与配置文件相对应的值

点这个：
在这里插入图片描述
在这里插入图片描述
可以看到，值已经传进来了

在网页端显示

控制类

package com.qiang.springbootfast.controller;
import com.qiang.springbootfast.bean.Person;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class ControllerApplication {
    
    
    @Autowired
    Person person;

    @RequestMapping("/hello") //在服务器的哪里打开
    public String hello(){
    
    
        return person.toString();
    }
}

在这里插入图片描述

4、.properties文件配置属性

在这里插入图片描述

server.port=8081

person.name=小强
person.age=22
person.boss=true
person.birth=2020/07/11
person.maps.k1=v1
person.maps.k2=v2
person.lists=a,b,c,d
person.gril.name=相泽南
person.gril.age=18

在这里插入图片描述
注意：这里的properties文件中的person，是要在Person类中用@ConfigurationProperties(prefix = "person")进行绑定的

5、@Value赋值

在上面，我们都是用注解@ConfigurationProperties(prefix = "xxxx")来进行赋值的，这个注解是在yml或者properties中写好然后全部赋值的。
但是@Value是可以一个个地赋值的，可以只拿yml或者properties中的某些值，也可以在类中直接@Value("xxx")赋值
yml:

server:
  port: 8081


person:
  name: 小强
  age: 22
  boss: true
  birth: 2020/07/04
  maps: {
    
    k1: v1,k2: v2}
  lists:
    - 对象1
    - 对象2
  gril:
    name: 相泽南
    age: 25

Person类：

package com.qiang.springbootfast.bean;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

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

@Component//把这个类实例化到spring boot容器中，就是把这个类当作组件
//@ConfigurationProperties(prefix = "person")
public class Person {
    
    
    @Value("${person.name}")//在yml写好，然后@Value拿person.name过来
    private String name;
    @Value("#{11*2}")//进行计算
    private int age;
    @Value("true")//直接赋值
    private boolean boss;
    private Date birth;

    private Map<String,Object> maps;
    private List<Object> lists;
    private Gril gril;

    @Override
    public String toString() {
    
    
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", boss=" + boss +
                ", birth=" + birth +
                ", maps=" + maps +
                ", lists=" + lists +
                ", gril=" + gril +
                '}';
    }

在这里插入图片描述
@Value有几种赋值方式

  1. @Value("xxx")直接赋值
  2. @Value(${xxx})xxx里写yml或者properties的对应值
  3. @Value(#{运算的结果})里面可以写#{11*2},的出来的就是@Value("22")，这个叫SpEL

6、番外篇：注解@Validated，数据校验

@Validated,这个注解是用来进行数据校验的，比如你在类上边写@Validated，那么在下面的属性前加上要校验的格式，就可以校验了，比如@Email，那么就会校验这个属性是不是邮箱格式，如果不是邮箱格式，那么会在控制台报错，如果是邮箱格式，那么就OK
但是这个@Validated注解，@ConfigurationProperties可以识别，@Value不能识别
需要导入jar包：

<dependency>
    <groupId>org.hibernate</groupId>
    <artifactId>hibernate-validator</artifactId>
    <version>6.0.7.Final</version>
</dependency>

@Component//把这个类实例化到spring boot容器中，就是把这个类当作组件
@Validated//数据校验
public class Person {
    
    
    @Email//检查name是不是邮箱格式
    @Value("小强")
    private String name;
   }

在这里插入图片描述

7、@Value与@ConfigurationProperties区别

在这里插入图片描述
SpEL是${获取对应的值}
JSR303是@Validated数据校验

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

上面的那些配置文件，都是配置在全局变量中的，但实际开发中，不会配置那么多在全局变量里面的，都是划分一堆文件，然后一个文件负责配置某几个类的赋值。那么要怎么获取那些分割开来的配置文件？用@PropertySource，把分割开来的放在resources中，内容的格式和properties的一样

在这里插入图片描述

person.name=小明
person.age=18
person.boss=false
person.birth=2020/07/11
person.maps.k1=v1
person.maps.k2=v2
person.lists=a,b,c,d
person.gril.name=小芳
person.gril.age=18

Person类

@PropertySource(value = {
    
    "classpath:person.properties"})
@Component//把这个类实例化到spring boot容器中，就是把这个类当作组件
@ConfigurationProperties(prefix = "person")//优先级是yml和properties的
public class Person {
    
    
    private String name;
    private int age;
    private boolean boss;
    private Date birth;

    private Map<String,Object> maps;
    private List<Object> lists;
    private Gril gril;

    @Override
    public String toString() {
    
    
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", boss=" + boss +
                ", birth=" + birth +
                ", maps=" + maps +
                ", lists=" + lists +
                ", gril=" + gril +
                '}';
    }
}

测试类：

//单元测试
@SpringBootTest
class SpringBootFastApplicationTests {
    
    

    @Autowired
    Person person;

    @Test
    void contextLoads() {
    
    
//        System.out.println(person);
        System.out.println(person);
    }
}

在这里插入图片描述

  • @PropertySource(value = {"classpath:指定的文件"})：这个指定的文件必须是resources下的文件
  • 配合@ConfigurationProperties(prefix = "xxxx")使用，xxx是指定文件下的对应值

9、@ImportResource：导入Spring的配置文件，让配置文件里面的内容生效

Spring Boot没有Spring的配置文件，我们自己写的配置文件呢，也没有办法识别，因为spring BOOT已经整合了，如果要加，那么就要用到@ImportResource注解
格式：

  • @ImportResource(locations = {"classpath:配置文件.xml"})，该xml文件放在resource下

但由于我没学过spring，所以没有办法演示，但是！！！看不懂没关系，继续往下面走

10、@Configuration与@Bean

spring boot推荐我们给容器中添加组件的方式，是使用全注解的方式，省事又不用麻烦

====================================================

1）这里先说一个东西：番外篇

ApplicationContext这是一个类，类中有一个方法containsBean(组件名)，判断该容器是否有该组件，有就返回true，没就返回false
使用

@Autowired
ApplicationContext ioc;

可以自动获得值，这个包含很多东西，但是我们只要其中的一个ApplicationContext.containsBean方法而已
依赖

<dependency>
            <groupId>....org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.2.1.RELEASE</version>
        </dependency>

============================================================

  1. 首先，创建一个配置类，用@Configuration标识该类，就像@SpringBootApplication和@RestController一样，标识了主程序类和容器类
  2. 在配置类中，用@Bean给容器中添加组件
  • 先创建一个类，内容为空，把他当作组件类/service类
    在这里插入图片描述
  • 写配置类
@Configuration
public class MyAppConfig {
    
    
    //将方法的返回值添加到容器中；容器中这个组件默认的id就是方法名
    @Bean//将返回值添加到容器中
    public HelloService helloService(){
    
    
        System.out.println("配置类@Bean给容器中添加组件了...");
        return new HelloService();
    }
}

注意，这个容器的名字，就是这个方法的名字，就是该容器id为helloService

========================

测试类：

//单元测试
@SpringBootTest
class SpringBootFastApplicationTests {
    
    
    @Autowired
    ApplicationContext ioc;
    
    @Test
    public void test(){
    
    
        boolean b = ioc.containsBean("helloService");//检查该对象是否已经添加到容器中了
        System.out.println(b);
    }
}

在这里插入图片描述
在这里插入图片描述

可以看到，通过@Configuration设置配置类，用@Bean进行组件的添加，id为方法名，这样就可以把HelloService加到组件中了，这样，我们也不用写xml来进行配置了

11、配置文件占位符

在yml或者properties中，可以用到随机数，或者调用刚赋值的值，又或者创建不存在的东西


person:
  name: ${
    
    random.uuid}
  age: ${
    
    random.int(100)} #100是最大值
  boss: true
  birth: 2020/07/04
  maps: {
    
    k1: v1,k2: v2}
  lists:
    - ${
    
    person.no1}
    - ${
    
    person.no5:不存在的对应属性}
  gril:
    name: ${
    
    person.name}的女朋友
    age: 25

输出的结果

Person{name='36fff990-c76f-4a26-bf96-17a3a66c841a', age=79, boss=true, birth=Sat Jul 04 00:00:00 CST 2020, maps={k1=v1, k2=v2}, lists=[${person.no1}, 不存在的对应属性], gril=Gril{name='758b21da-011f-4f56-b843-69667ea30238的女朋友', age=25}}

名字是随机生成的，年龄最大时100，然后lists,第一个person.no1不存在，所以直接输出${person.no1}，第二个person.no5虽然也不存在，但是:赋值了，所以值为不存在的对应属性，然后下面，还调用了person.name

12、profile

这个profile呢，是Spring对不同环境提供提供不同配置的支持，比如开发环境配置开发环境的东西，还有测试环境，生产环境和运行环境，每个环境都可以设置不同的环境，这样就方便程序员操作了
这个profile的设置，有好几种方法
profile文件的格式是application-profile的环境.properties或者是application-profile的环境.yml

1）多profile文件在application.properties下激活

比如我们写了两个profile的文件，prod（生产环境）和dev（开发环境）分别对应不同的生产环境
application-prod.properties:

server.port=8083

application-dev.properties:

server.port=8082

在这里插入图片描述
这个时候，我们只是写好文件还没有激活，如果没激活的话，默认使用的是application.properties或者application.yml。
要激活的话，在application.properties或者application.yml里面写spring.profiles.active=对应的生产环境
比如在application.properties里面写

spring.profiles.active=dev

这里的dev对应了我们上面的application-dev.properties,对应的是dev这个profile环境名字
这里主程序运行
在这里插入图片描述
可以看到，我们的dev环境设置的是8082端口，这里也改成了8082端口，就对应上了，除了端口设置，还有很多其他的变量赋值都是同样的道理

2）单文件在yml的多文档块方式使用

番外篇================================

yml还支持多文档块的方式，就加---，就可以划分文档块
在这里插入图片描述
鼠标移上去，可以看到这是第几部分

=========================

注意，这个的yml可以用多文档块方式使用，也可以用单文档块使用，不过单文档块使用的话，要配合多profile文件一起使用

使用单文件在yml的多文档块方式使用要把profile文件给注释掉了，因为多文件有优先权
第一部分必须是配置选择的位置，剩下的是待选项

server:
  port: 8081
spring:
  profiles:
    active: prod #spring-profiles-active中选择配置的环境
---
server:
  port: 8085
spring:
  profiles: dev #表明这个环境是dev环境的
---
server:
  port: 8086
spring:
  profiles: prod #表明这个环境是prod环境的

在这里插入图片描述

3）前两种方法的注意事项

可以看到多profile文件与yml的多文档块方式是一样的，就是说，这两个取一种方法即可，不要两种都写

4）IDEA的自带命令行方式激活

除了在properties和yml激活，IDEA还自带了激活的方式
在这里插入图片描述
在这里插入图片描述
这里的激活格式为--spring.profiles.active=环境名，这个激活的方式优先于前边两个方式，即使你YML写的是prod，这里写了dev，会覆盖yml写的东西
在这里插入图片描述

5）打包后在CMD中指定环境激活

在CMD里面的指定方式，比前面的优先级都要高
就，很上面的笔记，把项目打包成jar，然后cmd打开他，在 打开的时候，在最后面加上一句话，--spring.profiles.active=dev，就ok了

6）虚拟机参数激活

-Dspring.profiles.active=环境名
在这里插入图片描述
在这里插入图片描述

13、配置文件加载位置

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

–file:./config/

–file:./

–classpath:/config/

–classpath:/

优先级由高到底，高优先级的配置会覆盖低优先级的配置；

SpringBoot会从这四个位置全部加载主配置文件；互补配置；
在这里插入图片描述
这里的classpath默认是resources，file就是这个项目

1）指定配置文件路径

项目打包好以后，我们可以使用命令行参数的形式，启动项目的时候来指定配置文件的新位置；指定配置文件和默认加载的这些配置文件共同起作用形成互补配置；

java -jar spring-boot-02-config-02-0.0.1-SNAPSHOT.jar --spring.config.location=G:/application.properties

2）番外篇

在application.properties可以配置项目访问路径
server.context-path=/boot02
这样，我们就要localhost:8080/boot02/访问的东西如(hello)

14、外部配置加载顺序

参考官方文档，里面列举的加载顺序由高到低
SpringBoot也可以从以下位置加载配置； 优先级从高到低；高优先级的配置覆盖低优先级的配置，所有的配置会形成互补配置

  1. 命令行参数
  2. 来自java:comp/env的JNDI属性
  3. Java系统属性（System.getProperties()）
  4. 操作系统环境变量
  5. RandomValuePropertySource配置的random.*属性值
  6. jar包外部的application-{profile}.properties或application.yml(带spring.profile)配置文件
  7. jar包内部的application-{profile}.properties或application.yml(带spring.profile)配置文件
  8. jar包外部的application.properties或application.yml(不带spring.profile)配置文件
  9. jar包内部的application.properties或application.yml(不带spring.profile)配置文件
  10. @Configuration注解类上的@PropertySource
  11. 通过SpringApplication.setDefaultProperties指定的默认属性
1）命令行参数

比如用命令行来修改端口号
可以在IDEA下面这里，直接变成了CMD窗口了
在这里插入图片描述
在这里插入图片描述
java -jar spring-boot-fast-0.0.1-SNAPSHOT.jar --server.port=8000这个在CMD的时候，命令行修改参数
配置多个参数的时候，用空格隔开
--配置项=配置值

8）jar包外部的application.properties或application.yml(不带spring.profile)配置文件

这是个啥东西？简单来说 ，就是，cmd中可以添加指定的配置参数，但是一个个打太麻烦。就，当打包成jar包的时候，把application.properties和jar包放在一个文件夹，这样，直接执行jar包的时候，会自动加载外部的application.properties
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
也不用打什么设置加载这个文件的，只要和这个jar包同一个文件夹名叫application.properties，他就会一起加载的

15、@Conditional派生注解

@Conditional在Spring只有这个一个注解，但是在spring boot中拓展了，有很多个注解
在这里插入图片描述
这些，比如@ConditionalOnMissingBean(CharacterEncodingFilter.class)，判断容器中是不是没有CharacterEncodingFilter这个组件，如果没有这个组件类，返回true，就执行往后的代码；如果有，返回false，不执行往后的代码；其他的都一样，都是判断的，真就返回true

自动配置类必须在一定的条件下才能生效；

我们怎么知道哪些自动配置类生效；

我们可以通过启用 debug=true属性；来让控制台打印自动配置报告，这样我们就可以很方便的知道哪些自动配置类生效；

在application.properties中，输入debug=true,这样运行的时候，就可以看到哪些自动配置类有启动，哪些自动配置类没有启动
在这里插入图片描述
在这里插入图片描述

猜你喜欢

转载自blog.csdn.net/yi742891270/article/details/107425916
今日推荐
《美国对全球网络空间安全与发展的威胁和破坏》报告发布
火速冲上 GitHub 热榜 —— 开源编程语言、框架哪有这么可爱？
北京人形机器人创新中心发布全球首个纯电驱拟人奔跑的全尺寸人形机器人“天工”
LFOSSA 源来如此公开课 | 掌握云原生未来：CNCF 认证全面攻略与备考秘籍
周排行
循环神经网络（rnn）讲解
Tigao教程四：单独的关节运动
金蝶K3WISE15.0-注册套打教程
如何在Mac上配置Kubernetes
Android应用结束自身进程的方法
SpringMVC学习 十三 拦截器栈
中国驻洛杉矶总领馆举行新春招待会
HttpClient get post 发送
11 - three.js 笔记 - 绘制三维字体模型
Mysql递归获取某个父节点下面的所有子节点和子节点上的所有父节点
每日归档
更多
2024-05-01(4)
2024-04-30(1)
2024-04-29(40)
2024-04-28(0)
2024-04-27(56)
2024-04-26(39)
2024-04-25(22)
2024-04-24(36)
2024-04-23(26)
2024-04-22(39)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022