springboot：YAML语言整体概述

YAML 语言（发音 /ˈjæməl/ ）的设计目标，就是方便人类读写。它实质上是一种通用的数据串行化格式。

它的基本语法规则如下。

大小写敏感
使用缩进表示层级关系
缩进时不允许使用Tab键，只允许使用空格。
缩进的空格数目不重要，只要相同层级的元素左侧对齐即可

# 表示注释，从这个字符一直到行尾，都会被解析器忽略。

YAML 支持的数据结构有三种。

对象：键值对的集合，又称为映射（mapping）/ 哈希（hashes） / 字典（dictionary）
数组：一组按次序排列的值，又称为序列（sequence） / 列表（list）
纯量（scalars）：单个的、不可再分的值

以下分别介绍这三种数据结构。

二、对象

对象的一组键值对，使用冒号结构表示。

animal: pets

转为 JavaScript 如下。

{ animal: 'pets' }

Yaml 也允许另一种写法，将所有键值对写成一个行内对象。

hash: { name: Steve, foo: bar }

转为 JavaScript 如下。

{ hash: { name: 'Steve', foo: 'bar' } }

三、数组

一组连词线开头的行，构成一个数组。

- Cat - Dog - Goldfish

转为 JavaScript 如下。

[ 'Cat', 'Dog', 'Goldfish' ]

数据结构的子成员是一个数组，则可以在该项下面缩进一个空格。

- - Cat - Dog - Goldfish

转为 JavaScript 如下。

[ [ 'Cat', 'Dog', 'Goldfish' ] ]

数组也可以采用行内表示法。

animal: [Cat, Dog]

转为 JavaScript 如下。

{ animal: [ 'Cat', 'Dog' ] }

四、复合结构

对象和数组可以结合使用，形成复合结构。

languages: - Ruby - Perl - Python websites: YAML: yaml.org Ruby: ruby-lang.org Python: python.org Perl: use.perl.org

转为 JavaScript 如下。

{ languages: [ 'Ruby', 'Perl', 'Python' ], websites: { YAML: ' yaml.org', Ruby: ' ruby-lang.org', Python: ' python.org', Perl: ' use.perl.org' } }

五、纯量

纯量是最基本的、不可再分的值。以下数据类型都属于 JavaScript 的纯量。

字符串
布尔值
整数
浮点数
Null
时间
日期

数值直接以字面量的形式表示。

number: 12.30

转为 JavaScript 如下。

{ number: 12.30 }

布尔值用true和false表示。

isSet: true

转为 JavaScript 如下。

{ isSet: true }

null用~表示。

parent: ~

转为 JavaScript 如下。

{ parent: null }

时间采用 ISO8601 格式。

iso8601: 2001-12-14t21:59:43.10-05:00

转为 JavaScript 如下。

{ iso8601: new Date('2001-12-14t21:59:43.10-05:00') }

日期采用复合 iso8601 格式的年、月、日表示。

date: 1976-07-31

转为 JavaScript 如下。

{ date: new Date('1976-07-31') }

YAML 允许使用两个感叹号，强制转换数据类型。

e: !!str 123 f: !!str true

转为 JavaScript 如下。

{ e: '123', f: 'true' }

六、字符串

字符串是最常见，也是最复杂的一种数据类型。

字符串默认不使用引号表示。

str: 这是一行字符串

转为 JavaScript 如下。

{ str: '这是一行字符串' }

如果字符串之中包含空格或特殊字符，需要放在引号之中。

str: '内容： 字符串'

转为 JavaScript 如下。

{ str: '内容: 字符串' }

单引号和双引号都可以使用，双引号不会对特殊字符转义。

s1: '内容\n字符串' s2: "内容\n字符串"

转为 JavaScript 如下。

{ s1: '内容\\n字符串', s2: '内容\n字符串' }

单引号之中如果还有单引号，必须连续使用两个单引号转义。

str: 'labor''s day'

转为 JavaScript 如下。

{ str: 'labor\'s day' }

字符串可以写成多行，从第二行开始，必须有一个单空格缩进。换行符会被转为空格。

str: 这是一段 多行 字符串

转为 JavaScript 如下。

{ str: '这是一段 多行 字符串' }

多行字符串可以使用|保留换行符，也可以使用>折叠换行。

this: | Foo Bar that: > Foo Bar

转为 JavaScript 代码如下。

{ this: 'Foo\nBar\n', that: 'Foo Bar\n' }

+表示保留文字块末尾的换行，-表示删除字符串末尾的换行。

s1: | Foo s2: |+ Foo s3: |- Foo

转为 JavaScript 代码如下。

{ s1: 'Foo\n', s2: 'Foo\n\n\n', s3: 'Foo' }

字符串之中可以插入 HTML 标记。

message: | <p style="color: red"> 段落 </p>

转为 JavaScript 如下。

{ message: '\n<p style="color: red">\n 段落\n</p>\n' }

七、引用

锚点&和别名*，可以用来引用。

defaults: &defaults adapter: postgres host: localhost development: database: myapp_development <<: *defaults test: database: myapp_test <<: *defaults

等同于下面的代码。

defaults: adapter: postgres host: localhost development: database: myapp_development adapter: postgres host: localhost test: database: myapp_test adapter: postgres host: localhost

&用来建立锚点（defaults），<<表示合并到当前数据，*用来引用锚点。

下面是另一个例子。

- &showell Steve - Clark - Brian - Oren - *showell

转为 JavaScript 代码如下。

[ 'Steve', 'Clark', 'Brian', 'Oren', 'Steve' ]

八、函数和正则表达式的转换

这是 JS-YAML 库特有的功能，可以把函数和正则表达式转为字符串。

# example.yml fn: function () { return 1 } reg: /test/

解析上面的 yml 文件的代码如下。

var yaml = require('js-yaml'); var fs = require('fs'); try { var doc = yaml.load( fs.readFileSync('./example.yml', 'utf8') ); console.log(doc); } catch (e) { console.log(e); }

从 JavaScript 对象还原到 yaml 文件的代码如下。

var yaml = require('js-yaml'); var fs = require('fs'); var obj = { fn: function () { return 1 }, reg: /test/ }; try { fs.writeFileSync( './example.yml', yaml.dump(obj), 'utf8' ); } catch (e) { console.log(e); }

九、参考链接

• YAML 1.2 规格

• YAML from Wikipedia

• YAML for Ruby

（完）

文档信息

作者： 阮一峰

• 版权声明：自由转载-非商用-非衍生-保持署名（创意共享3.0许可证）

• 发表日期： 2016年7月 4日

• 更多内容： 档案 » 开发者手册

• 文集：《前方的路》，《未来世界的幸存者》

社交媒体：

twitter，

weibo

---

我们可能在spring配置文件里见到过.yml格式的东东，配置文件不都是.propertie或者.xml文件吗？.yml是什么鬼，今天我带你们来一探究竟。

YAML（Yet Another Markup Language）（发音 /ˈjæməl/ ）

一种基于Unicode容易阅读，容易和脚本语言交互的，用来表达资料序列的编程语言。

适应场景

1. 脚本语言：由于实现简单，解析成本很低，YAML 特别适合在脚本语言中使用

2. 序列化： YAML是由宿主语言数据类型直转，的比较适合做序列化。

3. 配置文件：写 YAML 要比写 XML 快得多(无需关注标签或引号)，并且比 INI 文档功能更强。由于兼容性问题，不同语言间的数据流转建议不要用 YAML。

语言优点

1. YAML易于人们阅读。

2. YAML数据在编程语言之间是可移植的。

3. YAML匹配敏捷语言的本机数据结构。

4. YAML具有一致的模型来支持通用工具。

5. YAML支持单程处理。

6. YAML具有表现力和可扩展性。

7. YAML易于实现和使用。

YAML 语法

1. 使用空格 Space 缩进表示分层，不同层次之间的缩进可以使用不同的空格数目，但是同层元素一定左对齐，即前面空格数目相同（不能使用 Tab，各个系统 Tab对应的 Space 数目可能不同，导致层次混乱）

2. ‘#’表示注释，只能单行注释，从#开始处到行尾

3. 破折号后面跟一个空格（a dash and space）表示列表

4. 用冒号和空格表示键值对 key: value

5. 简单数据（scalars，标量数据）可以不使用引号括起来，包括字符串数据。用单引号或者双引号括起来的被当作字符串数据，在单引号或双引号中使用C风格的转义字符

Sequence of Scalars 简单数据列表

1. - Mark McGwire

2. - Sammy Sosa

3. - Ken Griffey

Mapping Scalars to Scalars 简单数据键值对以及注释

1. hr:65# Home runs

2. avg:0.278# Batting average

3. rbi:147# Runs Batted In

Mapping Scalars to Sequences 简单数据列表键值对

1. american:

2. - Boston Red Sox

3. - Detroit Tigers

4. -New York Yankees

5. national:

6. -New York Mets

7. - Chicago Cubs

8. - Atlanta Braves

Sequence of Mappings 键值对列表

1. -

2. name:MarkMcGwire

3. hr: 65

4. avg: 0.278

5. -

6. name:SammySosa

7. hr: 63

8. avg: 0.288

YAML 还支持流类型，用中括号括起来表示列表，用逗号分隔元素；用大括号括起来表示键值对，用逗号分隔元素。

Sequence of Sequences 列表的列表

1. -[name , hr, avg ]

2. -[Mark McGwire, 65, 0.278]

3. -[Sammy Sosa , 63, 0.288]

Mapping of Mappings 键值对的键值对

1. MarkMcGwire: {hr:65, avg:0.278}

2. SammySosa: {

3. hr:63,

4. avg:0.288

5. }

yaml 官方网站：http://www.yaml.org

yaml 官方文档：http://www.yaml.org/spec/1.2/spec.html

---

YAML Ain't Markup Language

和GNU一样，YAML是一个递归着说“不”的名字。不同的是，GNU对UNIX说不，YAML说不的对象是XML。

YAML不是XML。

为什么不是XML呢？因为：

• YAML的可读性好。

• YAML和脚本语言的交互性好。

• YAML使用实现语言的数据类型。

• YAML有一个一致的信息模型。

• YAML易于实现。

上面5条也就是XML不足的地方。同时，YAML也有XML的下列优点：

• YAML可以基于流来处理；

• YAML表达能力强，扩展性好。

总之，YAML试图用一种比XML更敏捷的方式，来完成XML所完成的任务。

更多的内容及规范参见http://www.yaml.org。

语法

Structure通过空格来展示。Sequence里的项用"-"来代表，Map里的键值对用":"分隔.

这几乎就是所有的语法了.

比如……

一般YAML文件扩展名为.yaml。比如：John.yaml

12345678910name: John Smithage: 37spouse: name: Jane Smith age: 25children: - name: Jimmy Smith age: 15 - name: Jenny Smith age 12

John今年37岁，有一个幸福的四口之家。两个孩子Jimmy 和Jenny活泼可爱。妻子Jane年轻美貌。

如果深入研究的话还可能发现一些社会问题。

可见YAML的可读性是不错。

JYaml——YAML的Java实现

YAML已经有了不少实现,详细的实现列表参见http://www.yaml.org/download.html。

其中JYaml（http://jyaml.sourceforge.net）是YAML的Java实现。

JYaml简介

YAML使用实现语言的数据类型。我们看一下一些JYaml支持的Java数据类型：

• 原始数据和封装类（比如int，java.lang.Integer）

• JavaBean兼容对象（Structure支持）

• Collection （sequence支持）

• List

• Set

• Map （map支持）

• Arrays （sequence支持）

• BigInteger 和BigDecimal

• Date

我们给出John.yaml的java描述：

1234567public class Person { private String name; private int age; private Person sponse; private Person[] children; // setXXX, getXXX方法略.}

现在让我们装配一个Jone：

12345678910111213Person john = new Person();john.setAge(37);john.setName("John Smith");Person sponse = new Person();sponse.setName("Jane Smith");sponse.setAge(25);john.setSponse(sponse);Person[] children = {new Person(), new Person()};children[0].setName("Jimmy Smith");children[0].setAge(15);children[1].setName("Jenny Smith");children[1].setAge(12);john.setChildren(children);

使用JYaml把Jone“Dump”出来：

12File dumpfile = new File("John_dump.yaml");Yaml.dump(john, dumpfile);

下面我们看看John_dump.yaml是什么样子：

12345678910111213--- !yaml.test.internal.Personage: 37children: !yaml.test.internal.Person[] - !yaml.test.internal.Person age: 15 name: Jimmy Smith - !yaml.test.internal.Person age: 12 name: Jenny Smithname: John Smithsponse: !yaml.test.internal.Person age: 25 name: Jane Smith

其中!yaml.test.internal.Person是一些类型的信息。load的时候需要用。

现在用JYaml把Jone_dump.yaml load进来：

1Person john2 = (Person) Yaml.loadType(dumpfile, Person.class);

还可以用下面的代码dump出没有类型信息的John.yaml：

1Yaml.dump(john,dumpfile, true);

我们再来看看JYaml对流处理的支持。

为简便起见，我们只是把同一个john写10次：

1234567YamlEncoder enc = new YamlEncoder(new FileOutputStream(dumpfile)); for(int i=0; i<10; i++){ john.setAge(37+i); enc.writeObject(john); enc.flush(); }enc.close();

下面再把这十个对象一个一个读出来（注意while循环退出的方式）：

1234567891011YamlDecoder dec = new YamlDecoder(new FileInputStream(dumpfile));int age = 37;while(true){ try{ john = (Person) dec.readObject(); assertEquals(age, john.getAge()); age++; }catch(EOFException eofe){ break; }}

JYaml对JDK14的支持

JYaml的源码是基于JVM5的。也提供对JVM5功能的一些支持，比如对枚举类型的支持。

JYaml的JVM14的支持是通过retrotranslator(http://retrotranslator.sourceforge.net）. retrotranslator使用ASM（http://asm.objectweb.org ）动态修改JVM5字节码成JVM14，使JYaml在JVM14下可用。会牺牲一些效率。Debug时也会失真。

我修改了JYaml作者Toby Ho的一些源码（基于Beta2.2），使之与JVM14兼容。当然，为此也去掉了对JVM5才有的类型的支持（比如枚举类型）. 这个牺牲应该是值得的。需要的人可以来信索取。

YAML和SDO（只讨论双方的java实现）

如果读者想了解更多SDO的概念， 请参见http://www.ibm.com/developerworks/library/specification/j-commonj-sdowmt/index.html 。这里我们只讨论SDO的java实现。

SDO里有一个很重要的概念，DataObject。从DataObject的接口里，可以看出有两类的数据类型，一类是JYaml支持的，诸如String, List之类，一类是DataObject。因此我们只需要增加一种支持DataObject的类型，就可以完成对SDO DataObject的支持。

不妨叫YamlDataObject。下面是它的数据结构。

12345public class YamlDataObject { private String uRI; private String name; private Map attributes;}

YamlDataObject里用到的类型，都是JYaml能够支持的。其中，uRI和name用来描述DataObject自身。attributes来描述DataObject里的值。这些值可能为DataObject，也可能是JYaml所支持的其他类型。我们希望用YamlDataObject来担当DataObject的角色，因此YamlDataObject和DataObject要能互相转化。增加两个API：

12private static YamlDataObject newInstance(DataObject dataobject){...private DataObject toDataObject() {...

上面两个之所以是private的，是因为我们打算遵照JYaml的习惯，增加两个接口，dump和load，这样newInstance和toDataObject只在内部使用了。下面是dump和load的定义：

1234public static void dump(DataObject dataobject, File dumpfile) throws FileNotFoundException{...public static Object load(File file) throws FileNotFoundException{...

下面是一小段测试代码：

12345678910// ... create dataobject ...File bodump=new File("bodump.yaml");YamlDataObject.dump(dataobject,bodump);assertTrue(bodump.exists());DataObject dataobject2 = (DataObject) YamlDataObject.load(bodump); // check resultassertNotNull(dataobject2);for(int i=0; i<5; i++){ assertEquals(dataobject.get(i),dataobject2.get(i));}

具体的实现细节就不谈了。读者可以作为练习题，熟悉一下这两个数据整合方案。

YAML和Ruby

Ruby和YAML的联系，甚至比Java与XML的联系还要紧密。Ruby把YAML用到了和数据相关的方方面面。配置文件的约定格式是YAML。同时YAML还是Ruby的文本序列化格式，就像XML是SDO的文本序列化格式一样。

不夸张的说，YAML是Ruby中流动的血液。

那，Ruby为什么不选XML呢?

其一，XML对Ruby这样的脚本语言而言，解析起来比较困难。效率肯定是会有问题。Ruby的XML解析没有完全实现，走的是实用主义的路线，可能也缘于此。而YAML要轻快很多。

另外，XML使用自定义类型。就算解析出来，也不能直接用，还要再转一次。而YAML不定义自己的类型，直接使用宿主语言本身类型，直截了当。

下面给一个Ruby YAML的简介。

我们使用Ruby写一个Person类：

123456789class Person attr_accessor :name, :age, :sponse, :children def initialize(name, age, sponse=nil, children=nil) @name = name @age = age @sponse = sponse @children = children endend

把John装配起来：

123jane = Person.new("Jane Smith", 25)children = [Person.new("Jimmy Smith", 15), Person.new("Jenny Smith", 12)]john = Person.new("John Smith", 37, jane, children)

Dump出John到John.yaml：

123File.open('John_ruby.yaml', 'w') do |os| YAML::dump(john, os)end

我们看看Dump的结果：

12345678910111213141516171819--- !ruby/object:Personage: 37children:- !ruby/object:Person age: 15 children: name: Jimmy Smith sponse:- !ruby/object:Person age: 12 children: name: Jenny Smith sponse:name: John Smithsponse: !ruby/object:Person age: 25 children: name: Jane Smith sponse:

仔细观察会发现和JYaml Dump出来的还是有些区别的。

首先类型信息不一样。这还好说，虽然Ruby load Java的不太可能，但Java加载Ruby的应该没问题。

还有就是一些实现上细微的区别。比如Ruby::Yaml的"spone:"，JYaml认为是不合法的。还有children的不缩行。尽管Ruby::Yaml很流行，但JYaml认为这是Ruby的Bug。网上有相应的争论。

不过在一个语言里使用还是没问题的。下面是load John的代码：

1john2 = File.open('John.yaml') { |is| YAML::load(is) }

YAML的Ruby实现出现的很早。但由于某些原因，YAML的Ruby实现是不严格的。随着其他语言的YAML实现慢慢出现，这个问题日益明显了。

毕竟每个实现语言的类型不一样的，不同语言文化也不同。因此不同实现的YAML的交互是个问题。兼容性需要YAML规范来保证。而具体的实施还有很长的道路要走。

但YAML在单一语言中，YAML的应用是没有问题的。

YAML在Ruby On Rails中经常用作配置文件。比如数据库信息的配置：

12345678910111213test: adapter: mysql database: weblog_test username: root password: host: localhost production: adapter: mysql database: weblog_production username: root password: host: localhost

熟悉ROR的读者应该能看出这是`config/database.yml'文件。

YAML的适用范围

由于实现简单，解析成本很低，YAML特别适合在脚本语言中使用。列一下现有的语言实现：Ruby，Java，Perl，Python，PHP，OCaml，JavaScript。除了Java，其他都是脚本语言.

YAML比较适合做序列化。因为它是宿主语言数据类型直转的。

YAML做配置文件也不错。比如Ruby on Rails的配置就选用的YAML。对ROR而言，这很自然，也很省事.

由于兼容性问题，不同语言间的数据流转建议现在不要用YAML.

YAML存在的意义

无论多么完美的事物，都需要有对立面，有说“NO”的声音。XML也不例外。当然，站在主流的对立面，需要勇气和智慧。

YAML和XML不同，没有自己的数据类型的定义，而是使用实现语言的数据类型。这一点，有可能是出奇制胜的地方，也可能是一个败笔。如果兼容性保证的不好的话，YAML数据在不同语言间流转会有问题。如果兼容性好的话，YAML就会成为不同语言间数据流通的桥梁。建议yaml.org设立兼容认证机制，每个语言的实现必须通过认证。

假如兼容性没问题的话，YAML就太完美了。轻巧，敏捷，高效，简便，通用。这才是理想中的数据模型。当然就现在而言，这还只是个理想。