精华内容
下载资源
问答
  • YML
    千次阅读
    2021-03-30 10:49:25

    一、概述

    与properties文件,json格式三者都是配置属性文件;yaml 语言可以编写 .yml 文件,相比之下,YAML 是专门用来写配置属性文件的语言,非常简洁和强大,远比 JSON 格式方便。

    二、yml配置文件

    2.1 yml分析

    ——一种基于Unicode容易阅读,容易和脚本语言交互的,用来表达资料序列的编程语言。
    ——适应场景 脚本语言:由于实现简单,解析成本很低,YAML 特别适合在脚本语言中使用
    —— 序列化: YAML是由宿主语言数据类型直转,的比较适合做序列化。
    —— 配置文件:写 YAML 要比写 XML 快得多(无需关注标签或引号),并且比 INI 文档功能更强。由于兼容性问题,不同语言间的数据流转建议不要用 YAML。
    ——语言优点 YAML易于人们阅读。 YAML数据在编程语言之间是可移植的。 YAML匹配敏捷语言的本机数据结构。 YAML具有一致的模型来支持通用工具。 YAML支持单程处理。 YAML具有表现力和可扩展性。

    2.2 YAML 语法

    ——使用空格 Space 缩进表示分层,不同层次之间的缩进可以使用不同的空格数目,但是同层元素一定左对齐,即前面空格数目相同(不能使用 Tab,各个系统 Tab对应的 Space 数目可能不同,导致层次混乱)
    ——‘#’表示注释,只能单行注释,从#开始处到行尾
    ——破折号后面跟一个空格(a dash and space)表示列表
    ——用冒号和空格表示键值对 key: value
    ——简单数据(scalars,标量数据)可以不使用引号括起来,包括字符串数据。用单引号或者双引号括起来的被当作字符串数据,在单引号或双引号中使用C风格的转义字符

    2.3 配置数据

    ——配置普通数据
    语法: key: value
    代码演示:

    name: zhangsan
    

    说明:value之前有一个空格

    —— 配置对象数据
    语法:

    #方式一
    ​ key:
    ​ key1: value1
    ​ key2: value2
    
    #方式二
    ​ key: {key1: value1,key2: value2}
    

    示例代码:

    #方式一
    person:
      name: zhangsan
      age: 18
      addr: henan
     #方式二
    person: {name: zhangsan,age: 18,addr: henan}
    

    说明:key1前面的空格个数不限定,在yml语法中,相同缩进代表同一个级别

    ——配置Map数据
    与配置对象方式相同

    —— 配置数组(List、Set)数据
    语法:

    #方式一
    ​ key:- value1
    ​ - value2
    #方式二
    ​ key: [value1,value2]
    

    示例代码:

    city:
      - beijing
      - tianjin
      - shanghai
      - chongqing
      
    #或者
    city: [beijing,tianjin,shanghai,chongqing]
    
    #集合中的元素是对象形式
    student:
      - name: zhangsan
        age: 18
        score: 100
      - name: lisi
        age: 28
        score: 88
      - name: wangwu
        age: 38
        score: 90
    
    说明:value1与 - 之间存在一个空格
    

    例子:

    #普通数据配置
    name: 张三
    #对象的配置
    person:
      name: 张三
      age: 18
      addr: 北京
    
    #行内对象配置
    person: {name: 张三,age: 18,addr: 北京}
    
    #配置数据、集合(普通字符串)
    city:
      - beijing
      - shanghai
      - tianjin
    
    city: [beijin,tianjin,shanghai]
    
    #配置数据、集合(对象数据)
    student:
      - name: 张三
        age: 18
        addr: beijin
      - name: 李四
        age: 19
        addr: tianjin
    
    student: [{name: zhangsan,age: 19,addr: beijin},{name: lishi,age: 20,addr: beijin}]
    
    #map配置
    map:
      key1: value1
      key2: value2
    

    2.4 获取数据

    #方式一:
    
    @Controller
    public class quickController {
        //从容器中获取对象的的值
        @Value("${name}")
        private String name;
        @Value("${person.addr}")
        private String addr;
    
        @RequestMapping("/quick")
        @ResponseBody
        public String quick(){
            //获取配置文件的信息
            return "name:"+name+",addr="+addr;
        }
    }
    
    #方式二(@ConfigurationProperties):
    
    @Controller
    @ConfigurationProperties(prefix = "person")
    public class quick2Controller {
        //从容器中获取对象的的值
        private String name;
        private String addr;
        //这种方式需要提供set,get方法
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public String getAddr() {
            return addr;
        }
    
        public void setAddr(String addr) {
            this.addr = addr;
        }
    
        @RequestMapping("/quick2")
        @ResponseBody
        public String quick2(){
            //获取配置文件的信息
            return "name:"+name+",addr="+addr;
        }
    }
    
    更多相关内容
  • 合并-yml 将多个YML文件合并到一个文件中,并替换找到的任何环境变量(c)版权所有2013 Jonathan Cobb。 可以在Apache许可版本2下获得此代码: : 建造mvn -P uberjar package需要“ maven”构建自动化工具。 使用在...
  • 天气预报机器人数据集, nlu.yml city.yml response.yml
  • yml_comparer YML比较器 这是Java实现YML提供块的比较 用法: yml_comparer <old> 结果由<OfferId><r><n><m><p> ,其中 OfferId是要约的ID r表示要约已在删除的信号 在添加了n要约的信号 在修改了要约的m信号 p...
  • 其实yml和properties文件是一样的原理,且一个项目上要么yml或者properties,二选一的存在。这篇文章给大家介绍了Spring Boot 中application.yml与bootstrap.yml的区别,感兴趣的朋友一起看看吧
  • properties-yml.jar

    2021-08-11 14:58:38
    yml properties相互转换 工具 java小工具 命令:java -jar properties-yml.jar application.properties 生成application.properties 命令:java -jar properties-yml.jar application.yml 生成application.yml
  • kube-flannel.yml.yml

    2020-05-12 14:54:36
    https://github.com/coreos/flannel/blob/master/Documentation/kube-flannel.yml
  • 带有环境.yml的Conda环境 与environment.yml文件兼容的与Binder兼容的存储库。 通过单击上方或以下URL的蓝色徽标来访问此活页夹:笔记environment.yml文件应列出笔记本计算机所依赖的所有Python库,并以使用以下...
  • application.yml

    2020-07-05 21:35:21
    application.yml用于在java SPring boot连接数据库时的连接文件,将该文件放在main/resource中,并对其中内容进行修改,包括数据库的登录信息,数据库名等等,mysql8以及更高版本的需要修改字符集编码
  • 关于yml的介绍,java对yml的解析,yml的规范的详解。
  • 包-yml 这是和项目的工作。 为了对 npm 的包文件使用yml而不是json 。 重要的! 这将删除您现有的.json文件。 使用风险自负! 检查源代码,帮我把它做到最好。 安装 npm install package-yml --global npm config...
  • .gitlab-ci.yml :sparkles: :sparkles: :sparkles: :sparkles: :sparkles: :sparkles: :sparkles: :sparkles: 用法 在.gitlab-ci.yml : --- include : - project : SocialGouv/gitlab-ci-yml file : /base_...
  • 在web项目中读取yml配置文件的工具类.可以实现将 server : port : portnumber : 8081 转换为 key为"server.port.portnumber",值为"8081"的Map,String>集合
  • springboot_jpa中yml文件

    2018-11-16 14:42:27
    springboot+Jpa+JDBC做前后台交后的所需yml文件
  • 这个插件是用来支持springboot中yml文本的插件,非常的实用。
  • P社翻译文件YML翻译器(钢铁雄心4,群星)Paradox交互式YML转换器GitHub: : 需要安装.NET Framework 4.5。目前版本:V1.7.2 170510 old文件夹中是旧版的文本,因群星1.6加入了官中文本,分为en-1.6及cn-1.6两个。 ...
  • NULL 博文链接:https://1158023912.iteye.com/blog/2405078
  • 企业在经常使用的yml
  • 码头工人组成这是我所有docker docker-compose.yml -files的集合。 我希望它们可以为您节省时间。捐献如果这些文件确实为您节省了一些时间,则可以考虑给我买杯咖啡:
  • yml_tools Drupal 7 模块允许将产品从商店导出到 YML (Yandex.Market)。 支持 Ubercart 和 Drupal Commerce 商店。 基于 YML 导出 ( )。 去做: 添加字段映射支持完整模式在 cron 上生成 XML 文件验证生成的文件
  • YML简介

    千次阅读 2021-03-15 12:12:47
    在接触springboot的时候遇到了一种特殊的配置文件 .yml,本文对yml作简单介绍,快速入手yml。 一、YML是什么 YAML (YAML Ain't a Markup Language)YAML不是一种标记语言,通常以.yml为后缀的文件,是一种直观的...

    在接触springboot的时候遇到了一种特殊的配置文件 .yml,本文对yml作简单介绍,快速入手yml。

    一、YML是什么

    YAML (YAML Ain't a Markup Language)YAML不是一种标记语言,通常以.yml为后缀的文件,是一种直观的能够被电脑识别的数据序列化格式,并且容易被人类阅读,容易和脚本语言交互的,可以被支持YAML库的不同的编程语言程序导入,一种专门用来写配置文件的语言。可用于如: Java,C/C++, Ruby, Python, Perl, C#, PHP等。

    二、YML的优点

    1. YAML易于人们阅读。
    2. YAML数据在编程语言之间是可移植的。
    3. YAML匹配敏捷语言的本机数据结构。
    4. YAML具有一致的模型来支持通用工具。
    5. YAML支持单程处理。
    6. YAML具有表现力和可扩展性。
    7. YAML易于实现和使用。

    三、YML语法

    1.约定

    • k: v 表示键值对关系,冒号后面必须有一个空格

    • 使用空格的缩进表示层级关系,空格数目不重要,只要是左对齐的一列数据,都是同一个层级的

    • 大小写敏感

    • 缩进时不允许使用Tab键,只允许使用空格。

    • 松散表示,java中对于驼峰命名法,可用原名或使用-代替驼峰,如java中的lastName属性,在yml中使用lastName或 last-name都可正确映射。

     

    2.键值关系

    (以java语言为例,其它语言类似)对于键与值主要是看能否表示以下内容。普通的值(数字、字符串、布尔)、日期、对象、数组、集合等。

    1) 普通值(字面量)

    k: v:字面量直接写;

    ​ 字符串默认不用加上单引号或者双绰号;

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

    ​ name: "zhangsan \n lisi":输出;zhangsan 换行 lisi

    ​ '':单引号;会转义特殊字符,特殊字符最终只是一个普通的字符串数据

    name1: zhangsan
    name2: 'zhangsan \n lisi'
    name3: "zhangsan \n lisi"
    age: 18
    flag: true
    

    2)日期

    date: 2019/01/01
    

    3)对象(属性和值)、Map(键值对)

    ​ 在下一行来写对象的属性和值的关系,注意缩进

    people:
        name: zhangsan
        age: 20
    

    ​ 行内写法:

    people: {name:zhangsan,age: 20}
    

    4)数组、list、set

    用- 值表示数组中的一个元素

    pets:
        - dog
        - pig
        - cat
    

    行内写法

    pets: [dog,pig,cat]
    

    5)数组对象、list对象、set对象

    peoples:
        - name: zhangsan
          age: 22
        - name: lisi
          age: 20
        - {name: wangwu,age: 18}
    

    6)java代码示例

    java代码(省略get,set方法)

    public class Person {
    
        private String lastName;
        private Integer age;
        private Boolean boss;
    
        private Date birth;
        private Map<String,Object> maps;
        private List<Dog> lists;
        private Dog dog;
        private String[] arr;
    }
    public class Dog {
        private String name;
        private Integer age;
    }
    

    对应的yml

    person:
      boss: false
      maps:
        k1: v1
        k2: 14
      lists:
        - name: d1
          age: 2
        - name: d2
          age: 3
        - {name: d3,age: 4}
      birth: 2017/12/15
      dog:
        name: p_dog
        age: 15
      age: 13
      last-name: 张三
      arr: [s1,s2,s3]
    

    @Value 获取值和 @ConfigurationProperties 获取值的比较:

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

    3.文档块

    对于测试环境,预生产环境,生产环境可以使用不同的配置  [ config.dev.yml、config.prod.yml、config.test.yml]

    如果只想写到一个文件中,yml与是支持的,每个块用----隔开

    
    server:
      port: 8081
    spring:
      profiles:
        active: prod #激活对应的文档块
    
    ---
    server:
      port: 8083
    spring:
      profiles: dev #指定属于哪个环境
    
    
    ---
    
    server:
      port: 8084
    spring:
      profiles: prod  #指定属于哪个环境
    

     

     

    #################################### 简单的文件 ##########################################

    数据结构可以用类似大纲的缩进方式呈现

    receipt:     Oz-Ware Purchase Invoice
    date:        2012-08-06
    customer:
        given:   Dorothy
        family:  Gale
       
    items:
        - part_no:   A4786
          descrip:   Water Bucket (Filled)
          price:     1.47
          quantity:  4
    
        - part_no:   E1628
          descrip:   High Heeled "Ruby" Slippers
          size:      8
          price:     133.7
          quantity:  1
    
    bill-to:  &id001
        street: | 
                123 Tornado Alley
                Suite 16
        city:   East Centerville
        state:  KS
    
    ship-to:  *id001   
    
    specialDelivery:  >
        Follow the Yellow Brick
        Road to the Emerald City.
        Pay no attention to the
        man behind the curtain.
    

    注意在 YAML 中,字符串不一定要用双引号标示。另外,在缩进中空白字符的数目并不是非常重要,只要相同层次结构的元素左侧对齐就可以了(不过不能使用 TAB 字符)。这个文件的顶层由七个键值组成:其中一个键值 "items",是两个元素构成的数组(或称清单),这清单中的两个元素同时也是包含了四个键值的散列表。文件中重复的部分用这个方法处理:使用锚点( &)和引用(*)标签将 "bill-to" 散列表的内容复制到 "ship-to" 散列表。也可以在文件中加入选择性的空行,以增加可读性。在一个文件中,可同时包含多个文件,并用 "---"分隔。选择性的符号"..." 可以用来表示文件结尾(在利用流的通信中,这非常有用,可以在不关闭流的情况下,发送结束信号)。

    语言的构成元素

    YAML 的基本组件

    YAML 提供缩进/区块以及内置(inline)两种格式,来表示清单和散列表。以下展示几种 YAML 的基本原件。

    清单(数组)

     

     --- # 最喜爱的电影
     - Casablanca
     - North by Northwest
     - Notorious
    

    另外还有一种内置格式(inline format)可以选择──用方括号围住,并用逗号 + 空白区隔(类似 JSON 的语法)

     

     --- # 购物清单
     [milk, pumpkin pie, eggs, juice]
    

    散列表

    键值和数据由冒号及空白字符分开。区块形式(常使用与 YAML 数据文档中)使用缩进和换行符分隔 key: value 对。内置形式(常使用与 YAML 数据流中)在大括号中使用逗号 + 空白字符分隔 key: value 对。

     

     --- # 區塊形式
       name: John Smith
       age: 33
     --- # 內置形式
     {name: John Smith, age: 33}
    

    区块的字符

    再次强调,字符串不需要包在引号之内。有两种方法书写多行文字(multi-line strings),一种可以保存新行(使用 | 字符),另一种可以折叠新行(使用 > 字符)。

    保存新行 (Newlines preserved)

     

    data: |                                     # 譯者注:這是一首著名的五行民謠(limerick)
       There once was a man from Darjeeling     # 這裡曾有一個人來自大吉嶺
       Who got on a bus bound for Ealing        # 他搭上一班往伊靈的公車
           It said on the door                  # 門上這麼說的
           "Please don't spit on the floor"     # "請勿在地上吐痰"
       So he carefully spat on the ceiling      # 所以他小心翼翼的吐在天花板上
    

    根据设置,前方的引领空白符号(leading white space)必须排成条状,以便和其他数据或是行为(如示例中的缩进)明显区分。

    折叠新行 (Newlines folded)

     

    data: >
       Wrapped text         # 摺疊的文字
       will be folded       # 將會被收
       into a single        # 進單一一個
       paragraph            # 段落
       
       Blank lines denote   # 空白的行代表
       paragraph breaks     # 段落之間的區隔
    

    和保存新行不同的是,换行字符会被转换成空白字符。而引领空白字符则会被自动消去。

    层次结构化的元素

    于清单中使用散列表

     

    - {name: John Smith, age: 33}
    - name: Mary Smith
      age: 27
    

    于散列表中使用清单

     

    men: [John Smith, Bill Jones]
    women:
      - Mary Smith
      - Susan Williams
    

    YAML 的高级组件

    这部分算是一个后续的讨论,在比较各种数数据列语言时,YAML 最常被提到的特色有两个:关系树和数据形态。

    树状结构之间的交互引用

    数据合并和参考

    为了维持文件的简洁,并避免数据输入的错误,YAML 提供了结点参考(*)和散列合并(<<)参考到其他结点标签的锚点标记(&)。参考会将树状结构加入锚点标记的内容,并可以在所有数据结构中运作(可以参考上面 "ship-to" 的示例)合并只有散列表可以使用,可以将键值自锚点标记复制到指定的散列表中。

    当数据被 instantiate 合并和参考会被剖析器自动展开。

     

    #眼部雷射手術之標準程序
    ---
    - step:  &id001                  # 定義錨點標籤 &id001
        instrument:      Lasik 2000
        pulseEnergy:     5.4
        pulseDuration:   12
        repetition:      1000
        spotSize:        1mm
    
    - step:
         <<: *id001                  # 合併鍵值:使用在錨點標籤定義的內容
         spotSize:       2mm         # 覆寫"spotSize"鍵值
    
    - step:
         <<: *id001                  # 合併鍵值:使用在錨點標籤定義的內容
         pulseEnergy:    500.0       # 覆寫鍵值
         alert: >                    # 加入其他鍵值
               warn patient of 
               audible pop
    

    数据形态

    由于自动判定数据形态的功能,严格类型(也就是用户有宣告的数据形态)很难在大部分的 YAML 文件中看到。数据类型可以被区分成三大类:原码(core),定义(defined),用户定义(user-defined)。原码可以自动被解析器分析(例如:浮点数,整数,字符串,清单,映射,...)。有一些高级的数据形态──例如比特数据──在 YAML 中有被 “定义”,但不是每一种解析器都有支持。最后,YAML 支持用户自定的区域变量,包括:自定义的类别,结构或基本类型(例如:四倍精度的浮点数)。

    强制转型

    YAML 的自动判定数据形态是哪一种实体。但有时用户会想要将数据强制转型成自定的某种类型。最常见的状况是字符串,有时候可能看起来像数字或布尔值,这种时候可以使用双引号,或是使用严格类型标签。

     

    ---
    a: 123                     # 整數
    b: "123"                   # 字串(使用雙括號)
    c: 123.0                   # 浮點數
    d: !!float 123             # 浮點數,使用!!表達的嚴格型態
    e: !!str 123               # 字串,使用嚴格型態
    f: !!str Yes               # 字串,使用嚴格型態
    g: Yes                     # 布林值"真"
    h: Yes we have No bananas  # 字串(包含"Yes"和"No")
    

    其他特殊数据形态

    除了一般的数据形态之外,用户也可以使用一些较为高级的类型,但不保证可被每种解析器分析。使用时和强制转型类似,要在形态名称之前加上两个惊叹号(!!)。有几种重要的形态在本篇没有讨论,包括集合(sets),有序映照(ordered maps),时间戳记(timestamps)以及十六进制数据(hexadecimal)。下面这个示例则是比特数据(binary)

     

    ---
    picture: !!binary |
     R0lGODlhDAAMAIQAAP//9/X
     17unp5WZmZgAAAOfn515eXv
     Pz7Y6OjuDg4J+fn5OTk6enp
     56enmleECcgggoBADs=mZmE
    

    用户自行扩展的数据形态

    许多 YAML 的实现允许用户自定义数据形态。在将一个对象序列化时,这个方法还颇方便的。某些区域数据形态可能不存在默认的数据形态中,不过这种类型在特定的 YAML 应用程序中是有定义的。这种区域数据形态用惊叹号( !)表示。

     

    myObject:  !myClass { name: Joe, age: 15}
    

    语法

    在 yaml.org(英文)可以找到轻巧而好用的 小抄(亦是用 YAML 表示)及格式说明。下面的内容,是关于基本组件的摘要。

    YAML 使用可打印的 Unicode 字符,可使用 UTF-8 或 UTF-16。
    使用空白字符为文件缩进来表示结构;不过不能使用跳格字符 (TAB)。
    注解由井字号( # )开始,可以出现在一行中的任何位置,而且范围只有一行(也就是一般所谓的单行注解)
    每个清单成员以单行表示,并用短杠 + 空白( - )起始。或使用方括号( [ ] ),并用逗号 + 空白( , )分开成员。
    每个散列表的成员用冒号 + 空白( : )分开键值和内容。或使用大括号( { } ),并用逗号 + 空白( , )分开。
    散列表的键值可以用问号 ( ? ) 起始,用来明确的表示多个词汇组成的键值。
    字符串平常并不使用引号,但必要的时候可以用双引号 ( " ) 或单引号 ( ' ) 框住。
    使用双引号表示字符串时,可用倒斜线( \ )开始的转义字符(这跟 C 语言类似)表示特殊字符。
    区块的字符串用缩进和修饰符(非必要)来和其他数据分隔,有新行保留(preserve)(使用符号 | )或新行折叠(flod)(使用符号 > )两种方式。
    在单一文件中,可用连续三个连字号(---)区分多个文件。
    另外,还有选择性的连续三个点号( ... )用来表示文件结尾。
    重复的内容可使从参考标记星号 ( * ) 复制到锚点标记( & )。
    指定格式可以使用两个惊叹号 ( !! ),后面接上名称。
    文件中的单一文件可以使用指导指令,使用方法是百分比符号 ( % )。有两个指导指令在 YAML1.1 版中被定义:
    % YAML 指导指令,用来识别文件的 YAML 版本。
    % TAG 指导指令,被用在 URI 的前缀标记。这个方法在标记节点的类型时相当有用。
    YAML 在使用逗号及冒号时,后面都必须接一个空白字符,所以可以在字符串或数值中自由加入分隔符号(例如:5,280 或 http://www.wikipedia.org)而不需要使用引号。

    另外还有两个特殊符号在 YAML 中被保留,有可能在未来的版本被使用 --( @ )和( ` )

     

    展开全文
  • # group: *_GROUP_01 group: DEFAULT_GROUP #添加共享配置(公共配置) 以数组形式 读取配置也是从nacos上读取 shared-configs[0]: data-id: *-public.yml refresh: true shared-configs[1]: data-id: *-public.yml ...

    依赖:

    注意: (下载不下来使用阿里云镜像, 不使用中央仓库)  

    第一步: 添加公共依赖 Common 进行版本控制 

    <dependencyManagement>
            <dependencies>
    
                <!--微服务 版本依赖关系 (相互对应_官方)-->
                <dependency>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-dependencies</artifactId>
                    <version>2.3.2.RELEASE</version>
                    <type>pom</type>
                    <scope>import</scope><!--引入三方依赖版本的设计-->
                </dependency>
    
                <!--规范-->
                <dependency>
                    <groupId>org.springframework.cloud</groupId>
                    <artifactId>spring-cloud-dependencies</artifactId>
                    <version>Hoxton.SR9</version>
                    <!--只有pom 类型可以import-->
                    <type>pom</type>
                    <scope>import</scope>
                </dependency>
    
                <!--规范的实现-->
                <dependency>
                    <groupId>com.alibaba.cloud</groupId>
                    <artifactId>spring-cloud-alibaba-dependencies</artifactId>
                    <version>2.2.6.RELEASE</version>
                    <!--只有pom 类型可以import-->
                    <type>pom</type>
                    <scope>import</scope>
                </dependency>
            </dependencies>
        </dependencyManagement>

    第二步: 添加公共依赖

     <dependencies>
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
                <!--不用打包 默认: compile
                provided 表示只在此依赖编译阶段
                -->
                <scope>provided</scope>
            </dependency>
    
            <!--子工程中加入单元测试时候 不需要在引入此依赖-->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-test</artifactId>
                <scope>test</scope>
                <!--不需要的依赖 排除的-->
                <exclusions>
                    <exclusion>
                        <groupId>org.junit.jupiter</groupId>
                        <artifactId>junit-jupiter-engine</artifactId>
                    </exclusion>
                </exclusions>
            </dependency>
        </dependencies>

    第三步: 定义当前工程模块以及子模块的统一编译和运行版本

    <!--第三步: 定义当前工程模块以及子模块的统一编译和运行版本-->
    <build><!-- 项目构建配置 -->
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.1</version>
                <configuration>
                    <source>8</source>
                    <target>8</target>
                </configuration>
            </plugin>
        </plugins>
    </build>

    第四步: 子工程加入的配置

    <!--注册中心-->
    <dependency>
        <groupId>com.alibaba.cloud</groupId>
        <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
    </dependency>
    
    <!--配置中心-->
    <!-- 添加nacos配置中心的依赖 此时项目中就会多了一些java文件
        寻找bootstrap.yml
        这时候才不能使用application,yml
     -->
    <dependency>
        <groupId>com.alibaba.cloud</groupId>
        <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
    </dependency>

     (历史最全的yml配置)

    第五步: 填写bootstrap.yml

    server:
      port: 8082
    spring:
      application:
        name: app-cloudtest
    # nacos默认可以不写  但是 如果不是默认的必须要写
      cloud:
        nacos:
          #注册中心
          discovery:
            #server-addr: http://192.168.*:8848
            server-addr: http://*:8848
          #配置中心
          config:
            server-addr: http://*:8848
            file-extension: yml #配置的格式 yml
            #设置命名空间 这个是新建的dev命名空间(不写就是public)
            namespace: 5ff7df55-0fb2-4911-b4ca-dedcdf249d10
            #读取dev(UUID)命名空间下的group分组
           # group: *_GROUP_01
            group: DEFAULT_GROUP
            #添加共享配置(公共配置) 以数组形式 读取配置也是从nacos上读取
            shared-configs[0]:
                    data-id: *-public.yml
                    refresh: true
            shared-configs[1]:
                    data-id: *-public.yml
                    refresh: true
    #配置com.jt包以及子包中的日志级别 默认info 配置中心里了
    #logging:
    #  level:
    #    com.jt: debug #可以将这个写到配置中心里

    [新增TODO]

    网关gateway

    1.常用依赖(webFlux+gateway)

    <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-starter-gateway</artifactId>
            </dependency>
            <dependency>
                <groupId>com.alibaba.cloud</groupId>
                <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
            </dependency>
            <dependency>
                <groupId>com.alibaba.cloud</groupId>
                <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
            </dependency>
            <!--假如网关层面进行限流,添加如下依赖-->
            <dependency>
                <groupId>com.alibaba.cloud</groupId>
                <artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
            </dependency>
            <dependency>
                <groupId>com.alibaba.cloud</groupId>
                <artifactId>spring-cloud-alibaba-sentinel-gateway</artifactId>
            </dependency>
        </dependencies>

    2.yml配置(基本, 连接配置中心)

    server:
      port: 9000
    spring:
      application:
        name: pzy-sso-gateway
      cloud:
        nacos:
          discovery:
            server-addr: *:8848
          config:
            server-addr: *:8848
            file-extension: yml
            namespace: 85407696-397b-4fa4-b5c2-*
            group: PZY_GROUP
        sentinel:
          transport:
            dashboard: localhost:6379
          eager: true

    3. 配置中心nacos配置

     4. 配置中心详情(yml)

    spring:
        cloud: 
          gateway:
            routes:
            - id: router01
              uri: lb://pzy-sso-resource
              predicates:
                - Path=/sso/resource/**
              filters:
                - StripPrefix=1
            - id: router02
              uri: lb://pzy-sso-auth
              predicates:
                - Path=/sso/oauth/**
              filters:
                - StripPrefix=1
            globalcors: #跨域配置(写到配置文件的好处是可以将其配置写到配置中心)
              corsConfigurations:
                '[/**]':
                  allowedOrigins: "*"
                  allowedHeaders: "*"
                  allowedMethods: "*"
                  allowCredentials: true

     全局信息(图片)

    5.   启动gateway 的 sentinel

    在gateway的 application中添加 运行环境 

    -Dcsp.sentinel.app.type=1

     然后启动gateway

    6. 找到sentinel, 打开

    java -Dserver.port=6379 -Dcsp.sentinel.dashboard.server=localhost:6379 -Dproject.name=sentinel-dashboard -jar sentinel-dashboard-1.8.3.jar

     

    7. 出现这个就算成功

     

    展开全文
  • 如果人为手动的一条一条,将yml文件中的配置数据,添加到配置中心,难免会消耗大量的人力和精力,况且还容易输入错误。因此,需要一个工具或插件,将 yml 文件的格式,转换为properties文件。 【Convert YAML and...

    【诞生背景】

    最近在做某配置中心的时候,配置中心采用properties格式进行配置的(如下图)。

     而我们工程的项目配置文件是yml格式的(如下图)。

    如果人为手动的一条一条,将yml文件中的配置数据,添加到配置中心,难免会消耗大量的人力和精力,况且还容易输入错误。因此,需要一个工具或插件,将 yml 文件的格式,转换为properties文件。

    【Convert YAML and Properties File 插件的不足】

    IDEA 有一个插件叫 Convert YAML and Properties File, 于是,首先用了一下 这个插件后,发现了,发现这个插件不太友好,具体有以下几点。

     比如,现在我们有如下的 yml 配置文件:

     我们用插件将它转化为 properties 文件。

     下面是转化后的效果:

     从这转换后的效果,我们不难发现该插件有以下几点问题:

    (1)转化后,原 yml 配置文件消失(如果转出了问题,想看原配置文件,还看不了了);

    (2)排序出现混乱,没有按照原 yml 文件数据进行输出(msg相关的配置本来在原yml文件中是第二个配置,转换后却成为了第一个;同理,mybatis的配置本是最后一个,转化后却放在了第二个);

    (3)所有注释均不见了(所有相关的注释全都不见了,包括行级注释和末尾注释);

    (4)某些值没有进行配置,但转化后,却显示为了 null 字符串(如 msg.sex 的配置);

    (5)该插件仅IDEA有,Eclipse中还没有,不能垮开发工具使用;

    【自写小工具 YmlUtils 实现】

    针对上面 IDEA 插件的不足,于是自己写了一款小工具 YmlUtils(源码在文章结尾处 ),你可以将它放在工程中的任何位置。

    现在,我们同样以刚刚的 yml 配置文件为测试模板,来测试下这款小工具。

     测试的方法很简单,只需要将 yml 配置文件放在根目录下,然后写个 Test 类,调用里面的 castProperties 方法即可。

    YmlUtils.castProperties("application-test.yml");

     执行方法后,首先我们可以看到控制台会将 porperties 文件的内容打印到控制台上面:

    程序运行完成后,根目录下会多出一个与yml同名的properties文件,该文件就直接拷贝到相应的地方进行使用,而且原文件也并未收到任何损坏和影响。

    【源码展示】

    最后附上工具类源码,如果对你有用,记得一键三连(支持原创)。

    package com.test.utils;
    
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileWriter;
    import java.io.IOException;
    import java.nio.charset.StandardCharsets;
    import java.util.*;
    
    /**
     * Yaml 配置文件转 Properties 配置文件工具类
     * @author https://zyqok.blog.csdn.net/
     * @since 2021/08/24
     */
    public class YmlUtils {
    
        /**
         * 将 yml 文件转化为 properties 文件
         *
         * @param ymlFileName 工程根目录下(非resources目录)的 yml 文件名称(如:abc.yml)
         * @return List<Node> 每个Nyml 文件中每行对应解析的数据
         */
        public static List<YmlNode> castProperties(String ymlFileName) {
            if (ymlFileName == null || ymlFileName.isEmpty() || !ymlFileName.endsWith(".yml")) {
                throw new RuntimeException("请输入yml文件名称!!");
            }
            File ymlFile = new File(ymlFileName);
            if (!ymlFile.exists()) {
                throw new RuntimeException("工程根目录下不存在 " + ymlFileName + "文件!!");
            }
            String fileName = ymlFileName.split(".yml", 2)[0];
            // 获取文件数据
            String yml = read(ymlFile);
            List<YmlNode> nodeList = getNodeList(yml);
            // 去掉多余数据,并打印
            String str = printNodeList(nodeList);
            // 将数据写入到 properties 文件中
            String propertiesName = fileName + ".properties";
            File file = new File(propertiesName);
            if (!file.exists()) {
                try {
                    file.createNewFile();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            try (FileWriter writer = new FileWriter(file)) {
                writer.write(str);
                writer.flush();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return nodeList;
        }
    
        /**
         * 将yml转化为porperties文件,并获取转化后的键值对
         *
         * @param ymlFileName 工程根目录下的 yml 文件名称
         * @return 转化后的 porperties 文件键值对Map
         */
        public static Map<String, String> getPropertiesMap(String ymlFileName) {
            Map<String, String> map = new HashMap<>();
            List<YmlNode> list = castProperties(ymlFileName);
            for (YmlNode node : list) {
                if (node.getKey().length() > 0) {
                    map.put(node.getKey(), node.getValue());
                }
            }
            return map;
        }
    
        private static String read(File file) {
            if (Objects.isNull(file) || !file.exists()) {
                return "";
            }
            try (FileInputStream fis = new FileInputStream(file)) {
                byte[] b = new byte[(int) file.length()];
                fis.read(b);
                return new String(b, StandardCharsets.UTF_8);
            } catch (IOException e) {
                e.printStackTrace();
            }
            return "";
        }
    
        private static String printNodeList(List<YmlNode> nodeList) {
            StringBuilder sb = new StringBuilder();
            for (YmlNode node : nodeList) {
                if (node.getLast().equals(Boolean.FALSE)) {
                    continue;
                }
                if (node.getEmptyLine().equals(Boolean.TRUE)) {
                    System.out.println();
                    sb.append("\r\n");
                    continue;
                }
                // 判断是否有行级注释
                if (node.getHeadRemark().length() > 0) {
                    String s = "# " + node.getHeadRemark();
                    System.out.println(s);
                    sb.append(s).append("\r\n");
                    continue;
                }
                // 判断是否有行末注释 (properties中注释不允许末尾注释,故而放在上面)
                if (node.getTailRemark().length() > 0) {
                    String s = "# " + node.getTailRemark();
                    System.out.println(s);
                    sb.append(s).append("\r\n");
                }
                //
                String kv = node.getKey() + "=" + node.getValue();
                System.out.println(kv);
                sb.append(kv).append("\r\n");
            }
            return sb.toString();
        }
    
        private static List<YmlNode> getNodeList(String yml) {
            String[] lines = yml.split("\r\n");
            List<YmlNode> nodeList = new ArrayList<>();
            Map<Integer, String> keyMap = new HashMap<>();
            Set<String> keySet = new HashSet<>();
            for (String line : lines) {
                YmlNode node = getNode(line);
                if (node.getKey() != null && node.getKey().length() > 0) {
                    int level = node.getLevel();
                    if (level == 0) {
                        keyMap.clear();
                        keyMap.put(0, node.getKey());
                    } else {
                        int parentLevel = level - 1;
                        String parentKey = keyMap.get(parentLevel);
                        String currentKey = parentKey + "." + node.getKey();
                        keyMap.put(level, currentKey);
                        node.setKey(currentKey);
                    }
                }
                keySet.add(node.getKey() + ".");
                nodeList.add(node);
            }
            // 标识是否最后一级
            for (YmlNode each : nodeList) {
                each.setLast(getNodeLast(each.getKey(), keySet));
            }
            return nodeList;
        }
    
        private static boolean getNodeLast(String key, Set<String> keySet) {
            if (key.isEmpty()) {
                return true;
            }
            key = key + ".";
            int count = 0;
            for (String each : keySet) {
                if (each.startsWith(key)) {
                    count++;
                }
            }
            return count == 1;
        }
    
        private static YmlNode getNode(String line) {
            YmlNode node = new YmlNode();
            // 初始化默认数据(防止NPE)
            node.setEffective(Boolean.FALSE);
            node.setEmptyLine(Boolean.FALSE);
            node.setHeadRemark("");
            node.setKey("");
            node.setValue("");
            node.setTailRemark("");
            node.setLast(Boolean.FALSE);
            node.setLevel(0);
            // 空行,不处理
            String trimStr = line.trim();
            if (trimStr.isEmpty()) {
                node.setEmptyLine(Boolean.TRUE);
                return node;
            }
            // 行注释,不处理
            if (trimStr.startsWith("#")) {
                node.setHeadRemark(trimStr.replaceFirst("#", "").trim());
                return node;
            }
            // 处理值
            String[] strs = line.split(":", 2);
            // 拆分后长度为0的,属于异常数据,不做处理
            if (strs.length == 0) {
                return node;
            }
            // 获取键
            node.setKey(strs[0].trim());
            // 获取值
            String value;
            if (strs.length == 2) {
                value = strs[1];
            } else {
                value = "";
            }
            // 获取行末备注
            String tailRemark = "";
            if (value.contains(" #")) {
                String[] vs = value.split("#", 2);
                if (vs.length == 2) {
                    value = vs[0];
                    tailRemark = vs[1];
                }
            }
            node.setTailRemark(tailRemark.trim());
            node.setValue(value.trim());
            // 获取当前层级
            int level = getNodeLevel(line);
            node.setLevel(level);
            node.setEffective(Boolean.TRUE);
            return node;
        }
    
        private static int getNodeLevel(String line) {
            if (line.trim().isEmpty()) {
                return 0;
            }
            char[] chars = line.toCharArray();
            int count = 0;
            for (char c : chars) {
                if (c != ' ') {
                    break;
                }
                count++;
            }
            return count / 2;
        }
    }
    
    class YmlNode {
    
        /** 层级关系 */
        private Integer level;
        /** 键 */
        private String key;
        /** 值 */
        private String value;
        /** 是否为空行 */
        private Boolean emptyLine;
        /** 当前行是否为有效配置 */
        private Boolean effective;
        /** 头部注释(单行注释) */
        private String headRemark;
        /** 末尾注释 */
        private String tailRemark;
        /** 是否为最后一层配置 */
        private Boolean last;
    
        public Boolean getLast() {
            return last;
        }
    
        public void setLast(Boolean last) {
            this.last = last;
        }
    
        public Integer getLevel() {
            return level;
        }
    
        public void setLevel(Integer level) {
            this.level = level;
        }
    
        public String getKey() {
            return key;
        }
    
        public void setKey(String key) {
            this.key = key;
        }
    
        public String getValue() {
            return value;
        }
    
        public void setValue(String value) {
            this.value = value;
        }
    
        public Boolean getEmptyLine() {
            return emptyLine;
        }
    
        public void setEmptyLine(Boolean emptyLine) {
            this.emptyLine = emptyLine;
        }
    
        public Boolean getEffective() {
            return effective;
        }
    
        public void setEffective(Boolean effective) {
            this.effective = effective;
        }
    
        public String getHeadRemark() {
            return headRemark;
        }
    
        public void setHeadRemark(String headRemark) {
            this.headRemark = headRemark;
        }
    
        public String getTailRemark() {
            return tailRemark;
        }
    
        public void setTailRemark(String tailRemark) {
            this.tailRemark = tailRemark;
        }
    
    }
    

    展开全文
  • 递归地将.env.yml和.env.yml.d/*.yml合并到进程环境中。 支持 YAML 锚点和别名,这是对配置文件直接 JSON 的巨大胜利。 文件:.env.yml 环境配置文件。 如果此处未提及,则不会包括在内。 目录:.env.yml.d/ 配置...
  • 解析yml文件 转换 Map

    万次阅读 2021-07-27 15:06:05
    有一个需求是把一个yml文件解析成HashMap格式的数据,文件内容如下 spring: datasource: serviceDB: jdbc-url: jdbc:mysql://127.0.0.1:3306/serviceDB password: test minimum-idle: 1 idle-timeout: 60000...
  • application.yml与bootstrap.yml的区别

    千次阅读 2022-03-12 11:16:07
    bootstrap.yml 和 application.yml 都可以用来配置参数。 bootstrap.yml 用来程序引导时执行,应用于更加早期配置信息读取。可以理解成系统级别的一些参数配置,这些参数一般是不会变动的。 application.yml 可以...
  • Java基础系列:读取yml文件

    千次阅读 2022-03-02 21:19:29
    通过yml映射实体,直接实例化实体。
  • Bootstrap.yml 和 application.yml

    千次阅读 2022-01-13 11:04:27
    bootstrap.yml文件也是Spring Boot的默认配置文件,而且其加载的时间相比于application.yml更早。 application.yml和bootstrap.yml虽然都是Spring Boot的默认配置文件,但是定位却不相同。 bootstrap.yml可以理解成...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 801,655
精华内容 320,662
关键字:

YML