企业官网建设流程全解析

目录

1.配置文件作用

SpringBoot 配置文件

2.配置文件快速入手

3.配置文件的格式

特殊说明

4.properties 配置文件说明

4.1 properties 基本语法

4.2 读取配置文件

4.3 properties 缺点分析

补充：乱码问题

5.yml 配置文件说明

5.1 yml 基本语法

使用 yml 连接数据库

yml 和 properties 连接数据库的配置对比

5.2 yml 使用进阶

5.2.1 yml 配置不同数据类型及 null

5.2.1.1 yml 配置读取

5.2.1.2 注意事项：value 值加单双引号（课件内容）

5.2.2 配置对象

5.2.3 配置集合

5.2.4 配置Map

5.3 yml 优缺点

优点

缺点

本节目标

1. 学习SpringBoot配置文件的格式以及对应的语法
2. 了解两个配置文件格式的差异

1.配置文件作用

咱们经常接触配置文件，比如说咱们创建 IDEA 的项目，IDEA 的配置文件就在这里面呢👇

计算机上有数以千计的配置文件, 我们使用的绝大多数软件, 比如浏览器, 微信, Idea, 甚至电脑, 手机, 都离不开配置文件. 我们可能永远不会直接与其中的大部分文件打交道，但它们确实以不同的形式散落在我们的计算机上, 比如C:\Users, C:\Windows文件夹, 以及各种 *.config, *.xml 文件
配置文件主要是为了解决硬编码（代码写死）带来的问题, 把可能会发生改变的信息, 放在一个集中的地方, 当我们启动某个程序时, 应用程序从配置文件中读取数据, 并加载运行.
硬编码是将数据直接嵌入到程序或其他可执行对象的源代码中, 也就是我们常说的"代码写死".
比如手机字体大小
如果采用硬编码的方式, 就直接在程序中指定字体大小, 所有的用户使用的都是同一个字体大小
但是不同的用户有不同的偏好, 我们可以把手机字体的大小放在配置文件中, 当程序启动时, 读取配置, 以用户设置的字体大小来显示.
使用配置文件, 可以使程序完成用户和应用程序的交互, 或者应用程序与其他应用程序的交互

SpringBoot 配置文件

SpringBoot支持并定义了配置文件的格式, 也在另一个层面达到了规范其他框架集成到SpringBoot的目的.
很多项目或者框架的配置信息也放在配置文件中, 比如:
• 项目的启动端口
• 数据库的连接信息(包含用户名和密码的设置)

比如配置数据库的账号密码，JDBC 的账号密码要是写在代码里那就是写死了，接下来我们要学的话就是放在配置文件中了，要改就去配置文件中去改~~
• 第三方系统的调用密钥等信息
• 用于发现和定位问题的普通日志和异常日志等.
项目的启动端口
SpringBoot内置了Tomcat服务器, 默认端口号是8080, 但是用户电脑上8080端口号有可能就被其他应用程序占用了, 所以SpringBoot需要支持让用户自定义端口号

数据库连接信息
为了更方便简单的访问数据库, 出现了一些持久层框架, 其实就是对JDBC进行了更深层次的封装.让用户通过简单几行代码就可完成数据库的访问. 但是不同的应用程序访问的数据库不同, 这些持久层框架就需要支持用户可以自定义配置数据库的连接信息.

2.配置文件快速入手

我们在前面讲了Tocmat 默认端口号是 8080, 所以我们程序访问时的端口号也是 8080
但是如果8080端口号已经被其他进程使用了呢? 我们可以通过配置文件来修改服务的端口号
SpringBoot 在创建项目时, 就已经帮我们创建了配置文件

之前的配置文件里面都是空的，Spring 3.X 之后多了一行👇

spring.application.name=spring-book-demo

这个就是定义了应用的名称是什么~~
修改application.properties 文件，在里面添加一行，把端口号 8080 改为 9090

server.port=9090

重新运行程序, 观察日志
显示Tomcat启动端口号为9090
访问程序:

此时：http://127.0.0.1:8080/login.html 就不能访问了👇

需要改为：http://127.0.0.1:9090/login.html 才能访问👇

3.配置文件的格式

Spring Boot 配置文件有以下三种：
• application.properties
• application.yml
• application.yaml
yml 为yaml的简写, 就像 htm 是 html 的简写，实际开发中出现频率最高.yaml 和yml 的使用方式一样, 课堂中只讲yml文件的使用
当应用程序启动时, Spring Boot会自动从classpath路径找到并加载
application.properties 和 application.yaml 或者 application.yml 文件.

注意：此处的配置文件名只能是 application，改成 applications 都是用不了的！！👇

发现此时就不能生效了👇

也可以通过spring.config.name指定文件路径和名称, 参考Externalized Configuration :: Spring Boot
如下图所示：

类似商品的包装一样, 有新老两款包装. properties 类型的配置文件就属于老款包装，也是创建 Spring Boot 项目时默认的文件格式（主要是因为仓库里还有库存)，而 yml 属于新版包装，如果用户了解情况直接指定要新款包装，那么就直接发给他

特殊说明

1. 理论上讲 .properties 和 .yml 可以并存在于一个项目中，当 .properties 和 .yml 并存时，两个配置都会加载（取并集∪）. 如果配置文件内容有冲突, 则以 .properties 为主, 也就是.properties 优先级更高.

下面来演示一下，先把 application.properties 中的内容注释掉，确保二者都能生效👇

#spring.application.name=spring-book-demo #server.port=9090

application.yml 端口号设置为 9091👇格式后面会讲~~

server: port: 9091

此时发现 application.yml 能正常使用👇

接下来取消 application.properties 中的注释，再次运行👇

运行的端口号为 9090，证明 application.properties 优先级比 application.yml 更高~~

2. 虽然理论上来讲 .properties 可以和 .yml 共存，但实际的业务当中，我们通常会采取一种
统一的配置文件格式，这样可以更好的维护(降低故障率).

4.properties 配置文件说明

properties 配置文件是最早期的配置文件格式，也是创建 SpringBoot 项目默认的配置文件

4.1 properties 基本语法

properties 是以键值的形式配置的，key 和 value 之间是以"="连接的，如：

# 配置项目端口号 server.port=8080 #配置数据库连接信息 spring.datasource.url=jdbc:mysql://127.0.0.1:3306/testdb?characterEncoding=utf8&useSSL=false spring.datasource.username=root spring.datasource.password=root

key 建议：所有单词小写，单词之间使用 点( . ) 来分割

等号前后有无空格都可以

PS：小技巧：配置文件中使用“#”来添加注释信息。
咱们当前先学习语法和使用, 更多配置信息随着课堂练习再学习. 感兴趣的也可以参考官网:Common Application Properties :: Spring Boot

4.2 读取配置文件

如果在项目中，想要主动的读取配置文件中的内容，可以使用 @Value 注解来实现。
@Value 注解使用" ${} "的格式读取，如下代码所示：

application.properties👇

spring.application.name=spring-ioc-demo server.port=9090 #配置数据库连接信息 spring.datasource.url=jdbc:mysql://127.0.0.1:3306/testdb?characterEncoding=utf8&useSSL=false spring.datasource.username=root spring.datasource.password=root #自定义配置 my.key=10

properties 配置如下:

package com.bit.ioc.controller; import org.springframework.beans.factory.annotation.Value; import org.springframework.stereotype.Controller; import org.springframework.stereotype.Repository; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.ResponseBody; /** * Created with IntelliJ IDEA. * Description: * User: CoderYanger * Date: 2026-10-31 * Time: 18:35 */ @RequestMapping("/prop") @ResponseBody @Controller public class PropertiesController { @Value("${my.key}")//读取配置文件 private String mykey; @RequestMapping("/read") public String readvalue(){ return "读取配置文件my.key:"+mykey; } }

最终执行效果：http://127.0.0.1:9090/prop/read

那么接下来我像读取一些其他格式的，如何去读取呢？？

我们再来学习一个新的注解 @PostConstruct ，这是我们后面要学习的内容，提前给大家讲了

这个注解在实例化之后就会执行，是个初始化方法，我们生成一个对象，第一个要分配内存空间，第二个进行实例化，第三个就执行初始化方法了

application.properties👇

spring.application.name=spring-ioc-demo server.port=9090 #配置数据库连接信息 spring.datasource.url=jdbc:mysql://127.0.0.1:3306/testdb?characterEncoding=utf8&useSSL=false spring.datasource.username=root spring.datasource.password=root #自定义配置 my.key=10 my.key2=true

package com.bit.ioc.controller; import jakarta.annotation.PostConstruct; import org.springframework.beans.factory.annotation.Value; import org.springframework.stereotype.Controller; import org.springframework.stereotype.Repository; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.ResponseBody; /** * Created with IntelliJ IDEA. * Description: * User: CoderYanger * Date: 2026-10-31 * Time: 18:35 */ @RequestMapping("/prop") @ResponseBody @Controller public class PropertiesController { @Value("${my.key}")//读取配置文件 private String mykey; @Value("${my.key2}")//读取配置文件 private String mykey2; @RequestMapping("/read") public String readvalue(){ return "读取配置文件my.key:"+mykey; } @PostConstruct public void init(){ System.out.println("mykey2:"+mykey2); } }

运行程序后👇

我们发现它在应用初始化完成之后它就执行初始化方法了，然后打印了应用启动成功，说明这是个初始化的注解~~

那么我们就不用再去打开浏览器去访问了，直接一运行就可以看到结果了

我们接下来把上述代码的 String 换成 Boolean 👇

@Value("${my.key2}")//读取配置文件 private Boolean mykey2;

看看会不会报错👇

发现并没有，不用怀疑这个 true 是 String 类型，因为 Java 是一个强类型语言，如果是 String 是不能赋值给它的~~

这也就说明了，你想让它是个什么类型，在配置文件中👇是随便写的，你在另一边使用不同类型去接收就行了

spring.application.name=spring-ioc-demo server.port=9090 #配置数据库连接信息 spring.datasource.url=jdbc:mysql://127.0.0.1:3306/testdb?characterEncoding=utf8&useSSL=false spring.datasource.username=root spring.datasource.password=root #自定义配置 my.key=10 my.key2=true

比如说我就像把这个 10 改成 Integer 类型，那么只需在另一边改成 Integer 即可👇

@RequestMapping("/prop") @ResponseBody @Controller public class PropertiesController { @Value("${my.key}")//读取配置文件 private Integer mykey; @Value("${my.key2}")//读取配置文件 private Boolean mykey2; @RequestMapping("/read") public String readvalue(){ return "读取配置文件my.key:"+mykey; } @PostConstruct public void init(){ System.out.println("mukey:"+mykey); System.out.println("mykey2:"+mykey2); } }

我们运行后就能发现能够正确读进去👇

但是如果配置文件写的不是 10，而是 10aaa，在另一边拿的时候还用 Integer 能赋值成功吗？？👇

spring.application.name=spring-ioc-demo server.port=9090 #配置数据库连接信息 spring.datasource.url=jdbc:mysql://127.0.0.1:3306/testdb?characterEncoding=utf8&useSSL=false spring.datasource.username=root spring.datasource.password=root #自定义配置 my.key=10aaa my.key2=true

我们发现报错了👇

显示的是：10aaa 数字格式化异常，这说明这跟我们学习 Spring 接收参数是有一点点像的，传参数的时候可以不管它是什么，你需要什么类型，你在这边直接写什么类型就可以了，底层都是 String 转成相应类型的~~

4.3 properties 缺点分析

properties 配置是以 key-value 的形式配置的，如下图所示：

从上述配置 key 可以看出，properties 配置文件中会有很多冗余的信息，比如这些：

想要解决这个问题，就可以使用 yml 配置文件的格式化了.

补充：乱码问题

此时它的文件格式是 ISO-8859-1 而不是 UTF-8，我们需要把它转成 UTF-8，改的时候需要改两个地方👇

在设置中搜索 Encodeing，改完 UTF-8 后，然后点击 Apply 应用

需要注意，此时已经乱码的部分就恢复不了了，只能说接下来不会再乱码了~~

还有第二个要改的地方，刚刚我们改的 File Setting 只是说针对当前项目不会乱码，那么我们新建项目要避免乱码还要在这里也改一下👇

界面与上面也是一样的，也是这两个地方改为 UTF-8👇

接下来再创建项目的时候就默认是 UTF-8 了

闲聊：之前我们设置 Maven 的时候也是要改两遍的，第一次在这里改👇

这只是对当前项目生效，要想对新项目也生效，需要在这里用相同的方式再设置一遍👇

5.yml 配置文件说明

yml 是 YAML 是缩写，它的全称 Yet Another Markup Language 翻译成中文就是“另一种标记语言.
我们先来学习 yml 的语法

5.1 yml 基本语法

yml 是树形结构的配置文件，它的基础语法是"key: value".
key 和 value 之间使用英文冒号加空格的方式组成，空格不可省略👇

基础语法如下：

第一项的配置为正确的，key 也是高亮显示的. 第二项没有空格是错误的使用方式，第二项的 key 也没有高亮显示

当多层的时候，比如表示这个👇

#配置数据库连接信息 spring.datasource.url=jdbc:mysql://127.0.0.1:3306/testdb?characterEncoding=utf8&useSSL=false spring.datasource.username=root spring.datasource.password=root

我们用换行代替 . 👇

#一层 key mykey: value #多层 key spring: datasource: url: jdbc:mysql://127.0.0.1:3306/testdb?characterEncoding=utf8&useSSL=false username: root password: root

注意：

①key 不能重复，所以可以把多个 spring 和 datasource 目录里的写在一起

②spring 和 datasource 冒号后面可以不加空格，直接换行

③但是 url、username、password 这种 key 和 value 相连接的，在 冒号 后面 必须加上 空格

④同一级的空格数必须相同（必须对齐），否则会被认定为不同级别，比如写成👇

此时表示的路径就变成了👇把 url 当作 username 的上一级了

spring.datasource.url.username

你可以用一个空格，但是必须对齐，咱们通常情况下都是使用两个空格~~

⑤当然，只有一个的时候可以写成👇

spring.datasource.url: jdbc:mysql://127.0.0.1:3306/testdb?characterEncoding=utf8&useSSL=false spring.datasource.username: root spring.datasource.password: root

但是有重复的时候就不行了👇

⑥开头第一行不能加空格（spring 前面不能加，因为是开头）

使用 yml 连接数据库

yml 使用示例：

spring: datasource: url: jdbc:mysql://127.0.0.0:3306/dbname?characterEncoding=utf8&useSSL=false username: root password: root

yml 和 properties 连接数据库的配置对比

5.2 yml 使用进阶

5.2.1 yml 配置不同数据类型及 null

注意：下面是 非标准格式，标准格式是 冒号 然后换行~~

# 字符串 string.value: Hello # 布尔值，true或false boolean.value: true boolean.value1: false # 整数 int.value: 10 # 浮点数 float.value: 3.14159 # Null，~代表null null.value: ~ # "" 空字符串 #，直接后面什么都不加就可以了，但这种方式不直观，更多的表示是使用引号括起来 empty.value: ''

注意：

①Null：接收 null 的时候也要使用 能够接收 null 类型的去接收，不能说用 int 接收

②空字符串：后面直接啥也不加，但这种方式给人感觉就是忘加了，所以通常加上引号，单双引号都可以~~

5.2.1.1 yml 配置读取

yml 读取配置的方式和 properties 相同，使用 @Value 注解即可，实现代码如下：

yml 配置：

my: key3: Hello key4: 5

@Controller public class YmlController { @Value("${my.key3}") private String myKey3; @Value("${my.key4}") private String myKey4; @PostConstruct public void init(){ System.out.println("mukey3:"+myKey3); System.out.println("mykey4:"+myKey4); } }

运行结果👇

5.2.1.2 注意事项：value 值加单双引号（课件内容）

字符串默认不用加上单引号或者双引号，如果加英文的单双引号可以表示特殊的含义。
尝试在 application.yml 中配置如下信息：

string: str1: Hello \n Spring Boot. str2: 'Hello \n Spring Boot.' str3: "Hello \n Spring Boot."

读取程序实现代码如下：

@RestController public class ReadYml { @Value("${string.str1}") private String str1; @Value("${string.str2}") private String str2; @Value("${string.str3}") private String str3; @RequestMapping("/yml") public String readYml(){ System.out.println(str1); System.out.println(str2); System.out.println(str3); return "yml"; } }

以上程序的执行结果如下图所示：

从上述结果可以看出：
• 字符串默认不用加上单引号或者双引号。
• 单引号会转义特殊字符，使其失去特殊功能, 始终是一个普通的字符串.
• 双引号不会转义字符串里面的特殊字符, 特殊字符会表示本身的含义.
此处的转义理解起来会有些拗口, \n 本意表示的是换行
使用单引号会转义, 就是说, \n 不再表示换行了, 而是表示一个普通的字符串
使用双引号不会转义, 表示 \n 表示的是它本身的含义, 就是换行
JavaEE的学习重在理解和使用, 不纠结概念和描述

5.2.2 配置对象

我们还可以在 yml 中配置对象，如下配置：

person: id: 1 name: Java age: 18

或者是使用行内写法（与上面的写法作用一致）：（了解即可，八百年见不到一次）

person: {id: 1,name: Java,age: 18}

@Configuration//此时Spring会帮我创建一个对象放到容器中 @Data public class Person { private Integer id; private String name; private Integer age; }

@Controller public class YmlController { @Value("${my.key3}") private String myKey3; @Value("${my.key4}") private String myKey4; @Autowired//此时Spring就会从容器中根据类型去匹配了 private Person person; @PostConstruct public void init(){ System.out.println("mukey3:"+myKey3); System.out.println("mykey4:"+myKey4); System.out.println("person:"+person); } }

运行结果👇发现确实从 Spring 中拿到值了

但是值全是 null，那么我们希望接下来能够从 配置文件 中获取值，然后赋值上去，这时我们就需要学习一个新的注解了：@ConfigurationProperties

@ConfigurationProperties(prefix = "person")//前缀就是配置文件中的person @Configuration//此时Spring会帮我创建一个对象放到容器中 @Data public class Person { private Integer id; private String name; private Integer age; }

运行结果👇发现这就能够从配置文件中获取对象的值了

那如果说我就想拿到 id ，怎么去拿？？用 @Value 👇

@Controller public class YmlController { @Value("${my.key3}") private String myKey3; @Value("${my.key4}") private String myKey4; @Value("${person.id}") private Integer id; @Autowired//此时Spring就会从容器中根据类型去匹配了 private Person person; @PostConstruct public void init(){ System.out.println("id:"+id); System.out.println("mukey3:"+myKey3); System.out.println("mykey4:"+myKey4); System.out.println("person:"+person); } }

运行结果👇

但是这种就只能一个个去拿了，场景不一样~~

5.2.3 配置集合

在 yml 中配置 list 和 数组 是一模一样的，只不过接收的时候可以用 List 去接收也可以用数组去接收，所以此处我们只讲 List 就可以了~~

配置文件也可以配置 list 集合，如下所示：

dbtypes: name: - mysql - sqlserver - db2

我们配置 List 和配置 Map 都是基于对象的，我们不能单纯的去拿这个值 dbtypes.name，而且这个 - 后面的空格是不能省略的

集合的读取和对象一样，也是使用 @ConfigurationProperties 来读取的，具体实现如下：

@Component @ConfigurationProperties(prefix = "dbtypes") @Data public class DbTypes { private List<String> name; }

@Controller public class YmlController { @Value("${my.key3}") private String myKey3; @Value("${my.key4}") private String myKey4; @Value("${person.id}") private Integer id; @Autowired//此时Spring就会从容器中根据类型去匹配了 private Person person; @Autowired private DbTypes dbTypes; @PostConstruct public void init(){ System.out.println("id:"+id); System.out.println("mukey3:"+myKey3); System.out.println("mykey4:"+myKey4); System.out.println("person:"+person); System.out.println("dbTypes:"+dbTypes); } }

运行后我们发现就拿到值了👇

有同学会问：这真的是 list 吗？？是的，如果不是 list 的话，类型不匹配是会报错的

这里名称是一一对应的关系👇

如果我们把 DbTypes 类中的 name 改为 name1，那么就取不到值了👇

---

补充知识：这部分不做强要求，是后面 Spring 原理才会涉及到的理论知识，当前只是辅助理解（因为好多同学在问），当前我们学的还是有点少，主要应用为主~~

类的生命周期（把类交给 Spring 之后是如何管理的）

1.实例化

不管是不是交给 Spring 管理，都要先分配一个内存空间~~

2.属性注入（依赖注入）

分配完空间之后就去 new，但是 new 这个步骤又分为 3 步：

1）先 new 一半，因为里面还有一些值，需要注入进来

2）从容器中找这个对象

3）这个对象没有（依赖的东西不存在），接下来再创建

3.初始化方法

@PostConstruct 注解只是其中的一个初始化方法

为啥要先属性注入再初始化？？因为初始化方法里面有可能会用到它

4.应用启动成功，可以使用了

5.销毁

5.2.4 配置Map

配置文件也可以配置 map，如下所示：

maptypes: map: k1: kk1 k2: kk2 k3: kk3

或者是使用行内写法(与上面的写法作用一致):（了解即可，八百年见不到一次）

maptypes: {map: {k1: kk1,k2: kk2,k3: kk3}}

我们定义一个球类的 map👇

dbtypes: name: - mysql - sqlserver - db2 ball: k1: v1 k2: v2 k3: v3

Map 的读取和对象一样，也是使用 @ConfigurationProperties 来读取的，具体实现如下：

@Component @ConfigurationProperties(prefix = "dbtypes") @Data public class DbTypes { private List<String> name; private Map<String,String> ball; }

运行结果👇

我们上面通过 @Value 也能拿到值，那么这里我们能不能也通过 @Value 来拿到值呢？？我们来尝试一下👇

@Controller public class YmlController { @Value("${my.key3}") private String myKey3; @Value("${my.key4}") private String myKey4; @Value("${person.id}") private Integer id; @Value("${dbtypes.ball}") private Map<String,String> ball; @Autowired//此时Spring就会从容器中根据类型去匹配了 private Person person; @Autowired private DbTypes dbTypes; @PostConstruct public void init(){ System.out.println("id:"+id); System.out.println("mukey3:"+myKey3); System.out.println("mykey4:"+myKey4); System.out.println("person:"+person); System.out.println("dbTypes:"+dbTypes); System.out.println("ball:"+ball); } }

实践出真知，发现并不可以👇

所以说，配置集合、配置 map 这种方式我们只能把它们放在对象里面去使用，使用的时候也要在外层封装一层对象~~

但是在这里是可以有单个值的👇这就是一个普通的对象了，可以读

@Component @ConfigurationProperties(prefix = "dbtypes") @Data public class DbTypes { private Integer id; private List<String> name; private Map<String,String> ball; }

此时配置文件中也要有个 id 与之对应👇

dbtypes: id: 5 name: - mysql - sqlserver - db2 ball: k1: v1 k2: v2 k3: v3

运行结果👇发现赋值成功

闲聊：这部分的代码不需要大家背，只需要会判断题和选择题就行了

判断题：CV 过来之后判断是不是少个空格啥的，判断是不是复制粘贴错了

选择题：选择注解的时候大多都是相似的，别选错了

主要通过练习达到记忆的效果~~

5.3 yml 优缺点

优点

1.可读性高，写法简单，易于理解

2.支持更多的数据类型，可以简单表达对象，数组，List，Map 等数据形态

3. 支持更多的编程语言, 不止是Java中可以使用, 在Golang, Python, Ruby, JavaScript中也可以使用

闲聊：这些优点不是说 properties 不具备的，properties 也可以在 Java 外使用，也挺优秀~~

缺点

1. 不适合写复杂的配置文件
比如properties格式如下

keycloak.realm = demo keycloak.resource = fm-cache-cloud keycloak.credentials.secret = d4589683-0ce7-4982-bcd3 keycloak.security[0].authRoles[0]= user keycloak.security[0].collections[0].name = ssologinurl keycloak.security[0].collections[0].patterns[0] = /login/*

转换为yml

keycloak: realm: demo resource: fm-cache-cloud credentials: secret: d4589683-0ce7-4982-bcd3 security: - authRoles: - user collections: - name: ssologinurl patterns: - /login/*

转换的过程也比较花费精力, 如果配置更复杂一点, 可读性会更差, 代码也会更难写
2. 对格式有较强的要求(一个空格可能会引起一场血案)

答疑：yml、json、xml 有什么区别？？

最主要区别就是语法不同，这是最大的区别

json、xml、yml 的话其实都可以作为配置文件，也可以作为数据传输去使用的，很多场景下，它们三个也可以去替换，但是相对的应用场景也不太一样

我们一般 json 用于数据交互、数据传输，像 A系统 和 B系统 去发送消息

json 和 xml 的最大区别也是语法的区别，json 是不能写注释的，yml 和 xml 都是可以写注释的，但是 json 可以表示各种各样的格式，很复杂的格式也是可以表示的，相比之下，它的可读性也比较高，比较节约带宽

yml 和 xml 通常是做配置使用的，xml 一般是应用的一些相关配置，yml 的话一般是业务的相关配置

应用场景的话，在系统支持的情况下，它们三个是可以互相替换的

但是在咱们这里，Spring 没有 json，Spring 选择的是 yml 和 properties，所以不能使用 json