JAVA操作配置文件properties

一、Java Properties类

    Java中有个比较重要的类Properties（Java.util.Properties），主要用于读取Java的配置文件，各种语言都有自己所支持的配置文件，配置文件中很多变量是经常改变的，这样做也是为了方便用户，让用户能够脱离程序本身去修改相关的变量设置。像Python支持的配置文件是.ini文件，同样，它也有自己读取配置文件的类ConfigParse，方便程序员或用户通过该类的方法来修改.ini配置文件。在Java中，其配置文件常为.properties文件，格式为文本文件，文件的内容的格式是“键=值”的格式，文本注释信息可以用"#"来注释。

Properties类继承自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 ()，清除所有装载的 键 - 值对。该方法在基类中提供。

 

二、Java读取Properties文件

    Java读取Properties文件的方法有很多，详见： Java读取Properties文件的六种方法

但是最常用的还是通过java.lang.Class类的getResourceAsStream(String name)方法来实现，如下可以这样调用：

InputStream in = getClass().getResourceAsStream("资源Name");作为我们写程序的，用此一种足够。

或者下面这种也常用：

InputStream in = new BufferedInputStream(new FileInputStream(filepath));

---------------------------------------------------------分割线-----------------------------------------------

一、读取配置文件的六种方法

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);

补充

Servlet中可以使用javax.servlet.ServletContext的getResourceAsStream()方法
示例：InputStream in = context.getResourceAsStream(path);
Properties p = new Properties();

p.load(in);

二、对应代码

1. package com.test.modul.utils;
3. import java.io.BufferedInputStream;
4. import java.io.File;
5. import java.io.FileInputStream;
6. import java.io.FileNotFoundException;
7. import java.io.IOException;
8. import java.io.InputStream;
9. import java.util.Locale;
10. import java.util.Properties;
11. import java.util.PropertyResourceBundle;
12. import java.util.ResourceBundle;
14. /**
15. * 加载properties文件的方式
16. *
17. * @author wjzuo
18. *
19. */
20. public class LoadPropertiesFileUtil {
22. private static String basePath = "src/main/java/com/test/modul/utils/prop.properties";
23. private static String path = "";
25. /**
26. * 一、 使用java.util.Properties类的load(InputStream in)方法加载properties文件
27. *
28. * @return
29. */
30. public static String getPath1() {
32. try {
33. InputStream in = new BufferedInputStream( new FileInputStream(
34. new File(basePath)));
35. Properties prop = new Properties();
37. prop.load(in);
39. path = prop.getProperty( "path");
41. } catch (FileNotFoundException e) {
42. System.out.println( "properties文件路径书写有误，请检查！");
43. e.printStackTrace();
44. } catch (IOException e) {
45. // TODO Auto-generated catch block
46. e.printStackTrace();
47. }
49. return path;
50. }
52. /**
53. * 二、 使用java.util.ResourceBundle类的getBundle()方法
54. * 注意：这个getBundle()方法的参数只能写成包路径+properties文件名，否则将抛异常
55. *
56. * @return
57. */
58. public static String getPath2() {
59. ResourceBundle rb = ResourceBundle
60. .getBundle( "com/test/modul/utils/prop");
61. path = rb.getString( "path");
62. return path;
63. }
65. /**
66. * 三、 使用java.util.PropertyResourceBundle类的构造函数
67. *
68. * @return
69. */
70. public static String getPath3() {
71. InputStream in;
72. try {
73. in = new BufferedInputStream( new FileInputStream(basePath));
74. ResourceBundle rb = new PropertyResourceBundle(in);
75. path = rb.getString( "path");
76. } catch (FileNotFoundException e) {
77. // TODO Auto-generated catch block
78. e.printStackTrace();
79. } catch (IOException e) {
80. // TODO Auto-generated catch block
81. e.printStackTrace();
82. }
83. return path;
84. }
86. /**
87. * 四、 使用class变量的getResourceAsStream()方法
88. * 注意：getResourceAsStream()方法的参数按格式写到包路径+properties文件名+.后缀
89. *
90. * @return
91. */
92. public static String getPath4() {
93. InputStream in = LoadPropertiesFileUtil.class
94. .getResourceAsStream( "/com/test/modul/utils/prop.properties");
95. Properties p = new Properties();
96. try {
97. p.load(in);
98. path = p.getProperty( "path");
99. } catch (IOException e) {
100. // TODO Auto-generated catch block
101. e.printStackTrace();
102. }
103. return path;
104. }
106. /**
107. * 五、
108. * 使用class.getClassLoader()所得到的java.lang.ClassLoader的getResourceAsStream()方法
109. * getResourceAsStream(name)方法的参数必须是包路径+文件名+.后缀
110. * 否则会报空指针异常
111. * @return
112. */
113. public static String getPath5() {
114. InputStream in = LoadPropertiesFileUtil.class.getClassLoader()
115. .getResourceAsStream( "com/test/modul/utils/prop.properties");
116. Properties p = new Properties();
117. try {
118. p.load(in);
119. path = p.getProperty( "path");
120. } catch (IOException e) {
121. // TODO Auto-generated catch block
122. e.printStackTrace();
123. }
124. return path;
125. }
127. /**
128. * 六、 使用java.lang.ClassLoader类的getSystemResourceAsStream()静态方法
129. * getSystemResourceAsStream()方法的参数格式也是有固定要求的
130. *
131. * @return
132. */
133. public static String getPath6() {
134. InputStream in = ClassLoader
135. .getSystemResourceAsStream( "com/test/modul/utils/prop.properties");
136. Properties p = new Properties();
137. try {
138. p.load(in);
139. path = p.getProperty( "path");
140. } catch (IOException e) {
141. // TODO Auto-generated catch block
142. e.printStackTrace();
143. }
144. return path;
145. }
147. public static void main(String[] args) {
148. System.out.println(LoadPropertiesFileUtil.getPath1());
149. System.out.println(LoadPropertiesFileUtil.getPath2());
150. System.out.println(LoadPropertiesFileUtil.getPath3());
151. System.out.println(LoadPropertiesFileUtil.getPath4());
152. System.out.println(LoadPropertiesFileUtil.getPath5());
153. System.out.println(LoadPropertiesFileUtil.getPath6());
154. }
155. }

其中第一、四、五、六种方式都是先获得文件的输入流，然后通过Properties类的load(InputStream inStream)方法加载到Properties对象中，最后通过Properties对象来操作文件内容；

第二、三中方式是通过ResourceBundle类来加载Properties文件，然后ResourceBundle对象来操做properties文件内容。

其中最重要的就是每种方式加载文件时，文件的路径需要按照方法的定义的格式来加载，否则会抛出各种异常，比如空指针异常。