yaml配置注入

已于 2022-10-02 17:26:38 修改
阅读量501 收藏
点赞数
分类专栏： Java Springboot 文章标签： spring boot java
于 2022-10-02 17:09:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_48426115/article/details/127143701
版权

yaml语法学习

配置文件

SpringBoot使用一个全局的配置文件 ， 配置文件名称是固定的

  • application.properties
    • 语法结构：key=value
  • application.yml
    • 语法结构：key: 空格value

        配置文件的作用：修改SpringBoot自动配置的默认值，因为SpringBoot在底层都给我们自动配置好了；比如我们可以在配置文件中修改Tomcat 默认启动的端口号！测试一下！

server.port=8081

yaml概述

        YAML是 "YAML Ain't a Markup Language" （YAML不是一种标记语言）的递归缩写。在开发的这种语言时，YAML 的意思其实是："Yet Another Markup Language"（仍是一种标记语言）

        这种语言以数据作为中心，而不是以标记语言为重点！

        以前的配置文件，大多数都是使用xml来配置；比如一个简单的端口配置，我们来对比下yaml和xml

传统xml配置

<server>
    <port>8081<port>
</server>

yaml配置

server:
  port: 8080

yaml基础语法

    说明：语法要求严格

        1. 空格不能省略
        2. 以缩进来控制层级关系，只要是左边对齐的一列数据都是同一个层级的
        3. 属性和值的大小写都是十分敏感的

字面量：普通的值 [ 数字，布尔值，字符串 ]

        字面量直接写在后面就可以 ， 字符串默认不用加上双引号或者单引号；

注意：

  • ""双引号，不会转义字符串里面的特殊字符 ， 特殊字符会作为本身想表示的意思；

  比如 ：name: "hello \n world"  输出 ：hello 换行 world

  • ''单引号，会转义特殊字符 ， 特殊字符最终会变成和普通字符一样输出

  比如 ：name: ‘hello \n world’  输出 ：hello \n world

    对象、Map（键值对）

#对象、Map格式
k: 
    v1:
    v2:

        在下一行来写对象的属性和值的关系，注意缩进；比如：

student: 
  name: xiaoming
  age: 18

        行内写法

student: {name: xiaoming, age: 18}

    数组（ List、set ）

        用 - 值表示数组中的一个元素,比如：

pets:
  - cat
  - dog
  - pig

        行内写法

pets: [cat, dog, pig]

        修改SpringBoot的默认端口号

server:

  port: 8082

注入配置文件

        yaml文件更强大的地方在于，他可以给我们的实体类直接注入匹配值！

yaml注入配置文件

  1. 在springboot项目中的resources目录下新建一个文件 application.yaml

  2. 编写一个实体类Dog，并用@Value给bean注入属性值(注：通过配置文件给属性注入值，一定要写set方法，下面类其实可以暂时不用写set方法，不过后面会用到)

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

@Component
public class Dog {
    @Value("旺财")
    private String name;
    @Value("3")
    private Integer age;

    public Dog() {
    }

    public Dog(String name, Integer age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

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

        在测试类验证一下

import com.yuan.pojo.Dog;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
class Springboot02ConfigApplicationTests {

    @Autowired
    private Dog dog;

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

    }

}

        打印输入如下

        再新建一个复杂点的实体类Person 并注入到我们的类中

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

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

/*
@ConfigurationProperties作用：
将配置文件中配置的每一个属性的值，映射到这个组件中；
告诉SpringBoot将本类中的所有属性和配置文件中相关的配置进行绑定
参数 prefix = “person” : 将配置文件中的person下面的所有属性一一对应
*/

@Component
@ConfigurationProperties(prefix = "person")
public class Person {
    private String name;
    private Integer age;
    private Boolean happy;
    private Date birth;
    private Map<String,Object> maps;
    private List<Object> list;
    private Dog dog;

    public Person() {
    }

    public Person(String name, Integer age, Boolean happy, Date birth, Map<String, Object> maps, List<Object> list, Dog dog) {
        this.name = name;
        this.age = age;
        this.happy = happy;
        this.birth = birth;
        this.maps = maps;
        this.list = list;
        this.dog = dog;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public Boolean getHappy() {
        return happy;
    }

    public void setHappy(Boolean happy) {
        this.happy = happy;
    }

    public Date getBirth() {
        return birth;
    }

    public void setBirth(Date birth) {
        this.birth = birth;
    }

    public Map<String, Object> getMaps() {
        return maps;
    }

    public void setMaps(Map<String, Object> maps) {
        this.maps = maps;
    }

    public List<Object> getList() {
        return list;
    }

    public void setList(List<Object> list) {
        this.list = list;
    }

    public Dog getDog() {
        return dog;
    }

    public void setDog(Dog dog) {
        this.dog = dog;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", happy=" + happy +
                ", birth=" + birth +
                ", maps=" + maps +
                ", list=" + list +
                ", dog=" + dog +
                '}';
    }
}

        我们来使用yaml配置的方式进行注入，大家写的时候注意区别和优势，我们编写一个yaml配置！

person:
  name: xiaoming
  age: 18
  happy: true
  birth: 2000/10/01
  maps: {k1: v1,k2: v2}
  list:
    -code
    -music
    -run
  dog:
    name: 旺财
    age: 3

        IDEA 提示，springboot配置注解处理器没有找到，让我们看文档，我们可以查看文档，找到一个依赖！

        点击打开，跳转链接Configuration Metadata

        按照文档提供在pom.xml中导入依赖包,就不会报错了

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
            <optional>true</optional>
        </dependency>

        测试

import com.yuan.pojo.Person;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
class Springboot02ConfigApplicationTests {

    @Autowired
    private Person person;

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

加载指定的配置文件

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

        @ConfigurationProperties：默认从全局配置文件中获取值；

        我们去在resources目录下新建一个person.properties文件

name=xiaoming

        新建Person2，指定配置文件

@Component
@PropertySource(value = "classpath:person.properties")
public class Person2 {
    @Value("${name}")
    private String name;
    //...
}

配置文件占位符

        配置文件还可以编写占位符生成随机数

person:
  name: xiaoming${random.uuid}   # 随机uuid
  age: ${random.int} # 随机int
  happy: true
  birth: 1995/11/20
  map: {k1: v1, k2: v2}
  hello: a
  list:
    - code
    - music
  dog:
    name: ${person.hello:other}_小黄 # other代表默认值
    age: 1

        打印结果如下

Person{name='zyye360040f-0b1b-4562-b555-fa409901a021', age=218521969, happy=true, birth=Mon Nov 20 00:00:00 CST 1995, map={k1=v1, k2=v2}, list=[code, music], dog=Dog{name='a_小黄', age=1}}

    小结：

  • ${person.hello:other} 的用法是：当hello没有赋值的时候，直接赋予other值

回顾properties配置

        【注意】properties配置文件在写中文的时候，会有乱码 ， 我们需要去IDEA中设置编码格式为UTF-8；

        新建一个配置文件user.properties

name=xiaoming
age=18
sex=男

        新建一个实体类User，并给属性注入值

import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.PropertySource;
import org.springframework.stereotype.Component;

@Component
@PropertySource(value = "classpath:application.properties")
public class User {
    /**
     * 从配置文件中取值
     */
    @Value("${name}")
    private String name;
    /**
     * #{SPEL} Spring表达式
     */
    @Value("#{9*2}")
    private int age;
    /**
     * 字面量
     */
    @Value("男")
    private String sex;

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

        测试验证

import com.yuan.pojo.User;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
class Springboot01IdeaApplicationTests {

    @Autowired
    private User user;

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

 

对比小结

        @Value这个使用起来并不友好！我们需要为每个属性单独注解赋值，比较麻烦；我们来看个功能对比图

@ConfigurationProperties@Value
功能批量注入配置文件中的属性一个个指定
松散绑定支持不支持
SPEL不支持支持
JSR303数据校验支持不支持
复杂类型封装支持不支持

        1. @ConfigurationProperties只需要写一次即可 ， @Value则需要每个字段都添加

        2. 松散绑定：这个什么意思呢? 比如我的yml中写的last-name，这个和lastName是一样的，后面跟着的字母默认是大写的。这就是松散绑定。可以测试一下（注意set方法必须修改）

    yaml

person:
  last-name: xiaoming${random.uuid}   # 随机uuid
  age: ${random.int} # 随机int
# ....

//...
@Component
@ConfigurationProperties(prefix="person")
public class Person {
    private String lastName;
    //...
    public void setLastName(String lastName) {
        this.lastName = lastName;
    }
    //...
}

        这种也是可以正常输出的

        3.JSR303数据校验 ， 这个就是我们可以在字段是增加一层过滤器验证 ， 可以保证数据的合法性

    导入jar包

        <dependency>
            <groupId>javax.validation</groupId>
            <artifactId>validation-api</artifactId>
        </dependency>

        <dependency>
            <groupId>org.hibernate.validator</groupId>
            <artifactId>hibernate-validator</artifactId>
        </dependency>

        实体类校验

//...
@Component
@ConfigurationProperties(prefix = "person")
@Validated //数据校验
public class Person {
    @NotBlank(message = "姓名不可为空")
    private String name;
    private int age;
    //...
}

        application.yaml配置类

person:
  age: 18

        测试验证，报错如下

        拓展：

部分代码：
@NotNull(message="名字不能为空")
private String userName;
@Max(value=120,message="年龄最大不能查过120")
private int age;
@Email(message="邮箱格式错误")
private String email;
-----------------------
空检查
@Null       验证对象是否为null
@NotNull    验证对象是否不为null, 无法查检长度为0的字符串
@NotBlank   检查约束字符串是不是Null还有被Trim的长度是否大于0,只对字符串,且会去掉前后空格.
@NotEmpty   检查约束元素是否为NULL或者是EMPTY.
    
Booelan检查
@AssertTrue     验证 Boolean 对象是否为 true  
@AssertFalse    验证 Boolean 对象是否为 false  
    
长度检查
@Size(min=, max=) 验证对象（Array,Collection,Map,String）长度是否在给定的范围之内  
@Length(min=, max=) string is between min and max included.

日期检查
@Past       验证 Date 和 Calendar 对象是否在当前时间之前  
@Future     验证 Date 和 Calendar 对象是否在当前时间之后  
@Pattern    验证 String 对象是否符合正则表达式的规则

        4.复杂类型封装，yml中可以封装对象 ， 使用value就不支持

结论

  • 配置yml和配置properties都可以获取到值 ， 强烈推荐 yaml；
  • 如果我们在某个业务中，只需要获取配置文件中的某个值，可以使用一下 @value；
  • 如果说，我们专门编写了一个JavaBean来和配置文件进行一一映射，就直接使用@configurationProperties

ABCdxy~
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
3.yaml配置注入
我就要用HashMap的博客
01-11 401
SpringBoot使用一个全局的配置文件 ， 配置文件名称是固定的 application.properties语法结构 ： key=value application.yml语法结构 ：key：空格 value SpringBoot在底层都给我们自动配置好了，我们可以编写配置文件来修改SpringBoot自动配置的默认值 yml语法要求严格，注意空格不能省略，注意层级关系，属性和值的大小写都十分敏感 name: lisi 字面量直接写在后面就可以 ， 字符串默认不用加上双引号或者单引号，注意“ ” 双
YAMLDemo:Spring Boot 2.0获取自定义YAML配置Demo
05-13
在本文中，我们将深入探讨如何在Spring Boot 2.0应用程序中使用YAML配置文件，特别是在实现自定义YAML配置的加载。YAML（YAML Ain't Markup Language）是一种简洁且易于阅读的数据序列化格式，常用于配置文件，因为...
.yaml参数文件的编写和使用
weixin_30770783的博客
03-22 3506
.yaml参数文件的编写和使用 一、在ROS底下使用.yaml文件配置参数 在ROS底下用起来还是非常方便的，首先，写一个读参数的函数getParam(),由于参数类型不止一种，所以要使用模板。 具体语句如下： template<typename T> T getParam(const string& name,...
python用yaml装参数并支持命令行修改
iTom's blog
02-09 742
python 读、写 yaml，用 EasyDict，命令行多级指定参数
Hibernate的两种配置方法
fengyun86的专栏
12-21 592
 1、 hibernate的配置文件：hibernate可以使用properties文件配置也可以使用xml文件配置，用properties进行配置时(例子如下)：hibernate.propertieshibernate.connection.url=jdbc:mysql://localhost:3306/testhibernate.connection.username=roo
认识Yaml
weixin_54721820的博客
04-14 286
1.基本语法 大小写敏感 使用缩进表示层级关系 缩进不允许使用tab，只允许空格 缩进的空格数不重要，只要相同层级的元素左对齐即可 '#'表示注释 2.yaml支持的数据类型 对象：键值对的集合，又称为映射（mapping）/ 哈希（hashes） / 字典（dictionary） 数组：一组按次序排列的值，又称为序列（sequence） / 列表（list） 纯量（scalars）：单个的、不可再分的值、 YAML 对象 对象键值对使用冒号结构表示 key: value，冒号后面要加一.
springboot中配合使用yaml配置,适合初学者
04-29
对于初学者来说，理解和掌握Spring Boot中的YAML配置是至关重要的，因为它可以使项目的配置变得更加清晰和直观。下面我们将详细探讨Spring Boot与YAML配置的结合使用。 1. YAML的基础知识： YAML是一种人类可读的...
SpringBoot yml配置文件注入List和Map
12-20
本篇将详细介绍如何在Spring Boot的YAML配置文件中注入List和Map，并展示如何在代码中使用它们。 首先，我们需要在`application.yml`或`application.yaml`配置文件中定义List和Map。List的定义如下： ```yaml ...
MildLamb#Learn_SpringBoot#yaml配置与参数获取1
07-25
可以注入到我们的配置类中普通键值对存对象行内写法行内写法行内写法# 如果有champion.name则使用champion.name的值 没有则使用默认值kin
YAML解析器 SnakeYAML
06-06
4. **安全模式**：在解析YAML时，SnakeYAML可以启用安全模式，防止代码注入攻击。在安全模式下，库会限制某些可能导致执行Java代码的YAML特性。 5. **错误处理**：当解析YAML文档遇到问题时，SnakeYAML会抛出异常，...
kubernetes-yaml-templates：Kubernetes Yaml模板
01-30
- **ConfigMap和Secret YAML**：展示了如何创建和引用ConfigMap或Secret，以便将配置信息注入到Pod中。 此外，这个压缩包可能还包含了自定义资源定义（Custom Resource Definition, CRD）的YAML，用于扩展...
详解Python yaml模块
09-24
二、Python中读取yaml配置文件 1. 前提条件： 在Python中使用yaml模块，首先需要通过pip3安装pyyaml库：`pip3 install pyyaml`。然后在代码中导入yaml模块：`import yaml`。 2. 读取yaml文件数据： 使用Python的...
spring-boot-sample-yaml-config:使用 YAML 的 Spring 应用程序配置和配置文件
06-15
5. **配置属性注入**：在 Spring 组件中如何通过 `@Value` 或 `@ConfigurationProperties` 注解注入配置属性值。 6. **配置文件热更新**：Spring Boot 支持配置文件的热更新，修改配置后无需重启应用即可生效。 7....
bootstrap_配置文件_
10-03
在Spring Boot的应用中，Bootstrap.yaml（或bootstrap.properties）文件是用来加载应用程序的“外部”配置，这些配置通常包含敏感信息，如数据库连接字符串、API密钥等，因为它们可以在应用程序启动时安全地获取。...
005 springCloudAlibaba nacos配置中心
最新发布
05-06
3. **创建配置**：在Nacos控制台，创建配置项，数据ID通常以`${spring.application.name}.properties`或`yaml`格式，这样Nacos可以自动识别并加载对应的配置。 4. **使用配置**：在Spring Cloud应用中，可以使用`@...
Kubernetes管理容器——yaml文件的生成与重要参数详解
weixin_43831132的博客
05-16 3036
yaml文件的生成 格式：kubectl run 自定义pod名称 --image=自定义镜像名称 --dry-run=client（这里还可以定义为server但是推荐client） -o yaml > 自定义名称.yaml 例：kubectl run nginx --image=nginx --dry-run=client -o yaml > pod1.yaml 这样我们就定义好了一个yaml文件基础模板在当前目录下，剩下的工作就是在模板内修改部分参数并运行这个yaml文件即可。 查看yam
关于使用launch文件、yaml文件传入参数，并使用动态参数配置工具rqt_reconfigure调整参数的方法。
ws107845f的博客
05-10 3264
本文阐述了ros中动态配置参数，并通过launch文件yaml文件传参的方法
yaml数据参数化
yy050810的博客
04-05 2563
1、加载yaml文件 yaml.safe_ load(open(" ./data.yaml")) 2、yaml内容 e.g.1：字典 dict：companies: [{id: 1,name: company1,price: 200W},{id: 2,name: company2,price:500W}] yaml文件： companies: - id: 1 name...
【C++】42.使用YAML文件进行参数配置、读取与生成YAML文件
u011754972的博客
09-08 9480
c++中如果要使用YAML，需要安装yaml-cpp库，安装完成后使用时还需要包含下面的头文件： #include "yaml-cpp/yaml.h" 关于安装以及语法，可以参考下面两篇博客 C++ 解析yaml文件的使用方法：https://blog.csdn.net/sunlin972913894/article/details/103038082 c++ 开发中利用yaml-cpp读写yaml配置文件：https://cloud.tencent.com/developer/article/14234
yaml配置数据源的bean
05-31
在 Spring Boot 应用程序中，我们可以使用 YAML 配置文件来配置数据源的 Bean，具体操作步骤如下： 1. 在 `application.yml` 或 `application.properties` 配置文件中添加数据源的相关属性，例如： ```yaml spring...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值