前言：在我们的日常编程中难免会有些我们自定义的配置，虽然Java中提供了很多的读取配置文件的方法，但是当我们需要修改配置文件的key的时候，就会发现太过散乱了，工作量也会很大，涉及的文件还很多，一不小心就要出问题。那这个时候如果我们能够把所有的配置的key都放到一个文件中，其他文件需要获取配置的时候都调用这个文件，那么即使不管怎么修改配置配置文件的key，我也只需要修改这个文件，刚才的问题不就得到了完美的解决了么
 
废话不多说，直接上代码
 
项目目录结构
 

 
maven依赖：
 

 

 
4.0.0
 
org.springframework.boot
 
spring-boot-starter-parent
 
2.1.5.RELEASE
 
com.sxy
 
properties-read-demo
 
0.0.1-SNAPSHOT
 
properties-read-demo
 
Demo project for Spring Boot
 
1.8
 
2.5
 
org.springframework.boot
 
spring-boot-starter
 
org.projectlombok
 
lombok
 
true
 
commons-io
 
commons-io
 
${commons.io.version}
 
org.springframework.boot
 
spring-boot-starter-test
 
test
 
org.junit.vintage
 
junit-vintage-engine
 
org.springframework.boot
 
spring-boot-maven-plugin
 
pom.xml
 
自定义配置文件：
 

 

 
this.custom.config.content = 这是我的自定义配置内容
 
custom-config.properties
 
配置文件加载类：
 

 

 
packagecom.sxy.propertiesreaddemo.utils;importlombok.extern.slf4j.Slf4j;importorg.apache.commons.io.IOUtils;importorg.springframework.core.io.DefaultResourceLoader;importorg.springframework.core.io.Resource;importorg.springframework.core.io.ResourceLoader;importjava.io.IOException;importjava.io.InputStream;importjava.util.NoSuchElementException;importjava.util.Properties;/*** @Description 文件载入工具类.
 
* 可载入多个properties文件,
 
* 相同的属性在最后载入的文件中的值将会覆盖之前的值，但以System的Property优先.
 
* @Author SuXingYong
 
* @Date 2020/7/11 20:55
 
**/@Slf4jpublic classPropertiesLoader {private static ResourceLoader resourceLoader = newDefaultResourceLoader();private finalProperties properties;publicPropertiesLoader(String... resourcesPaths) {
 
properties=loadProperties(resourcesPaths);
 
}/*** @Description 取出Property，但以System的Property优先,取不到返回空字符串.
 
* @Author SuXingYong
 
* @Date 2020/7/11 20:55
 
* @Param [key]
 
*@paramkey 配置文件的key
 
* @Return java.lang.String
 
**/
 
privateString getValue(String key) {
 
String systemProperty=System.getProperty(key);if (systemProperty != null) {returnsystemProperty;
 
}if(properties.containsKey(key)) {returnproperties.getProperty(key);
 
}return "";
 
}/*** @Description 取出String类型的Property，但以System的Property优先,如果都为Null则抛出异常.
 
* @Author SuXingYong
 
* @Date 2020/7/11 20:55
 
* @Param [key]
 
* @Return java.lang.String
 
**/
 
publicString getProperty(String key) {
 
String value=getValue(key);if (value == null) {throw newNoSuchElementException();
 
}returnvalue;
 
}/*** @Description 载入多个文件, 文件路径使用Spring Resource格式.
 
* @Author SuXingYong
 
* @Date 2020/7/11 20:55
 
* @Param [resourcesPaths]
 
* @Return java.util.Properties
 
**/
 
privateProperties loadProperties(String... resourcesPaths) {
 
Properties props= newProperties();for(String location : resourcesPaths) {
 
log.debug("Loading properties file from:" +location);
 
InputStream is= null;try{
 
Resource resource=resourceLoader.getResource(location);
 
is=resource.getInputStream();
 
props.load(is);
 
}catch(IOException ex) {
 
log.info("Could not load properties from path:" + location + ", " +ex.getMessage());
 
}finally{
 
IOUtils.closeQuietly(is);
 
}
 
}returnprops;
 
}
 
}
 
PropertiesLoader.java
 
配置文件工具类：
 

 

 
packagecom.sxy.propertiesreaddemo.utils;importlombok.extern.slf4j.Slf4j;importorg.springframework.core.io.DefaultResourceLoader;importorg.springframework.core.io.ResourceLoader;/*** @Description 读取配置文件
 
* @Author SuXingYong
 
* @Date 2020/7/11 20:55
 
**/@Slf4jpublic classPropertiesUtils {/*** @Description 获取配置文件加载
 
* @Author SuXingYong
 
* @Date 2020/7/11 20:55
 
* @Param [configPath]
 
*@paramconfigPath 配置文件路径
 
* @Return com.sxy.platform.properties.PropertiesLoader
 
**/
 
public staticPropertiesLoader getProperties(String configPath) {
 
PropertiesLoader property=newPropertiesLoader(configPath);returnproperty;
 
}/*** @Description 根据key获取value
 
* @Author SuXingYong
 
* @Date 2020/7/11 20:55
 
* @Param [key, properties]
 
* @Return java.lang.String
 
**/
 
public staticString getPropertyValue(String key, PropertiesLoader properties) {
 
String value=properties.getProperty(key);returnvalue;
 
}
 
}
 
PropertiesUtils.java
 
配置文件统一对外调用类：
 

 

 
packagecom.sxy.propertiesreaddemo.utils;/*** @Description config配置文件读取类
 
* @By SuXingYong
 
* @DateTime 2020/7/11 20:55
 
**/
 
public classPropertyConfigValue {/*** 配置加载器*/
 
private staticPropertiesLoader propertiesLoader;/*** @Description 自定义配置内容
 
* @Author SuXingYong
 
* @Date 2020/7/11 20:55
 
**/
 
private static String THIS_CUSTOM_CONFIG_CONTENT = "this.custom.config.content";static{
 
propertiesLoader= PropertiesUtils.getProperties("classpath:config/custom-config.properties");
 
}/*** @Description 获取 自定义配置内容
 
* @Author SuXingYong
 
* @Date 2020/6/24 15:10
 
* @Param []
 
* @Return java.lang.String
 
**/
 
public staticString getThisCustomConfigContent(){
 
String value=PropertiesUtils.getPropertyValue(THIS_CUSTOM_CONFIG_CONTENT, propertiesLoader);returnvalue;
 
}
 
}
 
PropertyConfigValue.java
 
springboot项目启动类：
 

 

 
packagecom.sxy.propertiesreaddemo;importcom.sxy.propertiesreaddemo.utils.PropertyConfigValue;importlombok.extern.slf4j.Slf4j;importorg.springframework.boot.SpringApplication;importorg.springframework.boot.autoconfigure.SpringBootApplication;
 
@Slf4j
 
@SpringBootApplicationpublic classPropertiesReadDemoApplication {public static voidmain(String[] args) {
 
SpringApplication.run(PropertiesReadDemoApplication.class, args);
 
log.info("this.custom.config.content = "+PropertyConfigValue.getThisCustomConfigContent());
 
}
 
}
 
PropertiesReadDemoApplication.java
 
运行结果：
 

 
基于java读取并引用自定义配置文件
 
首先在resources目录创建自定义的配置文件
 

 
配置文件的格式：
 

 
写工具类，得到配置参数
 
import java.io.IOException;
 
import java.io.InputStream;
 
import java.util.Properties;
 
public class MyConfig {
 
public static Properties myProp = new Properties();
 
public static InputStream myResource = MyConfig.class.getResourceAsStream("/myConfig.properties");
 
static {
 
try {
 
myProp.load(myResource);
 
} catch (IOException e) {
 
e.printStackTrace();
 
}
 
}
 
public String getMyConf(String props) {
 
return myProp.getProperty(props);
 
}
 
public static void main(String[] args) {
 
final MyConfig myConfig = new MyConfig();
 
System.out.println(myConfig.getMyConf("master_ip"));
 
}
 
}
 
以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持我们。
 
时间： 2020-06-21
 
java获取配置文件.properties中的数据,具体内容如下所示: 方法太多,只写一种比较简单的. 文件test1.properties内容 test1 = 123; test2=3211 Properties prop = new Properties(); prop.load(new FileInputStream("src/test1.properties")); System.out.println(prop.get("test1")); 输出 123;
 
下载: 1.在spring-mvc中配置(用于100M以下的文件下载) 
 
一.介绍 Properties文件在Java中主要为配置文件,文件类型为:.properties,格式为文本文件,内容格式为"键=值" 二.读取 这里我采用的是getResourceAsStream的文件读取方法 如果想要使用这个方法,则需要了解一些基本使用信息: 1.读取文件路径范围:只局限于工程的源文件中 2.文件访问形式:带"/"是绝对路径,不带"/"是相对路径 3.读取文件类型:主要为:.properties文件,.xml文件 三.使用
 

 
方式一:采用ServletContext读取 获取配置文件的realpath,然后通过文件流读取出来或者通过方法getReasurceAsStream(). 因为是用ServletContext读取文件路径,所以配置文件可以放入在WEB-INF的classes目录中,也可以在应用层级及WEB-INF的目录中.文件存放位置具体在eclipse工程中的表现是:可以放在src下面,也可放在WEB-INF及Web-Root下面等.因为是读取出路径后,用文件流进行读取的,所以可以读取任意的配置文件包括xm
 

 
Spring读取配置XML文件分三步: 一.新建一个Java Bean: package springdemo; public class HelloBean { private String helloWorld; public String getHelloWorld() { return helloWorld; } public void setHelloWorld(String helloWorld) { this.helloWorld = helloWorld; } } 二.构建一个配
 
相信对于一名JAVA开发者开说properties文件一定再熟悉不过了,比如一下配置: config.properties会经常存放一些系统常量,版本号,路径之类的 database.properties存放数据库的连接参数 log4j.properties 日志的一些基本配置 redis.properties 缓存数据库的一些配置 当然前缀是根据用能自行定义的,一般来说文件的内容的格式是"键=值"的格式,文本注释信息可以用"#"来注释,下面来说说开发中如何读写pr
 
前言 在项目开发中经常会用到配置文件,配置文件的存在解决了很大一份重复的工作.今天就分享四种在Springboot中获取配置文件的方式. 注:前三种测试配置文件为springboot默认的application.properties文件 #######################方式一######################### com.zyd.type3=Springboot - @ConfigurationProperties com.zyd.title3=使用@Configura
 
Java 开发中,需要将一些易变的配置参数放置再 XML 配置文件或者 properties 配置文件中.然而 XML 配置文件需要通过 DOM 或 SAX 方式解析,而读取 properties 配置文件就比较容易. 介绍几种读取方式: 1.基于ClassLoder读取配置文件 注意:该方式只能读取类路径下的配置文件,有局限但是如果配置文件在类路径下比较方便. Properties properties = new Properties(); // 使用ClassLoader加载propert
 

 
本文实例讲述了java读取properties配置文件的方法.分享给大家供大家参考.具体分析如下: 这两天做java项目,用到属性文件,到网上查资料,好半天也没有找到一个满意的方法能让我读取到.properties文件中属性值,很是郁闷,网上讲的获取属性值大概有以下方法,以下三种方法逐渐优化,以达到最好的效果以下都以date.properties文件为例,该文件放在src目录下,文件内容为: startdate=2011-02-07 totalweek=25 方法一: public class
 
本文实例讲述了java简单读取properties配置文件的方法.分享给大家供大家参考,具体如下: 读取配置文件,小结如下 import java.io.FileNotFoundException; import java.io.IOException; import java.util.Properties; public class loadConf { private Properties prop = new Properties(); private void loadconf() t
 
如下所示: public static String getConfig(String key) { Properties pros = new Properties(); String value = ""; try { pros.load(new InputStreamReader(Object.class.getResourceAsStream("/properties.properties"), "UTF-8")); value = pr
 
Android读取properties配置文件的实例详解 因为一些配置信息,多处用到的.且以后可能变更的,我想写个.prorperties配置文件给管理起来. 我把配置文件放在了assets文件夹下 appConfig.properties: serverUrl=http://192.168.1.155 import java.io.InputStream; import java.util.Properties; import android.content.Context; /** * 读取
 
本文实例讲述了Python读取properties配置文件操作.分享给大家供大家参考,具体如下: 工作需要将Java项目的逻辑改为python执行,Java的很多配置文件都是.properties的,文件内容的格式是"键.键.键...＝值"的格式例如A.B.C=value1,D.F=value2等.并且"#"用来注视.python没有专门处理properties格式的包,只有处理标准的ini格式的包.所以需要自己写一个python程序来处理.不说了上程序. 这里参考
 
本文实例讲述了Python实现读取Properties配置文件的方法.分享给大家供大家参考,具体如下: JAVA本身提供了对于Properties文件操作的类,项目中的很多配置信息都是放在了Properties文件.但是Python并没有提供操作Properties文件的库,所以,自己动手写个一个可以加载Properties文件的脚本. class Properties: fileName = '' def __init__(self, fileName): self.fileName = fi

1. 前言
 
我们在实际开发过程中，如果有一个写在代码中的路径需要修改这时就需要开发人员修改源码然后编译再替换，当项目处于生产环境时，开发人员是不会维护的，有专门的维护人员，如果路径写在配置文件中，只需维护人员更改配置重启，提高程序的健壮性。
 
2. 具体实现
 
在项目中的resources文件夹中创建配置文件
 
引入外部配置文件默认是properties文件，如需要支持yaml/或yml时需要引入工具类
 
package com.chuan.ping.backend.util;

import java.io.IOException;
import java.util.Properties;

import org.springframework.core.env.PropertySource;
import org.springframework.core.io.support.EncodedResource;
import org.springframework.core.env.PropertiesPropertySource;
import org.springframework.core.io.support.DefaultPropertySourceFactory;
import org.springframework.beans.factory.config.YamlPropertiesFactoryBean;

/**
 * @Describe: 引入外部配置文件（默认是properties文件，此处设置成也支持yaml/yml文件）
 * @User: CS
 * @CreateTime: 2021-07-20 11:19
 **/
public class YamlPropertySourceFactoryUtil extends DefaultPropertySourceFactory {
    @Override
    public PropertySource<?> createPropertySource(String name, EncodedResource resource) throws IOException {
        String sourceName = (name == null) ? resource.getResource().getFilename() : name;
        assert sourceName != null;
        String sourceName1 = ".yml";
        String sourceName2 = ".yaml";
        if (sourceName.endsWith(sourceName1) || sourceName.endsWith(sourceName2)) {
            YamlPropertiesFactoryBean factory = new YamlPropertiesFactoryBean();
            factory.setResources(resource.getResource());
            factory.afterPropertiesSet();
            Properties properties = factory.getObject();
            assert properties != null;
            return new PropertiesPropertySource(sourceName, properties);
        }
        return super.createPropertySource(name, resource);
    }
}
 
在实体类中实现Serializable
 
@ConfigurationProperties(prefix = "common.path")
@PropertySource(value = "classpath:common-path.yml", factory = YamlPropertySourceFactoryUtil.class)
@Component
@Data
public class FilePath implements Serializable {
    private String radar;

    private String gridPoint;
}
 
@ConfigurationProperties 定义配置文件里的前缀
 @PropertySource 设置支持配置文件为yml/yaml格式
 
使用时将实体类注入进来
 
private final FilePath path;

public RadarController(FilePath path) {
    this.path = path;
}
 
至此Java读取自定义配置文件结束，仅供参考，接受指正。
 

背景
 
java应用，不管是web还是jar程序，读取配置文件始终是绕不过去的。
 
一开始没那么多弯弯绕绕，反正什么配置文件，完全打包就完事，读取也是相对路径，IDE能跑，部署到服务器也不会有问题。
 
然后，如果要提升部署的质量，满足运维的要求，那就没那么简单了。比如我们可能面临：
 
 
 
1、部署到Tomcat？springboot的jar进程部署？
 
 
2、配置文件需要从jar里面拉出来，方便部署时修改配置
 
 
主题
 
本文的主题就是配置文件的读取
 
首先直接上例子(几种常用读取路径的区别)
 
public class ServerPath {

    public static void main(String[] args) {

        ClassLoader loader = Thread.currentThread().getContextClassLoader();
        System.out.println("ClassLoader mode = " + loader.getResource("").getPath());

        System.out.println("class.getResource'' mode = " + ServerPath.class.getResource("").getPath());

        System.out.println("class.getResource'/' mode = " + ServerPath.class.getResource("/").getPath());

        System.out.println("System.getProperty(\"user.dir\") mode = " + System.getProperty("user.dir"));

    }
}
 
执行结果(两个操作系统环境)
 
 
结论：
 
1、loader.getResource("").getPath()  和  ServerPath.class.getResource("/").getPath()  结果是一样的，都是得到 classpath (classpath是JVM用到的一个环境变量，它用来指示JVM如何搜索class。)
 
2、ServerPath.class.getResource("").getPath() 得到的是执行类的完整路径
 
3、System.getProperty("user.dir") 得到的是基于当前用户的执行程序的文件路径
 
一般情况下，我们只需要用到classpath，毕竟很多配置路径缺省的情况下都是相对于classpath 去读取的，如果都改成绝对路径，代价太大，也容易出错。
 
围绕这点，进阶！
 
进阶
 
1、spring 配置加载application.yml文件顺序
 
springboot启动会扫描一下位置的application.properties或者application.yml作为默认的配置文件
工程根目录:./config/
工程根目录：./
classpath:/config/
classpath:/
加载的优先级顺序是从上向下加载，并且所有的文件都会被加载（后面的不会覆盖同名的前面配置）
 
2、执行jar 指定额外的classpath
 
java -Xbootclasspath/a:具体路径 -jar my.jar
 
基于以上配置(保证前两步的配置正常)的配置文件读取，以下各种场景皆可正常使用
 
我这里使用的是  java -Xbootclasspath/a:.  -jar my.jar
 
 
场景
 
1、入口程序的 ApplicationContext.xml 配置加载
 2、log4j配置文件加载
 
@ImportResource("classpath:config/spring/webApplicationContext.xml")
@EnableJpaRepositories
public class WebApplication {
    public static void main(String[] args) {
        System.out.println("classpath =" + SpringApplication.class.getResource("/").getPath());
        // 日志配置
        URL logConfigURL = WebApplication.class.getResource("/config/properties/log4j.properties");
        PropertyConfigurator.configure(logConfigURL);
        SpringApplication.run(WebApplication.class, args);
    }
}
 
3、ApplicationContext.xml 其他配置引用
 
<import resource="classpath*:/config/spring/redisConnect.xml"/>
<import resource="classpath*:/config/spring/mongodbConnect.xml"/>
<context:property-placeholder location="classpath*:/config/properties/*.properties"/>
 
4、程序内部读取配置文件
 
ClassPathResource c = new ClassPathResource("config/properties/test.properties");
EncodedResource encodedResource = new EncodedResource(c, StandardCharsets.UTF_8);
Properties properties = PropertiesLoaderUtils.loadProperties(encodedResource);
 
5、通过注解读取配置文件以及配置项
 
@Component
@PropertySource("classpath:config/properties/test.properties")
public class MyConfig {

    /** 用户名 */    
    @Value("${userName}")
    private String userName;

}
 
高级
 
1、配置文件位置任意定 (以上已实现，启动指定加载classpath，项目内部使用相对classpath的方式读取配置)
 
2、启动服务命令可以在任意目录执行
 
知识点包括：自定义启动jar ; 使用绝对路径读取启动项 ； 自动创建日志目录 ； 启动后自动打印日志 ；重复启动可选是否重启
 
以下是startup.sh内容：
 

# absolute-path
path=$(dirname `readlink -f $0`)
echo ${path}

name=$path/my.jar

build_dir=$path"/logs"
if [ ! -d "$build_dir" ]; then
  mkdir $build_dir
fi

pid=`ps -ef | grep $name| grep -v grep |awk '{print $2}'`
if [ $pid ]; then
  echo ${name} is running pid=$pid
  read -r -p "restart the server? [y/n] " input
  case $input in
    [yY][eE][sS]|[yY])
    kill -9 $pid
    echo restart ${name}......
    sleep 3                
    nohup java -Xbootclasspath/a:$path -jar -Xms128m -Xmx128m -XX:MetaspaceSize=128m -XX:MaxMetaspaceSize=128m $name >>logs/info.log  &
    tail -f $path/logs/info.log
    ;;

    [nN][oO]|[nN])
      echo "No"
      exit 1
      ;;
    *)
      echo "Invalid input Please enter [y/n]"
      echo ""
      exit 1
      ;;
esac
else
  nohup java -Xbootclasspath/a:. -jar -Xms128m -Xmx128m -XX:MetaspaceSize=128m -XX:MaxMetaspaceSize=128m $name >>logs/info.log &
  tail -f $path/logs/info.log
fi


 
3、以上基于一定的打包策略
 
① 所有依赖的jar 在当前目录的 lib 
 
② 配置文件放在 在当前目录的 config 
 
③启动配置 application.yml在当前目录
 
 
其他需要的细节请参考：
 
MAVEN打包包含其他模块配置文件
 
Springboot 项目 maven 打包不包含第三方jar包
 
Spring boot 项目打包 + Linux 部署 / maven jar项目打包部署到Linux/ start.sh