關於Java配置文件properties的學習

在Java早期的開發中，常用*.properties文件存儲一些配置信息。其文件中的信息主要是以key=value的方式進行存儲，在早期受到廣泛的應用。而后隨着xml使用的廣泛，其位置漸漸被取代，不過，目前仍有一些框架如log4J在使用它。最近在弄自己的小玩意兒的時候也用到了它，順便加深了一下了解，在此分享。 

 

Java在對*.properties文件進行操作的時候，實際上是通過IO對文檔進行逐行的掃描，然后將文中非注釋的部分存放在一個properties對象中。Properties 實際上是繼承了hashtable，實現了Map接口。可以這樣理解，它是進行了進一步封裝的HashMap。存放到properties中后，可以對properties進行一系列的操作，此時的數據保存在內存中。最后，當需要保存數據的時候，是將properties中所有的鍵值重新寫入到文件中去。 對properties文件的操作，jdk提供了一系列的API。一下是一個工具類，實現了對properties文件的增刪查改的功能。

package com.sean.file.properties;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.UnsupportedEncodingException;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Map;
import java.util.Properties;
/**
 * Java 操作Properties的工具類
 * 實現功能：
 * 1、Properties文件的增刪查改功能
 * 2、解決讀寫中文亂碼問題
 * @author Sean
 * 
 */
public class PropertiesUtil {

    /**
     * Properties地址值，不需要加根標記"/"
     */
    private String src = "";
    private InputStreamReader inputStream = null;
    private OutputStreamWriter outputStream = null;
    private String encode="utf-8";
    public Properties properties ;

    /**
     * 默認構造函數
     */
    public PropertiesUtil() {
    }

    /**
     * 構造函數
     * 
     * @param src        傳入Properties地址值，不需要加根標記"/"
     */
    public PropertiesUtil(String src) {
        this.src = src;
    }
    
    
    /**
     * 構造函數，提供設置編碼模式
     * @param src        傳入Properties地址值，不需要加根標記"/"
     * @param encode    傳入對應的編碼模式，默認是utf-8
     */
    public PropertiesUtil(String src, String encode) {
        this(src);
        this.encode = encode;
    }

    /**
     * 加載properties文件
     * @author Sean
     * @date 2015-6-5
     * @return 返回讀取到的properties對象
     */
    public Properties load(){
        if(src.trim().equals("")){
            throw new RuntimeException("The path of Properties File is need");
        }
        try {
            inputStream=new InputStreamReader(ClassLoader.getSystemResourceAsStream(src),encode);
        } catch (UnsupportedEncodingException e1) {
            e1.printStackTrace();
        }
        properties=new Properties();
        try {
            properties.load(inputStream);
        } catch (IOException e) {
            e.printStackTrace();
        }
        return properties;
    }
    
    /**
     * 將配置寫入到文件
     * @author Sean
     * @date 2015-6-5
     * @throws Exception
     */
    public void write2File() throws Exception{
        //獲取文件輸出流
        outputStream=new OutputStreamWriter(new FileOutputStream(new File(ClassLoader.getSystemResource(src).toURI())),encode);
        properties.store(outputStream, null);
        close();
    }
    
    
    /**
     * 通過關鍵字獲取值
     * @author Sean
     * @date 2015-6-5
     * @param key    需要獲取的關鍵字
     * @return        返回對應的字符串，如果無，返回null
     */
    public String getValueByKey(String key){
        properties=load();
        String val =properties.getProperty(key.trim());
        close();
        return val;
        
    }
    
    /**
     * 通過關鍵字獲取值
     * @author Sean
     * @date 2015-6-5
     * @param key            需要獲取的關鍵字
     * @param defaultValue    若找不到對應的關鍵字時返回的值
     * @return                返回找到的字符串
     */
    public String getValueByKey(String key ,String defaultValue){
        properties=load();
        String val =properties.getProperty(key.trim(),defaultValue.trim());
        close();
        return val;
    }
    
    /**
     * 關閉輸入輸出流
     * @author Sean
     * @date 2015-6-5
     */
    public void close(){
        try {
            if(inputStream!=null){inputStream.close();}
            if(outputStream!=null){outputStream.close();}
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    
    /**
     * 獲取Properties所有的值
     * @author Sean
     * @date 2015-6-5
     * @return            返回Properties的鍵值對
     */
    public Map<String,String> getAllProperties(){
        properties=load();
        Map<String,String> map=new HashMap<String,String>();
        //獲取所有的鍵值
        Enumeration enumeration=properties.propertyNames();
        while(enumeration.hasMoreElements()){
            String key=(String) enumeration.nextElement();
            String value=getValueByKey(key);
            map.put(key, value);
        }
        close();
        return  map;
    }
    
    /**
     * 往Properties寫入新的鍵值
     * @author Sean
     * @date 2015-6-5
     * @param key    對應的鍵
     * @param value    對應的值
     */
    public void addProperties(String key,String value){
        properties=load();
        properties.put(key, value);
        try {
            write2File();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    
    /**
     * 添加Map中所有的值
     * @author Sean
     * @date 2015-6-5
     * @param map    對應的鍵值對集合
     */
    public void addAllProperties(Map<String,String> map){
        properties=load();
        properties.putAll(map);
        try {
            write2File();
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException("write fail");
        }
    }
    
    /**
     * 更新配置文件
     * @author Sean
     * 2015-6-5
     * @param key    需要更新的鍵值
     * @param value    對應的值
     */
    public void update(String key,String value){
        properties=load();
        if(!properties.containsKey(key)){
            throw new RuntimeException("not such key");
        }
        properties.setProperty(key, value);
        try {
            write2File();
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException("write fail");
        }
    }
    
    /**
     * 刪除某一鍵值對
     * @author Sean
     * 2015-6-5
     * @param key    對應的鍵值
     */
    public void deleteKey(String key){
        properties=load();
        if(!properties.containsKey(key)){
            throw new RuntimeException("not such key");
        }
        properties.remove(key);
        try {
            write2File();
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException("write fail");
        }
    }
    
    /**
     * 設置path值
     * @author Sean
     * @date 2015-6-5
     * @param src    對應文件值
     */
    public void setSrc(String src) {
        this.src = src;
    }
}

基本上，常用的對properties的操作采用這個工具類都能完成。值得注意的是，因為程序在對properties進行掃描的時候，忽略了注釋的內容，而當重新寫內容入文字的時候，程序也只會將properties中的值寫入，這樣會注釋丟失的情況。這種情況，網上有人的解決方案是自己新建一個繼承了properties的類，然后將程序讀取到的信息包括注釋放入到LinkedHashMap中，這樣就可以保存注釋了。

不過，同樣的功能，通過Apache 上的開源項目commons-configuration也能實現。commons-configuration 主要是實現對如xml, properties等配置文件操作的API。通過它，同樣能實現對properties的操作，同時，在操作的時候，也可以保存文件中的注釋。

在使用commons-configuration進行properties的文件操作的時候，不僅需要導入commons-configuration.jar 包，還需要導入另外幾個依賴包才能實現。

 

 

以下是本能采用commons-configuration提供的api進行properties操作的一個Demo

package com.sean;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.net.URISyntaxException;

import org.apache.commons.configuration.Configuration;
import org.apache.commons.configuration.ConfigurationException;
import org.apache.commons.configuration.PropertiesConfiguration;

public class PropertiesUtil {
        private String src="";
        private PropertiesConfiguration pcf=null;
        private String encode="utf-8";
        /**
         * 默認構造函數
         */
        public PropertiesUtil(){};
        /**
         * 傳參構造函數
         * @param src    傳入對應文件地址
         */
        public PropertiesUtil(String src){
            this.src=src;
            try {
                pcf=new PropertiesConfiguration(src);
            } catch (ConfigurationException e) {
                e.printStackTrace();
            }
            pcf.setEncoding(encode);
        }
        
        
        /**
         * 獲取特定key的值
         * @param key    對應的鍵值
         * @return        返回對應value值，找不到返回null;
         */
        public String getValue(String key){
            String     s=pcf.getString(key);
            return s;
        }
        /**
         * 更新對應的值
         * @param key    對應的關鍵字
         * @param value    對應的值
         */
        public void updateValue(String key,String value) {
                if(!pcf.containsKey(key)){
                    throw new RuntimeException("not such key");
                }
                try {
                    pcf.save(new FileOutputStream(new File(ClassLoader.getSystemResource(src).toURI())),"utf-8");
                } catch (ConfigurationException e) {
                    e.printStackTrace();
                } catch (FileNotFoundException e) {
                    e.printStackTrace();
                } catch (URISyntaxException e) {
                    e.printStackTrace();
                }
        }
        
        /**
         * 添加鍵值對
         * @param key    關鍵字
         * @param value    值
         */
        public void addValue(String key,String value){
                pcf.addProperty(key, value);
                try {
                    pcf.save(new FileOutputStream(new File(ClassLoader.getSystemResource(src).toURI())),"utf-8");
                } catch (ConfigurationException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                } catch (FileNotFoundException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                } catch (URISyntaxException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
        }
        /**
         * 刪除關鍵字
         * @param key 關鍵字
         */
        public void delValue(String key){
                pcf.clearProperty(key);
                try {
                    pcf.save(new FileOutputStream(new File(ClassLoader.getSystemResource(src).toURI())),"utf-8");
                } catch (ConfigurationException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                } catch (FileNotFoundException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                } catch (URISyntaxException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
        }
        
        
}

可以看出，commons-configuration提供的api操作起來簡單多了。可是，因為commons-configuration是國外的開源項目，所以其對中文的支持存在一些問題。盡管API中提供了設置字符編碼的功能，但是還是沒有能夠非常好的解決中文的問題。相對而言，原生的API實現起來比較的簡單。

 

最后做下總結，關於對properties 的操作，jdk和commons-configuration都提供了較好的支持，關於使用原生還是框架，應該根據具體條件而定。不過我們在不重復造輪的情況下，還是應該保持對原理的探討