1. SpringBoot配置文件存放位置以及读取顺序
默认情况下，我们可以将application.properties或者application.yaml(为了方便演示，本文以下均以application.properties介绍)放置在如下四处： 1.1、idea中，为了我们本地方便开发测试，我们在此处创建一个config目录，然后把application.properties放进去，项目正常运行。jar包会自动生成在target目录下。 我们将生成的jar包，复制出来，到另外文件夹进行运行，比如，我现在该jar包复制到test目录下，但是这个时候是起不来，因为没有配置文件，虽然我们在idea里面是有config目录的，但是它并不没有被打包进去。我们要把config目录也复制过来，跟该jar包放在同一个目录下。 在此处，我们可以使用java -jar demo-0.01-SNAPSHOT来运行项目。 正常运行。 当我们将其打成jar包时，application.properties同样不会被打包进jar包中。需要另外复制出来和jar包放在才能正常运行。 推荐以上两种方式来放置配置文件，如果不写开发，测试，和生产好几套环境配置文件的话，就可以直接打开配置文件，改成自己需要的配置即可。 以下两种方式是将该配置文件打包在jar包里面了，即便只改一个端口号，开发人员先改配置文件，再打包，再运行。此处也记录下，并解开jar包，看下该配置文件被打包后，放置的位置。 打包后，如下图，jar包再target里面，我们寻找下application.properties文件。为了方便演示，我们将target目录下的demo-0.0.1-SNAPSHOT.jar放到一个新目录给它解压开，找下该配置文件，我放置到了一个test目录下。 解压后：如下图，我们进入目录 发现config目录被放置在classes目录下。然后这也就让我们明白了，什么是classpath？classpath的路径到底指的是哪里，在idea中我们就把它放置在resource目录，该目录就是表示classpath。而被打成jar包后classes目录就是所谓的classpath。 所有的yaml文件，同理。
2. springboot加载properties和yml配置文件的顺序
假设一个项目在同一位置同时存带让在application.properties和application.yml文件， 且其中都含有相同的某个key,但value不同，如：山行伏 application.properties中：server.port=8001， application.yml中：server.port=8888。 问题：springboot是否都加载这两个配置文件？如果两个文件有相同的key，取哪一个文件的value？ 答： 都加载，且按properties→yml的顺序加载。 在看到spring.factories中，配置加载器顺序是先执行再到YamlPropertySourceLoader。 在ConfigFileApplicationListener获取server.port这个key的value时候，可以发现两配置文件全都加载进去了，且注意顺序，application.properties文件在前。 getSource()方法获取到两个Source，先从application.properties文件中查找值，一旦找到立逗携即返回，如果找不到再从application.yml中查找。
3. Spring Boot 第二弹，配置文件详解-史上最全
Spring Boot 官方 提供了两种常用的配置文件格式，分别是 properties 、 YML 格式。相比于 properties 来说， YML 更加年轻，层级也是更加分明。 强烈推荐使用 YML 格式
Spring Boot项目 启动会扫描以下位置的 application.properties 或者 application.yml 作为默认的配置文件.
徒手撕源码
内部类Loader的load方法
getSearchLocations()方法
asResolvedSet()
下面给出优先级 从高到低 的配置文件排列顺序：
以设置应用端口为例 初体验Spring Boot配置文件
properties后缀结尾(application.properties)
yml/yaml后缀结尾(application.yml/application.yaml)
数字，字符串，布尔，日期
对象、Map
数组
数字，字符串，布尔，日期
对象、Map
数组
@ConfigurationProperties(prefix = “person”)详解
标注在类上
标注在方法上
综上所述 @ConfigurationProperties 注解能够轻松的让配置文件跟实体类绑定在一起。
值得关注的是： @ConfigurationProperties 这个注解仅仅是支持从 Spring Boot的默认配置文件 中取值，也就是 application.properties 、 application.yml 、 application.yaml ，那我们如何从自定义配置文件取值呢？？？ 别着急，有解决办法，那就是再加一个注解： @PropertySource(value = “classpath:custom-profile.properties”) ,下面会有对 @PropertySource 注解的介绍。请耐心往下面看。
使用@PropertySource注解
对应配置文件
创建两个配置文件 custom-profile.yml、custom-profile1.yml ，如下去引入。
我们可以通过控制变量法进行测试，具体过程我这里就不赘述了。 直接说 结论 吧： Spring加载顺序 为 从左到右顺序加载 ，后加载的会 覆盖 先加载的属性值。
另外需要注意的是 ： @PropertySource 默认加载 xxx.properties类型 的配置文件，不能加载 YML格式 的配置文件。如何解决呢？下面来解决这一问题
对应配置文件：
编写PropertiesController
扩展功能
application.yml 主配置文件
application-dev.yml 开发配置文件
application-prod.yml 生产配置文件
application-test.yml 测试配置文件
（1）主配置文件：配置激活选项
（2）其他配置文件：指定属于哪个环境（同yml，只不过表现形式是 key=value 的,三个配置文件分别是： application-dev.properties , application-prod.properties , application-test.properties ）
无论是使用上述 多文档块 的方式，还是新建 application-test.yml 文件，都可以在配置文件中指定 spring.profiles.active=test 激活指定的profile。
感谢阅读小生文章。祝大家早日富可敌国，实现财富自由。 写文不易 ,一定要 点赞、评论、收藏哦 , 感谢感谢感谢!!!
4. Spring载入多个配置文件加载顺序是怎么样的
这个顺序不需要关心吧？Spring是先加载配置文件，然后更加姿巧配置文件再初始化相应的类比如你在B配置文件中声明了一个BeanA 在A配置文件中用到了这个BeanA，Spring 不会由于配置文件加载顺迹穗键序的问题而造成找不到BeanA的错族碰误的。
5. spring常用注解
一、组件注解
1、 @Component(“xxx”)
指定某个类是容器的bean， @Component(value=”xx”) 相当于 ，其中 value 可以不写。
用于标注类为spring容器bean的注解有四个， 主要用于区别不同的组件类，提高代码的可读性：
a、 @Component, 用于标注一个普通的bean
b、 @Controller 用于标注一个控制器类（控制层 controller）
c、 @Service 用于标注业务逻辑类（业务逻辑层 service）
d、 @Repository 用于标注DAO数据访问类 （数据访问层 ）
对于上面四种注解的解析可能是相同的，尽量使用不同的注解提高代码可读性。
注解用于修饰类，当不写value属性值时，默认值为类名首字母小写。
2、 @Scope(“prototype”)
该注解和 @Component 这一类注解联合使用，用于标记该类的作用域，默认 singleton 。 也可以和 @Bean 一起使用，此时 @Scope 修饰一个方法。关于@Bean稍后有说明
3、 @Lazy（true）
指定bean是否延时初始化，相当于 ，默认false。@Lazy可以和@Component这一类注解联合使用修饰类，也可以和@Bean一起使用修饰方法
注 ：此处初始化不是指不执行 init-method ，而是不创建bean实例和依赖注入。只有当该bean（被@Lazy修饰的类或方法）被其他bean引用（可以是自动注入的方式）或者执行getBean方法获取，才会真正的创建该bean实例，其实这也是BeanFactory的执行方式。
4、 @DepondsOn({“aa”，“bb”})
该注解也是配合 @Component 这类注解使用，用于强制初始化其他bean
上面的代码指定，初始化bean “userAction”之前需要先初始化“aa”和“bb”两个bean,但是使用了@Lazy(true)所以spring容器初始化时不会初始化”userAction” bean。
5、 @PostConstructor和@PreDestroy
@PostConstructor 和 @PreDestroy 这两个注解是j2ee规范下的注解。这两个注解用于修饰方法，spring用这两个注解管理容器中spring生命周期行为。
a、 @PostConstructor 从名字可以看出构造器之后调用,相当于 。就是在依赖注入之后执行
b、 @PreDestroy 容器销毁之前bean调用的方法，相当于
6、 @Resource（name=“xx”）
@Resource 可以修饰成员变量也可以修饰set方法。当修饰成员变量时可以不写set方法，此时spring会直接使用j2ee规范的Field注入。
@Resource有两个比较重要的属性，name和type
a、 如果指定了name和type，则从Spring容器中找到唯一匹配的bean进行装配，找不到则抛出异常;
b、 如果指定了name，则从spring容器查找名称（id）匹配的bean进行装配，找不到则抛出异常;
c、 如果指定了type，则从spring容器中找到类型匹配的唯一bean进行装配，找不到或者找到多个，都会抛出异常;
d、 如果既没有指定name，又没有指定type，则自动按照byName方式进行装配
如果没有写name属性值时
a、 修饰成员变量，此时name为成员变量名称
b、 修饰set方法，此时name 为set方法的去掉set后首字母小写得到的字符串
7、 @Autowired（required=false）
@Autowired可以修饰构造器，成员变量，set方法，普通方法。@Autowired默认使用byType方式自动装配。required标记该类型的bean是否是必须的，默认为必须存在（true）。
可以配合 @Qualifier(value=”xx”) ,实现按beanName注入：
a、 required=true(默认），为true时，从spring容器查找和指定类型匹配的bean，匹配不到或匹配多个则抛出异常
b、 使用 @Qualifier（”xx”） ,则会从spring容器匹配类型和 id 一致的bean，匹配不到则抛出异常
@Autowired会根据修饰的成员选取不同的类型：
a、 修饰成员变量。该类型为成员变量类型
b、 修饰方法，构造器。注入类型为参数的数据类型，当然可以有多个参数
8、demo
业务逻辑层：
数据访问层：
测试类：
输出结果：
可以看到虽然UserDao 使用@Lazy，但是还是在spring容器初始化的时候还是创建了UserDao实例。原因很简单，因为在UserService中需要注入UserDao，所以在此时创建的UserDao实例也属于延时初始化。
在上面我们还使用了两个接口InitializingBean 和DisposableBean，这两个接口用于管理 singleton 作用域的bean的生命周期，类似init-method和destroy-method。不同之处就是调用的循序不一致：
a、 初始化调用顺序 ：@PostConstructor > InitializingBean > init-method 用于指定bean依赖注入后的行为
b、 销毁调用顺序 @PreDestroy > DisposableBean > destroy-method 用于定制bean销毁之前的行为
该注解是AspectJ中的注解，并不是spring提供的，所以还需要导入aspectjweaver.jar，aspectjrt.jar，除此之外还需要依赖aopalliance.jar
依赖包：
UserDao.java
配置文件 applicationContext.xml：
测试类：
1、 @Aspect
修饰Java类，指定该类为切面类。当spring容器检测到某个bean被@Aspect修饰时，spring容器不会对该bean做增强处理（bean后处理器增强，代理增强）
2、 @Before
修饰方法，before增强处理。用于对目标方法（切入点表达式表示方法）执行前做增强处理。可以用于权限检查，登陆检查。
常用属性：
value： 指定切入点表达式 或者引用一个切入点
对com.example.aop 包下所有的类的所有方法做 before增强处理：
结果：
如果同一条切入点表达式被使用多次，可以使用更友好的方式。定义一个切入点：
增强方法可以接受一个JoinPoint 类型的参数，用于获取被执行目标方法的一下属性。
结果：
3、 @AfterReturning
修饰方法，afterreturning增强处理。目标方法正常结束后做增强处理。
常用属性：
a、 pointcut/value：指定切入点表达式
b、 returning：指定一个参数名，用于接受目标方法正常结束时返回的值。参数名称需要在增强方法中定义同名的参数。
注意：
a、 如果使用了returning 。那么增强方法中的数据类型必须是返回结果的类型或者父类型，否则不会调用该增强处理。
b、 使用了returning 还可以用来 修改返回结果 。
以上面的例子来说，目标方法返回结果类型应该满足下面的条件
修改返回值：
结果：
可以看到 AfterReturning 修改了返回结果。
4、 @AfterThrowing
修饰方法，afterthrowing增强处理。当目标程序方法抛出 异常或者异常无法捕获时，做增强处理。
常用属性：
a、 pointcut/value ：指定切入点表达式
b、 throwing：指定一个形参，在增强方法中定义同名形参，用于访问目标方法抛出的异常
参数类型必须是 Throwable 的子类，同样也会有上面@AfterReturning 参数类型匹配的问题。
5、 @After
修饰方法 ，after增强处理。无论方法是否正常结束，都会调用该增强处理（@After= @[email protected]）。但是该增强方式无法获取目标方法的返回结果，也获取目标方法抛出的异常。所以一般用于进行释放资源，功能类似于 finally。
常用属性：
a、 value ：指定切入点表达式
结果：
从上面的结果来看 After 增加处理 ，因为不能接受返回结果作为参数，所以不能修改返回结果。
6、 @Around
修饰方法， around增强处理。该处理可以目标方法执行之前和执行之后织入增强处理（@[email protected]）。
Around增强处理通常需要在线程安全的环境下使用，如果@Before和@AfterReturning可以处理就没必要使用@Around。
常用属性：
a、 value ：指定切入点表达式
当定义一个Aound增前处理时，增强方法第一形参需要时ProceedingJoinPoint类型。ProceedingJoinPoint有一个Object proceed()方法，用于执行目标方法。当然也可以为目标方法传递数组参数，来修改目前方法的传入参数。
around小结：
a、 Around增强处理通常需要 在线程安全 的环境下使用
b、 调用 proceed()可以获取返回结果，所以可以修改目标方法的返回值
c、 proceed(Object[] var1) 可以修改入参，修改目标方法的入参
d、 可以进行目标方法执行之前和执行之后织入增强处理
around 和 afterReturning 都可以修改返回结果。不过两者的原理不同：
a、 around：可以任意修改，或者返回不相关的值。这个返回值完全可以自主控制
b、 afterReturning，通过方法参数 ，使用对象引用的方式来修改对象。修改对象引用地址那么修改时无效的
除此之外从输出结果来看，增强处理是有序的：
around 和 afterReturning小结：
a、 只有 around 和 afterReturning 可以获取并修改返回结果。需要注意两种方式修改的区别。
b、 around 需要线程安全
c、 虽然增强处理都需要 切入点表达式，并不是都支持 pointcut 属性，所以最好都是用value 属性指定。当注解只需要value属性时，value可以省略
7、 @Pointcut
修饰方法，定义一个切入点表达式用于被其他增强调用。使用该方式定义切入点方便管理，易复用。
切入点方法定义和测试方法定义类似，具有以下特点：
a、 无返回值 （void）
b、 无参数
c、 方法体为空
d、 方法名就是切入点名称
e、 方法名不能为 execution
切入点表达式
切入点表达式可以通过 && 、 || 、 ! 连接
1）、execution 表达式：
2）、within 表达式：
a、匹配指定类下的所有方法。
b、匹配执行包及其子包下所有类的所有方法。
所以within可以看做execution的简写，不需要指定返回类型、方法名、参数（ 最小作用单位是类 ）
3）、 @annotation：匹配使用指定注解修饰的目标方法；
匹配使用@CustomMethodAnnotation注解的目标方法。
4）、 @within: 用于匹配使用指定注解修饰的类下的所有方法
within 作用范围是类，@within的作用范围与其一致。不同的是@within 指定的不是类而是注解
匹配使用@ResponseBody 注解的类 下的所有方法。
AOP小结：
1）、 Around增强处理通常需要 在线程安全 的环境下使用
2）、 使用 around 和 afterReturning 可以获取并修改返回结果
3）、 增强处理指定 切入点表达式时，最好使用value 属性
4）、 切入点 名称（方法名）不能为 execution
5）、 AfterReturning 指定了 returning 属性接受目标方法返回结果，注意 参数类型需要和返回结果类型一致（满足 resutType instanceof argsType ）
增强方式的顺序：
1、 @Bean(name=“xxx”)
修饰方法，该方法的返回值为spring容器中管理的bean。当然该注解和上面的@Component效果一样，主要用于做区分。
@Bean 通常使用在 @Configuration 修饰的配置类中，该注解功能相当于 元素
常用的属性：
a、 name：bean id 。name可以省略，省略时bean名称为方法名。也可以指定多个名称（逗号隔开）。
b、 autowire： 是否自动注入，默认Autowire.NO
c、 initMethod：bean的初始化方法。在依赖注入之后执行
d、 destroyMethod: spring容器关闭时bean调用的方法 当然 @Bean 还可以配合 @Scope 指定bean的作用域
2、 @ConfigurationProperties
用于从属性文件中获取值 application.properties 或者 application.yml 。当然了 如果在配置文件中引入其他配置文件，也可以获取到属性值。
包含的属性：
a、 value | prefix 两者互为别名。指定前缀，默认为””
b、 ignoreUnknownFields：默认为true。是否忽略未知字段，当实体中的字段在配置文件中不存在时，是忽略还是抛出异常
c、 ignoreInvalidFields： 默认false。 是否忽略不合法的字段，此处的不合法是指类型不合适，配置文件中存在改配置但是无法转化为指定的字段类型。
Mybatis属性配置
application.properties：
ConfigurationProperties 可以配置前缀，然后会根据实体的变量名拼接前缀，去配置文件中查询配置。
3、 @Configuration
修饰一个Java类，被修饰的类相当于一个xml配置文件。功能类似于 。在springboot中大量使用了该注解，该注解提供了一种使用Java类方式配置bean。
可以发现 @Configuration使用了@Component 注解修饰。
实例 ：
配置Mybatis会话工厂
4、 @Import
功能和 类似，修饰Java类，用于向当前类导入其他配置类。 可以导入多个配置文件，通常用于导入不在包扫描范围内的配置文件。可以被扫描的配置类可以直接访问，没有必要使用@Import 导入。
比如 SpringBoot的启动类指定的包扫描路径为 com.example
数据库的配置文件在 com包下。
在MyBatisConfig 中引入 DataSourceConfig， 就会解析DataSourceConfig。将解析出的Bean交给容器管理
5、 @ImportResource
修饰Java类，用于向类引入xml配置文件。
用于导入包含bean定义的配置文件，功能和 类似。默认情况下可以处理后缀为 .groovy 和.xml 的配置文件
6、 @Value(“${expression}”)
修饰成员变量或者 方法、构造器的参数，用于属性值注入（在配置文件中配置的值）。
注意: @Value不能对 static 属性注入。
如果的确需要注入到静态变量，可以通过以下方式间接进行注入：
1）、设置一个私有静态 实例
2）、通过构造函数或者 @PostConstruct 注解为 静态实例 赋值，指向本身（this）
3）、对成员属性注入内容
4）、提供静态方法，使用静态实例获取成员属性
7、@PropertySource(value=“classpath:jdbc.properties”)
该注解用来加载属性文件。
常用属性：
a、 ignoreResourceNotFound： 当资源文件找不到的时候是否会忽略该配置，而不是抛出错误。一般用于可选项
b、 encoding ： 资源文件使用什么编码方式
c、 value ： 指定属性文件位置。可以配置多个属性文件，不可以使用通配符。
在 PropertySource 中可以指定多个路径，并且会将属性文件中的值加载到 Environment 中。
@ConfigurationProperties 和 @PropertySource
它们的使用有一些差异：
1）、 @PropertySource 使用该注解加载的是 相对独立的属性文件，可以同时加载多个文件 （xxx.properties），而且 不支持自动注入 ， 不支持前缀注入
2）、 @ConfigurationProperties 用于加载配置文件（application.properties | application.yml）。该注解功能更强大：
a、 支持前缀注入 （ prefix ）
b、 相同属性名的自动注入
c、 $(“”) 支持EL表达式注入
应用实例：
在以往的开发中通常会将数据库连接信息存放在单独的属性文件中（jdbc.properties）。而在spring boot 中我们会将数据库的信息存放在配置文件中，这会极大便利开发工作。
jdbc.properties：
可以通过 @Value 注解将配置文件的值注入到实体类中
也可以注入Environment ，通过Environment 获取值
1、 @ResponseBody
控制器方法返回值会使用 HttpMessageConverter 进行数据格式化，转化为jsON字符串。
同样的 ResponseBodyAdvice: 针对使用@ResponseBody的注解的类，方法做增强处理。
2、 @RestController
@RestController = @Controller + @ResponseBody ， 所以通常直接使用@RestController 注解
3、 @RequestBody
从Reuqest请求体中获取内容，绑定到方法的指定参数上。 SpringMVC 使用HttpMessageConverter 接口将请求体中的数据转化为方法参数类型。
SpringMVC 给用户对参数的处理提供了很大支配权。 我们可以使用 接口RequestBodyAdvice 来实现对参数进行拦截处理。
注意
1）、 RequestBodyAdvice : 针对所有以@RequestBody的参数做处理
2）、 自定义的处理对象类上必须得加上@ControllerAdvice注解!
利用此功能我们可以做以下处理工作：
1）、参数做解密处理。
2）、修改接受的参数数据。
4、 @RequestParam
从Request请求中获取指定的参数。
可以设置的属性：
1）、 required ： 默认为true 参数必须存在 。参数不存在时抛出异常(). 提示信息
2）、 defaultValue ： 设置参数默认值。 当参数没有提供或者为空值时生效, 包含隐式定义 required=false
3）、 name | value ， 互为别名的属性， 绑定请求中的参数名。 request.getParameter(name);
5、 @RequestMapping
用于设置 请求 和 Method 的映射关系。指明何种请求可以和方法匹配
可配置属性值：
1）、 path、value、 name, 互为别名，设置可以处理的url。
2）、 consumes，字符串数组。 指定可以处理的 媒资类型，仅当请求头中的 Content-Type 与其中一种媒体类型匹配时，才会映射请求。所以该配置会缩小可匹配的请求。 当url 匹配但是consumes不匹配时， 状态码415。 不设置的话，表示不限制媒资类型，参数的具体使用何种方式解析，SpringMVC会选择合适的处理器处理。
3）、 proces，字符串数组。 生成的媒资类型，该属性会影响实际的输出类型。和consumes一样，改配置会缩小匹配的范围。 只有当请求头中的 Accept 与 配置的任意一个媒资类型匹配时，才会映射请求。 当url 匹配与consumes不匹配时， 状态码406 。 比如：为了生成UTF-8编码的JSON响应，应使用 MediaType.APPLICATION_JSON_UTF8_VALUE。
6. springboot配置文件总结
springboot 本身支持多种灵活的配置方式，为开发 springboot 程序带来了很大的灵活性和扩展性，但是同时由于太灵活，经常会导致明明配置了相关属性，却没有生效。 本文总结了 springboot 配置文件的原理以及多个配置文件生效的顺序。 springboot 配置文件支持灵活的路径，以及灵活的文件名，用一个变量表达式总结如下： 部分源码如下： 当满足上述变量表达式的配置文件有多个时，会有一个配置的优先级。假设 上面每个条件组合起来，则最多有配置文件如下，且顺序从上到下： 获取属性时，按从上到下的顺序遍历由上述文件生成的属性资源对象 PropertySource ，如果遇到匹配的key直接返回。 总结一下：就是如果同一个key的属性只出现一次，则直接取该值即可。如果同一个key的属性出现多次，则取顺序靠前的属性资源对象。另外其中每个文件都是可选的。 需要注意的一点是：如果在同一个 location 下配置了多个文件名一样的文件，则只会取一个，比如在 classpath:/ ，有如下两个文件 application.yml ： 则只会根据 classloader 的 classpath 列表，选取第一个出现的文件。因为 springboot 加载配置文件时最底层是使用的下面的方法： 这两个方法只会获取 classloader 类的 ucp 属性里面第一个匹配到的值。如果对 springboot 自身的机制不满意，想获取所有的classpath:/路径下面的 applicaiton.yml 文件，可以使用下面的方法： 本文总结了 springboot 配置文件的原理以及多个配置文件生效的顺序。如果存在增加了配置文件或者在配置文件里面增加了属性却没有生效，可以参考上面的 springboot 配置文件表达式和配置文件生效顺序进行排查。 后面还会有一篇文章讨论基于 springboot 配置原理如何实现自定义的配置读取方式。
7. Spring Boot 配置的优先级
本文主要参考 Externalized Configuration 为了能让应用在不同的环境下运行，Spring Boot允许自定义配置文件，如properties文件、yaml文件、系统环境变量参数、命令行参数。配置文件的覆盖优先级如下 Developer Tools 提供了一些开发帮助工具，在build.gradle添加依赖后启用。 Spring Boot会读取在计算机用户的home目录下的 .spring-boot-devtools.properties 文件里的配置参数到该计算级的所有Spring Boot应用中作为顶层配置，岩顷颤如Linux环境下root用户下 ~/.spring-boot-devtools.properties 文件。开发过程中，可以将一些个人参数记录在这个配置文件中，例如ip地址，机器uuid，datasource参数等。在该配置文件中的定义的配置环境并不会影响到应用配置的读取，官方原话是： 但要注意，该配置优先级最高，设置的时候需要做好记录否则会出现"原因不明的bug"，不过应该很少人会用到这个功能。分析下源码，就是加了一个配置切面，并把其设置为顶层配置： 在测试的时候，可能会使用另一套测试专用的配置，该套配置的优先级高于系统环境变量、java系统参数、程序内部参数， @TestPropertySource 注解就是用来指定这一类配置的。该注解一共有5个参数可以设置： 如果使用注解的时候没有任何参数，那么会从标注了注解的测试类的包中尝试读取配置文件，例如测试类 com.spring.test.DemoTest ，那么相应的默认配置文件为 com.spring.test.DemoTest.properties ，如果没有找到默认的配置文件则乎慎抛出非法状态异常。 在初始化上下文的时候会调用一个读取、合并配置的方法 ，该方法通过工具类 TestPropertySourceUtils 读取类的注解信息。 TestPropertySourceUtils 从类的注解解析配置信息后返回一个可合并的粗败配置源。 @SpringBootTest 的value\properties属性用于注入一些自定义的注解，语法要求和 @TestPropertySource 的properties一样，这里就不详细展开了。 用命令行方式启动Spring Boot应用程序的时候，可以注入一些配置参数，参数的格式是 –key=name 。举个简单的例子，程序直接输出一个参数，然后打成jar包后运行。 运行： java -jar .\springbootconfiguraiton.jar –cl.name="Spring Boot Arguments" 从输出的结果中可以看到可以读取到命令行中的配置。 可以在环境变量中定义一个key为SPRING_APPLICATION_JSON的参数，值为json字符串，Spring Boot会解析该json字符串作为参数注入到系统中。SPRING_APPLICATION_JSON可以定义在环境变量、系统配置中，命令行也是可以的，例如命令行参数中用到的demo，执行以下的命令也应该能得到相同的参数结果。 java -jar .\springbootconfiguraiton.jar SPRING_APPLICATION_JSON='{"cl":{"name"="Spring Boot Arguments"}}' 结果输出是undefined，不知道原因，这个配置方式用的应该也很少，放弃研究。。。 优先级是 ServletConfig > ServletContext ，可以在application.yml中设置： 随机数配置大多用于测试，支持的类型如下： 其中long\int可以限制数据范围，[]是闭区间，()是开区间。 这个应该是我们用的最多的。首先说优先级，文件可以放在以下4个位置，相同文件从上到下覆盖。外部指的是启动应用程序的目录，例如gradle用application插件打包后，运行的脚本目录就是 ./ ： 文件的命名为 application-[当前激活的环境名].[yml/properties] ，当前激活的配置可以用 spring.profile.active=[当前激活的环境名] 定义，多个环境名用逗号分隔，未设置时用 default 标识。关于如果修改默认的加载路径和文件名，后面会继续讨论。 Spring Boot系统启动时默认会读取的配置文件，支持properties\yml格式。也就是说，会先加载 application.properties ，根据 spring.profile.active 的设置加载相应的 application-XX.properties 配置，然后按优先级合并配置文件。 不同文件目录下application.properties的优先级和 自定义配置文件 的顺序是一样的。 类似 @TestPropertySource注解 ，在项目中可以方便的注入自定义的配置文件，注解一共有5个参数：
8. 二、springboot配置文件
1. 配置文件 Spring Boot使用一个全局的配置文件 application.properties application.yml 配置文件的作用：修改Spring Boot自动配置的默认值，SpringBoot在底层都给我们自动 配置好。有什么配置项，可以移步官方文档 配置文件一般放在src/main/resources目录或者类路径/confifig下，当然还有很多位置可 以放，它们会有不同优先级，后面会讲到。 YAML （YAML Ain't Markup Language） 简单介绍 <!–绑定配置文件处理器，配置文件进行绑定的时候就会有提示–> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-configuration-processor</artifactId> <optional>true</optional> </dependency> <!– 将应用打包成一个可执行Jar包，直接使用java -jar xxxx的命令来执行 –> <build> <plugins> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> </plugin> </plugins> </build>以前的配置文件：大多是xml .yml是YAML语言的文件，以数据为中 心，比json、xml等更适合做配置文件 全局配置文件的可以对一些默认配置值进行修改 配置实例 xml： yml: 2. YAML语法 基本语法 K:(空格)V 标识一对键值对 以空格的缩进来控制层级关系 只要是左对齐的一列数据，都是同一层级的 属性和值也是大小写敏感 实例： 值的写法 普通的值 k: v 字面量直接来写，字符串默认不用添加单引号 " " 双引号 不会转义字符串里面的特殊字符； <server> <port>8081</port> </server> server: port: 8081 server: port: 8081 path: /hello // 冒号后面的空格不要拉下' ' 单引号 会转义字符，特殊字符最终是一个普通的字符串 对象 普通写法： 行内写法 frends:{ lastName: zhang,age: 18 } Map 示例： maps: {k1: v1,k2: v2} 数组 普通写法： pets: // var onj = {pets: ['cat','pig','dog']} – cat – pig – dog 行内写法 pets:[cat, pig, dog] 配置文件获取 将配置文件中的每一个值映射到此组件中 1. Persion name: "wang \n qian" // 输出：wang 换行 qian frends: lastName: zhang age: 20package com.wrq.boot.bean; @Component @ConfigurationProperties(prefix = "persion") public class Persion { private String name; private int age; private double weight; private boolean boss; private Date birth; private Map<String,Object> maps; private List<Object> list; private Dog dog; 此处，这个bean的getter、setter和tostring方法已经省略，千万不能忽略！ } @ConfifigurationProperties 意思是:我们类里面的属性和配置文件中的属性做绑定 不使用此注解，可以在bean的属性添加@value()注解，如下： @Component // @ConfigurationProperties(prefix = "persion") public class Persion { @value("${persion.name}") // $()读取配置文件、环境变量中的值 private String name; @value("#{11*2}") // #{SpEL} 采用表达式 private int age; @value("true") // 直接赋值 private boolean boos; } 此处采用@ConfifigurationProperties的方式，@value()和@ConfifigurationProperties的 区别见下方表格。prefifix = "persion" 配置文件中那个下面的属性来一一映射 @Component 如果想要这个注解起作用，必须放到容器里面 2. Dog package com.wrq.boot.bean; public class Dog { // 用作Persion中的属性 private String name; private int age; 此处，这个bean的getter、setter和tostring方法已经省略，千万不能忽略！ } 3. 配置文件 方式一: application.yml persion: name: 王大锤 age: 18 weight: 125 boss: false birth: 2018/5/5 maps: {k1: v1,k2: v2} list: – wangli – wang dog: name: xiaogou age: 2方式二: application.propertiespersion.name = 王大锤 persion.age = 18 persion.weight = 125 persion.boss = false persion.birth = 2018/5/5 persion.maps.k1 = v1 persion.maps.k2 = v2 persion.dog.name = xiaogou persion.dog.age = 15 4. 测试类：BootApplicationTests package com.wrq.boot; @RunWith(SpringRunner.class) @SpringBootTest public class BootApplicationTests { @Autowired Persion persion; @Test public void contextLoads() { System.out.print(persion); } } 5. 运行 BootApplicationTests方法 控制台打印： application.yml的结果： Persion{name='王大锤', age=18, weight=125.0, boss=false, birth=Sat May 05 00:00:00 CST 2018, maps={k1=v1, k2=v2}, list=[wangli, wang], dog=Dog{name='xiaogou', age=2}} application.properties的结果： Persion{name='��Ǭ', age=18, weight=125.0, boss=false, birth=Sat May 05 00:00:00 CST 2018, maps={k2=v2, k1=v1}, list=[wangli, wang], dog=Dog{name='xiaogou', age=15}} 把Bean中的属性和配置文件绑定，通过yml文件和properties都可以做到,但是properties 文件出现乱码。 properties中文读取乱码：File->Settings->File Encodings最底部选utf-8、Tranparent打 上勾 注解比较 @value和@ConfifigurationProperties获取值比较名词解释: 松散绑定 last-name和lastName都可以获取导致，则代表支持松散绑定 [email protected] @ConfigurationProperties(prefix = "persion") // 如果使用的是@value注入值 时，无法使用校验 @Validated // 添加此注解 public class Persion { @Email // 配置文件书写的属性必须是邮箱格式，不符合报错！ private String name; } 复杂类型封装 如果获取配置文件中map的值时,@value是获取不到值的 @value("${persion.maps}") // 由于使用的是@value，无法获取配置文件中的map private Map<String,Object> maps; @PropertySource @PropertySource：加载指定配置文件 @ConfifigurationProperties()默认是从全局配置文件中获取值，也就是 application.properties这个文件中获取值。 如果做的配置很多，全局的配置文件就会特别大，为了方便管理。我会创建不同的配置文 件定向管理不同的配置。 如创建persion.properties文件单独存放persion需要的配置 @PropertySource就是用来导入创建的配置文件 示例： 1. persion.properties 同时把两个全局的配置中关于Persion的配置都注释掉persion.name = 王弟弟 persion.age = 18 persion.weight = 125 persion.boss = false persion.birth = 2018/5/5 persion.maps.k1 = v1 persion.maps.k2 = v2 persion.dog.name = xiaogou persion.dog.age = 15 2. Persion package com.wrq.boot.bean; @Component @PropertySource(value = {"classpath:persion.properties"}) @ConfigurationProperties(prefix = "persion") public class Persion { private String name; private int age; private double weight; private boolean boss; private Date birth; private Map<String,Object> maps; private List<Object> list; private Dog dog; 此处，这个bean的getter、setter和tostring方法已经省略，千万不能忽略！ } 这样运行测试类，控制台就可以打印persion.properties中的数据。 通过下面的注解，把类路径下的persion.properties加载进来。并且把persion开头的数 据进行绑定。 @PropertySource(value = {"classpath:persion.properties"})@ConfifigurationProperties(prefifix = "persion") @ImportResource @ImportResource：导入Spring的配置文件，让配置文件生效。 示例： 1. com.wrq.boot.service package com.wrq.boot.service; /** * Created by wangqian on 2019/1/12. */ public class HelloService { } 2. resources目录手动建立bean.xml <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd"> <bean id="helloService" class="com.wrq.boot.service.HelloService"> </bean> </beans> 3. 测试类 package com.wrq.boot; @RunWith(SpringRunner.class) @SpringBootTest public class BootApplicationTests { @Autowired ApplicationContext ioc;@Test public void testConfig() { boolean b = ioc.containsBean("helloService"); System.out.print(b); } } 试图通过添加一个Spring的配置文件bean.xml来把HelloService注入进去。 运行测试类结果：false 结果表明IoC容器中并不包含HelloService，即：配置文件bean.xml没有生效 解决方式 方式一： 主程序中进行配置@ImportResouece注解 package com.wrq.boot; @ImportResource(locations = {"classpath:bean.xml"}) // 通过此配置是 bean.xml生效 @SpringBootApplication public class BootApplication { public static void main(String[] args) { //应用启动起来 SpringApplication.run(BootApplication.class, args); } } 方法二：通过配置类实现，这种方式也是Spring Boot推荐的 1. com.wrq.boot.confifigpackage com.wrq.boot.config; /** * Created by wangqian on 2019/1/12. */ @Configuration public class MyConfig { // 将方法的返回值添加到容器之中,并且容器中这个组件的id就是方法名 @Bean public HelloService helloService(){ System.out.print("通过@Bean给容器添加组件了.."); return new HelloService(); } } @Confifiguration标注这是一个配置类 通过@Bean注解，将方法的返回值添加到容器之中,并且容器中这个组件的id就是方 法名 2. 把主程序类中@ImportResource()配置注释掉 3. 测试成功，添加了HelloService()组件 3. 配置文件占位符 随机数 RandomValuePropertySource：配置文件中可以使用随机数 ${random.value} ${random.int} ${random.long} ${random.uuid} ${random.int(10)} ${random.int[1024,65536]} 属性配置占位符可以在配置文件中引用前面配置过的属性（优先级前面配置过的这里都能用） ${app.name:默认值}来指定找不到属性时的默认值 persion.name = 王弟弟${random.uuid} persion.age = ${random.int} persion.dog.name = ${persion.name}_dog 4. Profifile 多环境支持 Profifile是Spring对不同环境提供不同配置功能的支持，可以通过激活、 指定参数等方式 快速切换环境 1. 多Profifile的方式 格式：application-{profifile}.properties/yml application-dev.properties application-prod.properties 默认采用application.properties配置文件，如果使用别的，需要激活： 1. application.properties中配置： # 激活application-dev.properties配置文件 spring.profiles.active=dev 2. application-dev.properties: server.port=8082 3. 运行BootApplication主程序: 2019-01-12 20:46:09.345 INFO 14404 — [main] s.b.c.e.t. : Tomcat started on port(s): 8082 (http) 2. 多文档块的方式 除了上方多Profifile的方式来切换环境，也可以通过YAML多文档块的方式。示例: application.yml: server: port: 8081 spring: profiles: active: dev — spring: profiles: dev server: port: 8083 — spring: profiles: prod server: port: 8084 3. 激活指定Profifile 1. application.properties中配置： # 激活application-dev.properties配置文件 spring.profiles.active=dev 2. application.yml中配置 server: port: 8081 spring: profiles: active: dev — spring: profiles: dev server: port: 80833. 启动配置-参数 在IDE中，类似于配置tomcat的地方，按下方配置： Program arguments:–spring.profiles.active=dev 4. 启动配置-虚拟机 在IDE中，类似于配置tomcat的地方，按下方配置： VM options:-Dspring-profiles-active=dev 5. 命令行 使用Maven的package命令打包，移动到jar的目录。 java -jar spring-boot-project-config.jar –spring.profiles.active=dev 5. 配置文件优先级 GitHub对应项目：boot-confifig-position 优先级 Spring Boot 启动会扫描以下位置的application.properties或者 application.yml文件作 为Spring boot的默认配置文件 fifile:./confifig/ (项目根目录confifig文件夹下的配置文件) fifile:./ (项目根目下的配置文件) classpath:/confifig/ (resources目录confifig文件夹下的配置文件) classpath:/ (resources目下的配置文件) 以上是按照优先级从高到低的顺序，所有位置的文件都会被加载，高优先级配置内容会覆 盖低优先级配置内容,形成互补配置。 默认配置 我们也可以通过配置spring.confifig.location来改变默认配置。 项目打包后以后，我们可以使用命令行参数的形式，启动项目的时候来指定配置文件的新 位置；指定配置文件和默认加载的这些配置文件共同起作用，形成互补配置。 1. Maven->package对项目打包2. 把待使用的配置文件放在本地文件夹中，如：D:/application.properties 3. 命令行执行命令 java -jar boot-config-position-xxxxxx.jar — spring.config.location=D:/application.properties 这样即使项目上线了，我们也可以通过修改本地的配置文件，使用一行命令即可，极大方 便了运维人员。 6. 外部配置加载顺序 Spring Boot 支持多种外部配置方式 可以从以下位置加载配置，优先级从高到低，高优先级配置覆盖低优先级的，所以配置形 成互补配置。 1. 命令行参数 java -jar boot-config-position-xxxxxx.jar –server.port // 多个配置用空格 隔开 2. 来自java:comp/env的JNDI属性 3. Java系统属性（System.getProperties()） 4. 操作系统环境变量 5. RandomValuePropertySource配置的random.*属性值 6. jar包外部的application-{profifile}.properties或application.yml(带spring.profifile)配 置文件 7. jar包内部的application-{profifile}.properties或application.yml(带spring.profifile)配 置文件 8. jar包外部的application.properties或application.yml(不带spring.profifile)配置文件 9. jar包内部的application.properties或application.yml(不带spring.profifile)配置文件 10. @Confifiguration注解类上的@PropertySource 11. 通过SpringApplication.setDefaultProperties指定的默认属性 注意：从jar包外向jar包内寻找，优先加载profifile最后加载不带profifile，更多参考官方文 档 7. 自动配置原理GitHub对应项目：boot-confifig-autoconfifig 1. 配置文件写什么？ 配置文件可配置属性查阅 2. 什么是注解，如何实现一个注解？ 关于注解的机制和相关原理可以移步此篇博客 3. 配置原理解析 我们运行Spring Boot应用是从main方法启动，在主程序类上有一个 @SpringBootApplication注解。 @SpringBootApplication是一个复合注解，包括@ComponentScan，和 @SpringBootConfifiguration，@EnableAutoConfifiguration。 @SpringBootConfifiguration继承自@Confifiguration，二者功能也一致，标注当前类 是配置类，并会将当前类内声明的一个或多个以@Bean注解标记的方法的实例纳入到 srping容器中，并且实例名就是方法名。 @EnableAutoConfifiguration的作用启动自动的配置，@EnableAutoConfifiguration注 解的意思就是SpringBoot根据你添加的jar包来配置你项目的默认配置，比如根据 spring-boot-starter-web ，来判断你的项目是否需要添加了webmvc和tomcat，就 会自动的帮你配置web项目中所需要的默认配置 @ComponentScan，扫描当前包及其子包下被@Component，@Controller， @Service，@Repository注解标记的类并纳入到spring容器中进行管理。是以前的co ntext:component-scan（以前使用在xml中使用的标签，用来扫描包配置的平行支 持）。 @SpringBootApplication注解分析 配置原理视频讲解 4. 自动配置类判断 在配置文件properties中设置：debug=true 来让控制台打印自动配置报告，方便的得知 那些配置类生效。 ========================= AUTO-CONFIGURATION REPORT =========================Positive matches: —————– matched: – @ConditionalOnClass found required class 'org.springframework.web.servlet.DispatcherServlet'; @ConditionalOnMissingClass did not find unwanted class (OnClassCondition) – @ConditionalOnWebApplication (required) found 'session' scope (OnWebApplicationCondition) Negative matches: —————– ActiveMQAutoConfiguration: Did not match: – @ConditionalOnClass did not find required classes 'javax.jms.ConnectionFactory', 'org.apache.activemq.ActiveMQConnectionFactory' (OnClassCondition)
