Vmware提示以独占方式锁定此配置文件失败。另一个正在运行的VMware进程可能正在使用配置文件以及虚拟机黑屏
 
解决办法：看了很多说删除.lck文件的，还有说删除.vmdk文件的，.vmdk文件在删除的时候提示无法删除，.lck文件删除后，也无法解决问题，又不想卸载重装。之后就打开控制面板，更改-修复VMware，重启电脑，再打开VMware不提示独占锁定文件失败，但是一直黑屏，之后就搜索cmd命令，然后以管理员方式打开，输入netsh winsock reset(这个命令是重置网络规范，黑屏的原因很可能就是VMware软件跟本地网络规范有冲突)，回车之后提示成功重置winsock目录，您必须重新启动计算机才能重新完成配置。重启后打开即可。

写在前面
 
鉴于有人留言说想要学习SpringBoot相关的知识，我这里打算写一个SpringBoot系列的相关博文，目标呢是想让看了这一系列博文的同学呢，能够对SpringBoot略窥门径，这一系列的博文初步都定下来包括SpringBoot介绍、入门、配置、日志相关、web开发、数据访问、结合docker、缓存、消息队列、检索、任务安全、分布式等等一系列的博文，工作量很大，是个漫长的过程，每一步我都尽量详细，配上截图说明，也希望对看的同学真的有用。
 单纯就是想分享技术博文，还想说一句就是，如果觉得有用，请点个关注、给个赞吧，也算对我来说是个宽慰，毕竟也得掉不少头发，嘿嘿嘿
 
系列文章传送条
 
详细SpringBoot教程之入门（一）
 详细SpringBoot教程之入门（二）
 详细SpringBoot教程之配置文件（一）
 详细SpringBoot教程之配置文件（二）
 详细SpringBoot教程之日志框架
 详细SpringBoot教程之Web开发（一）
 详细SpringBoot教程之Web开发（二）
 详细SpringBoot教程之Web开发（三）
 详细SpringBoot教程之数据访问
 详细SpringBoot教程之启动配置原理
 详细SpringBoot教程之缓存开发
 
配置文件
 
SpringBoot可以使用全局配置或者其他配置文件，并且我们在SpringBoot开发中会经常需要去配置某些模块的配置，这样有利于我们业务分离，理清逻辑关系。这个时候可能会说了，不是说SpringBoot的优点之一就是省去了繁琐的配置，为什么这里又要学配置呢？哈哈哈，省去了繁琐的配置是因为SpringBoot帮我们把所有配置弄好了默认，如果我们需要更改一些默认配置，当然需要我们自己手动更改呀。对于一些分布式大型项目，我们需要分各种端口，分各种环境，这些都需要我们修改。而且我们可能需要对可以重复利用的模块进行封装，然后在新项目中作为默认配置进新项目的时候，也需要知道如何进行SpringBoot的配置，所以还是很重要的。
 
说了这么多，我们开始来将SpringBoot的配置文件吧，在SpringBoot中配置文件有两种，一种是application.properties，另一种是application.yml，其中yml配置文件是在properties之后才有的。配置文件放在src/main/resources 目录或者类路径/config下，配置文件的作用，就是修改SpringBoot自动配置的默认值，SpringBoot底层都给我们自动配置好了很多默认值，我们就需要通过灵活的使用properties和yml来进行修改默认配置。
 
我们通过Idea向导帮我们创建的新项目，在Resources目录下面会帮我们自动生成一个properties配置文件，如下图
 
 在resources目录下我们可以暂时手动再创建一个application.yml文件，为了比较学习他们的区别（说明一下的就是，二者可以同时存在，不过最终只会运行一个，一般默认运行application.properties，不过我们可以通过配置，在application.properties中同时应用yml，达到多个配置文件的目的），依旧在resources目录下，直接右键new->File，创建一个名为application.yml的文件，如下图
 
 YAML 是 “YAML Ain’t a Markup Language”（YAML 不是一种标记语言）。在开发的这种语言时，YAML 的意思其实是：“Yet Another Markup Language”（仍是一种标记语言）。它使用空白符号缩进和大量依赖外观的特色，特别适合用来表达或编辑数据结构、各种配置文件，即以数据为中心，比json、xml等更加适合做配置文件，以前的项目大都是使用xml作为配置文件的。在全局配置文件中，可以对一些默认配置值进行修改，比如我们修改默认的端口号，我们如果使用xml作为配置文件，配置端口可能会是如下
 
<server>
	<port>8090</port>
</server>
 
发现了没有，xml会浪费大量的内容给标签的开闭上，那如果我们在SpringBoot项目中使用properties和yml设置端口，又该如何呢，如下，左边是yml，右边是properties，两者看起来是不是都很简略
 
 
YAML语法
 
properties我们常见，我这里说一下YAML的一些基本语法，想要深入的可以直接到网上查，应该有很多详细的文档，我这里只是说一下基本语法，方便我们后面的讲解。
 
基本语法
 
大小写敏感
使用缩进表示层级关系
缩进不允许使用tab，只允许空格
缩进的空格数不重要，只要相同层级的元素左对齐即可
'#'表示注释
 
数据类型
 
YAML 支持以下几种数据类型：
 
对象：键值对的集合，又称为映射/ 哈希 / 字典
数组：一组按次序排列的值，又称为序列 / 列表
字面量：单个的、不可再分的值
 
字面量写法
 
字面量是最基本的，不可再分的值，包括：字符串、布尔值、整数、浮点数、时间、Null、日期。使用一个例子来快速了解字面量的基本使用：
 
boolean: 
    - TRUE  #true,True都可以
    - FALSE  #false，False都可以
#例子：isEmpty: false
float:
    - 3.14
    - 6.8523015e+5  #可以使用科学计数法
#例子：value: 3.14
int:
    - 123
    - 0b1010_0111_0100_1010_1110    #二进制表示
#例子：value: 123
null:
    nodeName: 'node'
    parent: ~  #使用~表示null
#例子：value: ~
string:
    - 哈哈
    - 'Hello world'  #可以使用双引号或者单引号包裹特殊字符
    - newline
      newline2    #字符串可以拆成多行，每一行会被转化成一个空格
#例子：value: 哈哈
date:
    - 2018-02-17    #日期必须使用ISO 8601格式，即yyyy-MM-dd
#例子：value: 2018-02-17
datetime: 
    -  2018-02-17T15:02:31+08:00    #时间使用ISO 8601格式，时间和
                              #日期之间使用T连接，最后使用+代表时区
 
这里多说一些字符串，字符串默认不用加上单引号或者双引号。其中，双引号不会转移字符串里面的特殊字符，特殊字符会作为本身祥表示的意思，比如
 name: “I am \n dbc” 输出 I am 换行 dbc
 而单引号则会转义字符串里面的特殊字符，特殊字符最终只是一个普通的字符串数据，比如
 name: “I am \n dbc” 输出 I am \n dbc
 
YAML 数组
 
以 - 开头的行表示构成一个数组：
 
num:
 - A
 - B
 - C
 
YAML 支持多维数组，可以使用行内表示：key: [value1, value2, …]
 
YAML 对象
 
对象键值对使用冒号结构表示 key: value，冒号后面要加一个空格。
 也可以使用 key:{key1: value1, key2: value2, …}。还可以使用缩进表示层级关系，如下：
 
key: 
    child-key: value
    child-key2: value2
 
较为复杂的对象格式，可以使用问号加一个空格代表一个复杂的 key，配合一个冒号加一个空格代表一个 value：
 
?  
    - complexkey1
    - complexkey2
:
    - complexvalue1
    - complexvalue2
 
意思即对象的属性是一个数组 [complexkey1,complexkey2]，对应的值也是一个数组 [complexvalue1,complexvalue2]
 YMAL基本语法先讲到这里，需要深入了解的自行查阅其他教程。
 
配置文件注入简单案例
 
这里我们在application.yml中写入一些数据，就是写一个类的属性值以及对应的数值，如下
 
 为了方便，我也把内容粘贴出来
 
person:
  lastName: dbc
  age: 22
  boss: false
  birth: 2017/12/12
  maps: {k1: v2,k2: ;2}
  lists:
   - lisi
   - dbc
  dog:
   name: 小狗
   age: 12
 
写好了之后，我们创建一个Person类和一个Dog类，类中的属性值和配置文件中的属性值要一一对应，并在Person的类上加上@ConfigurationProperties注解，注解中的前缀填写我们在配置文件中的person，如下
 
 
 因为我们需要将配置文件中配置的每一个属性值，映射到组件中，所以我们在Person类上添加一个@ConfigurationProperties，意思是告诉SpringBoot将本类中所有属性和配置文件中相关的配置进行绑定，prefix意思就是配置映射关系。这个时候发现编辑器提示如下
 
 我这里直接把依赖粘贴出来，然后把这段依赖粘贴进pom.xml文件中，Idea会自动加载依赖，加载完依赖之后，原本红色的提示，变成 了绿色即可，如下
 
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-configuration-processor</artifactId>
    <optional>true</optional>
</dependency>
 

 现在，完成了依赖的导入，也完成了配置文件的映射（即将配置文件和类进行了关联映射），映射之后，我们成这个映射为组件，不过现在我们只是完成了组件映射，我们还需要将这个组件注入到Spring容器中，因为只有这个组件是容器中的组件，才能容器提供的@ConfigurationProperties功能获取，所以我们还需要添加@Component，把类组件加到容器中，如图
 
 
测试案例
 
这样就完成了一个组件的注入，我们可以在容器中使用这个组件了，接下来我们进行单元测试了，细心的人会发现，我们使用Idea创建的SpringBoot项目中，在test目录下有一个java文件夹，被Idea标为绿色（如下），这个文件夹就是单元测试用的，当然我们手动创建的Maven项目，也可以手动配置，很简单，创建项目属性就可以了。接下来我们讲一下单元测试中的内容，如何使用
 
 SpringBoot 的单元测试 ,可以在测试期间很方便的通过类似编码一样的方式，进行自动注入容器的功能，我们进入到那个DemoApplicationTests里面，其中有一个注解@SpringBootTest ，它标注是SpringBoot的单元测试。接着我们只需要在测试类中注入我们刚刚编写好的Person类，然后在方法中输出一下就可以了，毕竟我们只是检查一下我们编写的配置文件有没有成功配置好。执行之后在下方的日志中我们可以检查输出，测试类的内容和输出的日志结果如下图
 
 
 
使用properties完成案例
 
我们前面完成了使用yml类型的配置文件，进行映射注入，现在我们来试试使用properties类型的配置文件进行映射注入，其实不难，我们可以先将yml配置文件中的内容注释掉（当然不注释也可以，因为默认是读取properties）。我们开始编写properties里面的内容，会发现我们在properties中编写的时候，已经有person的提示了，是因为我们已经建类组件注入容器了，现在我们在里面编写内容如下
 
 流程和yml中写的一样，获取配置文件值注入，导入处理器，注入写一个类，然后使用@ConfigurationProperties注解，注意了还得把类注入容器组件@Component
 （在这里我们只要把内容写进properties就可以了，类、映射和注入在测试yml的时候已经写好了）。编写好之后运行测试，发现依旧能够读取到，结果如下
 
 细心的人会发现，我们输出的结果出现了乱码，而出现乱码的原因是因为我们Idea默认的是utf-8编码，而properties用的是ASCII码，我们只要在Idea中将文件编码设置成Utf-8就可以了，如下
 
 
 
下一篇
 
写到这里篇幅有点长了，关于配置的剩下内容，我将在下一篇博文中进行讲解，可以先把上面学习的进行消化，加油，奥利给。

写在前面
 
鉴于有人留言说想要学习SpringBoot相关的知识，我这里打算写一个SpringBoot系列的相关博文，目标呢是想让看了这一系列博文的同学呢，能够对SpringBoot略窥门径，这一系列的博文初步都定下来包括SpringBoot介绍、入门、配置、日志相关、web开发、数据访问、结合docker、缓存、消息队列、检索、任务安全、分布式等等一系列的博文，工作量很大，是个漫长的过程，每一步我都尽量详细，配上截图说明，也希望对看的同学真的有用。
 单纯就是想分享技术博文，还想说一句就是，如果觉得有用，请点个关注、给个赞吧，也算对我来说是个宽慰，毕竟也得掉不少头发，嘿嘿嘿
 
系列文章传送条
 
详细SpringBoot教程之入门（一）
 详细SpringBoot教程之入门（二）
 详细SpringBoot教程之配置文件（一）
 详细SpringBoot教程之配置文件（二）
 详细SpringBoot教程之日志框架
 详细SpringBoot教程之Web开发（一）
 详细SpringBoot教程之Web开发（二）
 详细SpringBoot教程之Web开发（三）
 详细SpringBoot教程之数据访问
 详细SpringBoot教程之启动配置原理
 详细SpringBoot教程之缓存开发
 
配置映射的另一种方式
 
上一篇博文我们进行了配置文件的编写，映射，注入以及如何进行测试相关的操作，在这里我们再来介绍另一种配置文件的映射注入，即使用其他注解的方式进行注入，我们这里要使用的注解是@Value，@Value是Spring的底层注解。
 
我们回想一下我们以前写SpringMvc的配置文件的时候，我们在配置文件中使用bean进行配置，然后进行相关映射，还记得不，不记得我这里写出一个bean配置回忆一下，内容如下：
 
<bean class="Person">
	<property name="lastName" value="字面量/环境变量/#{获取值}等等"></property>
<bean/>
 
发现没有，以前的方式是我们通过一个一个给属性赋值，比如这里我们给lastName赋值，值就是value指定的。可能你已经意识到了，没错，@Value的作用其实和这里的value一样，相当于Spring帮我们简化了，只需要通过一个注解就能赋值，不过也是一个一个赋值哦，如何使用以及运行结果如下
 
 发现没有，结果依旧可以获取值，所以以为这我们依旧配置成功。
 
@ConfigurationProperties和@Value比较
 
我们上一篇博文使用的是@ConfigurationProperties映射yml或者properties配置文件，这篇博文前面我们举例使用@Value进行配置，那么这两者有什么区别呢？首先我这里给一个比较官方的区别
 
@ConfigurationProperties
@Value
功能
批量注入配置文件中的属性
一个个指定
松散绑定
支持
不支持
SpELl
不支持
支持
JSR30数据校验
支持
不支持
复杂类型封装
支持
不支持
那么这里来解释一下什么是松散绑定呢？其实我们前面已经接触过了，只是不知道那是松散语法而已。比如我们有一个属性时lastName，按道理我们在配置文件中的属性名和Person类中的属性名需要一直对不对，不然没办法映射，但是在松散语法中，lastName和last-name是认为同一个，这种写法就是松散写法，也就是说，我们在配置文件中，person.lastName和person.last-name两种写法都可以，但是@Value是不支持松散写法的，属性名必须一致。
 
还有就是JSR30数据校验，其实我们以前写Spring项目的时候基本都用过，就是校验器，比如对属性是否符合邮箱格式进行校验，不符合提示错误等，而配置文件注入值数据校验，只能使用ConfigurationProperties，如下
 
 所以如果说我们只是在某个业务逻辑中需要获取一下配置文件中的某项值，可以使用@Value比较简洁。而如果说我们专门编写一个javaBean来和配置文件进行映射，我们就直接使用ConfigurationProperties。
 
@PropertySource和@ImportResource比较
 
@PropertySource
 
我们前面在Person类上直接使用@ConfigurationProperties或者@Value进行映射，SpringBoot都是默认到主配置文件中寻找。而@PropertySource就是用来加载指定的配置文件。
 
怎么理解呢？比如我们的application.properties和application.Yml是全局配置文件，我们原先把配置内容都是写到全局配置文件中的，然后我们使用@ConfigurationProperties或者@Value进行映射，也就是说@ConfigurationProperties或者@Value是默认映射全局配置文件的，那么如果项目一旦很大，我们不可能所有配置都写到全局配置文件中，所以这个时候我们需要创建一些其他的配置文件，然后指定映射。
 
可能直接讲不容易理解，下面我举个例子，我们在resources下面创建一个person.properties，然后把application.properties里面的内容粘贴到person.properties中，这个时候我们通过@PropertySource，将Person类和person.properties进行映射，如下图。
 
 
@ImportResource
 
@ImportResource是用来导入原先Spring的配置文件，让配置文件里面的内容生效，也就是说，如果想按照以前SpringMVC的那种出入配置，我们可以使用这个注解来完成。
 
为了更好的理解，我们先在resourcs下创建一个bean.xml（就是以前Spring的配置文件），然后按照以前的方式写一个bean，如下内容
 
 然后我们新写一个测试类，使用ApplicationContext容器，判断容器中是否注入了helloService，内容如下
 
 然后启动测试类，运行之后查看发现helloService没有被注入，日志输出如下
 
 这个时候就可以用到我们的ImportResource了，SpringBoot里面没有Spring的配置文件，我们自己编写的Spring配置文件也不能自动识别，想让Spring的配置文件生效，加载进容器，就可以使用@ImportResource标注在一个配置类上，这里我们在主配置类上标注如下，再次运行测试类
 
 
 当然我们实际开发中不可能像这样使用注解一个一个导入，而我们SpringBoot推荐给容器中添加组件的方式，也就是使用全注解的方式。怎么理解呢？就是我们专门创建一些配置类，用来同意管理项目中所有的配置注入。举个例子，我们专门创建一个配置类，如下创建一个config包，然后创建一个MyAppConfig类，内容如下
 
 我们现在来测试一下，注意了，测试之前先把主配置类里面的@ImportResource去掉，我不使用@ImportResource注解，启动测试类，helloService注入依旧成功。
 
配置文件占位符
 
RandomValuePropertySource：配置文件中可以使用随机数如
 
${random.value}
${random.int}
${random.long}
${random.int(10)}
${random.int[1024,65536]}

 
还有属性配置占位符
 
app.name=MyApp
app.description=${app.name} is a Spring Boot application
 
可以在配置文件中引用前面配置过的属性（优先级前面配置过的这里都能使用）而可以通过${app.name:默认值}来指定找不到属性时的默认值，还是一样，我在配置文件中举个例子帮助理解
 
 
profile快速切换配置
 
profile是Spring对不同环境提供不同配置功能的支持，可以通过激活、指定参数等方式快速切换环境，通俗点理解就是，开发环境的配置，生产环境的配置，测试环境的配置分开，使用profile可以进行快速切换
 
激活方式（即切换方式）
 
命令行： --spring.profiles.active=dev （打包之后，使用命令行执行的时候，指定参数）
配置文件：spring.profiles.active=dev
Jvm参数 -Dspring.profiles.active=dev （在Idea修改参数）
 
多profile文件形式
 
有了激活方式，我们来看怎么使用，首先我们创建三种配置（包括原来的application.properties在内的三个），一般的配置文件格式：application-{profile}.properties。比如application-dev.properties、application-prod.properties。创建之后，我们可以在另外两个配置文件中配置我们想要的配置，然后在主配置文件中进行激活即可，如下
 
 
多profile文档块模式
 
上面是通过properties进行多profile的配置，我们也可以使用yml来进行多profile的配置，yml的配置更简洁，不需要额外创建像application-dev.properties、application-prod.properties这样的配置文件，只需要在主yml配置文件中，使用“—”的文档块模式，如下图
 
 
配置文件加载位置
 
SpringBoot启动会扫描以下位置的application.properties或者application.yml文件作为SpringBoot的默认配置文件，也就是说我们可以更改这两个配置文件的位置
 
file:./config/
file:./
classpath:/config/
classpath:/
 说明一下classpath是在resources目录位置，file是在项目根目录的位置，以上是按照优先级从高到低的顺序，所有位置的文件都会被加载，高优先级配置内容会覆盖低优先级配置内容，配置文件的内容是互补的，也就是说高优先级中没有的配置，如果低优先级有的话一样会生效，但是如果高优先级的配置中已经有了一项配置，低优先级中相同的配置就会被覆盖掉。
 
我们也可以通过配置spring.config.location来改变默认配置，也就是说配置文件可以放在任意的位置，网络上或者电脑桌面任意位置，把位置路径赋给location就可以了，这样对于打包后的项目，使用命令行做运维
 
外部配置的加载顺序
 
SpringBoot支持多种外部配置方式
命令行参数
来自java:comp/env的JNDI属性
Java系统属性（System.getProperties）
操作系统环境变量
RandomValuePropertySource配置的random.*属性值
Jar包外的application-{profile}.properties或application.yml（带spring.profile）配置文件
Jar包内的application-{profile}.properties或application.yml（带spring.profile）配置文件
Jar包外的application.properties或application.yml（不带spring.profile）配置文件
Jar包外的application.properties或application.yml（不带spring.profile）配置文件
@Configuration注解类上的@PropertySource
通过SpringApplication.setDefaultProperties指定的默认属性
 
也就是说，除了我们项目运行配置的文件，我们可以在任何外部环境中，继续配置相关文件进行运行，及时项目已经被打包了，我们也可以使用相关命令行指令，运行在某个位置我们的配置文件，从而启动项目，非常方便运维对项目进行维护而不需要重新打包项目。
 
自动配置原理
 
前面我们其实有提高过自动配置类，即@EnableAutoConfiguration，不过只是带过了他的作用，没有深入讨论，这里我们进行深入讨论，首先先放出所有自动配置文件属性的参考，官网文档位置
 
然后，我们这里通过观察HttpEncodingAutoConfiguration的这个自动配置来讲解，可以在如下位置中找到
 
 打开HttpEncodingAutoConfiguration，进入到里面，我们逐个进行分析
 
 点进HttpProperties.class我们会惊奇的发现，里面也是使用@ConfigurationProperties(prefix = “spring.http”)进行配置，这和我们之前在application.properties中手动配置相关组件的时候，使用的是一样的方式，所以能不能体会到，其实我们可以自行配置更多组件，并进行封装
 
 
 这里我们就可以总结一下自动配置文件的通用模式（即通过命名分辨）
 
xxxAutoConfiguration:自动配置类
xxxProperties：属性配置类
 也就是说，我们yml/properties文件中能配置的值就来源于属性配置类
 
@EnableAutoConfiguration 的作用是利用AutoConfigurationImportSelector给容器中导入一些组件，详细的可以查看SpringFactoriesLoader.loadFactoryNames
 意思是扫描所有jar包类路径下，META-INF/spring.factories。把扫描到的这些文件的内容装成properties对象，然后从properties中获取到EnableAutoConfiguration.class类对应的值，然后把它们添加到容器中，也就是将类路径下META-INF/spring.factories里面配置的所有EnableAutoConfiguration的值加入到容器中，类似下面这些自动配置类
 
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
org.springframework.boot.autoconfigure.admin.SpringApplicationAdminJmxAutoConfiguration,\
org.springframework.boot.autoconfigure.aop.AopAutoConfiguration,\
org.springframework.boot.autoconfigure.amqp.RabbitAutoConfiguration,\
org.springframework.boot.autoconfigure.batch.BatchAutoConfiguration,\
org.springframework.boot.autoconfigure.cache.CacheAutoConfiguration,\
org.springframework.boot.autoconfigure.cassandra.CassandraAutoConfiguration,\
org.springframework.boot.autoconfigure.cloud.CloudServiceConnectorsAutoConfiguration,\
org.springframework.boot.autoconfigure.context.ConfigurationPropertiesAutoConfiguration,\
org.springframework.boot.autoconfigure.context.MessageSourceAutoConfiguration,\
org.springframework.boot.autoconfigure.context.PropertyPlaceholderAutoConfiguration,\
org.springframework.boot.autoconfigure.couchbase.CouchbaseAutoConfiguration,\
org.springframework.boot.autoconfigure.dao.PersistenceExceptionTranslationAutoConfiguration,\
org.springframework.boot.autoconfigure.data.cassandra.CassandraDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.cassandra.CassandraReactiveDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.cassandra.CassandraReactiveRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.cassandra.CassandraRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.couchbase.CouchbaseDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.couchbase.CouchbaseReactiveDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.couchbase.CouchbaseReactiveRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.couchbase.CouchbaseRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.elasticsearch.ElasticsearchAutoConfiguration,\
org.springframework.boot.autoconfigure.data.elasticsearch.ElasticsearchDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.elasticsearch.ElasticsearchRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.elasticsearch.ReactiveElasticsearchRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.elasticsearch.ReactiveRestClientAutoConfiguration,\
org.springframework.boot.autoconfigure.data.jdbc.JdbcRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.jpa.JpaRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.ldap.LdapRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.mongo.MongoDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.mongo.MongoReactiveDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.mongo.MongoReactiveRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.mongo.MongoRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.neo4j.Neo4jDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.neo4j.Neo4jRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.solr.SolrRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.redis.RedisAutoConfiguration,\
org.springframework.boot.autoconfigure.data.redis.RedisReactiveAutoConfiguration,\

 
所有在配置文件中能配置的属性都是在xxxProperties类中封装这，配置文件能配置什么就可以参照某个功能对应的这个属性类，根据当前不同条件判断，决定这个配置是否生效。SpringBoot启动会加载大量的自动配置类，如果我们需要的功能有没有SpringBoot默认写好的自动配置类，那我们就手动引入或配置，在开发中，我们看这个自动配置类中到底配置了哪些组件，只要我们要用的组件存在，我们就不需要再来配置了。给容器中自动配置类添加组件的时候，会从properties类中获取某些属性，我们就可以在配置文件中指定配置属性的值。
 
细节
 
@Conditional由Spring提供，而在Spring Boot中衍生出了以下相关的注解：
@ConditionalOnBean：当容器中有指定Bean的条件下。
@ConditionalOnClass：当classpath类路径下有指定类的条件下。
@ConditionalOnCloudPlatform：当指定的云平台处于active状态时。
@ConditionalOnExpression：基于SpEL表达式的条件判断。
@ConditionalOnJava：基于JVM版本作为判断条件。
@ConditionalOnJndi：在JNDI存在的条件下查找指定的位置。
@ConditionalOnMissingBean：当容器里没有指定Bean的条件。
@ConditionalOnMissingClass：当类路径下没有指定类的条件下。
@ConditionalOnNotWebApplication：当项目不是一个Web项目的条件下。
@ConditionalOnProperty：当指定的属性有指定的值的条件下。
@ConditionalOnResource：类路径是否有指定的值。
@ConditionalOnSingleCandidate：当指定的Bean在容器中只有一个，或者有多个但是指定了首选的Bean。
@ConditionalOnWebApplication：当项目是一个Web项目的条件下。
 以上组合注解均位于spring-boot-autoconfigure jar包下的org.springframework.boot.autoconfigure.condition包
 
Debug查看详细的自动配置报告
 
SpringBoot的debug功能还是非常有帮助的，比如它可以帮助我们查看项目加载注入了哪些自动配置类，从而使得我们不用一个类一个类点入查看。SpringBoot启动的时候，加载主配置类，进而开启了自动配置功能@EnableAutoConfiguration。
 
因此，我们可以在配置文件中开启debug=true，来控制打印自动配置报告，这样我们就可以很方便的知道自动配置类生效
 

 
 

 


 
目录
 
一、SpringBoot配置文件
1. SpringBoot默认配置文件
2. 配置文件的作用
3. 配置文件的位置
4. 多环境切换
方式一：多配置文件
方式二：一个配置文件（yaml的多文档块）
  
  
二、YAML配置注入
1. YAML入门
1、什么是YAML？
2、对比传统标记语言
3、基本语法
4、数据类型
对象
数组
纯量
   
   
2. SpringBoot——yaml注入配置文件
1、编写一个实体类 Dog
2、编写一个Person实体类
3、编写yaml配置文件
4、yaml配置注入
5、测试
6、加载指定的配置文件
7、yaml配置文件占位符
   
3. 对比回顾properties配置
测试properties配置文件
对比小结
  
 

 
 
一、SpringBoot配置文件
 
1. SpringBoot默认配置文件
 
 
SpringBoot使用默认的全局的配置文件：application.properties/application.yml
 
 
配置文件名固定是是application
 
 
`application.properties`
	语法结构: key=value

`application.yml`
	语法结构: key：空格 value
 

 
2. 配置文件的作用
 
SpringBoot在底层给我们自动做了一些配置，所以springboot项目不编写配置文件也可以正常运行，但是根据我们的具体开发我们需要修改SpringBoot自动配置的默认值；
 
 
 
比如我们可以更改默认启动的端口号
 
 
在application.properties中添加
 
#更改项目端口号
server.port=8081
 
然后重新启动，可以看到启动的端口号变更
 
 然后访问localhost:8081即可
 
 
 
3. 配置文件的位置
 
 
 
springboot启动会扫描以下位置的application.properties/application.yml文件作为其默认配置文件：
 
 
优先级1:项目路径下的config文件夹配置文件
优先级2:项目路径下配置文件
优先级3:资源路径下的config文件夹配置文件
优先级4:资源路径下配置文件
 
可以发现：springboot项目生成时的默认配置文件优先级是最低的
 
 
 
优先级由高到底，高优先级的配置会覆盖低优先级的配置；
 
 
SpringBoot会从这四个位置全部加载主配置文件；互补配置；
 
 
 
 
我们在最低级的两个配置文件中设置项目访问路径和端口号的配置来测试互补问题
 
 
在默认位置（第四加载位置）的properties和yaml两个配置文件中添加以下代码测试
 
#配置项目的访问路径
server.servlet.context-path=/zsr
 
server:
  servlet:
    context-path: /zzz #配置项目的访问路径
  port: 8081 #配置端口号
 
然后启动项目测试，可以看到，最终配置的项目访问路径是/zsr，且访问端口为8081
 
 因此：当两个配置文件同时存在的时候，相同的配置会优先加载properties配置文件，多余的配置的会互补配置；
 

 
4. 多环境切换
 
 
 
实际开发中，我们针对不同的应用场景，可能有不同的环境，不同的配置文件
 
 
profile就是Spring对不同环境提供不同配置功能的支持，可以通过激活不同的环境版本，实现快速切换环境，
 
 
方式一：多配置文件
 
我们再编写配置文件时，文件名可以是application-{profile}.properties/yml，用来指定多个不同的环境版本；
 
 
 
例如（properties格式）
 
 
application.properties 代表主环境
 
# /src/main/resources/application.properties
server.port=8080
 
application-test.properties 代表测试环境配置
 
# /src/main/resources/application-test.properties
server.port=8081
 
application-dev.properties 代表开发环境配置
 
# /src/main/resources/application-dev.properties
server.port=8082
 
当我们运行测试时，如果未加指定，它默认使用application.properties主配置文件；
 
实际开发中，面对不同的环境，我们可以在默认配置文件application,properties中指定所需的配置文件环境，例如以下指定使用dev的配置文件：
 
# /src/main/resources/application.properties
server.port=8080
spring.profiles.active=dev
 
此后再启动SpringBoot，就可以看到已经切换到dev下的配置环境；
 
 
 
YAML格式亦是如此
 
 
 
方式二：一个配置文件（yaml的多文档块）
 
 
 
yaml多文档块：可以在一个配置文件中配置多个环境并根据需要进行选择，无需上述多个配置文件，更为方便
 
 
server:  
	port: 8080
#选择要激活那个环境块
spring:  
	profiles:    
		active: prod
		
---
server:  
	port: 8081
spring:  
	profiles: dev #配置环境名称dev

---
server:  
	port: 8082
spring:  
	profiles: prod  #配置环境名称prod
 
注意：如果yml和 properties的配置文件同时存在，同时都配置了端口，但是yaml多环境没有指定环境，默认会使用properties配置文件的！
 
 

 

 
二、YAML配置注入
 
 
 
当我们新建一个项目Springboot项目时，默认使用properties格式的配置文件，其实SpringBoot还支持yaml格式的配置文件，且这是最流行，最为广泛使用的
 
 
1. YAML入门
 
1、什么是YAML？
 
 
 
YAML 有两种展开方式：
 
 
 
YAML Ain't a Markup Language：YAML 不是一种标记语言
 
 
Yet Another Markup Language：YAML是一种标记语言
 
 
 
之所以用反向缩略语重命名，是为了强调 YAML以数据做为中心，而不是以标记语言为重点
 
功能：
 
 
YAML的语法和其他高级语言类似，并且可以简单表达清单、散列表，标量等数据形态。
 
 
它使用空白符号缩进和大量依赖外观的特色，特别适合用来表达或编辑数据结构、各种配置文件、倾印调试内容、文件大纲（例如：许多电子邮件标题格式和YAML非常接近）
 
 
2、对比传统标记语言
 
 
 
以前的配置文件，大多数都是使用 XML 来配置；YAML 作为一种比 XML 更为简单易读的序列化语言，正越来越多地被用于应用及配置文件的开发中
 
 
比如一个简单的端口配置，我们来对比下yaml和xml：
 
<!--传统xml配置-->
<server>
    <port>8081<port>
</server>
 
#YAML配置
server：
  prot: 8080
 
简单的一个对比就可以看出：YAML可读性好，易于实现
 
不仅如此，YAML还有很多其他有点：
 
YAML和脚本语言的交互性好
YAML使用实现语言的数据类型
YAML有一个一致的信息模型
YAML可以基于流来处理
YAML表达能力强，扩展性好
 
 
 
总之，YAML试图用一种比XML更敏捷的方式，来完成XML所完成的任务
 
 
3、基本语法
 
大小写敏感
使用缩进表示层级关系
缩进不允许使用tab，只允许空格
缩进的空格数不重要，只要相同层级的元素左对齐即可
#表示注释
 
4、数据类型
 
 
 
YAML 支持以下几种数据类型：
 
 
对象：键值对的集合，又称为映射（mapping）/ 哈希（hashes） / 字典（dictionary）
数组：一组按次序排列的值，又称为序列（sequence） / 列表（list）
纯量（scalars）：单个的、不可再分的值
 
 
对象
 
对象键值对使用冒号结构表示 key: value，冒号后面要加一个空格。
 
password: 123456
 
对象的行内写法：
 
User: {name: zsr,age: 20}
 
还可以使用缩进表示层级关系：
 
User:
  name: zsr
  age: 20
 
数组
 
用 - 值表示数组中的一个元素,比如：
 
pets:
 - cat
 - dog
 - pig
 
行内写法
 
pets: [cat,dog,pig]
 
数据结构的子成员是一个数组，则可以在该项下面缩进一个空格，例如：
 
companies:
    -
        id: 1
        name: company1
        price: 200W
    -
        id: 2
        name: company2
        price: 500W
 
意思是 companies 属性是一个数组，每一个数组元素又是由 id、name、price 三个属性构成。
 
数组也可以使用流式(flow)的方式表示：
 
companies: [{id: 1,name: company1,price: 200W},{id: 2,name: company2,price: 500W}]
 
纯量
 
 
 
纯量是最基本的，不可再分的值，包括：
 
 
字符串
布尔值
整数
浮点数
Null
时间
日期
 
 
纯量直接写在后面就可以，字符串默认不用加上双引号或者单引号；
 
key: value
 
当写一些特殊字符时，我们可能会用上单引号或者双引号：
 
 
" " 双引号：不会转义字符串里面的特殊字符 ， 特殊字符会作为本身想表示的意思；
 
#比如
name: "kuang \n shen"  
#输出 
kuang 换行 shen
 
 
' ' 单引号：会转义特殊字符 ， 特殊字符最终会变成和普通字符一样输出
 
#比如
name: ‘kuang \n shen’  
#输出
kuang \n shen
 
 
使用一个例子来快速了解纯量的基本使用：
 
boolean: 
    - TRUE  #true,True都可以
    - FALSE  #false，False都可以
float:
    - 3.14
    - 6.8523015e+5  #可以使用科学计数法
int:
    - 123
    - 0b1010_0111_0100_1010_1110    #二进制表示
null:
    nodeName: 'node'
    parent: ~  #使用~表示null
string:
    - 哈哈
    - 'Hello world'  #可以使用双引号或者单引号包裹特殊字符
    - newline
      newline2    #字符串可以拆成多行,每一行会被转化成一个空格
date:
    - 2018-02-17    #日期必须使用ISO 8601格式,即yyyy-MM-dd
datetime: 
    -  2018-02-17T15:02:31+08:00    #时间使用ISO 8601格式,时和日期之间使用T连接,最后使用+代表时区
 

 

 
2. SpringBoot——yaml注入配置文件
 
 
 
yaml文件更强大的地方在于，他可以给我们的实体类直接注入匹配值！
 
 
1、编写一个实体类 Dog
 
 
 
在主程序同级目录下新建pojo包，在包下新建一个Dog实体类
 
 
 
 
package com.zsr.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.springframework.stereotype.Component;

@Data
@AllArgsConstructor//有参构造
@NoArgsConstructor//无参构造
@Component//注册bean到容器中
public class Dog {
    private String name;
    private Integer age;
}
 
2、编写一个Person实体类
 
 
 
Person类，包含所有常见数据类型，以及Dog对象
 
 
@Data
@AllArgsConstructor
@NoArgsConstructor
@Component //注册bean到容器中
public class Person {
    private String name;
    private Integer age;
    private Boolean happy;
    private Date birth;
    private Map<String, Object> maps;
    private List<Object> lists;
    private Dog dog;
}
 
3、编写yaml配置文件
 
 
 
在springboot项目中的resources目录下新建一个文件 application.yml，使用yaml配置的方式进行注入
 
  
 
person:
  name: zsr
  age: 20
  happy: True
  birth: 2000/02/04
  maps: {k1: v1,k2: v2}
  lists:
    - guitar
    - sing
    - play
  dog:
    name: 多多
    age: 4
 
4、yaml配置注入
 
 
 
刚才已经把person对象的所有属性值都写好了
 
 
再通过@ConfigurationProperties注解注入到我们的类中，
 
 
/*
@ConfigurationProperties作用：
	将配置文件中配置的每一个属性的值，映射到这个组件中；
	告诉SpringBoot将本类中的所有属性和配置文件中相关的配置进行绑定
	参数 prefix = “person” : 将配置文件中的person下面的所有属性一一对应
*/
@Component //注册bean
@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> lists;
    private Dog dog;
}
 
IDEA爆红提示：springboot配置注解处理器没有找到，我们点击Open Document查看文档
 
 
 发现未找到，我们降低版本为2.1.9即可
 
https://docs.spring.io/spring-boot/docs/2.1.9.RELEASE/reference/html/configuration-metadata.html#configuration-metadata-annotation-processor
 
进入到网页中，可以找到一个依赖，加上他，就不会爆红提示
 
 
<!-- 导入配置文件处理器-->
<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-configuration-processor</artifactId>
	<optional>true</optional>
</dependency>
 
5、测试
 
 
 
配置完成后，我们修改测试类进行测试
 
 
package com.zsr;

import com.zsr.pojo.Dog;
import com.zsr.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 //将person自动注入进来
    private Person person;

    @Test
    void contextLoads() {
        System.out.println(person); //打印看下person对象
    }
}
 
结果：所有值全部注入成功！yaml配置成功注入到实体类！
 
 
6、加载指定的配置文件
 
 
 
以上我们通过@configurationProperties注解默认从全局配置文件中获取值
 
 
 
此时配置文件名必须为application才能被spring认出
 
 
其实我们可以通过@PropertySource指定加载的配置文件，可以自定义文件名
 
 
 
1、我们去在resources目录下新建一个person.properties文件
 
name=zsr
age=20
happy=True
birth=2000/02/04
lists=guitar,sing,play
 
2、相应修改对应的实体类，用@PropertySource注解加载指定person.properties文件
 
package com.zsr.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.PropertySource;
import org.springframework.stereotype.Component;

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

@Data
@AllArgsConstructor
@NoArgsConstructor
@Component //注册bean到容器中
@PropertySource(value = "classpath:person.properties")
public class Person {
    //SPEL表达式取出指定的值
    @Value("${name}")
    private String name;
    @Value("${age}")
    private Integer age;
    @Value("${happy}")
    private Boolean happy;
    @Value("${birth}")
    private Date birth;
    private Map<String, Object> maps;
    @Value("${lists}")
    private List<Object> lists;
    //properties不能存对象
    private Dog dog;
}
 
3、修改测试类
 
package com.zsr;

import com.zsr.pojo.Dog;
import com.zsr.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 //将person自动注入进来
    private Person person;
    @Test
    void contextLoads() {
        System.out.println(person); //打印看下person对象
    }
}
 
4、运行测试
 
指定配置文件绑定成功！
 
 
7、yaml配置文件占位符
 
yaml配置文件还可以编写占位符生成随机数
 
person:
    name: zsr${random.uuid} # 随机uuid
    age: ${random.int}  # 随机int
    happy: true
    birth: 2000/02/04
    maps: {k1: v1,k2: v2}
    lists:
      - guitar
      - sing
      - play
    dog:
      name: ${person.hello:other}_多多
      age: 4
 
然后运行测试：
 
 

 
3. 对比回顾properties配置
 
 
 
以上采用的yaml配置文件是最简单且最常用的方式；也是springboot所推荐的！
 
 
接下来来对比一下默认的properties配置文件
 
 
注：properties配置文件在写中文的时候，会有乱码，我们需要去IDEA中设置编码格式为UTF-8；
 
 
测试properties配置文件
 
1、新建一个实体类User
 
package com.zsr.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.springframework.stereotype.Component;

@Component
@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
    private String name;
    private int age;
    private String sex;
}
 
2、编辑配置文件 user.properties
 
name=zsr
 
3、我们在User类上使用@Value来进行注入！
 
package com.zsr.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.springframework.context.annotation.PropertySource;
import org.springframework.stereotype.Component;
import org.springframework.beans.factory.annotation.Value;

@Component
@Data
@AllArgsConstructor
@NoArgsConstructor
@PropertySource(value = "classpath:user.properties")
public class User {
    //直接使用@value()
    @Value("${user.name}")//从配置文件中取值
    private String name;
    @Value("#{9*2}")//SPEL表达式:@Value("#{表达式}")
    private int age;
    @Value("男") //纯量
    private String sex;
}
 
4、Springboot测试类测试
 
package com.zsr;

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

@SpringBootTest
class Springboot02ConfigApplicationTests {

    @Autowired //将user自动注入进来
    private User user;

    @Test
    void contextLoads() {
        System.out.println(user); //打印看下person对象
    }

}
 
结果正常输出：
 
 
对比小结
 
 
 
@ConfigurationProperties只需要写一次即可，@Value则需要对每个字段都添加
 
 
松散绑定：比如我的yaml中写的 last-name，这个和 lastName 是一样的，- 后面跟着的字母默认是大写的，这就是松散绑定
 
 
JSR303数据校验：可以在字段是增加一层过滤器验证，可以保证数据的合法性
 
 
复杂类型封装：yaml中可以封装对象，使用@value就不支持
 
 
最佳实践：
 
 
配置 yaml 和配置 properties 都可以获取到值时，首荐 yaml；
 
 
如果在某个业务中，只需要获取配置文件中的某个值，可以使用一下@value
 
 
如果有编写的JavaBean来和配置文件进行一一映射，就直接@configurationProperties