Java中封装配置文件使用Properties

1. 无论是有图形化的选项配置对话框，或者是系统 提供的注册表，文本形式的本地配置文件依然是最牢靠、应用最广泛的配置信息保存形式。配置信息的一般模式就是一个配置项对应一个值，前者一般是个字符串， 后者可能是数字或者字符串或者别的什么。在传统win32编程中有系统提供的api供我们解读.ini文件，后来也有操作注册表的封装好的api，在. net中更是有解读XML形式.config文件的现成方法。在Java中，对配置文件的使用进行封装也是十分有意义的。   
2.   
3. 　 　封装应该达到这样的效果：应用只管从配置信息进行按名读取值、设置值、保存等操作，而不需要关心具体以什么文件格式保存、如何解析。文件格式(纯文本? XML?数据库?)、IO方式(本地文件?远程文件?控制台流?)在封装类内部的变更，都不会影响应用对配置信息的感知。   
4.   
5. 　 　从键名-值的对应关系以及文件的存取，我们最容易想到的就是java.util.Properties对象，他是HashTable的子类，保存的就是 很多组键名-值的对应二原组，并提供快速的查询和直接的从文件读取、保存为文件的方法。具体请参考相关文档，我们直接看程序。   
6.   
7. 　　首先自定义一个异常：   
8.   
9.   
10. //ConfigurationException.java   
11. package configuration;    
12. public class ConfigurationException extends Exception{   
13. public ConfigurationException(){}   
14. public ConfigurationException(String msg){   
15.     super(msg);   
16. }   
17. }   
18.     
19. 　　然后是我们的封装类：   
20.   
21.   
22. //Configuration.java   
23. package configuration;   
24. import java.io.*;   
25. import java.util.*;   
26. import configuration.*;    
27. public class Configuration {   
28. private Properties config=new Properties();//记录配置项   
29. private String fn=null;//记录配置文件名   
30.   
31. //此构造方法用于新建配置文件   
32. public Configuration(){}   
33.   
34. //从指定文件名读入配置信息   
35. public Configuration(String fileName)   
36.       throws ConfigurationException {   
37.     try {   
38.       FileInputStream fin = new FileInputStream(fileName);   
39.       config.load(fin); //载入文件   
40.       fin.close();   
41.     }   
42.     catch (IOException ex) {   
43.       throw new ConfigurationException   
44.           ("无法读取指定的配置文件:"+fileName);   
45.     }   
46.     fn=fileName;   
47. }   
48.   
49. //指定配置项名称，返回配置值   
50. public String getValue(String itemName){   
51.     return config.getProperty(itemName);   
52. }   
53.   
54. //指定配置项名称和默认值，返回配置值   
55. public String getValue(String itemName,   
56.                          String defaultValue){   
57.     return config.getProperty(itemName,defaultValue);   
58. }   
59.   
60. //设置配置项名称及其值   
61. public void setValue(String itemName,String value){   
62.     config.setProperty(itemName,value);   
63.     return;   
64. }   
65.   
66. //保存配置文件，指定文件名和抬头描述   
67. public void saveFile(String fileName,String description)   
68.       throws ConfigurationException {   
69.     try {   
70.       FileOutputStream fout   
71.           = new FileOutputStream(fileName);   
72.       config.store(fout, description);//保存文件   
73.       fout.close();   
74.     }   
75.     catch (IOException ex) {   
76.       throw new ConfigurationException   
77.           ("无法保存指定的配置文件:"+fileName);   
78.     }   
79. }   
80.   
81. //保存配置文件，指定文件名   
82. public void saveFile(String fileName)   
83.       throws ConfigurationException {   
84.     saveFile(fileName,"");   
85. }   
86.   
87. //保存配置文件，采用原文件名   
88. public void saveFile() throws ConfigurationException {   
89.     if(fn.length()==0)   
90.       throw new ConfigurationException   
91.           ("需指定保存的配置文件名");   
92.     saveFile(fn);   
93. }   
94. }    
95.     
96. 　　从这个封装类我们可以看到，实例化对象的时候我们可以指定一个文件名使得从中读取配置信息，通过getValue方法取得属性值，setValue方法设置属性值，saveFile方法保存文件。然后我们具体来看看如何使用：   
97.   
98. //SetConfig.java   
99. import configuration.*;//包含这个包方能使用配置类   
100. import java.io.*;   
101.   
102. public class SetConfig {   
103. public static void main(String[] args) {   
104.     try {   
105.       Configuration config = new Configuration();   
106.       //设置一些属性值   
107.       config.setValue("Max_Users_Count", "50");   
108.       config.setValue("Max_OpenedFile_Count", "20");   
109.       //保存文件   
110.       config.saveFile("system.conf",   
111.                       "Sytem Global Configuration");   
112.     }   
113.     catch (ConfigurationException ex) {   
114.       //捕获我们自定义的异常   
115.       ex.printStackTrace();   
116.     }   
117. }   
118. }   
119.     
120. 　 　这段程序新建了一个配置，设置了两个配置项：Max_Users_Count为50；Max_OpenedFile_Count为20。最后将这个配置 保存为system.conf文件，并加入抬头注释"Sytem Global Configuration"。执行之后，在程序所在目录下产生了一个system.conf文件，我们用纯文本编辑器打开看看内容到底是什么：   
121.   
122.   
123. #Sytem Global Configuration   
124. #Mon Aug 02 23:43:39 PDT 2004  
125. Max_OpenedFile_Count=20  
126. Max_Users_Count=50     
127.   
128. 　　可以看到，第一行写入了我们加入的抬头注释，第二行自动产生了一个时间，后面两行用<配置项名称>=<配置值>的形式记录了配置信息。下面我们来读取这个配置文件：   
129.   
130.   
131. //ReadConfig.java   
132. import configuration.*;    
133. public class ReadConfig {   
134. public static void main(String[] args) {   
135.     try {   
136.       //读取指定文件   
137.       Configuration config   
138.           = new Configuration("system.conf");   
139.       //获取特定值   
140.       System.out.println   
141.           (config.getValue("Max_Users_Count") +   
142.           " users can be actived at the same time");   
143.      //指定默认值   
144.      System.out.println   
145.           (config.getValue("Max_OpenedFile_Count", "10") +   
146.           " files can be opened at the same time");   
147.     }   
148.     catch (ConfigurationException ex) {   
149.       ex.printStackTrace();   
150.     }   
151. }   
152. }    
153.     
154. 　　系统输出了   
155.   
156.   
157. 50 users can be actived at the same time   
158. 20 files can be opened at the same time   
159.     
160. 这样的信息。表明我们成功读取了配置信息。    
161.   
162. 　 　这样我们的封装类可以胜任普通的配置信息操作工作了。而且对于大多数的情况，这个类也足够用了。这里的代码都是可复用的，大家可以直接拷贝到自己的工程 中去。最后说明：这些属性值当然可以自己在文件里面改动，而且这也是配置文件最常见的使用方式；#号开头的都表示注释，可以任意添加和删除。   
163.   
164. 　 　任务完成了，但是还并不完美。采用Properties最大的方便就是有现成的查询、设置、文件存取方法，但是这样的<配置项名称>= <配置值>格式只是方便了在Java中的使用