YML学习

发布时间:2023年12月17日

1.基础知识

1.1 什么是YML

YAML 是 “YAML Ain’t a Markup Language”(YAML 不是一种标记语言)的递归缩写。在开发的这种语言时,YAML 的意思其实是:”Yet Another Markup Language”(仍是一种标记语言)。

YAML是一个类似 XML、JSON 的标记性语言。YAML 强调以数据为中心,并不是以标识语言为重点。因而 YAML 本身的定义比较简单,号称“一种人性化的数据格式语言”。

1.2 YML优点

  • YAML是一种非常简单的基于文本的人类可读的语言,用于在人和计算机之间交换数据。
  • YAML是不是一种编程语言。它主要用于存储配置信息。
  • YAML 的缩进就像 Python 的缩进一样优雅。
  • YAML 还减少了 JSON 和 XML 文件中的大部分“噪音”格式,例如引号、方括号和大括号

1.3 YML使用场景

yml主要用于软件配置,大有替代properties、XML、JSON的趋势,主要其格式简洁易懂

2.YML语法

2.1 基础语法

先看yml示例:

person:
  name: 蒋增奎
  gender: 男
  
spring:
  profiles: dev
  datasource:
    url: jdbc:mysql://127.0.01/banchengbang_springboot
    username: root
    password: root
    driver-class-name: com.mysql.jdbc.Driver

对比json

spring:{
	profiles:"dev",
	datasource:{
		url:"jdbc:mysql://127.0.01/banchengbang_springboot",
		username:"root",
		password:"root",
		driver-class-name:"com.mysql.jdbc.Driver"
	}
}

对比java,和java对象之间的关系更接近

private String profiles;
private Datasource datasource;
  • 使用缩进表示层级关系。 | json使用花括号{}
  • 缩进时不允许使用 Tab 键,只允许使用空格。
  • 缩进的空格数不重要,但同级元素必须左侧对齐。
  • 大小写敏感
  • key:value键值对模式 |和json一样
  • 内容如字符串,不需要加""

与json区别

  • 大小写敏感 (json 里也是大小写敏感的)
  • 使用缩进表示层级关系 (json 中使用 {} 表示层级)
  • "#"表示注释 (json 不允许写注释, yaml 写的配置文件要比 json 方便很多)
  • key : val 值之前必须有空格
  • 多个key-val组合,不需要加逗号","

总结:比json少{},逗号,多缩进和值前空格

YAML 支持以下三种数据结构:

  • 对象:键值对的集合
  • 数组:一组按次序排列的值
  • 字面量:单个的、不可拆分的值

2.2 字面量数据类型

  1. 字面量是指单个的,不可拆分的值,例如:数字、字符串、布尔值、以及日期等。
  2. 在 YAML 中,使用“key:[空格]value”的形式表示一对键值对(空格不能省略), 如 url:
    www.biancheng.net。
  3. 字面量直接写在键值对的“value”中即可,且默认情况下字符串是不需要使用单引号或双引号的。

示例:

name: 蒋增奎  #姓名
isMan: true  # 男士
birth: 2023-12-01  #出身日期
weight: 80.5
height: 172
parent: ~   # ~ 表示null

2.2.1 字符串

字符串可以加单引号或双引号或者没有引号。

quoted: 
    - 'single quoted string'
    - "double quoted strings"
    - withoout quoted string

都是合法的,等价于json

{
    "quoted": [
        "single quoted string",
        "double quoted strings",
        "withoout quoted string"
    ]
}

多行文本
字符串比较多的时候,更好的展示,选择单行/多行文本展示,用| 前缀。
例如,配置 GitHub Actions 时候运行一些命令:

# Multiline strings start with |
execute: |
    npm ci
    npm build
    npm test

等价json

{
    "execute": "npm ci\nnpm build\nnpm test\n"
}

2.2.2 NULL

YAML 声明空值有以下几种方法:

manager: null
blank:
tilde: ~
title: null
~: null key

等同json

{
    "manager": null,
    "blank": null,
    "tilde": null,
    "title": null,
    "null": "null key"
}

2.4.5 时间戳(timestamp)

时间戳表示单个时间点。它使用符号形式 ISO8601。如果未添加时区,则假定该时区为 UTC。要描述日期格式,可以省略时间部分。在这种情况下,时间默认为00:00:00Z。请参见下面示例中的用法。

time: 2020-12-07T01:02:59:34.02Z
timestamp: 2020-12-07T01:02:59:34.02 +05:30
datetime: 2020-12-07T01:02:59:34.02+05:30
notimezone: 2020-12-07T01:02:59:34.02
date: 2020-12-07

但实际转化有点问题

2.3 对象\MAP类型

使用缩进表示对象与属性的层级关系。
写法1:推荐

key1: value1
key2: value2

写法2:不推荐,除非比较深的嵌套。感觉有点像json数据

key: {key1: value1, key2: value2, …}

website: 
  name: baidu
  url: www.baidu.com

或者

website: {name: baidu,url: www.baidu.com}

2.4 数组/List/Set

2.4.1 值为基础类型

写法1:推荐
YAML 使用“-”表示数组中的元素,注意:- 后面也要加空格

pets:
  - cat
  - dog
  - pig

写法2:这种也推荐,比较简化
用[]表示 key: [value1,value2]

pets: [cat,dog,pig]

2.4.2 值为对象

如果值一个对象如:

# java 代码:
private List<Dog> lists;

#yml数据
lists:
	- name: 可乐
	  age: 2   #注意前面没有 -- name: 卷毛
	  age: 3
或者:
lists: 
	- {name: 可乐,age: 2}
	- {name: 卷毛,age: 3}
或者:
lists: [{name: 可乐,age: 2},{name: 卷毛,age: 3}]

2.4.3 多维数组

-
 - A
 - B
 - C
-
 - D
 - E
 - F
结果:[["A", "B", "C"],["D", "E", "F"]] 

2.4.4 复杂类型

有对象,有数组、基本数据类型

  name: zhangsan
  age: 30
  pets:
    -dog
    -cat
    -pig
  car:
    name: QQ
  child:
    name: zhangxiaosan
    age: 2

java代码

public class Person {

  private String lastName;
  private Integer age;
  private Boolean boss;

  private Date birth;
  private Map<String,Object> maps;
  private List<Dog> lists;
  private Dog dog;
  private String[] arr;
}
public class Dog {
  private String name;
  private Integer age;
}


对应的yml填充数据

person:
  boss: false
  maps:
    k1: v1
    k2: 14
  lists:
    - name: d1
      age: 2
    - name: d2
      age: 3
    - {name: d3,age: 4}
  birth: 2017/12/15
  dog:
    name: p_dog
    age: 15
  age: 13
  last-name: 张三
  arr: [s1,s2,s3]

2.5 显示类型

默认情况下,YAML 会自动推断数据类型,就像 TypeScript 的类型推断一样,但是当你需要你也可以使用 标签(tags)显示指定类型,比如整数类型 两个英文感叹号 !! 再加上 int 就变成了一个整数 tag ——!!int。

# The following value should be an int, no matter what:
should-be-int: !!int 3.2

# Parse any value to string:
should-be-string: !!str 30.25

# I need the next value to be boolean:
should-be-boolean: !!bool yes

!!com.jsoft.po.Company
address: 天府大道
boss: {birth: !!date '2023-12-13', id: 1, name: 蒋增奎, weight: 78.78}
creat_date: 2000-12-31
id: 1
name: 雪州科技
users:
  - {birth: !!timestamp'2023-12-13T01:10:32.464Z', id: 2, name: 张三丰, weight: !!float '89'}
  - {birth: !!timestamp '2023-12-13T01:10:32.464Z', id: 3, name: 张无忌, weight: !!float '100'}

2.6 引用和复用

YML值相互引用的基本语法如下:
key:&anchor
value other_key:anchor
在上面的例子中,key是一个YML键,&anchor是一个锚点,value是一个值。
通过在其他地方使用
anchor来引用这个值。

database:
  host: &db_host localhost   #给key[host]取一个别名
  prot: &db_port 3306
  username: &db_username root
  pwd: &db_pwd 11111

development:
  database:
    host: *db_host  # *别名,引用别名对应的值 这里就是localhost   
    prot: *db_port
    username: *db_username
    pwd: *db_pwd

实际效果如下

development:
  database:
    host: localhost
    prot: 3306
    username: root
    pwd: 11111

development:
  database:
    host: localhost
    prot: 3306
    username: root
    pwd: 11111

复用大节点

basic: &common   #这个basic节点时可复用的
  sex: 男
  city: 女

user:
  name: 蒋增奎
  <<: *common

等价于

basic: &common   #这个basic节点时可复用的
  sex: 男
  city: 女

user:
  name: 蒋增奎
  sex: 男
  city:

& 用来建立锚点(defaults),<< 表示合并到当前数据,* 用来引用锚点。注意只是复用这个节点的数据,这个节点不会复用过来

3.YML解析

3.1准备工作

准备两个vo类

public class Company {
    private Long id;
    private String name;
    private String address;
    private User boss;
    private List<User> users;
    .......
}
public class User {
    private Long id;
    private String name;
    private Date birth;
    private BigDecimal weight;
...
}

3.1 spring解析

3.1.1 Environment注解

在Spring中有一个类Environment,它可以被认为是当前应用程序正在运行的环境,它继承了PropertyResolver接口,因此可以作为一个属性解析器使用。先创建一个yml文件,属性如下:

person:
  name: hydra
  gender: male
  age: 18

使用起来也非常简单,直接使用@Autowired就可以注入到要使用的类中,然后调用它的getProperty()方法就可以根据属性名称取出对应的值了。

@RestController
public class EnvironmentController {
    @Autowired
    private Environment environment;  //注入

    @GetMapping("envTest")
    private void getEnv(){
        System.out.println(environment.getProperty("person.name"));  //通过key获取
        System.out.println(environment.getProperty("person.gender"));

        Integer autoClose = environment
            .getProperty("person.age", Integer.class);  //类型转化
        System.out.println(autoClose);
        String defaultValue = environment
            .getProperty("person.other", String.class, "defaultValue");//类型转化
        System.out.println(defaultValue);
    }
}

3.1.2 YamlPropertiesFactoryBean

在Spring中还可以使用YamlPropertiesFactoryBean来读取自定义配置的yml文件,而不用再被拘束于application.yml及其激活的其他配置文件。

在使用过程中,只需要通过setResources()方法设置自定义yml配置文件的存储路径,再通过getObject()方法获取Properties对象,后续就可以通过它获取具体的属性,下面看一个例子:

@GetMapping("fcTest")
public void ymlProFctest(){
    YamlPropertiesFactoryBean yamlProFb = new YamlPropertiesFactoryBean();
    yamlProFb.setResources(new ClassPathResource("application2.yml"));
    Properties properties = yamlProFb.getObject();
    System.out.println(properties.get("person2.name"));
    System.out.println(properties.get("person2.gender"));
    System.out.println(properties.toString());
}

3.2 SnakeYml组件

前面介绍的几种方式,在Spring环境下无需引入其他依赖就可以完成的,接下来要介绍的SnakeYml在使用前需要引入依赖,但是同时也可以脱离Spring环境单独使用。先引入依赖坐标:

3.2.1 pom依赖

<!-- https://mvnrepository.com/artifact/org.yaml/snakeyaml -->
<dependency>
    <groupId>org.yaml</groupId>
    <artifactId>snakeyaml</artifactId>
    <version>1.30</version>
</dependency>

3.2.2 解析yml文件到map

test.yml

id: 10
title: 钢铁是怎么炼成的
price: 35
author:
  firstName: 蒋
  lastName: 增奎
  tel: 13688006645

解析:
Yaml yaml=new Yaml();
1.返回的是一个map对象:map<key,value>
Map<String, Object> map=yaml).load(inputStream);
2.返回的是一个VO对象
VO vo=yaml).load(inputStream,VO.class);

    @Test
    public void t2() {
        Yaml yaml=new Yaml();
        Map<String, Object> map =
                yaml.load(getClass().getClassLoader()
                        .getResourceAsStream("test.yml"));

        //System.out.println(map);

        for (Map.Entry<String, Object> entry : map.entrySet()) {
            System.out.println("key = " + entry.getKey() + ", value = " + entry.getValue());
        }

        //获得基础类型
        String title=(String)map.get("title");
        System.out.println("title->"+title+";id->"+map.get("id")+";price->"+map.get("price"));
        //获得对象
        Map<String, Object> author =(Map)map.get("author");
        //获得对象的子属性
        String lastName=(String) author.get("lastName");
        System.out.println("lastName="+lastName);

    }

效果

key = id, value = 10
key = title, value = 钢铁是怎么炼成的
key = price, value = 35
key = author, value = {firstName=, lastName=增奎, tel=13688006645}
title->钢铁是怎么炼成的;id->10;price->35
lastName=增奎

3.2.3 解析yml到vo对象

把上一个步骤生成字符串,保存到company.yml文件,放置到类的根目录下
代码:

@Test
    public void t2(){
        Yaml yaml=new Yaml();
        Company Company =
                yaml.loadAs(getClass().getClassLoader().
                        getResourceAsStream("company.yml"), Company.class);
        System.out.println(Company.toString());
    }

效果

Company{
id=1, name='雪州科技', address='天府大道', boss=User{id=1, 
name='蒋增奎', birth=Tue Dec 12 22:32:36 CST 2023, weight=78.78}, 
users=[
 User{id=2, name='张三丰', birth=Tue Dec 12 22:32:36 CST 2023, weight=89},
 User{id=3, name='张无忌', birth=Tue Dec 12 22:32:36 CST 2023, weight=100}
 ]
 }

3.2.4 vo生成yml格式字符串

public class TestDemo {
    /**
     * vo生成yml格式字符串
     */
    @Test
    public void t1() {
        Company company=getGS();
        Yaml yaml = new Yaml();
        StringWriter sw = new StringWriter();
        yaml.dump(company, sw);
        System.out.println(sw.toString());
    }


  public Company getGS(){
        Company gs=new Company();
        gs.setAddress("天府大道");
        gs.setBoss(new User(1l,"蒋增奎",new Date(), new BigDecimal("78.78")));
        gs.setId(1l);
        gs.setName("雪州科技");
        List<User> users=new ArrayList<>();
        users.add(new User(2l,"张三丰",new Date(), new BigDecimal("89")));
        users.add(new User(3l,"张无忌",new Date(), new BigDecimal("100")));
        gs.setUsers(users);
        return gs;
    }
}

执行效果:

!!com.jsoft.po.Company
address: 天府大道
boss: {birth: !!timestamp '2023-12-12T23:37:08.209Z', id: 1, name: 蒋增奎, weight: 78.78}
id: 1
name: 雪州科技
users:
- {birth: !!timestamp '2023-12-12T23:37:08.211Z', id: 2, name: 张三丰, weight: !!float '89'}
- {birth: !!timestamp '2023-12-12T23:37:08.211Z', id: 3, name: 张无忌, weight: !!float '100'}

3.3 jackson组件

jackson不仅可以解析json,也支持yml

3.3.1 pom依赖

 <dependency>
            <groupId>com.fasterxml.jackson.dataformat</groupId>
            <artifactId>jackson-dataformat-yaml</artifactId>
            <version>2.12.3</version>
 </dependency>

3.3.2 解析yml文件到map

test.yml

id: 10
title: 钢铁是怎么炼成的
price: 35
author:
  firstName: 蒋
  lastName: 增奎
  tel: 13688006645

java代码

    @Test
    public void t4() throws IOException {
        ObjectMapper objectMapper = new ObjectMapper(new YAMLFactory());
        InputStream input=this.getClass().getClassLoader().getResourceAsStream("test.yml");
        Map<String,Object> map = objectMapper.readValue(input, Map.class);
        for (Map.Entry<String, Object> entry : map.entrySet()) {
            System.out.println("key = " + entry.getKey() + ", value = " + entry.getValue());
        }

        //获得基础类型
        String title=(String)map.get("title");
        System.out.println("title->"+title+";id->"+map.get("id")+";price->"+map.get("price"));
        //获得对象
        Map<String, Object> author =(Map)map.get("author");
        //获得对象的子属性
        String lastName=(String) author.get("lastName");
        System.out.println("lastName="+lastName);

    }

效果

key = id, value = 10
key = title, value = 钢铁是怎么炼成的
key = price, value = 35
key = author, value = {firstName=, lastName=增奎, tel=13688006645}
title->钢铁是怎么炼成的;id->10;price->35
lastName=增奎

3.3.3 解析yml到vo对象

把上一个步骤生成字符串,保存到company.yml文件,放置到类的根目录下
代码:

@Test
    public void t5() throws IOException {
        ObjectMapper objectMapper = new ObjectMapper(new YAMLFactory());
        InputStream input=this.getClass().getClassLoader().getResourceAsStream("company.yml");
        Company Company = objectMapper.readValue(input, Company.class);
        System.out.println(Company.toString());
    }

效果

Company{
id=1, name='雪州科技', address='天府大道', boss=User{id=1, 
name='蒋增奎', birth=Tue Dec 12 22:32:36 CST 2023, weight=78.78}, 
users=[
 User{id=2, name='张三丰', birth=Tue Dec 12 22:32:36 CST 2023, weight=89},
 User{id=3, name='张无忌', birth=Tue Dec 12 22:32:36 CST 2023, weight=100}
 ]
 }

4.总结

4.1 XML、JSON、YAML

看下图,从左往右是 XML、JSON、YAML 文件,JSON 通过 {} 和 [] 等简化了 XML,变得更加直观,但是当嵌套过深 XML 需要找结尾标签,JSON 需要找结尾的 },无论 XML 还是 JSON 都需要找结尾标记,很不直观,但 YAML 直接做的比 JSON 更加激进,连符号都没了,立体结构也变得扁平了,更加符合人类阅读习惯。

4.2 易错点

Java

public class Person {
    private String name;
    private String tel;
    //-----
    }

对应yml

name : jzk
tel : 13688006635

错误:

person:
 name : jzk
 tel : 13688006635

不要因为缩进把java类名也写入,和json一样,yml只和对象的属性值有关,和类无关

文章来源:https://blog.csdn.net/weixin_41158378/article/details/134940318
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。