精华内容
下载资源
问答
  • 关于Java类读取 application.yml 配置文件里的的问题。 目前我所了解的主要是三种方式: ①@Value("${xxxx}") ② ConfigurationProperties 配置 ③ 通过 Enviroment 获取 这里只介绍第三种静态工具JdbcUtil ...

     关于Java类读取 application.yml 配置文件里的值的问题。 目前我所了解的主要是三种方式:

    ①@Value("${xxxx}")

    ② ConfigurationProperties 配置

    ③ 通过 Enviroment 获取

    这里只介绍第三种静态工具类JdbcUtil 里获取 application.yml 里的数据源信息(user) 解决代码如下

    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.core.env.Environment;
    import org.springframework.stereotype.Component;
    
    import javax.annotation.PostConstruct;

     

     
    

    其他地方使用,只需要通过get方法即可获取到;

     

    展开全文
  • 目录 1.读取配置文件到实体 ...2.读取配置文件静态变量 1.读取配置文件到实体 在实际开发中,我们知道数据库的配置信息不能在代码中写死,得放到配置文件中,动态的去读取,这样当我们修改数据库密码

    目录

    1.读取配置文件到实体类
     1.1 配置文件和实体类准备
     1.2 读取配置文件到实体类的方法
      1.2.1 @Value注解
      1.2.2 @ConfigurationProperties注解
      1.2.3 @PropertySource注解加载其他配置文件
      1.2.4 @ImportResource注解应用xml配置文件
    2.读取配置文件到静态变量
     2.1 在方法上添加@Value注解
     2.2 使用@PostConstruct注解在初始化Servlet之前初始化静态变量

    1.读取配置文件到实体类

    在实际开发中,我们知道数据库的配置信息不能在代码中写死,得放到配置文件中,动态的去读取,这样当我们修改数据库密码或者其他参数的时候,就不用重新编译和打包了,直接修改配置文件即可。所以,和数据源类似,有时我们需要从配置文件中读取数据到实体类中。

    1.1 配置文件和实体类准备

    首先在SpringBoot的application.yml 配置文件中配置示例数据emp:

    server:
      port: 80
    #emp的配置数据
    emp:
      name: korbin
      age: 21
      map:
        key1: value1
        key2: value2
      list:
        - one
        - two
        - three
      forte:
        name: java
        time: 8
    

    示例实体类emp,必须包含set方法才能实现后续将从配置文件中读取的值注入到实体类的对应变量中:

    public class Emp{
        private String name;
        private int age;
        private Map map;
        private List list;
        private Forte forte;
    
        @Override
        public String toString() {
            return "Emp{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    ", map=" + map +
                    ", list=" + list +
                    ", forte=" + forte +
                    '}';
        }
    
        public void setName(String name) {this.name = name;}
    
        public void setAge(int age) {this.age = age;}
    
        public void setMap(Map map) {this.map = map;}
    
        public void setList(List list) {this.list = list;}
    
        public void setForte(Forte forte) {this.forte = forte;}
    }
    

    1.2 读取配置文件到实体类的方法

    SpringBoot提供了多种注解来快速读取配置文件中值的方式,如下:

    1.2.1 @Value注解

    首先需要在实体类上添加@Component注解表示将该实体类放入到Spring容器中,然后只需要在每个成员变量上添加@Value注解即可,注解中的参数值为配置文件中的参数名,并用${}包起来:

    @Component
    public class Emp{
        @Value("${emp.name}")
        private String name;
        @Value("${emp.age}")
        private int age;
        private Map map;//Map和List和对象不能使用@Value
        private List list;//Map和List和对象不能使用@Value
        private Forte forte;//Map和List和对象不能使用@Value
    
        public void setName(String name) {this.name = name;}
    
        public void setAge(int age) {this.age = age;}
    
        public void setMap(Map map) {this.map = map;}
    
        public void setList(List list) {this.list = list;}
    
        public void setForte(Forte forte) {this.forte = forte;}
    }
    

    在测试类中进行测试,下述其他注解以同样方式测试,后文不再赘述。且为了表述简洁,实体类中的toString方法请自行添加:

    @RunWith(SpringRunner.class)
    @SpringBootTest
    public class HellospringbootApplicationTests {
    
        @Autowired
        private Emp emp;
        @Test
        public void contextLoads() {
            System.out.println(emp);
        }
    }
    

    注意:该注解仅能读取单个值,对于Map、List和Bean对象这类数据不能读取和自动注入,也就是说不能读取一系列的多个数据。 所以上述示例仅对name和age两个成员变量添加了@Value注解。

    1.2.2 @ConfigurationProperties注解

    对于@Value注解的局限性,@ConfigurationProperties注解对其进行了解决,该注解可以实现对配置文件中的属性值批量读取和注入。

    使用方法依旧是首先添加@Component注解将实体类放入到Spring容器中,然后添加@ConfigurationProperties注解,并指定该注解的prefix参数表示对应实体类的前缀:

    @Component
    @ConfigurationProperties(prefix = "emp")
    public class Emp{
        private String name;
        private int age;
        private Map map;
        private List list;
        private Forte forte;
    
        public void setName(String name) {this.name = name;}
    
        public void setAge(int age) {this.age = age;}
    
        public void setMap(Map map) {this.map = map;}
    
        public void setList(List list) {this.list = list;}
    
        public void setForte(Forte forte) {this.forte = forte;}
    }
    

    该注解可以实现对上述配置文件中的单个值、Map、List集合和其他对象的快速注入到实体类中。所以@Value@ConfigurationProperties 注解的差异在于:需要批量注入配置文件的属性值时用后者,需要指定单个属性值时用前者。

    1.2.3 @PropertySource注解加载其他配置文件

    上述的@ConfigurationProperties注解和 @ConfigurationProperties 注解默认都是从SpringBoot的全局配置文件application.properties/application.yml中获取的值。所有配置数据写在全局配置文件中,会显得配置文件过于臃肿和杂乱,所以可将和全局配置无关的配置参数(如上述的实体类参数)抽取出来,单独放到另一个局部配置文件中。这就是@PropertySource注解的作用,指定想要读取的配置文件的来源。

    首先将上述application.yml配置文件中的emp示例的配置数据全部抽取到新建的一个emp.properties 文件中,放到application的同级目录resources下。

    #emp的配置数据
    emp.name=korbin
    emp.age=21
    emp.map.key1=value1
    emp.map.key2=value3
    emp.list=one,two,three
    emp.forte.name=java
    emp.forte.time=10
    

    注解使用方法只需在上述注解使用的基础上,添加@PropertySource注解即可,将默认配置文件改为我们自己指定的配置文件,注解参数value属性是数组类型,用于指定配置文件位置。:

    @Component
    @ConfigurationProperties(prefix = "emp")
    @PropertySource(value = {"classpath:emp.properties"})
    public class Emp{
        private String name;
        private int age;
        private Map map;
        private List list;
        private Forte forte;
    
        public void setName(String name) {this.name = name;}
    
        public void setAge(int age) {this.age = age;}
    
        public void setMap(Map map) {this.map = map;}
    
        public void setList(List list) {this.list = list;}
    
        public void setForte(Forte forte) {this.forte = forte;}
    }
    

    1.2.4 @ImportResource注解应用xml配置文件

    SpringBoot提倡零配置, 即无xml配置,但是在实际开发中,可能有一些特殊要求必须使用 xml 配置;这时我们可以通过 Spring 提供的 @ImportResource 来应用 xml 配置文件。

    比如上述我们需要将一个实体类中的数据全部从配置文件中读取,所以我们除了上述SpringBoot本身就提供的便捷的注解之外,还可以直接在Spring的xml配置文件中配置实体类的属性值,直接在配置文件中配置相当于也实现了从配置文件中读取数据。

    @ImportResource的作用是加载Spring的xml配置文件的配置内容并应用到容器中使用:
    1.创建 resources/spring01.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="emp1" class="cn.korb1n.hellospringboot.bean.Emp"></bean>
    </beans>
    

    2.使用 @ImportResource注解标注在一个配置类上,实现将Spring的该配置文件加载应用到容器中,下例是主配置类:

    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    import org.springframework.context.annotation.ImportResource;
    
    @ImportResource(locations = {"classpath:spring01.xml"})
    @SpringBootApplication
    public class HellospringbootApplication {
    
    	public static void main(String[] args) {
         SpringApplication.run(HellospringbootApplication.class, args);
        }
    
    }
    

    单元测试:

    @RunWith(SpringRunner.class)
    @SpringBootTest
    public class HellospringbootApplicationTests {
    
        @Autowired
        private ApplicationContext applicationContext;
        @Test
        public void testXml(){
            //没有找到就报错
            System.out.println("empService:"+applicationContext.getBean("emp1"));
        }
    
    }
    

    @ImportResource注解实际提供的是一种向容器中注入组件的方式,同理,可以通过其他向容器中注入组件的方式来实现对实体类数据的解耦,如@@Configuration@Bean注解搭配等。

    2.读取配置文件到静态变量

    在使用阿里云的短信服务时,accessKeyId和accessSecret等参数不能在代码中写死,需要解耦,并且可能OSS对象存储也需要用到这个密钥,所以想到的方案是将这些参数放到一个静态变量中,供全局调用,然后静态变量中的值来源于配置文件。所以出现了需要读取配置文件到静态变量的需求。

    2.1 在方法上添加@Value注解

    上述描述的读取配置文件到实体类中@Value注解是添加在成员变量上,但对于静态成员变量就不行了,会是一个空值。但可以将其添加到set方法上,实现对静态变量的注入。另外,依旧是得在类上添加@Component注解,要注入就要放入容器嘛~

    AliyunParameter.properties配置文件:

    #阿里云短信服务的参数数据
    aliyun.accessKeyId=xxxxxxxxxxxx
    aliyun.accessSecret=yyyyyyyyyyyy
    aliyun.smsSignName=科彬个人社区
    aliyun.smsRegionId=cn-hangzhou
    aliyun.smsTemplateCode.REGISTER_CODE=SMS_1111111111
    aliyun.smsTemplateCode.VERIFY_CODE=SMS_222222222
    

    含静态变量的实体类:

    import java.util.Map;
    
    @PropertySource(value = {"classpath:AliyunParameter.properties"})
    @Component
    public class AliyunParameter {
        public static String accessKeyId;
        public static String accessSecret;
        public static String smsRegionId;
        public static String smsSignName;
        public static Map<String,String> smsTemplateCode;
    
    	@Value("${aliyun.accessKeyId}")
        public void setAccessKeyId(String accessKeyId){
            AliyunParameter.accessKeyId = accessKeyId;
        }
    
    }
    

    这种读取配置文件到静态变量的方式依旧存在@Value注解的局限性,只能注入单个变量,对于集合List、Map这类数据不能注入。

    2.2 使用@PostConstruct注解在初始化Servlet之前初始化静态变量

    @PostConstruct注解修饰的方法会在服务器加载Servlet的时候运行,并且只会被服务器执行一次。PostConstruct修饰的方法在其所在类的构造函数之后执行,Servlet的 init() 方法之前执行。通常我们在Spring框架中使用到@PostConstruct注解的方法在整个Bean初始化中的执行顺序为:Constructor(构造方法) -> @Autowired(依赖注入) -> @PostConstruct(注释的方法)

    创建一个配置类AliyunConfig,该配置类通过上述的@ConfigurationProperties注解将配置文件中的值注入到实体类中,然后再通过@PostConstruct注解对上述AliyunParameter类中的静态变量进行初始化:

    import org.springframework.boot.context.properties.ConfigurationProperties;
    import org.springframework.context.annotation.PropertySource;
    import org.springframework.stereotype.Component;
    
    import javax.annotation.PostConstruct;
    import java.util.Map;
    
    @PropertySource(value = {"classpath:AliyunParameter.properties"})
    @Component
    @ConfigurationProperties(prefix = "aliyun")
    public class AliyunConfig {
        private String accessKeyId;
        private String accessSecret;
        private String smsRegionId;
        private String smsSignName;
        private Map<String,String> smsTemplateCode;
    
        @PostConstruct
        public void aliyunParameterInit(){
            AliyunParameter.setParameter(this);
        }
    
        public String getAccessKeyId() {
            return accessKeyId;
        }
    
        public void setAccessKeyId(String accessKeyId) {
            this.accessKeyId = accessKeyId;
        }
    
        public String getAccessSecret() {
            return accessSecret;
        }
    
        public void setAccessSecret(String accessSecret) {
            this.accessSecret = accessSecret;
        }
    
        public String getSmsRegionId() {
            return smsRegionId;
        }
    
        public void setSmsRegionId(String smsRegionId) {
            this.smsRegionId = smsRegionId;
        }
    
        public String getSmsSignName() {
            return smsSignName;
        }
    
        public void setSmsSignName(String smsSignName) {
            this.smsSignName = smsSignName;
        }
    
        public Map<String, String> getSmsTemplateCode() {
            return smsTemplateCode;
        }
    
        public void setSmsTemplateCode(Map<String, String> smsTemplateCode) {
            this.smsTemplateCode = smsTemplateCode;
        }
    }
    

    调整包含静态变量的 AliyunParameter 类,提供一个set方法对静态变量进行赋值:

    import java.util.Map;
    
    public class AliyunParameter {
        public static String accessKeyId;
        public static String accessSecret;
        public static String smsRegionId;
        public static String smsSignName;
        public static Map<String,String> smsTemplateCode;
    
        public static void setParameter(AliyunConfig aliyunConfig) {
            AliyunParameter.accessKeyId = aliyunConfig.getAccessKeyId();
            AliyunParameter.accessSecret = aliyunConfig.getAccessSecret();
            AliyunParameter.smsRegionId = aliyunConfig.getSmsRegionId();
            AliyunParameter.smsSignName = aliyunConfig.getSmsSignName();
            AliyunParameter.smsTemplateCode = aliyunConfig.getSmsTemplateCode();
        }
    
        public static void print() {
            System.out.println("SmsParameter{" +
                    "regionId='" + smsRegionId + '\'' +
                    ", accessKeyId='" + accessKeyId + '\'' +
                    ", accessSecret='" + accessSecret + '\'' +
                    ", signName='" + smsSignName + '\'' +
                    ", templateCode=" + smsTemplateCode +
                    '}');
        }
    }
    
    展开全文
  • 在项目开发中,通常会将一些经常变动...而在项目上线的时候,为了方便后期运维,将配置写在代码里面的方式是肯定不行的了,这时需要将配置信息提取出来,放到配置文件中。下面是一种采用静态代码块配置静态变量的方法。

    在项目开发中,通常会将一些经常变动的配置提取出来,做成一个配置类,通过该类的静态属性来引用配置。而在项目上线的时候,为了方便后期运维,将配置写在代码里面的方式是肯定不行的了,这时需要将配置信息提取出来,放到配置文件中。下面是一种采用静态代码块配置静态变量的方法。
    java配置类,通过静态变量记录各种属性,在工程的其他方可以很方便的引用,可以根据配置文件里面配置的属性重新设置静态属性,如果没有配置文件则使用代码里面的默认值。
    Config .java

    package com.utils;
    
    import java.io.FileNotFoundException;
    import java.io.IOException;
    import java.io.InputStreamReader;
    import java.util.Properties;
    
    public class Config {
        /**是否调试模式*/
        public static boolean isDebug=false;
        /**登陆超时时间*/
        public static long activeTime=5000L;
        /**日志路径**/
        public static String log_path="/default_log/";
    
        static{
            Properties pro = new Properties();
            InputStreamReader in=null;
                try {
                    in=new InputStreamReader(Config.class.getResourceAsStream("/config.properties"),"utf-8");
                    pro.load(in);
                    isDebug=Boolean.parseBoolean(pro.getProperty("isDebug"));
                    activeTime=Long.parseLong(pro.getProperty("activeTime"));
                    log_path=pro.getProperty("log_path");
                    System.out.println("配置文件读取成功:\n{isDebug:"+isDebug+",activeTime:"+activeTime+",log_path:"+log_path);
                } catch (FileNotFoundException e) {
                    System.out.println("找不到配置文件");
                    e.printStackTrace();
                } catch (IOException e) {
                    e.printStackTrace();
                }finally {
                    if(in!=null){
                        try {
                            in.close();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }
                }
        }
        public static void main(String []ss){
            System.out.println("开始业务处理!");
        }
    }

    配置文件,放在项目根路劲下即可
    config.properties

    isDebug=true
    activeTime=20000
    log_path=/日志路径/log

    运行main方法,可以看到在方法执行之前,各静态属性已经根据配置config.properties中的值进行了赋值,以下是测试输出结果。

    配置文件读取成功:
    {isDebug:true,activeTime:20000,log_path:/日志路径/log
    开始业务处理!
    展开全文
  • springboot 项目 用到静态的工具来 引用配置(yml获取这 pro)文件中的 直接@Value("${xxx.xxx.xx}") 不可以 直接就不能用 结果: Environment environment = ApplicationContextUtils.get(Environment.class); ...

    事由:
    springboot 项目 用到静态的工具类来 引用配置(yml获取这 pro)文件中的值
    直接@Value("${xxx.xxx.xx}") 不可以 直接就不能用

    结果:

    Environment environment = ApplicationContextUtils.get(Environment.class);
    String value= environment.getProperty("配置文件中的路径 比如:(spring.boot.path)");
    

    此时的value 就是配置文件中你想要的值

    Environment 导包:

    import org.springframework.core.env.Environment;
    

    再配上 ApplicationContextUtils工具类

    import org.springframework.beans.BeansException;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.ApplicationContextAware;
    import org.springframework.context.annotation.Configuration;
    
    import java.util.Objects;
    
    @Configuration
    public class ApplicationContextUtils implements ApplicationContextAware {
    
        //定义静态的ApplicationContext对象
        private static ApplicationContext applicationContext;
    
        //重写 方法 并赋值
        @Override
        public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
            ApplicationContextUtils.applicationContext = applicationContext;
        }
    
        //调用上下文的getBean方法获取容器中的对象
        public static <T> T get(Class<T> clazz){
            return applicationContext.getBean(clazz);
        }
    
        public static Object get(String name) {
            return applicationContext.getBean(name);
        }
    
    }
    

    完美

    展开全文
  • 通过@value("${key}")的方式获取配置文件。 该(加注解@Component被Spring容器管理)里面的属性为static静态属性。此时 对应的的setter,getter按照默认的是分别为: @Value("${ss.name}") private static ...
  • 静态类读取配置文件

    2015-05-27 18:05:00
    InputStream in=ConfInfo.class.getClassLoader().getResourceAsStream("conifg.properties"); 转载于:https://www.cnblogs.com/yan456jie/p/5369464.html
  • 静态方法获取配置文件中配置的

    千次阅读 2019-08-27 11:09:58
    在开发中写Utils需要使用很多静态方法,但是直接通过@Value的方法,会获取不到配置文件 @Value("${file.dir}") private String fileDir; 解决方法: 首先要将标注@Component @Component public final class ...
  • 需求:写了一个工具,但是工具中的一些变量需要放到配置文件中,而这个工具...我的工具ClientUtil,setConfigInfo()方法用来供读取配置文件的Config调用来进行对静态变量赋值: public class ClientU...
  • springboot从配置文件读取值注入静态属性

    千次阅读 多人点赞 2020-08-11 15:06:50
    应用开发中,经常会使用到一些配置信息,这些配置信息通常会配置到yml配置文件中并且可能会提供给一些静态方法使用 1.yml配置参数信息 ali: topPrefix: topPrefix accessKey: accessKey accessSecret: ...
  • Java类获取配置文件中的静态常量通过注解方式获取常量@Value注解进行配置文件信息的获取@ConfigurationProperties注解获取配置文件 通过注解方式获取常量 当我们在编写代码过程中,部分常量信息可能需要多处公用...
  • 例如,application-dev.properties 配置文件有如下配置: 给普通变量赋值时,直接在变量声明之上添加@Value()注解即可,如下所示: 当要给静态变量注入的时候,若是在静态变量声明之上直接添加@Value()注解是...
  • properties文件获取工具静态加载properties配置文件,有根据key获取值的方法
  • 但是在我们静态资源获取xxx.properties配置文件中的时,不能采用Spring原始注解的方法@Value(${xxxx})获取,因为Static静态资源加载的顺序在Spring容器加载之前,所以无法读取xxx.properties中的;如果需要静态...
  • @Value my.test=demo private static String test; @Value("${my.test}") public void setTest(String test) { TestController.test = test;...//上需要打上@Component注解,把交给Spring来管理 //把se...
  • 和普通的变量不一样,static修饰的静态变量直接用@Value注解是获取不到对应的配置文件中的的,需要通过set函数来设置,且set函数无需用static修饰,先记录一下,原理暂时未知,猜想有可能是和static变量加载的顺序...
  • springboot引用静态资源static中变量常用方法,经常用到的是非静态变量,在需求方法中引入比较容易配置,当遇到静态变量时常出现错误,本文档为手动操作样例与结构展示
  • springBoot中static静态工具方法获取配置文件属性 参考网址: https://mp.weixin.qq.com/s/iOWdDnPt5aQaHR9gRjwtAA ...
  • 文章目录SpringBoot 从配置文件获取属性初始化静态变量1、Configurations配置2、my.properties配置文件 SpringBoot 从配置文件获取属性初始化静态变量 1、Configurations配置 import org.spring...
  • 静态变量与非静态变量获取配置文件application中变量的区别 在项目配置文件application.yml或者application.properties中添加两个变量并赋值 value: 127.0.0.1:8081 staticvalue: 127.0.0.1:8081 在controller...
  • springboot如何在静态类获取配置? 以下所有示例都通过验证。 1.定义配置文件格式 这里主要指常见的配置文件:properties, yaml. 当然,json也可以作为配置,不过不是首选。 使用的配置文件: application....
  • # 使用注解或其他静态注入的方法 这里不讨论 相关文章:https://blog.csdn.net/5iasp/article/details/46652115 https://blog.csdn.net/z69183787/article/details/39343259 Java Field 详解 ...
  • @Component public class UploadFileUtil{ private static String signReplacePath; @Value("${file.replacePath}") private void setReplacePath(String replacePath){ signReplacePath = replacePath;...
  • 在springboot项目中,静态工具无法使用@Value来自动注入配置文件,但是工具中会需要读取配置的情况 解决方案: private static String ClassPathResource = "application.yml"; WritableResource ...
  • static静态方法使用yml配置文件

    千次阅读 热门讨论 2018-11-20 18:42:54
    java正常获取yml配置文件,可以使用@value注解获取,如下: 但是我们经常会写util等,里面的方法都是静态static的,这种情况下我们就没法像普通方法一样获取到yml的配置了,此时我们应该怎么获取呢? 1.在...
  • * <p>Description:读取properties文件 * * @Author: Austin **/ @Component public class ESParams { public static String esIpNode; public static String clusterName; public static String ...
  • 需求:工具中方法一般是static的,一般不会把工具作为bean放在spring容器中,无法使用@Value等注解注入配置文件的配置项 注意:getPropertry只能读取value为String的配置项,无法读取配置项应尝试使用get ...
  • 1 读取配置文件到常量中 大家熟知的方式是将配置文件注入到一个bean中去访问,但是这种方式每次使用这个bean都要写一个注入@Autowired去引用这个bean不是很方便,如果将配置文件注入到一个配置常量用,那么每次访问...
  • 可以两种方式读取test.properties配置文件 第一种:此方法可以写配置文件的绝对路径 InputStream is = new BufferedInputStream(new FileInputStream(new File("F:\\java\\idea-workspace\\javaDemoForTest\\src\...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 220,327
精华内容 88,130
关键字:

获取配置文件值静态类