实现对properties文件的有序读写

r囧r小猫 2022-06-13 00:39 189阅读 0赞

###     ###

最近遇到一项需求，要求把properties文件中的内容读取出来供用户修改，修改完后需要再重新保存到properties文件中。很简单的需求吧，可问题是Properties是继承自HashTable的，直接通过keySet()、keys()或entrySet()方法对Properties中的元素进行遍历时取出来的内容顺序与properties文件中的顺序不一致，这是问题一；问题二是就算取出来的时候是有序的，保存到文件中时又是无序的了。

当然，解决这两个问题的方法有很多。我最终采用的方法是自定义一个PropertiesUtil类，该类继承自Properties。PropertiesUtil提供一个返回由key按照存入顺序组成的List的方法，getKeyList()，这样问题一就解决了。那如何保证getKeyList()方法返回的就是有序的key组成的集合呢？我查看了一下Properties方法的源码，发现其setProperty()方法实际上就是调用了父类HashTable的put()方法，其次Properties在从文件中加载内容时是按照文件顺序进行读取，然后调用父类HashTable的put()方法进行储存。所以问题的解决办法就是PropertiesUtil持有一个私有的可以有序存储key的集合，然后重写父类的put()方法，在方法体中照常通过super.put()进行属性的存储，同时将key添加到存储key的集合中。

Properties提供有save()方法和store()方法可以将当前对象的内容存放到指定的输出流中，但它们的底层逻辑都是一样的。通过调用keys()方法获取一个Enumeration，然后对该Enumeration进行遍历，依次将对应的key和value写入到输出流中，所以要保证写入是有序的，就要保证遍历keys()返回的Enumeration时取出的元素key是有序的。所以解决方法是重写keys()方法，保证遍历返回的Enumeration时得到的key是有序的。完整代码如下：

Java代码   ![收藏代码][icon_star.png]

1.  import java.io.BufferedWriter;  
2.  import java.io.FileInputStream;  
3.  import java.io.FileNotFoundException;  
4.  import java.io.FileOutputStream;  
5.  import java.io.IOException;  
6.  import java.io.InputStream;  
7.  import java.io.OutputStream;  
8.  import java.io.OutputStreamWriter;  
9.  import java.util.ArrayList;  
10. import java.util.Enumeration;  
11. import java.util.List;  
12. import java.util.Properties;  
13.   
14. public class PropertiesUtil extends Properties \{  
15.   
16.     private static final long serialVersionUID = 1L;  
17.   
18.     private List<Object> keyList = new ArrayList<Object>();  
19.       
20.     /\*\* 
21.      \* 默认构造方法 
22.      \*/  
23.     public PropertiesUtil() \{  
24.           
25.     \}  
26.       
27.     /\*\* 
28.      \* 从指定路径加载信息到Properties 
29.      \* @param path 
30.      \*/  
31.     public PropertiesUtil(String path) \{  
32.         try \{  
33.             InputStream is = new FileInputStream(path);  
34.             this.load(is);  
35.         \} catch (FileNotFoundException e) \{  
36.             e.printStackTrace();  
37.             throw new RuntimeException("指定文件不存在！");  
38.         \} catch (IOException e) \{  
39.             e.printStackTrace();  
40.         \}  
41.     \}  
42.       
43.     /\*\* 
44.      \* 重写put方法，按照property的存入顺序保存key到keyList，遇到重复的后者将覆盖前者。 
45.      \*/  
46.     @Override  
47.     public synchronized Object put(Object key, Object value) \{  
48.         this.removeKeyIfExists(key);  
49.         keyList.add(key);  
50.         return super.put(key, value);  
51.     \}  
52.       
53.   
54.     /\*\* 
55.      \* 重写remove方法，删除属性时清除keyList中对应的key。 
56.      \*/  
57.     @Override  
58.     public synchronized Object remove(Object key) \{  
59.         this.removeKeyIfExists(key);  
60.         return super.remove(key);  
61.     \}  
62.       
63.     /\*\* 
64.      \* keyList中存在指定的key时则将其删除 
65.      \*/  
66.     private void removeKeyIfExists(Object key) \{  
67.         keyList.remove(key);  
68.     \}  
69.       
70.     /\*\* 
71.      \* 获取Properties中key的有序集合 
72.      \* @return 
73.      \*/  
74.     public List<Object> getKeyList() \{  
75.         return keyList;  
76.     \}  
77.       
78.     /\*\* 
79.      \* 保存Properties到指定文件，默认使用UTF-8编码 
80.      \* @param path 指定文件路径 
81.      \*/  
82.     public void store(String path) \{  
83.         this.store(path, "UTF-8");  
84.     \}  
85.       
86.     /\*\* 
87.      \* 保存Properties到指定文件，并指定对应存放编码 
88.      \* @param path 指定路径 
89.      \* @param charset 文件编码 
90.      \*/  
91.     public void store(String path, String charset) \{  
92.         if (path != null && !"".equals(path)) \{  
93.             try \{  
94.                 OutputStream os = new FileOutputStream(path);  
95.                 BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(os, charset));  
96.                 this.store(bw, null);  
97.                 bw.close();  
98.             \} catch (FileNotFoundException e) \{  
99.                 e.printStackTrace();  
100.             \} catch (IOException e) \{  
101.                 e.printStackTrace();  
102.             \}  
103.         \} else \{  
104.             throw new RuntimeException("存储路径不能为空!");  
105.         \}  
106.     \}  
107.   
108.     /\*\* 
109.      \* 重写keys方法，返回根据keyList适配的Enumeration，且保持HashTable keys()方法的原有语义， 
110.      \* 每次都调用返回一个新的Enumeration对象，且和之前的不产生冲突 
111.      \*/  
112.     @Override  
113.     public synchronized Enumeration<Object> keys() \{  
114.         return new EnumerationAdapter<Object>(keyList);  
115.     \}  
116.       
117.     /\*\* 
118.      \* List到Enumeration的适配器 
119.      \*/  
120.     private class EnumerationAdapter<T> implements Enumeration<T> \{  
121.         private int index = 0;  
122.         private final List<T> list;  
123.         private final boolean isEmpty;  
124.           
125.         public EnumerationAdapter(List<T> list) \{  
126.             this.list = list;  
127.             this.isEmpty = list.isEmpty();  
128.         \}  
129.           
130.         public boolean hasMoreElements() \{  
131.             //isEmpty的引入是为了更贴近HashTable原有的语义，在HashTable中添加元素前调用其keys()方法获得一个Enumeration的引用，  
132.             //之后往HashTable中添加数据后，调用之前获取到的Enumeration的hasMoreElements()将返回false，但如果此时重新获取一个  
133.             //Enumeration的引用，则新Enumeration的hasMoreElements()将返回true，而且之后对HashTable数据的增、删、改都是可以在  
134.             //nextElement中获取到的。  
135.             return !isEmpty && index < list.size();  
136.         \}  
137.   
138.         public T nextElement() \{  
139.             if (this.hasMoreElements()) \{  
140.                 return list.get(index++);  
141.             \}  
142.             return null;  
143.         \}  
144.           
145.     \}  
146.   
147. \}

[icon_star.png]: /images/20220613/7d676d5e584a4b518c8a745d07725018.png