精华内容
下载资源
问答
  • import org.springframework.beans.factory.config.YamlPropertiesFactoryBean; import org.springframework.core.io.ClassPathResource; import org.springframework.core.io.Resource; import java.util....
    import org.springframework.beans.factory.config.YamlPropertiesFactoryBean;
    import org.springframework.core.io.ClassPathResource;
    import org.springframework.core.io.Resource;
    
    import java.util.ArrayList;
    import java.util.List;
    import java.util.Properties;
    
    
    public class YamlPropertiesUtils {
        private static final String[] CONFIG_FILES = {"application.yml", "customdir/custom.yml", "aaa.yml"};
    
        public static Object getCommonYml(Object key){
            Properties properties = null;
            YamlPropertiesFactoryBean yamlFactory = new YamlPropertiesFactoryBean();
    
            List<Resource> resourceList = new ArrayList<>();
            for (String configFile: CONFIG_FILES)
            {
                Resource resource = new ClassPathResource(configFile);
                resourceList.add(resource);
            }
            Resource[] resourcesArr = resourceList.toArray(new Resource[resourceList.size()]);
            yamlFactory.setResources(resourcesArr);
    
            try {
                properties =  yamlFactory.getObject();
            } catch (Exception e) {
                e.printStackTrace();
                return null;
            }
            return properties.get(key);
        }
    }

    展开全文
  • 主要介绍了spring+apollo动态获取yaml格式的配置方式,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • 在resources目录下新建一个application.yaml[这个名字是固定的,约定读] server: port: 8081 conn: ip: 111 pwd: 222 maps: {ip: 192.168.5.1 ,port: 3306 } list: [192.16..5.2,3306] mysql_con...

    spring boot 项目推荐使用自动导入

    在resources目录下新建一个application.yaml[这个名字是固定的,约定读]

    server:
      port: 8081
    
    conn:
      ip: 111
      pwd: 222
      maps: {ip: 192.168.5.1 ,port: 3306 }
      list: [192.16..5.2,3306]
      mysql_con:
        ip : localhost
        port : 3306
    
    

    注意yaml写法中间有空格

    在项目启动主程序的包下新建bean包,在bean包下新建conn.class

    package com.yzs.spring_boot_02_yaml.bean;
    
    import org.springframework.boot.context.properties.ConfigurationProperties;
    import org.springframework.stereotype.Component;
    
    import java.util.List;
    import java.util.Map;
    
    @Component
    @ConfigurationProperties(prefix = "conn")
    public class conn {
        // 配置文件直接路径
        private String ip;
        private String pwd;
    
        // 从配置文件可以直接读取list
        private List<Object> list;
    
        // 从配置文件获取map数据
        private Map<String, Object> maps;
    
        // 从配置文件获取对象
        private Mysql_con mysql_con;

           get,set,string 方法...

     

    在测试目录下运行

    /*
    springboot的单元测试
    可以在测试阶段类似于编码一样,进行测试注入等容器的功能
     */
    
    @SpringBootTest
    class SpringBoot02YamlApplicationTests {
       //自动注入对象
       @Autowired
       conn con;
    
       @Test
       void contextLoads() {
          System.out.println(con);
       }

    输出结果

    conn{ip='111', pwd='222', list=[192.16..5.2, 3306], maps={ip=192.168.5.1, port=3306}, mysql_con=Mysql_con{ip='localhost', port=3306}}
     

     

     

     

     

    展开全文
  • SpringBoot支持使用Properties和YAML两种配置方式。两者功能类似,都能完成SpringBoot的配置,但是Properties的优先级要高于YAMLYAML语言的文件以“.yml”为后缀)。 使用application.yml文件配置SpringBoot项目...

    SpringBoot支持使用Properties和YAML两种配置方式。两者功能类似,都能完成SpringBoot的配置,但是Properties的优先级要高于YAML(YAML语言的文件以“.yml”为后缀)。

    使用application.yml文件配置SpringBoot项目。主要对SpringBoot项目的端口号、超时时间、参数值等进行配置。YAML文件的好处是——它采用的是树形结构,一目了然。如下:

    server:
      port: 8080
      servlet:
        session:
          timeout: 30M
      tomcat:
        uri-encoding: UTF-8
    userinfo:
      user-id: 1
      user-name: pan_junbiao的博客
      blog-url: https://blog.csdn.net/pan_junbiao
      hobbys: -[篮球,足球,羽毛球,乒乓球,游泳]
      blog-remark: 您好,欢迎访问 pan_junbiao的博客

    下面将介绍SpringBoot项目中获取YAML配置文件中的自定义属性值。

    1、方法一:使用@Value注解

    示例:创建 com.pjb.properties 包,创建 UserProperties类(用户配置信息类),并使用@Value注解注入配置文件内容,以装载配置文件的信息。

    package com.pjb.properties;
    
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.stereotype.Component;
    
    /**
     * 用户配置信息类
     * @author pan_junbiao
     **/
    @Component
    public class UserProperties
    {
        /**
         * 用户编号
         */
        @Value("${userinfo.user-id}")
        private int userId;
    
        /**
         * 用户名称
         */
        @Value("${userinfo.user-name}")
        private String userName;
    
        /**
         * 博客地址
         */
        @Value("${userinfo.blog-url}")
        private String blogUrl;
    
        /**
         * 兴趣爱好
         */
        @Value("${userinfo.hobbys}")
        private String[] hobbys;
    
        /**
         * 备注信息
         */
        @Value("${userinfo.blog-remark}")
        private String blogRemark;
    
        //省略getter与setter方法...
    }

    编写测试方法,获取用户YAML配置信息。

    import com.pjb.properties.UserProperties;
    import org.junit.jupiter.api.AfterEach;
    import org.junit.jupiter.api.BeforeEach;
    import org.junit.jupiter.api.Test;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.boot.test.context.SpringBootTest;
    import java.util.Arrays;
    
    /**
     * 用户配置测试类
     * @author pan_junbiao
     **/
    @SpringBootTest
    public class UserTest
    {
        @Autowired
        private UserProperties userProperties;
    
        /**
         * 获取用户YAML配置信息
         * @author pan_junbiao
         */
        @Test
        public void getUserProperties()
        {
            System.out.println("获取application.yml配置文件中的信息:");
            System.out.println("用户编号:" + userProperties.getUserId());
            System.out.println("用户名称:" + userProperties.getUserName());
            System.out.println("博客地址:" + userProperties.getBlogUrl());
            System.out.println("兴趣爱好:共" + userProperties.getHobbys().length + "个," + Arrays.toString(userProperties.getHobbys()));
            System.out.println("备注信息:" + userProperties.getBlogRemark());
        }
    }

    执行结果:

     

    2、方法二:使用@ConfigurationProperties注解

    示例:修改 UserProperties类(用户配置信息类),使用@ConfigurationProperties注解处理配置文件中以 “userinfo” 为前缀的配置项的值,以装载配置文件的信息。

    package com.pjb.properties;
    
    import org.springframework.boot.context.properties.ConfigurationProperties;
    import org.springframework.stereotype.Component;
    
    /**
     * 用户配置信息类
     * @author pan_junbiao
     **/
    @Component
    @ConfigurationProperties(prefix = "userinfo")
    public class UserProperties
    {
        /**
         * 用户编号
         */
        private int userId;
    
        /**
         * 用户名称
         */
        private String userName;
    
        /**
         * 博客地址
         */
        private String blogUrl;
    
        /**
         * 兴趣爱好
         */
        private String[] hobbys;
    
        /**
         * 备注信息
         */
        private String blogRemark;
    
        //省略getter与setter方法...
    }

    代码说明:

    @Component注解:声明此类是Spring管理类。

    @ConfigurationProperties注解:把同类配置信息自动封装成一个实体类。其属性 prefix 代表配置文件中配置项的前缀,如在配置文件中定义的“userinfo”。

    还可以把@ConfigurationProperties注解直接定义在@Bean注解里,这时Bean实体类就不需要@Component注解和@ConfigurationProperties注解了,在调用时依然一样调用,如下代码:

    @Bean
    @ConfigurationProperties(prefix = "userinfo")
    public UserInfo userInfo()
    {
        return new UserInfo();
    }

    执行结果:

     

    3、方法三:使用参数的形式

    示例:创建 RedisConfig.java 文件用于读取 application.yml 文件的配置信息。

    /**
     * Redis配置类
     * @author pan_junbiao
     **/
    @Configuration
    public class RedisConfig
    {
        /**
         * Jedis连接池
         */
        @Bean("jedis.pool")
        @Autowired
        public JedisPool jedisPool(@Qualifier("jedis.pool.config") JedisPoolConfig config,
                                   @Value("${spring.redis.host}") String host,
                                   @Value("${spring.redis.port}") int port)
        {
            return new JedisPool(config, host, port);
        }
    
        /**
         * Jedis连接池配置信息
         */
        @Bean(name = "jedis.pool.config")
        public JedisPoolConfig jedisPoolConfig(@Value("${spring.redis.jedis.pool.max-active}") int maxActive,
                                               @Value("${spring.redis.jedis.pool.max-wait}") Duration maxWait,
                                               @Value("${spring.redis.jedis.pool.max-idle}") int maxIdle,
                                               @Value("${spring.redis.jedis.pool.min-idle}") int minIdle)
        {
            JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
    
            //连接池最大连接数(使用负值表示没有限制)
            jedisPoolConfig.setMaxTotal(maxActive);
    
            //连接池最大阻塞等待时间(使用负值表示没有限制)
            jedisPoolConfig.setMaxWaitMillis(maxWait.toMillis());
    
            //连接池中的最大空闲连接
            jedisPoolConfig.setMaxIdle(maxIdle);
    
            //连接池中的最小空闲连接
            jedisPoolConfig.setMinIdle(minIdle);
    
            return jedisPoolConfig;
        }
    }

     

    4、综合实例

    实例:在 application.yml 配置文件中配置 Redis 信息,创建 RedisConfig.java 类(Redis配置类),初始化 Redis 服务。

    (1)在 application.yml 配置文件中配置 Redis 信息。

    spring:
      redis:
        database: 0 #Redis数据库索引(默认为0)
        host: 127.0.0.1 #Redis服务器地址
        port: 6379 #Redis服务器连接端口
        password:  #Redis服务器连接密码(默认为空)
        jedis:
          pool:
            max-active: 8 #连接池最大连接数(使用负值表示没有限制)
            max-wait: -1s #连接池最大阻塞等待时间(使用负值表示没有限制)
            max-idle: 8  #连接池中的最大空闲连接
            min-idle: 0 #连接池中的最小空闲连接
        lettuce:
          shutdown-timeout: 100ms #关闭超时时间,默认值100ms

    (2)创建 RedisProperties.java(Redis配置属性类),并使用@Value注解注入配置文件内容,以装载配置文件的信息。

    package com.pjb.ems.properties;
    
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.stereotype.Component;
    
    import java.time.Duration;
    
    /**
     * Redis配置属性类
     * @author pan_junbiao
     **/
    @Component
    public class RedisProperties
    {
        /**
         * Redis数据库索引
         */
        @Value("${spring.redis.database}")
        private int database;
    
        /**
         * Redis服务器地址
         */
        @Value("${spring.redis.host}")
        private String host;
    
        /**
         * Redis服务器连接端口
         */
        @Value("${spring.redis.port}")
        private int port;
    
        /**
         * Redis服务器连接密码
         */
        @Value("${spring.redis.port}")
        private String password;
    
        /**
         * 连接池最大连接数
         */
        @Value("${spring.redis.jedis.pool.max-active}")
        private int maxActive;
    
        /**
         * 连接池最大连接数
         */
        @Value("${spring.redis.jedis.pool.max-wait}")
        private Duration maxWait;
    
        /**
         * 连接池中的最大空闲连接
         */
        @Value("${spring.redis.jedis.pool.max-idle}")
        private int maxIdle;
    
        /**
         * 连接池中的最小空闲连接
         */
        @Value("${spring.redis.jedis.pool.min-idle}")
        private int minIdle;
    
        public int getDatabase()
        {
            return database;
        }
    
        public void setDatabase(int database)
        {
            this.database = database;
        }
    
        public String getHost()
        {
            return host;
        }
    
        public void setHost(String host)
        {
            this.host = host;
        }
    
        public int getPort()
        {
            return port;
        }
    
        public void setPort(int port)
        {
            this.port = port;
        }
    
        public String getPassword()
        {
            return password;
        }
    
        public void setPassword(String password)
        {
            this.password = password;
        }
    
        public int getMaxActive()
        {
            return maxActive;
        }
    
        public void setMaxActive(int maxActive)
        {
            this.maxActive = maxActive;
        }
    
        public Duration getMaxWait()
        {
            return maxWait;
        }
    
        public void setMaxWait(Duration maxWait)
        {
            this.maxWait = maxWait;
        }
    
        public int getMaxIdle()
        {
            return maxIdle;
        }
    
        public void setMaxIdle(int maxIdle)
        {
            this.maxIdle = maxIdle;
        }
    
        public int getMinIdle()
        {
            return minIdle;
        }
    
        public void setMinIdle(int minIdle)
        {
            this.minIdle = minIdle;
        }
    }

    (3)创建 RedisConfig.java 类(Redis配置类),初始化 Redis 服务。

    /**
     * Redis配置类
     * @author pan_junbiao
     **/
    @Configuration
    public class RedisConfig
    {
        @Autowired
        private RedisProperties redisProperties;
    
        /**
         * Jedis连接池
         */
        @Bean("jedis.pool")
        @Autowired
        public JedisPool jedisPool(@Qualifier("jedis.pool.config") JedisPoolConfig config)
        {
            return new JedisPool(config, redisProperties.getHost(), redisProperties.getPort());
        }
    
        /**
         * Jedis连接池配置信息
         */
        @Bean(name = "jedis.pool.config")
        public JedisPoolConfig jedisPoolConfig()
        {
            JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
    
            //连接池最大连接数(使用负值表示没有限制)
            jedisPoolConfig.setMaxTotal(redisProperties.getMaxActive());
    
            //连接池最大阻塞等待时间(使用负值表示没有限制)
            jedisPoolConfig.setMaxWaitMillis(redisProperties.getMaxWait().toMillis());
    
            //连接池中的最大空闲连接
            jedisPoolConfig.setMaxIdle(redisProperties.getMaxIdle());
    
            //连接池中的最小空闲连接
            jedisPoolConfig.setMinIdle(redisProperties.getMinIdle());
    
            return jedisPoolConfig;
        }
    }

     

    展开全文
  • YAMLDemo Spring Boot 2.0获取自定义YAML配置Demo 使用YamlPropertySourceLoader加载自定义YAML配置文件
  • yaml中配置: permission: method: POST path: auth/login** spring boot: 在需要使用到该配置的controller或者service或者专门的配置,添加method和path字段,注意要添加getter和setter import org...

    一、获取对象

    例子:

    yaml中的配置:

    permission:
       method: POST
       path: auth/login**

    spring boot 中:

    在需要使用到该配置的controller或者service或者专门的配置类中,添加method和path字段,注意要添加getter和setter

    import org.springframework.boot.context.properties.ConfigurationProperties;
    
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    
    @ConfigurationProperties(prefix = "permission")
    public class AuthConfig  {
        private String method;
        private String path;
       
        @Bean
        public Auth getAuth()
        {
    
            System.out.println(method+path);
        }
    
        public String getMethod() {
            return method;
        }
    
        public void setMethod(String method) {
            this.method = method;
        }
    
        public String getPath() {
            return path;
        }
    
        public void setPath(String path) {
            this.path = path;
        }
    
    }
    
    

    二、获取对象数组

    例子:

    yaml中的配置

    permissions:
      list: 
       - method: POST
         path: auth/login/*
       - method: POST
         path: auht/login/

    spring boot中

    先定义一个Permission类,该类至少要包含method和path字段。然后在需要使用该配置的类中,添加一个list字段,该字段名与yaml中permissions下的list属性对应。

     

    
    
    import org.springframework.boot.context.properties.ConfigurationProperties;
    
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    
    import windcore.authservice.model.myBatisEntity.Permission;
    
    import java.util.List;
    
    
    /**
     * 
     *
     * @Description:权限拦截器配置
    
     */
    @Configuration
    @ConfigurationProperties(prefix = "permission")
    public class AuthConfig  {
    
        private List<Permission>list;
        @Bean
        public Auth getAuth()
        {
            Auth auth=new Auth();
            for (Permission permission:list
                 ) {
                auth.ignore(permission.getMethod(),permission.getPath());
            }
    
    
    
            return auth;
        }
    
    
        public List<Permission> getList() {
            return list;
        }
    
        public void setList(List<Permission> list) {
            this.list = list;
        }
    }

     

    展开全文
  • 获取项目yaml配置

    2020-05-08 11:07:07
    } } 获取配置 ApplicationContextHelper.applicationContext.getEnvironment().getProperty("config") application.yaml config: xxx 学习Java的同学注意了!!! 学习过程遇到什么问题或者想获取学习资源的话,...
  • YAML配置,yaml配置中使用随机数

    千次阅读 2019-08-09 17:51:27
    YAML配置,spring boot 配置文件
  • spring+apollo动态获取yaml格式的配置

    千次阅读 2019-09-27 13:40:01
    默认spring装载的都是.properties格式的配置文件,但是有时我们需要定义list或者map类型的配置,那么yaml就具有优势。 以下演示利用apollo来完成自动更新ip白名单的功能 1.重写配置工厂 public class ...
  • java 获取yaml中常量

    2019-07-29 16:32:30
    获取age和name 方法1:@value import org.springframework.beans.factory.annotation.Value; 方法2:引入环境变量 Environment import org.springframework.core.env.Environment; 方法3: @...
  • SpringBoot配置——yaml配置文件值获取

    千次阅读 2020-03-25 11:08:04
    YAML语法可以参考《YAML文件的基本语法》 application.properties和application.yml都是SpringBoot的配置文件,它们位于src/main/resources目录下,专门用于修改默认配置的。 1、首先在src/main/resources目录下...
  • c++ 开发利用yaml-cpp读写yaml配置文件

    万次阅读 多人点赞 2019-04-25 14:27:47
    在程序员的开发生涯,读写配置文件必不可少。 配置文件有利于我们灵活配置工程,解决大量重复...今天的博文介绍的是如何在 C++ 开发利用 yaml-cpp 开源库读写 yaml 配置文件。 如果有 Python 开发经验的同学...
  • yaml注入配置文件

    2021-01-26 20:30:07
    yaml注入配置文件 1、在springboot项目的resources目录下新建一个文件 application.yml 2、编写一个实体类 Dog; @Component //注册bean到容器 public class Dog { private String name; private Integer ...
  • 1.前言 关于yaml和ini的相关理论暂不做记录,不影响代码编写,百度即可。 2.关于配置文件的选择 yaml 和 ini 都使用过, 但是yaml更符合人类...3.1 先创建yaml文件,并书写相关配置数据。 ​​​ ​​ ​ ...
  • 在项目获取配置文件的值有如下几种方法: 1.在工具类中获取,写一个工具类,在工具类指定配置文件名。这种情况网上很多博客都是这种操作,太low,太不灵活,如果存在多环境的配置文件,就不能用该方法。 2...
  • SpringBoot使用一个全局的配置文件,也就是下面这两个的任意一个SpringBoot都会把它当做配置文件,配置文件名是固定的 application.properties application.yml 配置文件的作用:修改SpringBoot自动配置的默认值;...
  • yaml配置文件值获取

    2020-04-14 13:45:19
    一:配置文件值注入 配置文件编写application.yml person: lastName: dhx age: 25 boss: dhx birth: 1994/02/10 maps: {k1: v1,k2: w2} lists: [a1,22] dog: name: dog age: 4 javaBean /* 将配置...
  • 官方推荐yaml配置 yaml语法: 可以注入到配置类 绑定起来,就有注入的值, 测试一下 以后redis,Template全部写在yaml,去获取。 全局配置,配置类和配置文件绑定,通过@ConfigurationProperties(prefix =...
  • YAML 配置文件值获取
  • yaml文件配置随机数

    千次阅读 2018-09-08 18:27:15
      ...在yaml配置文件使用${random.int}即可获得一个随机的int型数据。 名称 描述 ${random.value} 取得随机字符串 ${random.int} 取得随机int...
  • python读取yaml文件配置

    2021-03-09 18:00:35
    yaml文件示例 python 代码 import os, yaml from rest_framework.views import APIView from rest_framework.response import Response Base_dir = os.path.dirname(os.path.abspath(__file__)) yamlpath = os....
  • 一、简介 搞Spring Boot的小伙伴都知道,Spring Boot的配置文件有两种格式,properties或者yaml,一般情况下,两者可以随意使用,选择自己顺手的就行了,那么这...本文就来和大伙重点介绍下yaml配置,最后再来...
  • python读取yaml配置文件

    万次阅读 2018-04-20 21:43:19
    yaml 是专门用来写配置文件的语言,非常简洁和强大,之前用ini也能写配置文件,看了yaml后,发现这个更直观,更方便,有点类似于json格式2.yaml基本语法规则:大小写敏感使用缩进表示层级关系缩进时不允许使用Tab键,...
  • 配置文件中配置的每一个属性的值,映射到这个组件 @ConfigurationProperties:告诉SpringBoot将本类的所有属性和配置文件相关的配置进行绑定; prefix = "person":配置文件哪个下面的所有属性进行一一...
  • 1.springboot的appliaciton.yaml配置原理 application.yaml文件的属性配置是如何在springboot生效呢? 我们又能配置些什么呢? application.yaml与spring.factories有巨大的联系. 回到自动装配原理,在springboot...
  • 如果说,我们只是在某个业务逻辑需要获取一下配置文件的某项值,使用@Value; 如果说,我们专门编写了一个javaBean来和配置文件进行映射,我们就直接使用@ConfigurationProperties; properties 写中文乱码...
  • robot framework 与yaml 第八天:yaml文件支持函数配置

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 43,835
精华内容 17,534
关键字:

获取yaml中的配置