精华内容
下载资源
问答
  • SpringBoot yml配置文件注入List和Map 首先要在配置文件中配置List和Map信息: List需要注意: – 首页 这里有一个空格 同样Map这里也需要注意: 5: 首页 这里也有一个空格 myprops: showpagemaps: 5: 首页 6: 主...
  • Docker Compose yml配置文件及常用指令简介 Docker?Compose 使用 YAML 文件来定义多服务的应用YAML 是 JSON 的一个子集因此也可以使用 JSON Docker Compose 默认使用文件名 docker-compose.yml当然也可以使用 -f ...
  • 主要介绍了如何基于JAVA读取yml配置文件指定key内容,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • 主要介绍了springboot 使用yml配置文件给静态变量赋值教程,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • 在web项目中读取yml配置文件的工具类.可以实现将 server : port : portnumber : 8081 转换为 key为"server.port.portnumber",值为"8081"的Map,String>集合
  • 最新版的druid和旧版在filter配置方面有些不同,以下是旧版druid中配置filter: spring: ##数据库连接信息 datasource: url: jdbc:mysql://localhost:3306/young username: root password: root driver-class...
  • 主要介绍了SpringBoot读取properties或者application.yml配置文件中的数据,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • springboot之yml配置文件信息加密.docx
  • 本篇文章主要介绍了详解Spring Boot加载properties和yml配置文件,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • idea读取YML配置文件readApplication,本demo适用于刚入坑gradle,教程比较基础详细,教程地址:https://mp.csdn.net/postedit/80379357
  • 在本篇文章里小编给大家整理了关于SpringBoot从yml配置文件中读常用参数值实例方法,有需要的朋友们学习下。
  • elasticsearch.yml 配置文件 ,大自然的搬运工
  • 主要介绍了springboot的yml配置文件通过db2的方式整合mysql的教程,本文给大家介绍的非常详细,对大家的学习或工作具有一定的参考借鉴价值,需要的朋友可以参考下
  • 主要介绍了SpringBoot yml配置文件调用过程解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • SpringBoot yml配置文件

    千次阅读 2019-03-07 14:56:29
      yml配置文件比properties配置文件更为强大,它可以在主配置文件引入其他配置文件,也可以在主配置文件上配置多个配置文件。

      yml配置文件比properties配置文件更为强大,下面一 一概述

    1. 缩进规则:
      yml配置文件的每一段都要进行缩进,一段代表一级,并且键和值之间必须得有个空格,否则spring boot会不认识你这个键,例如
    spring:
       datasource:
          driver-class-name: com.mysql.jdbc.Driver
          url: jdbc:mysql://localhost:3306/demo
          username: root
          password: root
    

    这样能让每一段都看的清清楚楚,肯定会比下面的properties好得多

    spring.datasource.driVerclAssname=com.mysql.jdbc.Driver
    spring.datasource.url=jdbc:mysql://localhost:3306/demo
    spring.datasource.username=root
    spring.datasource.password=root
    
    1. 松散的命名:不区分大小写,可以省略连字符等
    # 松散命名,把driver的连字符去掉了,并且把Class和Name首字母变成大写
    spring:
       datasource:
          driverClass-Name: com.mysql.jdbc.Driver
          url: jdbc:mysql://localhost:3306/demo
          username: root
          password: root
    
    # 正规命名
    spring.datasource.driVerclAssname=com.mysql.jdbc.Driver
    spring.datasource.url=jdbc:mysql://localhost:3306/demo
    spring.datasource.username=root
    spring.datasource.password=root
    

    但如果是properties的话,会不允许这种松散命名,否则会报错。

    1. 嵌套对象

      yml里可以嵌套一个类,但嵌套的本质是把配置文件的信息赋值给自己编写的类中,例如现在有个demo实体类

    // 自动生成get set toString方法的注解
    @Data
    // 此前缀就是在yml配置文件里的级别最高的那一段,作用是让yml里的demo和类里的demo能够匹配
    @ConfigurationProperties(prefix = "demo")
    public class Demo {
        private Integer id;
        private String name;
    }
    // 这个类的字段必须有getter,setter,并且与配置文件中去掉前缀之后的名字匹配
    

    yml配置文件

    demo:
      id: 1
      name: admin
    

    启动类

    // 启动类注解
    @SpringBootApplication
    // 将Demo类注册到spring中,相当于被spring管理
    @EnableConfigurationProperties(Demo.class)
    public class YmlApplication implements CommandLineRunner {
        @Autowired
        private Demo demo;
        
        public static void main(String[] args) {
            SpringApplication.run(YmlApplication.class, args);
        }
    
        @Override
        public void run(String... args) throws Exception {
           System.out.println("-----debug: demo = " + demo);
        }
    
    }
    

    输出结果
    在这里插入图片描述
      注册的方式有两种,第一种是在启动类里加上@EnableConfigurationProperties(要注册的类,可以是数组),第二种是在要注册的类上面加上@Component,推荐第一种的原因也是因为第二种要在每个类上加注解,太过麻烦。

      匹配的方式也有两种,一种是加@ConfigurationProperties(prefix = “demo”)注解,第二种是加@Value注解,推荐第一种的原因是因为第一种支持松散命名。

    1. 随机数

    在yml里可以用${}表达式生成随机数或者其他的一些东西,但properties没有

    # 表示生成20-100之间的一个整数
    demo:
      id: ${random.int(20,100)}
      name: admin
    

    输出结果
    在这里插入图片描述

    1. 引用其他变量
      不仅可以引用自己类的变量,也可以引用别的类的变量
    demo:
      id: ${random.int(20,100)}
      name: ${demo.id} admin
    

    输出结果
    在这里插入图片描述

    1. 数组
    demo:
      id: ${random.int(20,100)}
      name:
        - xx
        - aa
    

    当然Demo类的name也要变成数组类型才行

    @Data
    @Component
    @ConfigurationProperties(prefix = "demo")
    public class Demo {
        private Integer id;
        private String[] name;
    }
    

    运行结果
    在这里插入图片描述
    当然也可以存集合,只是需要实体类那边更换类型,这边就不细说了。

    1. 键值对编写

      首先在实体类中加上Map集合字段类型。

    @Data
    @Component
    @ConfigurationProperties(prefix = "demo")
    public class Demo {
        private Integer id;
        private String[] name;
        private Map<String, Integer> scores;
    }
    

    yml配置文件

    demo:
      id: ${random.int(20,100)}
      name:
        - xx
        - aa
      scores:
        yuwen: 10
        shuxue: 20
    

    运行结果
    在这里插入图片描述

    1. 多配置文件

      第一种写法:在一个配置文件中编写多个配置,用—分割

    demo:
      id: 8000
      name: main
      
    # 指定选用哪个配置文件
    spring:
      profiles:
        active: production
    ---
    spring:
      profiles:
        dev
    
    demo:
      id: 8080
    
    ---
    spring:
      profiles:
        production
    demo:
      id: 80
    

    一开始demo的id是8080的,name是main,但是它引用了叫producttion的配置文件,所以demo的id就会被替换成production的id
    在这里插入图片描述
    第二种写法:有多个配置文件,在主配置文件中指定使用哪一个

      第二种写法大致和第一种一样,不过就是把配置分成了一个个文件。

    1. 引入其他配置文件

    application.yml

    spring:
      profiles:
        include: dev
    

    application-dev.yml

    demo:
    	id: 1
    	name: main
    

    运行结果
    在这里插入图片描述

    展开全文
  • SpringBoot 获取yml配置文件信息

    千次阅读 2020-01-10 16:13:20
    1.@ConfigurationProperties获取yml配置文件信息 1.1:pom配置 <dependency> <groupId>org.projectlombok</groupId> <artifactId>lombok</artifactId> ...

    1.@ConfigurationProperties获取yml配置文件信息

    1.1:pom配置

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

    1.2:application.yml

    person:
      lastName: zhangsan
      age: 18
      boss: false
      brith: 2019/12/01
      maps: {k1: v1,k2: v2}
      lists:
        - list
        - wang
      dog:
         name: 小狗
         age: 12
    
    

    1.3:entiy

    /**
        将配置文件中配置的每一个属性的值,映射在这个组件中
        ConfigurationProperties:告诉spring boot将本类中的所有属性和配置文件中的相关配置进行绑定:
        prefix = "person "配置文件中哪个下面的所有属性进行--映射
    
        只有这个组件是容器中的组件,才能使用容器提供的ConfigurationProperties功能
    
        注意:默认读取全局配置文件
     */
    @Component
    @ConfigurationProperties(prefix = "person")
    @Data
    public class Person {
        private String lastName;
        private Integer age;
        private boolean boss;
        private Date brith;
        private Map<String,Object> maps;
        private List<String> lists;
        private Dog dog;
        
    }
    

    1.4:测试

    @RunWith(SpringRunner.class)
    @SpringBootTest
    public class SpringbootDempApplicationTests {
    
        @Autowired
        private Person person;
    
        @Test
        public void contextLoads() {
            System.out.println(person);
        }
    
    }

    注意:

    如果是application.properties配置文件编码问题.(idea默认是utf-8)。

    解决:settings--搜索(file enc)

    2.获取application.properties配置文件信息

    2.1:application.properties

    person.last-name=沈宁
    person.age=22
    person.boss=false
    person.brith=2019/12/01
    person.maps.k1=v1
    person.maps.k2=v2
    person.lists=a,b,c,d,e,e,p
    person.dog.name=宗臣
    person.dog.age=18
    

    2.2:entity

    @Data
    @Component
    //@Validated //数据校验
    public class Persons {
        //获取配置文件中的属性
        @Value("${person.last-name}")
        private String lastName;
        //直接给变量赋值
        @Value("#{11*2}")
        private Integer age;
        @Value("${person.boss}")
        private boolean boss;
        @Value("${person.brith}")
        private Date brith;
        // @Value 不支持
        private Map<String,Object> maps;
        @Value("${person.lists}")
        private List<String> lists;
        private Dog dog;
    }

    2.3:测试

      同1.4

    2.4.@Value和@ConfigurationProperties区别

     @ConfigurationProperties@Value
    功能批量注入配置文件的属性一个个指定
    松散绑定(松散语法)支持不支持
    spel(spring表达式语言)不支持支持
    JSR303数据校验支持不支持
    复杂类型封装支持不支持

    根据需求使用。。

    3. @PropertySource使用

    3.1:自定义一个配置文件(我就全部加载了)

    @PropertySource作用:加载自定义配置文件.

    @PropertySource(value = {"classpath:person.properties"})
    @Component
    @ConfigurationProperties(prefix = "person")
    @Data
    public class Person {
        private String lastName;
        private Integer age;
        private boolean boss;
        private Date brith;
        private Map<String,Object> maps;
        private List<String> lists;
        private Dog dog;
    }

     4.@Configuration(自定义配置类)

    /**
     Configuration:指定当前类是一个配置类
     Bean:将方法的返回值添加到容器中
     */
    @Configuration
    public class MyTest {
    
        @Bean
        public String testData(){
            String test="我是返回值";
            return test;
        }
    }

    5.配置文件占位符

    #随机uuid
    person.last-name==宁${random.uuid}
    person.age=22
    person.boss=false
    person.brith=2019/12/01
    person.maps.k1=v1
    person.maps.k2=v2
    person.lists=a,b,c,d,e,e,p
    
    #获取之前配置信息的值,如果没有默认值
    person.dog.name=${person.hello:sss}_宗臣
    #person.dog.name=${person.last-name}_宗臣
    person.dog.age=18

    6.Profile

    Profile是spring对不同环境提供不同配置功能的支持。

    6.1:多properties激活

    在application.properties里配置,注销spring.profiles.active,激活自己。

    #激活配置文件
    spring.profiles.active=dev

    6.2:yml激活

    server:
      port: 8010
    #这是代表激活dev块的配置,不配置自己8010
    spring:
      profiles: dev
    ---
    server:
      port: 8011
    spring:
      profiles: dev
    ---
    server:
         port: 8012
    
    spring:
      profiles: prod

     

    展开全文
  • 立什么flag,都是要倒的(摔! 果然就是过个年,开年来项目一来,二月份的博客就欠下了,...文章目录1、序2、加载自定义yml文件2.1、使用@PropertiesSource注解读取yml配置文件-简单版2.2、使用@PropertiesSource注...

    立什么flag,都是要倒的(摔!
    果然就是过个年,开年来项目一来,二月份的博客就欠下了,三月即将结束,惴惴不安,厚着脸皮写个最近用到的,之前没找到很好的资料(大概是搜商颇低导致的)来说这一块的东西:spring自定义配置文件的部署。

    1、序

    背景:有个小项目需要后台,俺顶着Java菜逼的头衔接下来了,被男票疯狂安利spring boot,于是(被逼无奈)开始了边学边开发的躺坑之路……真香,资料超多,超好用!!!
    电厂的项目,用了公司自己开发的实时数据库,后台这边就涉及到很多测点的信息需要存储到配置文件(为什么不是关系数据库真的不要问我),并且希望在部署的时候方便修改,考虑到内容颇多,放在application-pro.yml中实在不合适,就加了个point.yml。倒不是因为现场测点信息会变才需要更改,更多的是突然一拍脑袋,发现手抖写错了?

    首先,因为一不小心变成了xxx.yml玩家,好好用哦,没能回去xxx.properties,传说中官方不支持像加载xxx.properties配置文件那样使用注解@PropertySource("classpath:xxx.properties")的方式加载yml配置文件,这里要说的就是加载自定义yml文件的方法。
    官方说明:
    https://docs.spring.io/spring-boot/docs/current/reference/htmlsingle/#boot-features-external-config-yaml-shortcomings
    加载自定义xxx.properties文件的方法参考这位大佬的文章哦:
    springBoot基础系列–properties配置

    注意:之前在找多数据源配置的资料时,就因为资料对应的spring boot版本差异搞得很郁闷,请务必注意俺用的版本是:

    spring boot 2.13

    2、加载自定义yml文件

    spring boot的资料非常多,多到非常容易不用动脑就解决了问题呢~项目做完之后冷静下来,觉得还是应该验证一下,毕竟打脸是为了以后有头有脸。

    2.1、使用@PropertiesSource注解读取yml配置文件-简单版

    按照上面给出的官宣,这条路是不行的。因为没看到文档对应的版本号,还是试一下:

    # 配置文件 point.yml
    id: 2233
    name: Ellie
    

    (呃,这种信息为啥要叫point啊啊啊!

    // 配置对应的config类
    @Data
    @Configuration
    @PropertySource(value = {"classpath:point.yml"})
    @ConfigurationProperties()
    public class TestPoint {
        private int id;
        private String name;
    
        @Override
        public String toString() {
            return "TestPoint{" +
                    "id=" + id +
                    ", name='" + name + '\'' +
                    '}';
        }
    }
    

    随手糊了个controller来测试

    @RestController
    public class TestConfigController {
        @Resource
        TestPoint testPoint;
    
        @ApiOperation("测试 配置文件")
        @RequestMapping(value = "/config")
        public ResultBean<String> testConfig() {
            return ResultBeanUtil.makeOkResp(testPoint.toString());
        }
    }
    

    postman搞起来
    在这里插入图片描述
    都挺好!
    所以如果只是要读取这样简单的信息的话,直接使用注解@PropertiesSource是可以的,官方说的不确定的影响我也不知道是啥哦。

    2.2、使用@PropertiesSource注解读取yml配置文件-不简单版?

    加个list<基础类型>看看。

    # point.yml
    id: 2233
    name: Ellie
    cards:
      - XD02101263
      - ZY8965
      - GX0009
     
     // 配置类
     @Data
    @Configuration
    @PropertySource(value = {"classpath:point.yml"})
    @ConfigurationProperties()
    public class TestPoint {
        private int id;
        private String name;
        private List<String> cards;
    
        @Override
        public String toString() {
            return "TestPoint{" +
                    "id=" + id +
                    ", name='" + name + '\'' +
                    ", cards=" + cards +
                    '}';
        }
    }
    

    postman
    在这里插入图片描述
    装逼失败,不行了哦。使用@Value("id")注解也是不行的呢,因为这个注解是用来匹配变量名称和配置文件不一致的情况。
    按照其他博客里讲的(才糊代码一个月根本没有深入看原理的我只好是:大佬说啥就是啥),是因为使用@PropertySource注解只能加载yml配置文件,但不能将其配置信息暴露给spring environment,需要手动暴露。方法就是在让application启动的时候把下面的bean加载。

    @Bean
    	public static PropertySourcesPlaceholderConfigurer properties() {
    		PropertySourcesPlaceholderConfigurer configurer = new PropertySourcesPlaceholderConfigurer();
    		YamlPropertiesFactoryBean yaml = new YamlPropertiesFactoryBean();
    		yaml.setResources(new ClassPathResource("point.yml"));
    		configurer.setProperties(yaml.getObject());
    		return configurer;
    	}
    

    偷懒的我直接丢到了main函数所在的.java文件。运行:
    在这里插入图片描述
    真的不是我截错图哦。

    2.3、加前缀可行版

    毕竟我这么机智(无脑分析!),悄咪咪加了个前缀,前缀的名字随意取哈,与配置类中对应即可,我只是偷懒叫做prefix

    # point.yml
    prefix:
      id: 2233
      name: Ellie
      cards:
        - XD02101263
        - ZY8965
        - GX0009
     
     // config类
     @Data
    @Configuration
    @PropertySource(value = {"classpath:point.yml"})
    @ConfigurationProperties(prefix = "prefix") 
    public class TestPoint {
        private int id;
    
        private String name;
    
        private List<String> cards;
    
        @Override
        public String toString() {
            return "TestPoint{" +
                    "id=" + id +
                    ", name='" + name + '\'' +
                    ", cards=" + cards +
                    '}';
        }
    }
    

    都挺好大结局?
    在这里插入图片描述
    求助
    这样为什么可行,俺是一点都不晓得的,如果有大佬路过,请帮忙解答!!!跪谢orz

    顺便说一句,出于好奇,试了下某些博文里说的前缀加yml分隔符---配合的方式,感觉上是一本正经胡说八道,实际上也没读出来。
    读取List<类>也是同样可行的。

    # point.yml
    prefix:
      id: 2233
      name: Ellie
      cards:
        - name: XD
          code: XD02101263
        - name: ZY
          code: ZY8965
        - name: GX
          code: GX0009
          
    // config 类
    @Data
    @Configuration
    @PropertySource(value = {"classpath:point.yml"})
    @ConfigurationProperties(prefix = "prefix")
    public class TestPoint {
        private int id;
    
        private String name;
    
        private List<Card> cards;
    
        @Override
        public String toString() {
            return "TestPoint{" +
                    "id=" + id +
                    ", name='" + name + '\'' +
                    ", cards=" + cards +
                    '}';
        }
    }
    
    // 并不需要有什么与众不同的card类
    @Data
    public class Card {
        private String name;
        private String code;
    
        @Override
        public String toString() {
            return "Card{" +
                    "name='" + name + '\'' +
                    ", code='" + code + '\'' +
                    '}';
        }
    }
    

    请求
    在这里插入图片描述

    查找资料的过程中还看到了一种别致的写法,是为了解决多层嵌套的yml的读写,未验证,因为有选择的话,我不愿意这样写,不过写法确实很别致,哈哈哈!
    https://my.oschina.net/u/2486137/blog/1512294

    3、外部部署

    其实就是把配置文件部署在jar包外部,方便修改而不必重新打包。

    3.1、spring boot核心配置文件外部加载

    希望外部加载自定义配置文件,需要先了解spring默认的文件加载方式。
    spring程序会按优先级从下面这些路径来加载application.properties配置文件:

    • 当前目录下的/config目录
    • 当前目录
    • classpath里的/config目录
    • classpath 根目录

    idea中,在源码下的classpath对应src/main/resources很明确,打包后的classpath在哪里俺是不知道的,然后就把打包后的jar包解压看了下,在BOOT-INF\classes下看到了application.yml和point.yml。所以要想覆盖配置文件,我再jar包同级目录下建了config文件夹,修改配置文件内容看覆盖是否生效。
    具体操作:

    • 打包的时候默认将application.yml和point.yml打包到jar中(classpath)
    • 部署时,jar包同级目录下建立config文件夹,修改application.yml中端口号和point.yml内容,看修改是否生效。

    修改后的point.yml文件如下:

    prefix:
      id: 2233
      name: FakeEllie
      cards:
        - name: NONE
          code: 00000001
    

    测试结果:端口号修改生效(application.yml修改生效),修改后的point.yml并未生效。
    毕竟自定义配置文件,一厢情愿希望spring boot按照核心文件加载方式加载point.yml,没有生效也在意料之中,不过路并没有堵死。

    3.2、在@PropertySource中添加路径

    查资料的时候注意到还有这种写法:

    @Data
    @Configuration
    @PropertySource(value = {"file:config/point.yml"})
    @ConfigurationProperties(prefix = "prefix")
    public class TestPoint {
        private int id;
    
        private String name;
    
        private List<Card> cards;
    
        @Override
        public String toString() {
            return "TestPoint{" +
                    "id=" + id +
                    ", name='" + name + '\'' +
                    ", cards=" + cards +
                    '}';
        }
    }
    

    就是通过file来指定文件路径,之前是classpath来指定资源相对路径,说来神奇,这种方式没有报错,但读取的内容却是classpath下的point.yml,而不是config下的point.yml。想来是通过@ConfigurationProperties(prefix = "prefix")指定的前缀去classpath下匹配到的。跟@PropertySource(value = {"file:config/point.yml"})大概是没有关系了,忘崽牛奶真好喝。

    3.3、通过YamlPropertiesFactoryBean添加路径

    回想上面的描述,YamlPropertiesFactoryBean是将配置文件暴露给spring环境的,可以考虑使用它来指定文件路径。
    修改bean,添加new FileSystemResource("config/point.yml")来指定config文件夹下的配置。

    @Bean
    	public static PropertySourcesPlaceholderConfigurer properties() {
    		PropertySourcesPlaceholderConfigurer configurer = new PropertySourcesPlaceholderConfigurer();
    		YamlPropertiesFactoryBean yaml = new YamlPropertiesFactoryBean();
    		yaml.setResources(new ClassPathResource("point.yml"), new FileSystemResource("config/point.yml"));
    		configurer.setProperties(yaml.getObject());
    		return configurer;
    	}
    

    此时配置类上使用@PropertySource(value = {"file:config/point.yml"})这种写法,返回的是

    成功了?但是好像搞笑了。不过也说明了配置文件读取的顺序。config文件夹下的有最终决定权。
    为了直观些,俺顺手修改jar包同级目录下config文件夹中point.yml配置文件,保证list元素个数相同:

    prefix:
      id: 2233
      name: FakeEllie
      cards:
        - name: NONE
          code: 00000001
        - name: NONE
          code: 00000002
        - name: NONE
          code: 00000003
    

    不搞笑了。

    但是,改成此时配置类上使用@PropertySource(value = {"classpath:point.yml"})后,返回并没有变化。所以YamlPropertiesFactoryBean将配置文件暴露给spring环境,说的应该就是将文件添加到spring的classpath下了,先读默认的,再读新添加这样子的。然鹅这样就没有办法在不进行外部配置的时候使用默认的classpath下的配置文件了。

    此外,通过YamlPropertiesFactoryBean添加配置文件的方式,就需要保证config/point.yml一定要存在,要想达到不进行外部配置的时候读取默认classpath下point.yml,在进行外部配置的时候读取config/point.yml。那就只好耍流氓了。

    @Data
    @Configuration
    @PropertySource(value = {"file:config/point.yml", "classpath:point.yml"}, ignoreResourceNotFound = true)
    @ConfigurationProperties(prefix = "prefix")
    public class TestPoint {
        private int id;
    
        private String name;
    
        private List<Card> cards;
    
        @Override
        public String toString() {
            return "TestPoint{" +
                    "id=" + id +
                    ", name='" + name + '\'' +
                    ", cards=" + cards +
                    '}';
        }
    }
    

    重点:然后!在不进行外部配置的时候,config/point.yml内容为空,或者干脆跟classpath下的point.yml内容保持一致。

    小孩子才做选择题,我全都想要


    虽然看上去像个意外,但是好在意啊啊啊啊,遏制不住的好奇心啊!就是刚刚那个拼起来的返回值。
    想看看是不是application.yml覆盖list也会这样,俺把配置类对应的内容举家搬迁到了application.yml中。如下:

    // 配置类
    @Data
    @Configuration
    @ConfigurationProperties(prefix = "prefix")
    public class TestPoint {
        private int id;
    
        private String name;
    
        private List<Card> cards;
    
        @Override
        public String toString() {
            return "TestPoint{" +
                    "id=" + id +
                    ", name='" + name + '\'' +
                    ", cards=" + cards +
                    '}';
        }
    }
    

    配置类默认读取application.yml。

    # classpath:application.yml
    prefix:
      id: 2233
      name: Ellie
      cards:
        - name: XD
          code: XD02101263
        - name: ZY
          code: ZY8965
        - name: GX
          code: GX0009
    
    #config/application.yml
    prefix:
      id: 2233
      name: FakeEllie
      cards:
        - name: NONE
          code: 00000001
    

    测试结果:

    并没有进行拼接啊喂!!!

    在各种调换顺序看影响的时候,修改了YamlPropertiesFactoryBean添加source的顺序,返回结果发生了变化。

    @Bean
    	public static PropertySourcesPlaceholderConfigurer properties() {
    		PropertySourcesPlaceholderConfigurer configurer = new PropertySourcesPlaceholderConfigurer();
    		YamlPropertiesFactoryBean yaml = new YamlPropertiesFactoryBean();
    		yaml.setResources(new FileSystemResource("config/point.yml"), new ClassPathResource("point.yml"));
    		configurer.setProperties(yaml.getObject());
            configurer.setIgnoreResourceNotFound(true);
    		return configurer;
    	}
    

    返回结果

    有一种简单的在运行时通过命令参数指定配置文件的方式效果与此类似。

    java -jar demo.jar --Dspring.config.location=point.yml
    

    俺的原则时,代码能解决的,就不要交给人来解决。
    虽然没有解决任何问题,但是顺便知道了读取的先后顺序就是setResources的先后顺序。卒

    所以目前的结论是,对于有list的配置,并且个数发生变化的时候,这种方式并不适用。

    3.4、自定义yaml文件资源加载类

    在注解@PropertySource中,有个属性factory主要用来声明解析配置文件的类,这个类必须是PropertySourceFactory接口的实现。从这里入手。

    参考资料:
    Spring Boot自定义加载yml实现,附源码解读
    Springboot加载自定义yml文件配置的方法

    默认调用的是PropertySourceFactory的实现DefaultPropertySourceFactory,因此可以自定义factory实现PropertySourceFactory接口,也可以扩展DefaultPropertySourceFactory类。两种写法的效果是一样的,列出来。

    • 直接实现PropertySourceFactory接口
    public class YamlPropertyLoaderFactory implements PropertySourceFactory {
        @Override
        public PropertySource<?> createPropertySource(String name, EncodedResource encodedResource) throws IOException {
    
            List<PropertySource<?>> sources = name != null ? new YamlPropertySourceLoader().load(name, encodedResource.getResource()) : new YamlPropertySourceLoader().load(
                    getNameForResource(encodedResource.getResource()), encodedResource.getResource());
            if (sources.size() == 0) {
                return null;
            }
    
            return sources.get(0);
        }
    
        private static String getNameForResource(Resource resource) {
            String name = resource.getDescription();
            if (!StringUtils.hasText(name)) {
                name = resource.getClass().getSimpleName() + "@" + System.identityHashCode(resource);
            }
            return name;
        }
    }
    
    • 扩展DefaultPropertySourceFactory
     public class YamlPropertyLoaderFactory extends DefaultPropertySourceFactory {
        @Override
        public PropertySource<?> createPropertySource(String name, EncodedResource resource) throws IOException {
            if (resource == null) {
                return super.createPropertySource(name, resource);
            }
            List<PropertySource<?>> sources = new YamlPropertySourceLoader().load(resource.getResource().getFilename(), resource.getResource());
            if (sources.size() == 0) {
                return super.createPropertySource(name, resource);
            }
    
            return sources.get(0);
        }
    }
    

    建议用第二种方式。
    用factory的方式来实现的话,前面莫名其妙加个prefix就可以正常读取的诡异操作也不需要了哦。
    使用方式如下:

    @Data
    @Configuration
    @PropertySource(value = {"classpath:point.yml", "file:config/point.yml"}, factory = YamlPropertyLoaderFactory.class, ignoreResourceNotFound = true)
    @ConfigurationProperties
    public class TestPoint{
        private int id;
    
        private String name;
    
        private List<Card> cards;
    
        @Override
        public String toString() {
            return "TestPoint{" +
                    "id=" + id +
                    ", name='" + name + '\'' +
                    ", cards=" + cards +
                    '}';
        }
    }
    
    # config/point.yml
    id: 2233
    name: FakeEllie
    cards:
      - name: NONE
        code: 00000001
    

    测试结果:

    自定义factory的方式,读取多种路径的配置文件时,也是有先后顺序的,就是@PropertySource中value属性指定的顺序,与使用YamlPropertiesFactoryBean将资源暴露给spring环境不同,这个不会有前面出现的“拼接”效果出现,棒呆~


    以解决问题为目标和以写清楚博文为目标去看同样的问题,真的是不一样的探索路径呢,凑字数和为了flag不倒的文写的远远超出自己最初的预期,真好,超喜欢!

    展开全文
  • Spring Boot的yml配置文件讲解

    千次阅读 2019-04-03 18:50:49
    一、Spring Boot配置文件...【2】application.yml全局配置文件 Spring Boot的配置文件一般放在 src / main / resources 路径下面,而且全局配置文件可以对一些默认属性进行修改。在学习Spring Boot之前我们一直使...

    一、Spring Boot配置文件介绍
    Spring Boot中的配置文件主要是分为以下两种类型:
    【1】application.properties全局配置文件
    【2】application.yml全局配置文件
    Spring Boot的配置文件一般放在 src / main / resources 路径下面,而且全局配置文件可以对一些默认属性进行修改。在学习Spring Boot之前我们一直使用的全局配置文件是以properties结尾的配置文件,所以在这里我们主要讲解application.yml配置文件。

    二、yml文件介绍
    yml文件是YAML语言的文件,YAML(Yet Another Markup Language)是一种基于Unicode容易阅读,容易和脚本语言交互的,用来表达资料序列的编程语言,并且它是以数据为中心,比JSON,XML等更适合做配置文件。

    三、yml文件的应用场景
    【1】脚本语言:由于实现简单,解析成本很低,YAML 特别适合在脚本语言中使用
    【2】序列化: YAML是由宿主语言数据类型直转,的比较适合做序列化。
    【3】配置文件:写 YAML 要比写 XML 快得多(无需关注标签或引号),并且比 INI 文档功能更强。由于兼容性问题,不同语言间的数据流转建议不要用 YAML。

    四、yml文件的语法

    【1】yml的基本格式
    key: value:表示一对键值对,并且 : 与value必须有一个空格。
    yml是以空格的缩进来控制层级的关系,只要是左对齐的一列数据,都算是同一个层级的,并且大小写也是敏感的,如下所示:

    server:
        port: 8080
        path: /helloworld
    

    【2】yml的值的写法

    ①、普通的值(数值,字符串,布尔值)
    key: value 直接写即可,例如:

    name: ZhangSan
    

    如果是字符串要加上引号的话,分以下两种情况:
    1.双引号:不会对字符串里面的特殊符号进行转义,例如 “my name is \n ZhangSan” 输出结果为"my name is " 换行之后再输出 “ZhangSan”。
    2.单引号:对字符串里面的转义字符进行转义,使之变为普通字符,例如 'my name is \n ZhangSan’输出结果为 ‘my name is ZhangSan’。

    ②、对象,Map(属性和值)
    第一种格式,如下所示:

    person:
        name: ZhangSan
        age: 20
        sex: 男
    

    第二种格式,如下所示:

    person: {name: ZhangSan,age: 20,sex: 男}
    

    ③、数组(List,Set等)
    第一种格式,如下所示:

    pets
       - dog
       - pig
       - duck
    

    第二种格式,如下所示:

    pets: [dpg,pig,duck]
    

    注意:冒号后面一定要有空格,即key: value。

    四、案例演示
    【1】创建两个Bean,一个是Cat,另外一个是Person,如下所示:
    ①、Cat.java

    package bean;
    
    /**
     * @author czd
     */
    public class Cat {
        private String name;
        private Integer age;
    
        //下面省略Setter和Getter方法以及toString方法
    }
    
    

    在pom.xml文件中导入以下依赖

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

    ②、Person.java

    package com.czd.springbootdemo.bean;
    
    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;
    
    /**
     * @author czd
     * 将配置文件的属性映射到这个类的组件中
     * @ConfigurationProperties代表告诉SrpingBoot将本类中的属性与配置文件中的属性进行绑定
     */
    @Component
    @ConfigurationProperties(prefix = "person")
    @PropertySource("classpath:application.yml")
    public class Person {
        private String name;
        private Integer age;
        private Boolean man;
        private Date birth;
        private Map<String,Object> map;
        private List<Object> list;
        private Cat cat;
    
        //下面省略Setter和Getter方法以及toString方法
    }
    
    

    【2】在resources包下创建一个application.yml配置文件,输入如下内容:

    person:
      name: 张三
      age: 20
      man: true
      birth: 12/3/12
      map: { width: 25,height: 25}
      list: [1,2,3,4,5]
      cat:
        name: coffee
        age: 8
    

    【3】在Spring Boot测试包(test包)中进行测试

    package com.czd.springbootdemo;
    
    import bean.Person;
    import org.junit.Test;
    import org.junit.runner.RunWith;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.boot.test.context.SpringBootTest;
    import org.springframework.test.context.junit4.SpringRunner;
    
    @RunWith(SpringRunner.class)
    @SpringBootTest
    public class SpringbootdemoApplicationTests {
    
        @Autowired
        private Person person;
        @Test
        public void contextLoads() {
            System.out.println(person);
        }
    
    }
    
    

    输出结果

    Person{name='张三', age=20, man=true, birth=Mon Dec 03 00:00:00 CST 2012, map={width=25, height=25}, list=[1, 2, 3, 4, 5], cat=Cat{name='coffee', age=8}}
    

    五、解决配置文件编码问题
    【1】打开IDEA的Settings界面,在输入框中输入: File Encoding,如下图:
    在这里插入图片描述
    【2】在下面找到 Default encoding for properties files,选择 UTF-8,并且在后面打上勾就可以了,如下图所示:
    在这里插入图片描述

    展开全文
  • yml配置文件

    千次阅读 2018-04-24 13:07:26
    Spring Boot里面没有Spring的配置文件,我们自己编写的配置文件,也不能自动识别; 想让Spring的配置文件生效,加载进来;@ImportResource标注在一个配置类上 SpringBoot推荐给容器中添加组件的方式;推荐使用全注解...
  • SpringBoot YML配置文件

    万次阅读 2019-03-09 20:37:49
    在之前的博客中说到了怎么样去创建一个SpringBoot的项目以及创建这个Spring项目之后怎么去启动使用这个SpringBoot的项目文件,还有就是SpringBoot项目的启动原理。下面的博客中就开始进入到SpringBoot关于配置的学习...
  • springboot配置文件可以是properties,也可以是yml类型,它们都支持字符型,也支持列表list类型,假定在yml配置文件中支持列表类型格式如下: application.yml demo: type: code: - 200 - 201 - 300 - 400...
  • 主要介绍了springboot启动时是如何加载配置文件application.yml文件,本文给大家介绍的非常详细,对大家的学习或工作具有一定的参考借鉴价值,需要的朋友可以参考下
  • yml配置文件一、 yml基本语法二、yml值的写法三、@ConfigurationProperties注解获取全局配置文件中内容四、@Value注解获取全局配置文件中内容五 @Value与@ConfigurationProperties对比 springboot使用一个全局的配置...
  • yml配置文件的使用略讲

    千次阅读 2019-09-02 16:47:59
    一、yml简介 1、配置文件 Springboot使用一个全局配置文件配置文件名是固定的: application.properties application.yml ...YML:以数据为中心,比json、xml更适合做配置文件; 二、yml语法 1、基本...
  • SpringBoot的yml配置文件(三)

    千次阅读 2021-04-10 16:24:56
    本文主要介绍点: 1. yaml 配置文件的规则 2. ConfigurationProperties注解的绑定 3.PropertySource 注解的使用
  • yml 取值 import org.springframework.beans.factory.annotation.Value; import org.springframework.stereotype.Service; import org.springframework.context.annotation.Configuration; @Service @...
  • 主要介绍了spring boot-2.1.16整合swagger-2.9.2 含yml配置文件,本文通过实例代码给大家介绍的非常详细,对大家的学习或工作具有一定的参考借鉴价值,需要的朋友可以参考下
  • java 读取 yml 配置 文件

    千次阅读 2020-01-10 14:14:49
    InputStream resourceAsStream = ShiroConfig.class.getClassLoader().getResourceAsStream("application.yml"); obj = (Map) yaml.load(resourceAsStream); } catch (Exception e) { e.printStackTrace(); } ...
  • 读取yml配置文件中的值

    千次阅读 2021-03-13 09:26:09
    1.yml文件person:lastName: helloage: 18boss: falsebirth: 2017/12/12maps: {k1: v1,k2: 12}lists:-lisi-zhaoliudog:name: 小狗age: 122.javaBean/*** 将配置文件中配置的每一个属性的值,映射到这个组件中* @...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 192,851
精华内容 77,140
关键字:

yml配置文件

友情链接: intermec fp指令.rar