spring boot jpa 配置了yml文件后怎么扫描包

Posted 2023-04-16

参考技术A 在spring boot中，简单几步，读取配置文件（application.yml）中各种不同类型的属性值：

1、引入依赖：

[html] view plain copy
<!-- 支持 @ConfigurationProperties 注解 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-configuration-processor</artifactId>
<optional>true</optional>
</dependency>

2、配置文件（application.yml）中配置各个属性的值：

[plain] view plain copy
myProps: #自定义的属性和值
simpleProp: simplePropValue
arrayProps: 1,2,3,4,5
listProp1:
- name: abc
value: abcValue
- name: efg
value: efgValue
listProp2:
- config2Value1
- config2Vavlue2
mapProps:
key1: value1
key2: value2

3、创建一个bean来接收配置信息：

[java] view plain copy
@Component
@ConfigurationProperties(prefix="myProps") //接收application.yml中的myProps下面的属性
public class MyProps
private String simpleProp;
private String[] arrayProps;
private List<Map<String, String>> listProp1 = new ArrayList<>(); //接收prop1里面的属性值
private List<String> listProp2 = new ArrayList<>(); //接收prop2里面的属性值
private Map<String, String> mapProps = new HashMap<>(); //接收prop1里面的属性值

public String getSimpleProp()
return simpleProp;


//String类型的一定需要setter来接收属性值；maps, collections, 和 arrays 不需要
public void setSimpleProp(String simpleProp)
this.simpleProp = simpleProp;


public List<Map<String, String>> getListProp1()
return listProp1;

public List<String> getListProp2()
return listProp2;


public String[] getArrayProps()
return arrayProps;


public void setArrayProps(String[] arrayProps)
this.arrayProps = arrayProps;


public Map<String, String> getMapProps()
return mapProps;


public void setMapProps(Map<String, String> mapProps)
this.mapProps = mapProps;



启动后，这个bean里面的属性就会自动接收配置的值了。

4、单元测试用例：

[java] view plain copy
@Autowired
private MyProps myProps;

@Test
public void propsTest() throws JsonProcessingException
System.out.println("simpleProp: " + myProps.getSimpleProp());
System.out.println("arrayProps: " + objectMapper.writeValueAsString(myProps.getArrayProps()));
System.out.println("listProp1: " + objectMapper.writeValueAsString(myProps.getListProp1()));
System.out.println("listProp2: " + objectMapper.writeValueAsString(myProps.getListProp2()));
System.out.println("mapProps: " + objectMapper.writeValueAsString(myProps.getMapProps()));


测试结果：

[plain] view plain copy
simpleProp: simplePropValue
arrayProps: ["1","2","3","4","5"]
listProp1: ["name":"abc","value":"abcValue","name":"efg","value":"efgValue"]
listProp2: ["config2Value1","config2Vavlue2"]
mapProps: "key1":"value1","key2":"value2"本回答被提问者采纳

Spring Boot配置文件

一、基本介绍

　　Spring Boot提供了两种常用的配置文件，分别是properties文件和yml文件。

• application.properties
• application.yml

　　他们的作用都是修改Spring Boot自动配置的默认值。相对于properties文件而言，yml文件更年轻，也有很多的坑。可谓成也萧何败也萧何，yml通过空格来确定层级关系，使配置文件结构更清晰，但也会因为微不足道的空格而破坏了层级关系。

二、YAML简介

yml是YAML（YAML Ain‘t Markup Language）语言的文件，以数据为中心，比json、xml等更适合做配置文件

　　以前的配置文件；大多都使用的是 xxxx.xml文件；yml和xml相比，少了一些结构化的代码，使数据更直接，一目了然。举例:

　　YAML

server:
  port: 8081

　　XML:

<server>
    <port>8081</port>
</server>

　　yml和json呢？没有谁好谁坏，合适才是最好的。yml的语法比json优雅，注释更标准，适合做配置文件。json作为一种机器交换格式比yml强，更适合做api调用的数据交换。

2.1 YAML的语法

　　k:(空格)v：表示一对键值对（空格必须有）；

　　以空格的缩进程度来控制层级关系。空格的个数并不重要，只要左边空格对齐则视为同一个层级。注意不能用tab代替空格。且大小写敏感。

server:
    port: 8081
    path: /hello

　　YAML支持字面值，对象，数组三种数据结构，也支持复合结构。

【字面值】——字符串，布尔类型，数值，日期。

　　k: v：字面直接来写；

　　字符串默认不用加上单引号或者双引号；

　　""：双引号；不会转义字符串里面的特殊字符；特殊字符会作为本身想表示的意思

name:   "zhangsan \\n lisi"：输出；zhangsan 换行  lisi

　　‘‘：单引号；会转义特殊字符，特殊字符最终只是一个普通的字符串数据

name:   ‘zhangsan \\n lisi’：输出；zhangsan \\n  lisi

【对象】

　　由键值对组成，形如 key:(空格)value 的数据组成。冒号后面的空格是必须要有的，每组键值对占用一行，且缩进的程度要一致。

friends:
        lastName: zhangsan
        age: 20

　　也可以使用行内写法：k1: v1, ....kn: vn

friends: lastName: zhangsan,age: 18

【数组】——List、Set

　　由形如 -(空格)value 的数据组成。短横线后面的空格是必须要有的，每组数据占用一行，且缩进的程度要一致，也可以使用行内写法： [1,2,...n]

pets:
 - cat
 - dog
 - pig

　　行内写法

pets: [cat,dog,pig]

2.2 YAML的运用

　　创建一个Spring Boot 的全局配置文件 application.yml，配置属性参数。

person:
  lastName: hello
  age: 18
  boss: false
  birth: 2019/7/14
  maps: k1: v1,k2: v2
  lists:
    - zhangsan
    - lisi
  dog:
    name: 小狗
    age: 12

　　创建实体类Person.java 获取配置文件中的属性值，通过注解@ConfigurationProperties获取配置文件中的指定值并注入到实体类中。

/**
 * 将配置文件中配置的每一个属性的值，映射到这个组件中
 * @ConfigurationProperties：告诉SpringBoot将本类中的所有属性和配置文件中相关的配置进行绑定；
 *      prefix = "person"：配置文件中哪个下面的所有属性进行一一映射
 *
 * 只有这个组件是容器中的组件，才能容器提供的@ConfigurationProperties功能；
 *
 */
@Component
@ConfigurationProperties(prefix = "person")
public class Person 

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

    private Map<String,Object> maps;
    private List<Object> lists;
    private Dog dog;

    // 省略getter，setter，toString方法  

　　我们可以导入配置文件处理器，以后编写配置就有提示了

<!--导入配置文件处理器，配置文件进行绑定就会有提示-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-configuration-processor</artifactId>
    <optional>true</optional>
</dependency>

　　创建一个单元测试类:

/**
 * SpringBoot单元测试;
 *
 * 可以在测试期间很方便的类似编码一样进行自动注入等容器的功能
 *
 */
@RunWith(SpringRunner.class)
@SpringBootTest
public class PersonTest 
    @Autowired
    private Person person;

    @Test
    public void test() 
        System.out.println(person);
    

　　注意：在运行测试类之前，要确保spring boot的引导类（主程序）是已启动状态。

2.3 YML小结

1. 字符串可以不加引号，若加双引号则输出特殊字符，若不加或加单引号则转义特殊字符；
2. 数组类型，短横线后面要有空格；对象类型，冒号后面要有空格；
3. YAML是以空格缩进的程度来控制层级关系，但不能用tab键代替空格，大小写敏感；
4. 如何让一个程序员崩溃？在yml文件中加几个空格！

三、Properties简介

　　properties文件经常用，这里就简单介绍一下。其语法结构形如：key=value。

userinfo.account=zhangsan
userinfo.age=25
userinfo.active=true
userinfo.created-date=2019/07/14 16:54:30
userinfo.map.k1=v1
userinfo.map.k2=v2
userinfo.list=one,two,three

　　从配置文件中取值注入到实体类中，和YAML是一样的。

/**
 * 用户信息
 * @ConfigurationProperties : 被修饰类中的所有属性会和配置文件中的指定值（该值通过prefix找到）进行绑定
 */
@Component
@ConfigurationProperties(prefix = "userinfo")
public class UserInfo 

    private String account;
    private Integer age;
    private Boolean active;
    private Date createdDate;
    private Map<String, Object> map;
    private List<Object> list;

   // 省略getter，setter，toString方法

　　 注意：properties配置文件在idea中默认utf-8可能会乱码。调整如下：

 

　　【注意】：spring boot项目中同时存在application.properties和application.yml文件时，两个文件都有效，但是application.properties的优先级会比application.yml高。

四、配置文件取值

　　Spring Boot通过ConfigurationProperties注解从配置文件中获取属性。从上面的例子可以看出ConfigurationProperties注解可以通过设置prefix指定需要批量导入的数据。支持获取字面值，集合，Map，对象等复杂数据。ConfigurationProperties注解还有其他特么呢？它和Spring的Value注解又有什么区别呢？带着这些问题，我们继续往下看。

4.1 ConfigurationProperties和Value对比

　　ConfigurationProperties注解的优缺点

1. 可以从配置文件中批量注入属性；
2. 支持获取复杂的数据类型；
3. 对属性名匹配的要求较低，比如user-name，user_name，userName，USER_NAME都可以取值；
4. 支持JAVA的JSR303数据校验；
5. 缺点是不支持强大的SpEL表达式；

　　Value注解的优缺点正好相反，它只能一个个配置注入值；不支持数组、集合等复杂的数据类型；不支持数据校验；对属性名匹配有严格的要求。最大的特点是支持SpEL表达式，使其拥有更丰富的功能。　　 

4.2 @ConfigurationProperties详解

　　第一步：导入依赖。若要使用ConfigurationProperties注解，需要导入依赖 spring-boot-configuration-processor；

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-configuration-processor</artifactId>
  <optional>true</optional>
</dependency>

　　 第二步：配置数据。在application.yml配置文件中，配置属性参数，其前缀为employee，参数有字面值和数组，用来判断是否支持获取复杂属性的能力；（nick-name是用来判断匹配属性的松散性，若换成nick_name依然可以获取值。）

employee:
  nick-name: itachi
  email: [email protected]
  phone: [phone]
  abilities: [java,sql,html]
  created_date: 2019/7/14 13:40

　　第三步：匹配数据。在类上添加注解ConfigurationProperties，并设置prefix属性值为employee。并把该类添加到Spring的IOC容器中。

　　第四步：校验数据。添加数据校验Validated注解，开启数据校验，测试其是否支持数据校验的功能；

　　第五步：测试ConfigurationProperties注解是否支持SpEL表达式；

/**
 * ConfigurationProperties 注解语法类
 * 第一步：导入依赖 spring-boot-configuration-processor；
 * 第二步：把ConfigurationProperties注解修饰的类添加到Spring的IOC容器中；
 * 第三步：设置prefix属性，指定需要注入属性的前缀；
 * 第四步：添加数据校验注解，开启数据校验；
 *
 * 注意点：
 * 一、nickName和createdDate在yml配置文件中，对应参数分别是中划线和下划线，用于测试其对属性名匹配的松散性
 * 二、email和iphone 测试其支持JSR303数据校验
 * 三、abilities 测试其支持复杂的数据结构
 */
@Component
@ConfigurationProperties(prefix = "employee")
@Validated
public class ConfigurationPropertiesEntity 
    private String nickName; // 解析成功，支持松散匹配属性
    private String email;
    // @Email //表示phone必须填成email格式。此处解析失败：Binding validation errors on employee
    private String phone;
    private List<String> abilities;
    private Date createdDate; // 解析成功，支持松散匹配属性

    // @ConfigurationProperties("#11*2") //语法报错，不支持SpEL表达式：not applicable to field
    private String operator;

   // 省略get/set和toString方法  

4.3 @Value详解

　　第一步：在属性上添加Value注解，通过$设置参数从配置文件中注入值；

　　第二步：修改$employee.ceatred_date中的参数值，改为$employee.ceatredDate测试是否能解析成功；

　　第三步：添加数据校验Validated注解，开启数据校验，测试其是否支持数据校验的功能；

　　第四步：测试Value注解是否支持SpEL表达式；

/**
 * Value 注解语法类
 * 第一步：在属性上添加注解Value注入参数
 * 第二步：把Value注解修饰的类添加到Spring的IOC容器中；
 * 第三步：添加数据校验注解，检查是否支持数据校验；
 *
 * 注意点：
 * 一、nickName和createdDate在yml配置文件中，对应参数分别是中划线和下划线，用于测试其对属性名匹配的松散性
 * 二、email和iphone 测试其支持JSR303数据校验
 * 三、abilities 测试其支持复杂的数据结构
 *
 * 结论：
 * 一、createDate取值必须和yml配置文件中的参数保持一致，
 * 二、既是在iphone上添加邮箱验证注解依然可以通过测试，
 * 三、不支持复杂的数据结构，提示错误和第一条相同：IllegalArgumentException: Could not resolve placeholder ‘itdragon.abilities‘ in value "$itdragon.abilities"
 */
@Component
@Validated
public class ValueEntity 
    @Value("$employee.nick-name")
    private String nickName;
    @Value("$employee.email")
    private String email;
    @Email
    @Value("$employee.phone") // 解析成功，并不支持数据校验
    private String phone;
    // @Value("$employee.abilities") //解析错误，并不支持复杂的数据结构
    private List<String> abilities;
    // @Value("$employee.createDate") // 解析错误，并不支持松散匹配属性，必须严格一致
    @Value("$employee.created_date")
    private Date createDate;

    // Value注解的强大一面：支持SpEL表达式
    @Value("#11*2") // 算术运算
    private String operator;

    @Value("#1>2 || 2<=3") // 关系运算
    private Boolean comparison;

    @Value("#systemProperties[‘java.version‘]") //系统配置：os.name
    private String systemProperties;

    @Value("#T(java.lang.Math).abs(-18)") // 表达式
    private String mapExpression;
   
    // 省略get/set和toString()
    

4.4 配置文件取值小结

1. ConfigurationProperties注解支持批量注入，而Value注解适合单个注入；
2. ConfigurationProperties注解支持数据校验，而Value注解不支持；
3. ConfigurationProperties注解支持松散匹配属性，而Value注解必须严格匹配属性；
4. ConfigurationProperties不支持强大的SpEL表达式，而Value支持；

　　如果说，我们只是在某个业务逻辑中需要获取一下配置文件中的某项值，使用@Value；

　　如果说，我们专门编写了一个javaBean来和配置文件进行映射，我们就直接使用@ConfigurationProperties；

五、@PropertySource&@ImportResource&@Bean

5.1 @PropertySource

　　@ConfigurationProperties注解默认只能读取系统全局的配置文件，要加载非全局的配置，需要使用@PropertySource加载文件。@PropertySource的目的是加载指定的属性文件。

　　比如定义一个person.properties

person.last-name=李四
person.age=12
person.birth=2019/7/14
person.boss=false
person.maps.k1=v1
person.maps.k2=14
person.lists=a,b,c
person.dog.name=dog
person.dog.age=15

　　如果要在配置类中加载person.properties配置文件，则需要用到@PropertySource

/**
 * 将配置文件中配置的每一个属性的值，映射到这个组件中
 * @ConfigurationProperties：告诉SpringBoot将本类中的所有属性和配置文件中相关的配置进行绑定；
 *      prefix = "person"：配置文件中哪个下面的所有属性进行一一映射
 *
 * 只有这个组件是容器中的组件，才能容器提供的@ConfigurationProperties功能；
 *  @ConfigurationProperties(prefix = "person")默认从全局配置文件中获取值；
 *
 */
@PropertySource(value = "classpath:person.properties")
@Component
@ConfigurationProperties(prefix = "person")
public class Person 
    private String lastName;
    private Integer age;
    private Boolean boss;
    private Date birth;

    private Map<String, Object> maps;
    private List<Object> lists;
    private Dog dog;

    // 省略get/set和toString()方法

5.2 @ImportResource

　　编写一个HelloService.java

public class HelloService 

　　编写一个beans.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.pinyougou.service.HelloService"></bean>
</beans>

　　在测试类中测试该配置文件有没有生效：

@RunWith(SpringRunner.class)
@SpringBootTest
public class SpringBootConfigApplicationTest 

    @Autowired
    private ApplicationContext context;

    @Test
    public void testHelloService() 
        boolean b = context.containsBean("helloService");
        System.out.println(b); // false
    

　　测试表明，Spring Boot里面没有Spring的配置文件，我们自己编写的配置文件，也不能自动识别；

　　想让Spring的配置文件生效，加载进来；可以使用@ImportResource标注在一个配置类上：

@ImportResource(locations = "classpath:beans.xml")
@SpringBootApplication
public class SpringbootdemoApplication 

    public static void main(String[] args) 
        SpringApplication.run(SpringbootdemoApplication.class, args);
    

　　这时候再次运行testHelloService()测试方法，结果为true。说明自己编写的beans.xml配置文件已经生效了。

　　总结：@ImportResource的作用是：导入Spring的配置文件，让配置文件里面的内容生效；

5.3 @Bean

　　虽然使用@ImportResource能导入我们编写的配置文件，但是SpringBoot并不推荐这种方式，SpringBoot推荐使用全注解的方式来给容器中添加组件。这时候就使用到了@Bean来给容器中添加组件。

　　为了测试效果明显，将beans.xml删掉，并且将@ImportResource注释掉：

　　创建一个配置类：

/**
 * @Configuration：指明当前类是一个配置类；就是来替代之前的Spring配置文件。@Configuration可理解为用spring的时候xml里面的<beans>标签。
 * @Configuration标注在类上，相当于把该类作为spring的xml配置文件中的<beans>，作用为：配置spring容器（应用上下文对象）　
 */
@Configuration
public class MyAppConfig 

    // 将方法的返回值添加到容器中；容器中这个组件默认的id就是方法名
　　 // @Bean标注在方法上（返回某个实例的方法），等价于spring配置文件中的<bean></bean>，作用为：注册bean对象
    // @Bean可理解为用spring的时候xml里面的<bean>标签。  
    @Bean
    public HelloService helloService() 
        System.out.println("配置了@Bean给容器中添加了组件。。。");
        return new HelloService();
    

　　再次运行测试类:

　　

　　注意：

1. @Bean注解在返回实例的方法上，如果未通过@Bean指定bean的名称，则默认与标注的方法名相同； 
2. @Bean注解默认作用域为单例singleton作用域，可通过@Scope(“prototype”)设置为原型作用域； 
3. 既然@Bean的作用是注册bean对象，那么完全可以使用@Component、@Controller、@Service、@Repository等注解注册bean（在需要注册的类上加注解），当然需要配置@ComponentScan注解进行自动扫描。

　　Spring Boot不是spring的加强版，所以@Configuration和@Bean同样可以用在普通的spring项目中。

六、配置文件占位符

　　占位符和随机数比较简单，这里就直接贴出代码。需要注意的是：

• 占位符的值必须是完整路径
• 占位符设置默认值，冒号后面不能有空格

ran:  # 这里的prefix不能是random，
  ran-value: $random.value
  ran-int: $random.int
  ran-long: $random.long
  ran-int-num: $random.int(10)
  ran-int-range: $random.int[10,20]
  ran-placeholder: placeholder_$ran.ran-value:此处不能有空格，且key为完整路径 

/**
 * 随机数和占位符语法类
 */
@Component
@ConfigurationProperties(prefix = "ran")
public class RandomEntity 

    private String ranValue;    // 随机生成一个字符串
    private Integer ranInt;     // 随机生成一个整数
    private Long ranLong;       // 随机生成一个长整数
    private Integer ranIntNum;  // 在指定范围内随机生成一个整数
    private Integer ranIntRange;// 在指定区间内随机生成一个整数
    private String ranPlaceholder;// 占位符

    // 省略getter，setter，toString方法e

 　　测试代码： 

@RunWith(SpringRunner.class)
@SpringBootTest
public class SpringBootYmlApplicationTests 
    @Autowired
    private RandomEntity randomEntity;

    @Test
    public void contextLoads() 
        System.out.println("Random Grammar : " + randomEntity);
    

七、Profile多环境支持

7.1 使用properties作为配置文件时 

　　我们在主配置文件编写的时候，文件名可以是 application-profile.properties。如：

　　application-dev.properties

　　

　　application-prod.properties

　　

　　application.properties主配置文件

　　

　　运行主程序时，默认使用的是application.properties主配置文件的端口号:8080

　　当我们要激活指定的profile时，比如要激活开发环境的8081端口，可以在主配置文件中添加spring.profiles.active=dev

　　

7.2 使用yml作为配置文件时

　　yml支持多文档块方式

server:
  port: 8080
spring:
  profiles:
    active: prod #指定使用生产环境运行
---
server:
  port: 8081
spring:
  profiles: dev
---
server:
  port: 8082
spring:
  profiles: prod

7.3 激活指定的profile

　　除了在配置文件中通过代码来激活指定的profile，还可以通过命令行和指定虚拟机参数的方式来激活指定的profile。

【命令行】

　　可以直接在测试的时候，配置传入命令行参数：

　　

　　此外，如果将项目package后，也可以通过命令行的方式来指定profile：

　　

【虚拟机参数】

八、配置文件的加载路径及顺序

　　springboot 启动会扫描以下位置的application.properties或者application.yml文件作为Spring boot的默认配置文件

1. 工程根目录的config目录：file:./config/
2. 工程根目录：file:./
3. 类路径的config目录：classpath:/config/
4. 类路径：classpath:/

　　如果存在多个配置文件，则严格按照优先级进行覆盖，最高者胜出。如下图1~4优先级从高到低：

　　 

　　SpringBoot会从这四个位置全部加载主配置文件；互补配置；

　　我们还可以通过spring.config.location来改变默认的配置文件位置。

　　项目打包好以后，我们可以使用命令行参数的形式，启动项目的时候来指定配置文件的新位置；指定配置文件和默认加载的这些配置文件共同起作用形成互补配置；

java -jar spring-boot-02-config-02-0.0.1-SNAPSHOT.jar --spring.config.location=G:/application.properties

 

 

 

参考：https://www.cnblogs.com/itdragon/p/8686554.html