java加载properties文件的六种基本方式

原文链接：http://blog.csdn.net/u011063151/article/details/51888640

 今天在学习spring的时候，突然想到用工具类的方式来加载properties文件，这样就可以在不改变代码的情况下，更改配置信息，以下是Java加载properties文件的六种基本方式的代码：

[java] view plain copy

 print?

1. package com.test.modul.utils;  
2.   
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;  
13.   
14. /** 
15.  * 加载properties文件的方式 
16.  * 
17.  * @author wjzuo 
18.  * 
19.  */  
20. public class LoadPropertiesFileUtil {  
21.   
22.     private static String basePath = "src/main/java/com/test/modul/utils/prop.properties";  
23.     private static String path = "";  
24.   
25.     /** 
26.      * 一、 使用java.util.Properties类的load(InputStream in)方法加载properties文件 
27.      * 
28.      * @return 
29.      */  
30.     public static String getPath1() {  
31.   
32.         try {  
33.             InputStream in = new BufferedInputStream(new FileInputStream(  
34.                     new File(basePath)));  
35.             Properties prop = new Properties();  
36.   
37.             prop.load(in);  
38.   
39.             path = prop.getProperty("path");  
40.   
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.         }  
48.   
49.         return path;  
50.     }  
51.   
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.     }  
64.   
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.     }  
85.   
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.     }  
105.   
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.     }  
126.   
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.     }  
146.   
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文件内容。

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