关于.properties文件-package文件

在我们平时写程序的时候，有些参数是经常改变的，而这种改变不是我们预知的。比如说我们开发了一个操作数据库的模块，在开发的时候我们连接本地的数据库那么 IP ，数据库名称，表名称，数据库主机等信息是我们本地的，要使得这个操作数据的模块具有通用性，那么以上信息就不能写死在程序里。通常我们的做法是用配置文件来解决。

各种语言都有自己所支持的配置文件类型。比如 Python ，他支持 .ini 文件。因为他内部有一个 ConfigParser 类来支持 .ini 文件的读写，根据该类提供的方法程序员可以自由的来操作 .ini 文件。而在 Java 中， Java 支持的是 .properties 文件的读写。 JDK 内置的 java.util.Properties 类为我们操作 .properties 文件提供了便利。

一． .properties 文件的形式 ==========================================================

# 以下为服务器、数据库信息

dbPort = localhost

databaseName = mydb

dbUserName = root

dbPassword = root

# 以下为数据库表信息

dbTable = mytable

# 以下为服务器信息

ip = 192.168.0.9

······

在上面的文件中我们假设该文件名为： test.properties 文件。其中 # 开始的一行为注释信息；在等号“ = ”左边的我们称之为 key ；等号“ = ”右边的我们称之为 value 。（其实就是我们常说的键 - 值对） key 应该是我们程序中的变量。而 value 是我们根据实际情况配置的。

二． JDK 中的 Properties 类 Properties 类存在于胞 Java.util 中，该类继承自 Hashtable ，它提供了几个主要的方法： 1． getProperty ( String key) ， 用指定的键在此属性列表中搜索属性。也就是通过参数 key ，得到 key 所对应的 value 。

2． load ( InputStream inStream) ，从输入流中读取属性列表（键和元素对）。通过对指定的文件（比如说上面的 test.properties 文件）进行装载来获取该文件中的所有键 - 值对。以供 getProperty ( String key) 来搜索。 3． setProperty ( String key, String value) ，调用 Hashtable 的方法 put 。他通过调用基类的put 方法来设置 键 - 值对。

4． store ( OutputStream out, String comments) ， 以适合使用 load 方法加载到 Properties 表中的格式，将此 Properties 表中的属性列表（键和元素对）写入输出流。与 load 方法相反，该方法将键 - 值对写入到指定的文件中去。

5． clear () ，清除所有装载的 键 - 值对。该方法在基类中提供。

有了以上几个方法我们就可以对 .properties 文件进行操作了！

简单实例：

Java代码

1. package cn.net.yans.common.util;
3. import java.io.FileInputStream;
4. import java.io.FileNotFoundException;
5. import java.io.FileOutputStream;
6. import java.io.IOException;
7. import java.util.Properties;
9. /**
10. * 读取properties文件
11. *
12. * @author yans
13. *
14. */
15. public class Configuration {
16. private Properties propertie;
17. private FileInputStream inputFile;
18. private FileOutputStream outputFile;
20. /**
21. * 初始化Configuration类
22. */
23. public Configuration() {
24. propertie = new Properties();
25. }
27. /**
28. * 初始化Configuration类
29. *
30. * @param filePath
31. * 要读取的配置文件的路径+名称
32. */
33. public Configuration(String filePath) {
34. propertie = new Properties();
35. try {
36. inputFile = new FileInputStream(this.getClass().getClassLoader()
37. .getResource(filePath).getPath());
38. propertie.load(inputFile);
39. inputFile.close();
40. } catch (FileNotFoundException ex) {
41. System.out.println("读取属性文件--->失败！- 原因：文件路径错误或者文件不存在");
42. ex.printStackTrace();
43. } catch (IOException ex) {
44. System.out.println("装载文件--->失败!");
45. ex.printStackTrace();
46. }
47. }// end ReadConfigInfo(...)
49. /**
50. * 重载函数，得到key的值
51. *
52. * @param key
53. * 取得其值的键
54. * @return key的值
55. */
56. public String getValue(String key) {
57. if (propertie.containsKey(key)) {
58. String value = propertie.getProperty(key);// 得到某一属性的值
59. return value;
60. } else
61. return "";
62. }// end getValue(...)
64. /**
65. * 重载函数，得到key的值
66. *
67. * @param fileName
68. * properties文件的路径+文件名
69. * @param key
70. * 取得其值的键
71. * @return key的值
72. */
73. public String getValue(String fileName, String key) {
74. try {
75. String value = "";
76. inputFile = new FileInputStream(fileName);
77. propertie.load(inputFile);
78. inputFile.close();
79. if (propertie.containsKey(key)) {
80. value = propertie.getProperty(key);
81. return value;
82. } else
83. return value;
84. } catch (FileNotFoundException e) {
85. e.printStackTrace();
86. return "";
87. } catch (IOException e) {
88. e.printStackTrace();
89. return "";
90. } catch (Exception ex) {
91. ex.printStackTrace();
92. return "";
93. }
94. }// end getValue(...)
96. /**
97. * 清除properties文件中所有的key和其值
98. */
99. public void clear() {
100. propertie.clear();
101. }// end clear();
103. /**
104. * 改变或添加一个key的值，当key存在于properties文件中时该key的值被value所代替， 当key不存在时，该key的值是value
105. *
106. * @param key
107. * 要存入的键
108. * @param value
109. * 要存入的值
110. */
111. public void setValue(String key, String value) {
112. propertie.setProperty(key, value);
113. }// end setValue(...)
115. /**
116. * 将更改后的文件数据存入指定的文件中，该文件可以事先不存在。
117. *
118. * @param fileName
119. * 文件路径+文件名称
120. * @param description
121. * 对该文件的描述
122. */
123. public void saveFile(String fileName, String description) {
124. try {
125. outputFile = new FileOutputStream(fileName);
126. propertie.store(outputFile, description);
127. outputFile.close();
128. } catch (FileNotFoundException e) {
129. e.printStackTrace();
130. } catch (IOException ioe) {
131. ioe.printStackTrace();
132. }
133. }// end saveFile(...)
135. public static void main(String[] args) throws IOException {
136. Configuration rc = new Configuration("powers.properties");
137. String[] powerList = rc.getValue("list").split(",");
138. for (String po : powerList) {
139. System.out.println(po);
140. }
141. }
142. }

package cn.net.yans.common.util;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Properties;
/**
 * 读取properties文件
 * 
 * @author yans
 * 
 */
public class Configuration {
	private Properties propertie;
	private FileInputStream inputFile;
	private FileOutputStream outputFile;
	/**
	 * 初始化Configuration类
	 */
	public Configuration() {
		propertie = new Properties();
	}
	/**
	 * 初始化Configuration类
	 * 
	 * @param filePath
	 * 要读取的配置文件的路径+名称
	 */
	public Configuration(String filePath) {
		propertie = new Properties();
		try {
			inputFile = new FileInputStream(this.getClass().getClassLoader()
					.getResource(filePath).getPath());
			propertie.load(inputFile);
			inputFile.close();
		} catch (FileNotFoundException ex) {
			System.out.println("读取属性文件--->失败！- 原因：文件路径错误或者文件不存在");
			ex.printStackTrace();
		} catch (IOException ex) {
			System.out.println("装载文件--->失败!");
			ex.printStackTrace();
		}
	}// end ReadConfigInfo(...)
	/**
	 * 重载函数，得到key的值
	 * 
	 * @param key
	 * 取得其值的键
	 * @return key的值
	 */
	public String getValue(String key) {
		if (propertie.containsKey(key)) {
			String value = propertie.getProperty(key);// 得到某一属性的值
			return value;
		} else
			return "";
	}// end getValue(...)
	/**
	 * 重载函数，得到key的值
	 * 
	 * @param fileName
	 * properties文件的路径+文件名
	 * @param key
	 * 取得其值的键
	 * @return key的值
	 */
	public String getValue(String fileName, String key) {
		try {
			String value = "";
			inputFile = new FileInputStream(fileName);
			propertie.load(inputFile);
			inputFile.close();
			if (propertie.containsKey(key)) {
				value = propertie.getProperty(key);
				return value;
			} else
				return value;
		} catch (FileNotFoundException e) {
			e.printStackTrace();
			return "";
		} catch (IOException e) {
			e.printStackTrace();
			return "";
		} catch (Exception ex) {
			ex.printStackTrace();
			return "";
		}
	}// end getValue(...)
	/**
	 * 清除properties文件中所有的key和其值
	 */
	public void clear() {
		propertie.clear();
	}// end clear();
	/**
	 * 改变或添加一个key的值，当key存在于properties文件中时该key的值被value所代替， 当key不存在时，该key的值是value
	 * 
	 * @param key
	 * 要存入的键
	 * @param value
	 * 要存入的值
	 */
	public void setValue(String key, String value) {
		propertie.setProperty(key, value);
	}// end setValue(...)
	/**
	 * 将更改后的文件数据存入指定的文件中，该文件可以事先不存在。
	 * 
	 * @param fileName
	 * 文件路径+文件名称
	 * @param description
	 * 对该文件的描述
	 */
	public void saveFile(String fileName, String description) {
		try {
			outputFile = new FileOutputStream(fileName);
			propertie.store(outputFile, description);
			outputFile.close();
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException ioe) {
			ioe.printStackTrace();
		}
	}// end saveFile(...)
	public static void main(String[] args) throws IOException {
		Configuration rc = new Configuration("powers.properties");
		String[] powerList = rc.getValue("list").split(",");
		for (String po : powerList) {
			System.out.println(po);
		}
	}
}

路径相关问题：

在java中使用相对路径

无标题文档

?

在开发过程中，我们经常会遇到读取配置文件的情况，对于配置文件的读取，根据环境等情况又各有不同，一般情况下，如果从非jar包中使用相对/路径，比较简单，就不在累述了，而在很多

情况下，我们需要把我们的class打包成jar文件，进行使用，这时就会发现，我们先前如果没有考虑到这些，可能就行不通了，那么，该如何解决呢？方法如下

：

有如下路径 ：

Web-info--|-->classes--->conf-->config.properties

|-->lib

此时加入我们需要读取config.properties，在不使用jar包时，使用如下方式读取，不失为一种方法：

File f = new File(this.getClass().getResource("/").getPath());

f = new File(f.getPath() + "/conf/config.properties");

或者：（this.getClass().getClassLoader().getResource(fileName).getPath()）

注：f.getPath()即为当class所在的绝对路径。如：c:\javasrc\web-inf\classes

然后,对文件对象进行处理，就能把配置信息读取出来了，但是加入如上class被打包成jar文件，那么，在程序执行到这里时，就会无法找到配置文件，那么该如何处理呢？

处理方法如下：

String s_config="conf/config.properties";

InputStream in = ClassLoader.getSystemResourceAsStream(s_config);

if( in == null ){

System.out.println( " 打开 " + s_config + "失败！" );

}else

{

Properties properties = new Properties();

properties.load(in);

//

//接下来就可以通过properties.getProperty(String obj)方法对进行配置信息读取了

1. System.getProperty （"user.dir" ）当前用户目录的相对路径。

2. this.getClass().getResource("") 到的也是当前ClassPath 的绝对URI 路径。

3. ClassLoader.getSystemResource("") 到的也是当前ClassPath 的绝对URI 路径。

4. Thread.currentThread().getContextClassLoader().getResource("") 到的也是当前ClassPath 的绝对URI 路径。

读取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() 所得到的java.lang.ClassLoader 的getResourceAsStream() 方法。

示例：

InputStream in = JProperties.class.getClassLoader().getResourceAsStream(name);

Properties p = new Properties();

p.load(in);

6. 使用java.lang.ClassLoader 类的getSystemResourceAsStream() 静态方法

示例： InputStream in = ClassLoader.getSystemResourceAsStream(name);

Properties p = new Properties();

p.load(in);

7.Servlet 中可以使用javax.servlet.ServletContext 的getResourceAsStream() 方法

示例： InputStream in = context.getResourceAsStream(path);

Properties p = new Properties();

p.load(in);

空格

//获得文件路径,并对路径进行处理

private static String getUrl()

{

String path = configLoad.class.getResource("config.properties").toString();

path = path.replace(", " "); //引号中有一个半角的空格

path = path.substring(6);

return path;

}

}

那么这里返回了一个Properties类型的值,在这里就可以使用getProperty()来获得值

如:Properties pro = configLoad.getConfig();

String http = pro.getProperty("url").toString();

总 结：java的properties文件需要放到classpath下面，这样程序才能读取到，有关classpath实际上就是java类或者库的存放 路径，在java工程中，properties放到class文件一块。在web应用中，最简单的方法是放到web应用的WEB-INF/classes 目录下即可，也可以放在其他文件夹下面，这时候需要在设置classpath环境变量的时候，将这个文件夹路径加到classpath变量中，这样也也可 以读取到。在此，你需要对classpath有个深刻理解，classpath绝非系统中刻意设定的那个系统环境变量，WEB-INF/classes其 实也是，java工程的class文件目录也是。

properties属性文件内容都是以键值对形式存在的，比如我写一个叫test.properties的文件，打开后可以再里面写如：name=Tom

而在java类中需要new一个Properties类的对象，如下：

Properties properties = new Properties();

接下来需要获取test.properties的文件路径：

String path = Thread.currentThread().getContextClassLoader().getResource("test.properties").getPath();

然后加载该文件：

properties.load(new FileInputStream(path));

最后你就可以get它的属性了：

String name_1=properties.getProperty("name");

这个name_1的值就是“TOM”了。

（因为涉及到文件流，所以加载那一步需要try catch，根据编译器提示自己加吧）

Java 读取 .properties 配置文件的几种方式Java 开发中，需要将一些易变的配置参数放置再 XML 配置文件或者 properties 配置文件中。然而 XML 配置文件需要通过 DOM 或 SAX 方式解析，而读取 properties 配置文件就比较容易。

介绍几种读取方式：

1、基于ClassLoder读取配置文件

注意：该方式只能读取类路径下的配置文件，有局限但是如果配置文件在类路径下比较方便。

1 Properties properties = new Properties();
2 // 使用ClassLoader加载properties配置文件生成对应的输入流
3 InputStream in = PropertiesMain.class.getClassLoader().getResourceAsStream("config/config.properties");
4 // 使用properties对象加载输入流
5 properties.load(in);
6 //获取key对应的value值
7 properties.getProperty(String key);

2、基于 InputStream 读取配置文件

注意：该方式的优点在于可以读取任意路径下的配置文件

1 Properties properties = new Properties();
2 // 使用InPutStream流读取properties文件
3 BufferedReader bufferedReader = new BufferedReader(new FileReader("E:/config.properties"));
4 properties.load(bufferedReader);
5 // 获取key对应的value值
6 properties.getProperty(String key);

3、通过 java.util.ResourceBundle 类来读取，这种方式比使用 Properties 要方便一些

1>通过 ResourceBundle.getBundle() 静态方法来获取（ResourceBundle是一个抽象类），这种方式来获取properties属性文件不需要加.properties后缀名，只需要文件名即可

1 　　 properties.getProperty(String key);
2 //config为属性文件名，放在包com.test.config下，如果是放在src下，直接用config即可 
3 ResourceBundle resource = ResourceBundle.getBundle("com/test/config/config");
4 String key = resource.getString("keyWord"); 

2>从 InputStream 中读取，获取 InputStream 的方法和上面一样，不再赘述

1 　　ResourceBundle resource = new PropertyResourceBundle(inStream);

注意：在使用中遇到的最大的问题可能是配置文件的路径问题，如果配置文件入在当前类所在的包下，那么需要使用包名限定，如：config.properties入在com.test.config包下，则要使用com/test/config/config.properties（通过Properties来获取）或com/test/config/config（通过ResourceBundle来获取）；属性文件在src根目录下，则直接使用config.properties或config即可。

下面附上几种方式的测试代码，仅供参考：

 1 package com.test.properties;
 2 
 3 import java.io.BufferedInputStream;
 4 import java.io.File;
 5 import java.io.FileInputStream;
 6 import java.io.IOException;
 7 import java.io.InputStream;
 8 import java.util.Enumeration;
 9 import java.util.Properties;
 10 
 11 import org.springframework.core.io.support.PropertiesLoaderUtils;
 12 
 13 /**
 14 * 
 15 * @ClassName: TestProperties 
 16 * @Description: 获取配置文件信息 
 17 * @date: 2017年11月25日 上午10:56:00 
 18 * @version: 1.0.0
 19 */
 20 public class TestProperties {
 21 
 22 
 23 /**
 24 * 
 25 * @Title: printAllProperty 
 26 * @Description: 输出所有配置信息 
 27 * @param props
 28 * @return void 
 29 * @throws
 30 */
 31 private static void printAllProperty(Properties props) 
 32 { 
 33 @SuppressWarnings("rawtypes") 
 34 Enumeration en = props.propertyNames(); 
 35 while (en.hasMoreElements()) 
 36 { 
 37 String key = (String) en.nextElement(); 
 38 String value = props.getProperty(key); 
 39 System.out.println(key + " : " + value); 
 40 } 
 41 }
 42 
 43 /**
 44 * 根据key读取value
 45 * 
 46 * @Title: getProperties_1 
 47 * @Description: 第一种方式：根据文件名使用spring中的工具类进行解析 
 48 * filePath是相对路劲，文件需在classpath目录下
 49 * 比如：config.properties在包com.test.config下， 
 50 * 路径就是com/test/config/config.properties 
 51 * 
 52 * @param filePath 
 53 * @param keyWord 
 54 * @return
 55 * @return String 
 56 * @throws
 57 */
 58 public static String getProperties_1(String filePath, String keyWord){
 59 Properties prop = null;
 60 String value = null;
 61 try {
 62 // 通过Spring中的PropertiesLoaderUtils工具类进行获取
 63 prop = PropertiesLoaderUtils.loadAllProperties(filePath);
 64 // 根据关键字查询相应的值
 65 value = prop.getProperty(keyWord);
 66 } catch (IOException e) {
 67 e.printStackTrace();
 68 }
 69 return value;
 70 }
 71 
 72 /**
 73 * 读取配置文件所有信息
 74 * 
 75 * @Title: getProperties_1 
 76 * @Description: 第一种方式：根据文件名使用Spring中的工具类进行解析 
 77 * filePath是相对路劲，文件需在classpath目录下
 78 * 比如：config.properties在包com.test.config下， 
 79 * 路径就是com/test/config/config.properties
 80 * 
 81 * @param filePath 
 82 * @return void 
 83 * @throws
 84 */
 85 public static void getProperties_1(String filePath){
 86 Properties prop = null;
 87 try {
 88 // 通过Spring中的PropertiesLoaderUtils工具类进行获取
 89 prop = PropertiesLoaderUtils.loadAllProperties(filePath);
 90 printAllProperty(prop);
 91 } catch (IOException e) {
 92 e.printStackTrace();
 93 }
 94 }
 95 
 96 /**
 97 * 根据key读取value
 98 * 
 99 * @Title: getProperties_2 
100 * @Description: 第二种方式：使用缓冲输入流读取配置文件，然后将其加载，再按需操作
101 * 绝对路径或相对路径， 如果是相对路径，则从当前项目下的目录开始计算， 
102 * 如：当前项目路径/config/config.properties, 
103 * 相对路径就是config/config.properties 
104 * 
105 * @param filePath
106 * @param keyWord
107 * @return
108 * @return String 
109 * @throws
110 */
111 public static String getProperties_2(String filePath, String keyWord){
112 Properties prop = new Properties();
113 String value = null;
114 try {
115 // 通过输入缓冲流进行读取配置文件
116 InputStream InputStream = new BufferedInputStream(new FileInputStream(new File(filePath)));
117 // 加载输入流
118 prop.load(InputStream);
119 // 根据关键字获取value值
120 value = prop.getProperty(keyWord);
121 } catch (Exception e) {
122 e.printStackTrace();
123 }
124 return value;
125 }
126 
127 /**
128 * 读取配置文件所有信息
129 * 
130 * @Title: getProperties_2 
131 * @Description: 第二种方式：使用缓冲输入流读取配置文件，然后将其加载，再按需操作
132 * 绝对路径或相对路径， 如果是相对路径，则从当前项目下的目录开始计算， 
133 * 如：当前项目路径/config/config.properties, 
134 * 相对路径就是config/config.properties 
135 * 
136 * @param filePath
137 * @return void
138 * @throws
139 */
140 public static void getProperties_2(String filePath){
141 Properties prop = new Properties();
142 try {
143 // 通过输入缓冲流进行读取配置文件
144 InputStream InputStream = new BufferedInputStream(new FileInputStream(new File(filePath)));
145 // 加载输入流
146 prop.load(InputStream);
147 printAllProperty(prop);
148 } catch (Exception e) {
149 e.printStackTrace();
150 }
151 }
152 
153 /**
154 * 根据key读取value
155 * 
156 * @Title: getProperties_3 
157 * @Description: 第三种方式：
158 * 相对路径， properties文件需在classpath目录下， 
159 * 比如：config.properties在包com.test.config下， 
160 * 路径就是/com/test/config/config.properties 
161 * @param filePath
162 * @param keyWord
163 * @return
164 * @return String 
165 * @throws
166 */
167 public static String getProperties_3(String filePath, String keyWord){
168 Properties prop = new Properties();
169 String value = null;
170 try {
171 InputStream inputStream = TestProperties.class.getResourceAsStream(filePath);
172 prop.load(inputStream);
173 value = prop.getProperty(keyWord);
174 } catch (IOException e) {
175 e.printStackTrace();
176 }
177 return value;
178 }
179 
180 /**
181 * 读取配置文件所有信息
182 * 
183 * @Title: getProperties_3 
184 * @Description: 第三种方式：
185 * 相对路径， properties文件需在classpath目录下， 
186 * 比如：config.properties在包com.test.config下， 
187 * 路径就是/com/test/config/config.properties 
188 * @param filePath
189 * @return
190 * @throws
191 */
192 public static void getProperties_3(String filePath){
193 Properties prop = new Properties();
194 try {
195 InputStream inputStream = TestProperties.class.getResourceAsStream(filePath);
196 prop.load(inputStream);
197 printAllProperty(prop);
198 } catch (IOException e) {
199 e.printStackTrace();
200 }
201 }
202 
203 
204 public static void main(String[] args) {
205 // 注意路径问题
206 String properties_1 = getProperties_1("com/test/config/config.properties", "wechat_appid");
207 System.out.println("wechat_appid = " + properties_1);
208 getProperties_1("com/test/config/config.properties");
209 System.out.println("*********************************************");
210 // 注意路径问题
211 String properties_2 = getProperties_2("configure/configure.properties", "jdbc.url");
212 System.out.println("jdbc.url = " + properties_2);
213 getProperties_2("configure/configure.properties");
214 System.out.println("*********************************************");
215 // 注意路径问题
216 String properties_3 = getProperties_3("/com/test/config/config.properties", "wechat_appid");
217 System.out.println("wechat_appid = " + properties_3);
218 getProperties_3("/com/test/config/config.properties");
219 }
220 }