关于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都提供了较好的支持，关于使用原生还是框架，应该根据具体条件而定。不过我们在不重复造轮的情况下，还是应该保持对原理的探讨