您的位置：360文档中心› java读取配置文件

java读取配置文件

合集下载

java获取配置文件的参数的方法

java获取配置文件的参数的方法

一、概述Java是一种流行的编程语言，广泛应用于企业级软件开发。

在Java应用程序中，经常需要读取配置文件中的参数，以便程序在不同环境下能够灵活运行。

本文将介绍在Java中获取配置文件参数的方法。

二、使用Properties类在Java中，可以使用Properties类来读取配置文件。

Properties是HashTable的子类，它用于处理键值对形式的配置信息。

下面是使用Properties类获取配置文件参数的步骤：1. 创建Properties对象首先使用Properties类创建一个对象，用于存储配置文件中的参数。

可以通过以下代码实现：```javaProperties props = new Properties();```2. 加载配置文件接下来，需要将配置文件加载到Properties对象中。

通常配置文件的格式是.properties，可以通过以下代码加载：```javatry{InputStream inputStream =getClass().getClassLoader().getResourceAsStream("config.prope rties");props.load(inputStream);}catch(IOException e){e.printStackTrace();}```上述代码中，使用ClassLoader的getResourceAsStream方法加载配置文件，并使用Properties的load方法将文件内容加载到props 对象中。

3. 获取参数值一旦配置文件加载到props对象中，就可以通过getProperty方法获取参数值。

获取名为"db.url"的参数值可以使用以下代码：```javaString dbUrl = props.getProperty("db.url");```通过上述步骤，就可以在Java中轻松获取配置文件中的参数值了。

Properties的相对路径以及文件的读取操作

Properties的相对路径以及文件的读取操作

Properties的相对路径以及⽂件的读取操作在我们平时写程序的时候，有些参数是经常改变的，⽽这种改变不是我们预知的。

⽐如说我们开发了⼀个操作数据库的模块，在开发的时候我们连接本地的数据库那么 IP ，数据库名称，表名称，数据库主机等信息是我们本地的，要使得这个操作数据的模块具有通⽤性，那么以上信息就不能写死在程序⾥。

通常我们的做法是⽤配置⽂件来解决。

各种语⾔都有⾃⼰所⽀持的配置⽂件类型。

⽐如 Python，他⽀持 .ini⽂件。

因为他内部有⼀个 ConfigParser类来⽀持 .ini⽂件的读写，根据该类提供的⽅法程序员可以⾃由的来操作 .ini⽂件。

⽽在 Java中， Java⽀持的是 .properties⽂件的读写。

JDK内置的 java.util.Properties类为我们操作 .properties⽂件提供了便利。

⼀． .properties⽂件的形式 ==========================================================#以下为服务器、数据库信息dbPort = localhostdatabaseName = mydbdbUserName = rootdbPassword = root#以下为数据库表信息dbTable = mytable#以下为服务器信息ip = 192.168.0.9······在上⾯的⽂件中我们假设该⽂件名为： test.properties⽂件。

其中 #开始的⼀⾏为注释信息；在等号“ =”左边的我们称之为 key；等号“ =”右边的我们称之为 value 。

（其实就是我们常说的键 -值对） key应该是我们程序中的变量。

⽽ value是我们根据实际情况配置的。

⼆． JDK中的 Properties类 Properties类存在于胞 Java.util中，该类继承⾃ Hashtable ，它提供了⼏个主要的⽅法：1． ( key) ，⽤指定的键在此属性列表中搜索属性。

Java程序读取配置文件的几种方法

Java程序读取配置文件的几种方法

Java程序读取配置⽂件的⼏种⽅法Java 开发中，需要将⼀些易变的配置参数放置再 XML 配置⽂件或者 properties 配置⽂件中。

然⽽ XML 配置⽂件需要通过 DOM 或 SAX ⽅式解析，⽽读取 properties 配置⽂件就⽐较容易。

1. 读取properties⽂件的⽅法1. 使⽤类加载器ClassLoder类读取配置⽂件InputStream in = MainClass.class.getClassLoader().getResourceAsStream("com/demo/config.properties");MainClass.class是主类的反射对象，因为getClassLoader()是class类的对象⽅法。

在类加载器中调⽤getResourceAsStream()时，采⽤相对路径，起始位置在src⽬录，路径开头没有“/”。

InputStream in = (new MainClass()).getClass().getClassLoader().getResourceAsStream("com/demo/config.properties");因为getClass()是object类的对象⽅法，所有在主类调⽤时要将主类实体化，即new MainClass()。

同理，相对路径起始位置同上。

2. ⽤class对象读取配置⽂件之所以Class对象也可以加载资源⽂件是因为Class类封装的getResourceAsStream⽅法的源码中调⽤了类加载器。

InputStream in = MainClass.class.getResourceAsStream(“/com/demo/config.properties”);同样MainClass.class是主类的反射对象。

在class对象中调⽤getResourceAsStream()时，采⽤绝对路径，起始位置在类路径（bin⽬录），因此路径要以“/”开头。

读取 Properties 文件 六种方法

读取 Properties 文件 六种方法

读取Properties文件六种方法private static void init() {try {if (pro == null)synchronized (SsoParams.class) {if (pro == null) {pro = new Properties();InputStream in =SsoParams.class.getResourceAsStream("sso_config.properties");pro.load(in);}}}catch (Exception e) {e.printStackTrace();}}开发项目时，经常把一些参数存入Properties文件，以增加程序的灵活性。

我们可以通过以下六种方法读取配置参数（注意：spring对properties的读取也有很好的集成）：1、使用java.util.Properties类的load()方法示例：InputStream in = lnew BufferedInputStream(new FileInputStream(name));Properties p = new Properties();p.load(in);2、使用java.util.ResourceBundle类的getBundle()方法示例：ResourceBundle rb = ResourceBundle.getBundle(name, Locale.getDefault());3、使用java.util.PropertyResourceBundle类的构造函数示例：InputStream in = new BufferedInputStream(new FileInputStream(name));ResourceBundle rb = new PropertyResourceBundle(in);4、使用class变量的getResourceAsStream()方法示例：InputStream in = JProperties.class.getResourceAsStream(name);Properties p = new Properties();p.load(in);5、使用class.getClassLoader()所得到的ng.ClassLoader的getResourceAsStream()方法示例：InputStream in = JProperties.class.getClassLoader().getResourceAsStream(name);Properties p = new Properties();p.load(in);6、使用ng.ClassLoader类的getSystemResourceAsStream()静态方法示例：InputStream in = ClassLoader.getSystemResourceAsStream(name);Properties p = new Properties();p.load(in);补充Servlet中可以使用javax.servlet.ServletContext的getResourceAsStream()方法示例：InputStream in = context.getResourceAsStream(path);Properties p = new Properties();p.load(in);。

Java_JDBC连接数据库_使用读取配置文件的方式

Java_JDBC连接数据库_使用读取配置文件的方式

Java_JDBC连接数据库_使⽤读取配置⽂件的⽅式 1package com.homewoek3_4.dao;23import java.io.IOException;4import java.io.InputStream;5import java.sql.Connection;6import java.sql.DriverManager;7import java.sql.PreparedStatement;8import java.sql.ResultSet;9import java.sql.SQLException;10import java.util.Properties;1112/**13 * 数据库连接通⽤类14 * @author Administrator15*/16public abstract class BaseDao {17private static final String path = "database.properties";18private static String DB_DRIVER;19private static String DB_URL;20private static String DB_USER;21private static String DB_PWD;2223protected Connection conn = null;24protected PreparedStatement ps = null;25protected ResultSet rs = null;2627static {28 Properties pro = new Properties();29 InputStream io = BaseDao.class.getClassLoader().getResourceAsStream(path);30try {31//读取配置⽂件32 pro.load(io);33 } catch (IOException e) {34 e.printStackTrace();35 }36 DB_DRIVER = pro.getProperty("DB_DRIVER");37 DB_URL = pro.getProperty("DB_URL");38 DB_USER = pro.getProperty("DB_USER");39 DB_PWD = pro.getProperty("DB_PWD");40try {41//加载驱动类42 Class.forName(DB_DRIVER);43 } catch (ClassNotFoundException e) {44 e.printStackTrace();45 }46 }47/**48 * 打开数据库连接49*/50protected void openConn() {51try {52 conn = DriverManager.getConnection(DB_URL, DB_USER, DB_PWD);53 } catch (SQLException e) {54 e.printStackTrace();55 }56 }57/**58 * 关闭数据库连接59*/60protected void closeConn() {61try {62if (rs != null) {63 rs.close();64 }65if (ps != null) {66 ps.close();67 }68if (conn != null) {69 conn.close();70 }71 } catch (SQLException e) {72 e.printStackTrace();73 }74 }75/**76 * 增删改77 * @param sql78 * @param obj79 * @return80*/81protected int executeUpdate(String sql, Object...obj) {82int result = -1;83this.openConn();84try {85 ps = conn.prepareStatement(sql);86if (obj != null) {87for (int i = 0; i < obj.length; i++) {88 ps.setObject(i+1, obj[i]);89 }90 }91 result = ps.executeUpdate();92 } catch (SQLException e) {93 e.printStackTrace();94 }95return result;96 }97/**98 * 查询99 * @param sql100 * @param obj101 * @return102*/103protected void executeQuery(String sql, Object...obj) {104this.openConn();105try {106 ps = conn.prepareStatement(sql);107if (obj != null) {108for (int i = 0; i < obj.length; i++) {109 ps.setObject(i+1, obj[i]);110 }111 }112 rs = ps.executeQuery();113 } catch (SQLException e) {114 e.printStackTrace();115 }116 }117 }创建database.properties⽂件，注意：后缀名⼀定是properties。

java读JAR包里的配置文件

java读JAR包里的配置文件

private static String getXmlContent()throws IOException {Reader f = newInputStreamReader(QueryWeather.class.getClass().getResourceAsStream("/weather/we ather.xml"));BufferedReader fb = new BufferedReader(f);StringBuffer sb = new StringBuffer(“”);String s = "";while((s = fb.readLine()) != null) {sb = sb.append(s);}return sb.toString();}package com.read;import java.io.*;public class Resource {public void getResource() throws IOException{//返回读取指定资源的输入流InputStream is=this.getClass().getResourceAsStream("/struts-default.xml"); BufferedReader br=new BufferedReader(new InputStreamReader(is));String s="";while((s=br.readLine())!=null)System.out.println(s);}}这个类是jar包中的类,同时jar根下还有个struts-default.xml文件。

ClassLoader classloader = Thread.currentThread().getContextClassLoader(); InputStream is = classloader.getResourceAsStream("com/xxx/xxxx/yourfile.xml");一般情况下properties文件都是在工程内使用的，如果application打成jar包之后，修改properties文件后就需要重新打jar，很麻烦。

java 引用外部配置文件的方法

java 引用外部配置文件的方法

java 引用外部配置文件的方法Java作为一种广泛应用的编程语言，经常需要引用外部配置文件来获取程序的设置参数。

本文将介绍几种常用的方法来实现这个目的。

一、使用Properties类Properties类是Java提供的一个用于处理配置文件的工具类，它可以读取和写入配置文件的键值对。

使用Properties类引用外部配置文件的步骤如下：1. 创建一个Properties对象。

2. 使用load()方法读取配置文件，将配置文件的内容加载到Properties对象中。

3. 使用getProperty()方法根据键名获取配置项的值。

下面是一个示例代码：```javaimport java.io.FileInputStream;import java.io.IOException;import java.util.Properties;public class ConfigReader {public static void main(String[] args) {Properties properties = new Properties();try {FileInputStream fis = newFileInputStream("config.properties");properties.load(fis);fis.close();} catch (IOException e) {e.printStackTrace();}String url = properties.getProperty("url");String username = properties.getProperty("username"); String password = properties.getProperty("password"); System.out.println("url: " + url);System.out.println("username: " + username);System.out.println("password: " + password);}}```在这个例子中，我们使用了一个名为config.properties的配置文件，其中包含了url、username和password三个配置项的值。

java读取外部配置文件的方法

java读取外部配置文件的方法

java读取外部配置文件的方法在Java中，您可以使用多种方法来读取外部配置文件，这有助于将应用程序配置信息从代码中分离，使得配置更加灵活。

以下是一些常见的方法：1.使用`Properties`类：可以使用Java的`Properties`类来读取键值对形式的配置文件，通常是`.properties`文件。

例如：```javaimport java.io.FileInputStream;import java.io.IOException;import java.util.Properties;public class ConfigReader{public static void main(String[]args){Properties properties=new Properties();try(FileInputStream fileInputStream=newFileInputStream("config.properties")){properties.load(fileInputStream);String value=properties.getProperty("key");System.out.println("Value:"+value);}catch(IOException e){e.printStackTrace();}}}```2.使用`ResourceBundle`类：如果您的配置文件在类路径中，可以使用`ResourceBundle`类来读取配置信息。

这对于国际化和本地化也很有用。

```javaimport java.util.ResourceBundle;public class ConfigReader{public static void main(String[]args){ResourceBundle bundle=ResourceBundle.getBundle("config");String value=bundle.getString("key");System.out.println("Value:"+value);}}```3.使用第三方库：除了标准Java库，您还可以使用第三方库，如Apache Commons Configuration或Typesafe Config，来更灵活地处理配置文件。

java代码中读项目工程中的文件

java代码中读项目工程中的文件

【文章标题】：深度解析Java代码中读取项目工程中的文件的方法与技巧在我们的日常开发中，读取项目工程中的文件是一项非常常见的任务。

特别是在Java开发中，我们经常需要读取配置文件、模板文件、日志文件等。

本文将围绕这一主题展开讨论，探讨Java代码中读取项目工程中的文件的方法与技巧，帮助读者更深入地理解并灵活运用相关知识。

1. 文件读取的基本概念在开始具体讨论Java代码中读取项目工程中的文件之前，我们首先来回顾一下文件读取的基本概念。

文件读取是指程序通过输入设备获取文件中的数据，常见的文件读取操作包括文件的打开、读取、关闭等。

在Java中，文件读取通常涉及到IO流的使用，其核心思想是通过流来实现对文件的读取和写入。

2. 使用File类进行文件读取Java中提供了File类来表示文件和目录路径名，我们可以通过File类来实现对项目工程中文件的读取操作。

首先通过File类的实例化对象来表示要读取的文件，然后可以通过该对象调用相关方法实现文件的读取操作。

在代码中，通常会使用FileInputStream或FileReader来读取文件的内容，通过这些类提供的方法，可以逐行或者逐个字节地读取文件的数据。

3. 使用ClassLoader获取资源文件除了使用File类来读取文件外，我们还可以通过ClassLoader来获取项目工程中的资源文件。

ClassLoader是Java中用于加载类文件和资源文件的类加载器，通过ClassLoader可以直接获取到项目工程中的资源文件的输入流，从而进行文件的读取操作。

相比于File类，通过ClassLoader获取资源文件可以更方便地定位和读取资源，特别适合于读取类路径下的文件。

4. Apache Commons IO库的应用除了Java标准库提供的File类和ClassLoader，我们还可以借助第三方库来简化文件读取的操作。

Apache Commons IO是一个常用的Java开发工具库，在文件操作方面提供了丰富且便捷的功能。

JAVA中读写配置文件

JAVA中读写配置文件

JAVA中读写配置文件2007-12-22java中读写属性文件下面的文章来自CSDN hyde82的专栏,因为很实用,所以就摘下来放在此处,具体网址忘记啦.无论是有图形化的选项配置对话框，或者是系统提供的注册表，文本形式的本地配置文件依然是最牢靠、应用最广泛的配置信息保存形式。

配置信息的一般模式就是一个配置项对应一个值，前者一般是个字符串，后者可能是数字或者字符串或者别的什么。

在传统win32编程中有系统提供的api供我们解读.ini文件，后来也有操作注册表的封装好的api，在.net中更是有解读XML形式.config文件的现成方法。

在Java中，对配置文件的使用进行封装也是十分有意义的。

封装应该达到这样的效果：应用只管从配置信息进行按名读取值、设置值、保存等操作，而不需要关心具体以什么文件格式保存、如何解析。

文件格式(纯文本?XML?数据库?)、IO 方式(本地文件?远程文件?控制台流?)在封装类内部的变更，都不会影响应用对配置信息的感知。

从键名-值的对应关系以及文件的存取，我们最容易想到的就是java.util.Properties对象，他是HashTable的子类，保存的就是很多组键名-值的对应二原组，并提供快速的查询和直接的从文件读取、保存为文件的方法。

具体请参考相关文档，我们直接看程序。

首先自定义一个异常：//ConfigurationException.javapackage configuration;public class ConfigurationException extends Exception{ public ConfigurationException(){}public ConfigurationException(String msg){super(msg);}}然后是我们的封装类：//Configuration.javapackage configuration;import java.io.*;import java.util.*;import configuration.*;public class Configuration {private Properties config=new Properties();//记录配置项private String fn=null;//记录配置文件名//此构造方法用于新建配置文件public Configuration(){}//从指定文件名读入配置信息public Configuration(String fileName)throws ConfigurationException {try {FileInputStream fin = new FileInputStream(fileName); config.load(fin); //载入文件fin.close();}catch (IOException ex) {throw new ConfigurationException("无法读取指定的配置文件:"+fileName);}fn=fileName;}//指定配置项名称，返回配置值public String getValue(String itemName){return config.getProperty(itemName);}//指定配置项名称和默认值，返回配置值public String getValue(String itemName,String defaultValue){return config.getProperty(itemName,defaultValue);}//设置配置项名称及其值public void setValue(String itemName,String value){ config.setProperty(itemName,value);return;}//保存配置文件，指定文件名和抬头描述public void saveFile(String fileName,String description) throws ConfigurationException {try {FileOutputStream fout= new FileOutputStream(fileName);config.store(fout, description);//保存文件fout.close();}catch (IOExeption ex) {throw new ConfigurationException("无法保存指定的配置文件:"+fileName);}}//保存配置文件，指定文件名public void saveFile(String fileName)throws ConfigurationException {saveFile(fileName,"");}//保存配置文件，采用原文件名public void saveFile() throws ConfigurationException { if(fn.length()==0)throw new ConfigurationException("需指定保存的配置文件名");saveFile(fn);}}从这个封装类我们可以看到，实例化对象的时候我们可以指定一个文件名使得从中读取配置信息，通过getValue方法取得属性值，setValue方法设置属性值，saveFile方法保存文件。

java获取文件内容的方法

java获取文件内容的方法

java获取文件内容的方法【实用版4篇】篇1 目录I.获取文件内容的方法概述II.使用Scanner类读取文件内容III.使用BufferedReader类读取文件内容IV.使用FileInputStream类读取文件内容V.使用FileChannel类读取文件内容篇1正文Java中获取文件内容的方法有很多种，下面介绍几种常用的方法：1.使用Scanner类读取文件内容Scanner类是Java中常用的类之一，它可以帮助我们方便地读取文件内容。

具体实现方法如下：```javatry (Scanner scanner = new Scanner(new File("filename.txt"))) {while (scanner.hasNextLine()) {String line = scanner.nextLine();// 处理每一行内容}} catch (FileNotFoundException e) {e.printStackTrace();}```2.使用BufferedReader类读取文件内容BufferedReader类可以帮助我们快速读取文件内容，它可以读取文本文件、CSV文件等。

具体实现方法如下：```javatry (BufferedReader reader = new BufferedReader(new FileReader("filename.txt"))) {String line;while ((line = reader.readLine()) != null) {// 处理每一行内容}} catch (IOException e) {e.printStackTrace();}```3.使用FileInputStream类读取文件内容FileInputStream类可以帮助我们读取二进制文件，它可以读取图片、音频、视频等文件。

java读取资源文件的方法

java读取资源文件的方法

java读取资源文件的方法Java是一种广泛应用于开发各种应用程序的编程语言。

在Java中，读取资源文件是一项常见的任务，它允许我们从外部文件中获取数据或配置信息。

本文将介绍几种常用的Java读取资源文件的方法。

一、使用ClassLoader读取资源文件Java中的ClassLoader是用于加载类的关键组件之一。

它不仅可以加载类，还可以加载其他类型的资源文件。

通过ClassLoader，我们可以很方便地读取资源文件。

我们需要使用ClassLoader的getResourceAsStream()方法获取资源文件的输入流。

这个方法可以接受一个相对路径作为参数，并返回一个InputStream对象。

然后，我们可以使用这个输入流来读取资源文件的内容。

下面是一个使用ClassLoader读取资源文件的示例代码：```javaClassLoader classLoader = getClass().getClassLoader(); InputStream inputStream = classLoader.getResourceAsStream("config.properties");```在上面的代码中，我们使用了getClass().getClassLoader()方法获取当前类的ClassLoader。

然后，我们调用getResourceAsStream()方法获取资源文件config.properties的输入流。

二、使用InputStream读取资源文件除了使用ClassLoader，我们还可以使用InputStream来读取资源文件。

这种方法适用于读取位于文件系统中的资源文件。

我们需要创建一个File对象，用于表示资源文件的路径。

然后，我们可以使用FileInputStream来打开这个文件，并获取其输入流。

最后，我们可以使用这个输入流来读取资源文件的内容。

下面是一个使用InputStream读取资源文件的示例代码：```javaFile file = new File("path/to/config.properties"); InputStream inputStream = new FileInputStream(file);```在上面的代码中，我们创建了一个File对象，表示资源文件config.properties的路径。

java获取yml配置的方法

java获取yml配置的方法

一、介绍在Java开发中，我们经常需要读取外部配置文件，来获取一些配置信息，比如数据库连接信息、服务端口等。

而YML（YAML）是一种常用的配置文件格式，它具有结构化、易读、易写的特点，因此在Java 开发中也经常用来做配置文件。

本文将介绍如何在Java中获取YML 配置的方法。

二、YML配置文件的基本结构YML文件采用缩进来表示层级关系，可以使用空格或者Tab来进行缩进。

YML配置文件由键值对组成，键值对之间使用冒号“:”来分隔，键值对的值可以是字符串、布尔值、数字、数组或者对象。

以下是一个简单的YML配置文件的示例：```yamlserver:port: 8080hostname: localhostdatabase:driver:.mysql.jdbc.Driverurl: jdbc:mysql://localhost:3306/testusername: rootpassword: 123456```三、使用Spring Boot读取YML配置在Spring Boot项目中，可以使用@ConfigurationProperties注解来将YML文件中的配置映射到Java对象中。

首先需要在pom.xml文件中引入相应的依赖：```xml<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-configuration-processor</artifactId> <optional>true</optional></dependency>```接着定义一个配置类，使用@ConfigurationProperties注解来指定YML文件的前缀，然后定义相应的属性：```javaimportorg.springframework.boot.context.properties.ConfigurationProperties;import ponent;@Component@ConfigurationProperties(prefix = "server")public class ServerConfig {private int port;private String hostname;// 省略getter和setter方法}```在YML配置文件中，将配置和属性对应起来：```yamlserver:port: 8080hostname: localhost```然后就可以在其他组件中注入ServerConfig类，获取YML配置的值了：```java@Autowiredprivate ServerConfig serverConfig;```四、使用SnakeYAML读取YML配置除了使用Spring Boot的@ConfigurationProperties注解来读取YML配置外，我们还可以使用SnakeYAML来手动读取YML配置。

java中ini4j的用法 -回复

java中ini4j的用法 -回复

java中ini4j的用法-回复Java中ini4j的用法在Java开发中，我们经常需要处理配置文件。

对于简单的配置文件，我们可以直接使用Properties类进行读写操作。

但是当配置文件比较复杂时，例如包含多个节（section）和键值对（key-value pair），Properties类就显得力不从心了。

这时，我们就需要用到一些第三方库，如ini4j。

ini4j是一个开源的Java库，用于读写Windows INI格式的配置文件。

它提供了一套完整的API，使得我们可以像操作对象一样操作INI文件。

下面我们将一步一步地介绍如何使用ini4j库来读写INI文件。

1. 添加依赖首先，我们需要将ini4j库添加到我们的项目中。

如果你使用的是Maven，你可以在pom.xml文件中添加以下依赖：xml<dependency><groupId>org.ini4j</groupId><artifactId>ini4j</artifactId><version>0.5.4</version></dependency>2. 创建Ini对象接下来，我们需要创建一个Ini对象，用来表示一个INI文件。

你可以通过调用Ini对象的构造函数并传入一个File对象来创建一个Ini对象：javaIni ini = new Ini(new File("config.ini"));或者，你也可以通过传入一个InputStream对象来创建一个Ini对象：javaInputStream in = new FileInputStream("config.ini");Ini ini = new Ini(in);in.close();3. 读取配置信息有了Ini对象之后，我们就可以开始读取配置信息了。

java中properties用法

java中properties用法

java中properties用法Properties是Java中一种用于处理配置文件的类。

通过Properties，我们可以方便地读取和写入配置文件中的属性。

首先，我们可以使用Properties类来读取配置文件中的属性。

我们可以使用load()方法从文件中加载配置属性，并将它们存储在Properties对象中。

然后，我们可以使用getProperty()方法根据属性的键来获取对应的值。

例如：```javaProperties properties = new Properties();try {properties.load(new FileInputStream("config.properties"));String username = properties.getProperty("username");String password = properties.getProperty("password");System.out.println("Username: " + username);System.out.println("Password: " + password);} catch (IOException e) {e.printStackTrace();}```在上面的例子中，假设config.properties文件中包含以下内容：```username=johndoepassword=secretpassword```通过加载配置文件并使用getProperty()方法，我们可以轻松地获取到用户名和密码的值。

另外，我们也可以使用Properties类来写入配置属性到配置文件。

我们可以使用setProperty()方法来设置属性的键值对。

然后，我们可以使用store()方法将属性写入到文件中。

Java-如何读取配置文件中参数信息

Java-如何读取配置文件中参数信息

Java-如何读取配置⽂件中参数信息Java中读取配置⽂件中参数：通过JDK中Properties来实现对配置⽂件的读取。

⽅法⼀：通过⽅法⼀： Properties主要⽤于读取Java的配置⽂件，不同的编程语⾔有⾃⼰所⽀持的配置⽂件，配置⽂件中很多变量是经常改变的，为了⽅便⽤户的配置，能让⽤户够脱离程序本⾝去修改相关的变量设置。

就像在Java中，其配置⽂件常为.properties⽂件，是以键值对的形式进⾏参数配置的。

1、配置⽂件的设置sysName StefanieSunsysChinesName=孙燕姿sysBirthday:1976-07-02#空格、：、= 三种⽅式均可表⽰键值对的存在。

2、新建读取类public class SystemProperties{ //设置配置⽂件路径 private final static String urlPath1 = "cn/com/yitong/util/system.properties"; private final static String urlPath2 = "src/main/java/cn/com/yitong/util/system.properties"; private fianl static Properties properties = new Properties(); ⽅法1：使⽤classLoader来获取相对⽬录下⽂件（⽂件必须同SystemProperties同⽬录下；路径见"图1"；此⽂件地址⽆需精确⾄"src/main/java/cn/com/yitong/util/system.properties",因为是同 SystemProperties同⽬录） static{ try{ InputStream inputStream = ClassLoader.getSystemResourceAsStream(urlPath1); properties.load(inputStream); //properties.load(new InputStreamReader(ClassLoader.getSystemResourceAsStream(urlPath), "UTF-8"));⽅法类似 }catch(IOExecption e){ e.printStackTrace(); } } ⽅法2：使⽤BufferedReader来读取配置⽂件。

如何基于JAVA读取yml配置文件指定key内容

如何基于JAVA读取yml配置文件指定key内容

如何基于JAVA读取yml配置⽂件指定key内容这篇⽂章主要介绍了如何基于JAVA读取yml配置⽂件指定key内容,⽂中通过⽰例代码介绍的⾮常详细，对⼤家的学习或者⼯作具有⼀定的参考学习价值,需要的朋友可以参考下先引⼊需要的依赖<!--读取yml⽂件--><dependency><groupId>org.yaml</groupId><artifactId>snakeyaml</artifactId><version>1.23</version></dependency>读取YML⽂件⼯具类的代码import ng3.StringUtils;import org.slf4j.Logger;import org.slf4j.LoggerFactory;import org.springframework.util.ResourceUtils;import org.yaml.snakeyaml.Yaml;import java.io.*;import java.util.HashMap;import java.util.Map;import java.util.Set;/*** @author hunmeng* @create 2020-01-10 20:34*/public class YmlUtils {private static final Logger LOGGER = LoggerFactory.getLogger(YmlUtils.class);private static String bootstrap_file = "classpath:application-test.yml";private static Map<String,String> result = new HashMap<>();/*** 根据⽂件名获取yml的⽂件内容* @param filePath* @param keys 第⼀个参数对应第⼀个key，第⼆个参数对应第⼆个key ⽐如下的所有就是两个参数、* getYmlByFileName(bootstrap_file,"spring", "name");* @return*/public static Map<String,String> getYmlByFileName(String filePath, String... keys) {result = new HashMap<>();if(filePath == null) filePath = bootstrap_file;InputStream in = null;try {File file = ResourceUtils.getFile(filePath);in = new BufferedInputStream(new FileInputStream(file));Yaml props = new Yaml();Object obj = props.loadAs(in,Map.class);Map<String,Object> param = (Map<String, Object>) obj;for(Map.Entry<String,Object> entry:param.entrySet()){String key = entry.getKey();Object val = entry.getValue();if (keys.length != 0 && !keys[0].equals(key)){continue;}if(val instanceof Map){forEachYaml(key,(Map<String, Object>) val, 1, keys);}else{result.put(key, val.toString());}}return result;} catch (FileNotFoundException e) {LOGGER.error(e.getMessage(),e);}finally {if (in != null){try {in.close();} catch (IOException e) {LOGGER.error(e.getMessage(),e);}}}return null;}/*** 根据key获取值* @param key* @return*/public static String getValue(String key) throws FileNotFoundException {Map<String,String> map = getYmlByFileName(null);if(map==null)return null;return map.get(key);}/*** 遍历yml⽂件，获取map集合* @param key_str* @param obj* @param i* @param keys* @return*/public static Map<String,String> forEachYaml(String key_str,Map<String, Object> obj, int i, String... keys){ for(Map.Entry<String,Object> entry:obj.entrySet()){String key = entry.getKey();Object val = entry.getValue();if (keys.length > i && !keys[i].equals(key)){continue;}String str_new = "";if(StringUtils.isNotEmpty(key_str)){str_new = key_str+ "."+key;}else{str_new = key;}if(val instanceof Map){forEachYaml(str_new,(Map<String, Object>) val, ++i, keys);i--;}else{result.put(str_new,val.toString());}}return result;}/*** 获取bootstrap.yml的name* @return*/public static String getApplicationName() throws FileNotFoundException {return getYmlByFileName(bootstrap_file).get("server.port");}/*** 获取bootstrap.yml的name* @return*/public static String getApplicationName1() throws FileNotFoundException {String name = getYmlByFileName(bootstrap_file).get("");return name + "center";}public static void main(String[] args) throws FileNotFoundException {Map<String, String> ymlByFileName = getYmlByFileName(bootstrap_file,"spring");Set<Map.Entry<String, String>> entries = ymlByFileName.entrySet();for (Map.Entry<String, String> entry : entries) {System.out.println(entry.getKey()+"==="+entry.getValue());}System.out.println(getApplicationName());}}以上就是本⽂的全部内容，希望对⼤家的学习有所帮助，也希望⼤家多多⽀持。

java配置文件properties，yml，一般文件

java配置文件properties，yml，一般文件

java配置⽂件properties，yml，⼀般⽂件JAVA编写配置⽂件的⼏种⽅式：JAVA配置⽂件，⼀般都放在resource⽬录下，⽆论是下⾯提到的properties、yml还是普通的txt等⽂件。

在打成jar包之后，只需要jar包程序就可运⾏，如果要修改配置⽂件，只需将配置⽂件放在与jar包同⼀⽬录下即可，jar包会⾃动读取。

1、properties⽂件配置⽂件⾥⾯写好你要⽤的配置值：创建获取properties对象的函数：public static Properties loadPropertiesFromFile(String filename) throws IOException {Properties p = new Properties();InputStream input = Downloader.class.getClassLoader().getResourceAsStream(filename);p.load(input);return p;}代码中调⽤配置量：Properties p = loadPropertiesFromFile("downloader.properties");String regex=p.getProperty("local_ip_regex")；2、yml⽂件配置⽂件⾥⾯配置值的⽅式与properties类似，也是⽤变量名=值的⽅式，但是中间可以⽤----隔开，然后yml会⾃动将两个-------之间的内容解析为⼀个map⼀个yml⽂件解析出来就是⼀个List<Map>3、直接读取⽂件转化为String或InputStream参考：、java中读取resources⽬录下的配置⽂件：https:///xu511739113/article/details/52440982使⽤inputstream按⾏读取⽂件：https:///u010889616/article/details/51477037public static InputStream get_whitelist_inputstream(){//获取配置⽂件的inputstreamClassLoader classLoader=Downloader.class.getClassLoader();InputStream whitelist_inputstream=classLoader.getResourceAsStream(p.getProperty("white_list_file"));return whitelist_inputstream;//获取配置⽂件的路径名// ClassLoader classLoader=Downloader.class.getClassLoader();// URL resource=classLoader.getResource(p.getProperty("white_list_file"));// String path=resource.getPath();}。

java读取项目中模板文件（srcmainresources）

java读取项目中模板文件（srcmainresources）

java读取项⽬中模板⽂件（srcmainresources）在springboot项⽬的开发中，当需要读取src/下的配置⽂件时，该怎么做？Resources下有⼀个⽂件名为acceptsNum.xls的模板⽂件1.在java类中读取若配置⽂件不在src/main/resources⽬录下，可以直接使⽤1. Properties prop = new properties();2. prop.load(new InputStream("acceptsNum.xls"));当配置⽂件放在src/main/resources的⽬录下时，只能使⽤Class.getResourceAsStream()⽅法来加载1. Properties prop = new properties();2. prop.load(this.getClass().getResourceAsStream("/acceptsNum.xls"));InputStream is = null;is = this.getClass().getResourceAsStream("/static/xls/acceptsNum.xls");此时，getResourceAsStream(String name)⽅法中参数路径的写法：1).若写成"acceptsNum.xls"，则是去当前类的class⽂件同⼀⽬录下找（但是显然在正常项⽬不会有⼈将配置⽂件放在这种位置）。

2).若写成"/acceptsNum.xls"，则是去整个项⽬的classes⽬录下去找，即target/classes--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------2.在spring框架的xml⽂件中读取配置⽂件kafka.properties以下就有两种⽅法来调⽤1).⾸先可以在spring的bean中配置<bean id="propertyConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer"><property name="locations"><list><span style="white-space:pre"> </span><value>/kafka.properties</value></list></property></bean>这⾥还可以在list标签中配置多个value，这样就可以在bean中读取⼀个甚⾄多个配置⽂件。

java（包括springboot）读取resources下文件方式

java（包括springboot）读取resources下文件方式

java（包括springboot）读取resources下⽂件⽅式1、使⽤项⽬内路径读取，该路径只在开发⼯具中显⽰，类似：src/main/resources/resource.properties。

只能在开发⼯具中使⽤，部署之后⽆法读取。

（不通⽤） File file = new File("src/main/resources/resource.properties"); @Testpublic void testReadFile2() throws IOException {File file = new File("src/main/resources/resource.properties");FileInputStream fis = new FileInputStream(file);InputStreamReader isr = new InputStreamReader(fis);BufferedReader br = new BufferedReader(isr);String data = null;while((data = br.readLine()) != null) {System.out.println(data);}br.close();isr.close();fis.close();}2、使⽤org.springframework.util.ResourceUtils，读取。

在linux环境中⽆法读取。

（不通⽤）File file = ResourceUtils.getFile("classpath:resource.properties");FileInputStream fis = new FileInputStream(file);@Testpublic void testReadFile3() throws IOException {File file = ResourceUtils.getFile("classpath:resource.properties");FileInputStream fis = new FileInputStream(file);InputStreamReader isr = new InputStreamReader(fis);BufferedReader br = new BufferedReader(isr);String data = null;while((data = br.readLine()) != null) {System.out.println(data);}br.close();isr.close();fis.close();}3、使⽤org.springframework.core.io.ClassPathResource，各种环境都能读取。

  1. 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

一般来说，首页的内容比较多，但内容大多也有重复的地方，比如说某几块内容都是文章，只是文章类别不同，或者说某几块都是商品，只是商品的分类不同，那么我们在后台取数据时，都需要根据类别ID来取值的。

通常的做法都是写死ID，但写死又分为三种情况：
1、前台写死ID，通过<jsp:include page="xx.do?id=xx">，可以进行动态的包含内容。

2、可在service层写一个id的数组，String[] ids = ｛“”,"",""｝;用ids数组的下标来获得id值，这样也可以实现，如果数据库的ID值发生改变，只需要改变service层的ID数组就行。

3、用配置文件（这个配置文件以.properties结尾）。

将ID值写在配置文件中，表示的方法就和map一样，key=value，这样就OK。

下面我要说的是第三种方案，个人觉得第三种方案比第二种方案好，因为第二种方案改数据时，去找的话，有点不太方便。

/**
*java读取配置文件工具类
**
*/
public class ProperUtil {
private static final Logger log= Logger.getLogger(ProperUtil.class);
/**服务器配置文件的文件名*/
private static final String FILE_NAME = "resources.properties";
private static final Properties prop = new Properties();
static {
InputStream in
=ProperUtil.class.getClassLoader().getResourceAsStream(FILE_NAME);
("开始加载配置文件"+FILE_NAME);
try {
prop.load(in);
(FILE_NAME+"配置文件读取完毕!");
} catch (Exception e) {
log.error("加载"+FILE_NAME+"配置文件出错!"+e.getMessage());
}finally{
if(null != in){
try {
in.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
public static Properties getProp() {
return prop;
}
}
这里配置文件的地址一定要写对，不然就会报错。

SysConfig.properties里面的内容是：
/**
*基站照片保存路径
*@return
*/
public static String getSiteImagePath(){
Properties prop = ProperUtil.getProp();
return prop.getProperty("NewSId");
}
最后结果输出：002。

相关文档
最新文档