PropertiesDemo

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

import java.io.File;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class PropertiesDemo {

    public static void main(String[] args) throws IOException, ConfigurationException {
        String path = PropertiesDemo.class.getResource("/t.properties").getPath();

        PropertiesConfiguration config = new PropertiesConfiguration(new File(path));
        System.out.println(config.getEncoding());
        config.setEncoding("gbk");
        config.setAutoSave(false);
        String value = new SimpleDateFormat("yyyy-mm-dd HH:mm:ss").format(new Date());
        System.out.println(value);
        config.setProperty("ums.version.endTime444", value);
        config.setProperty("中文key", "中文value");
        System.out.println(config.getEncoding());
        config.save();

//        Properties properties = new Properties();
//        properties.load(new FileReader(new File(path)));
//        properties.setProperty("hello", value);
//        FileWriter fileWriter = new FileWriter(new File(path));
//        properties.store(fileWriter, "Comment");

    }

}

在Java早期的开发中，常用*.properties文件存储一些配置信息。其文件中的信息主要是以key=value的方式进行存储，在早期受到广泛的应用。而后随着xml使用的广泛，其位置渐渐被取代，不过，目前仍有一些框架如log4J在使用它。最近在弄自己的小玩意儿的时候也用到了它，顺便加深了一下了解，在此分享。

Java在对*.properties文件进行操作的时候，实际上是通过IO对文档进行逐行的扫描，然后将文中非注释的部分存放在一个properties对象中。Properties 实际上是继承了hashtable，实现了Map接口。可以这样理解，它是进行了进一步封装的HashMap。存放到properties中后，可以对properties进行一系列的操作，此时的数据保存在内存中。最后，当需要保存数据的时候，是将properties中所有的键值重新写入到文件中去。 对properties文件的操作，jdk提供了一系列的API。一下是一个工具类，实现了对properties文件的增删查改的功能。

  1 package com.sean.file.properties;
  2
  3 import java.io.File;
  4 import java.io.FileOutputStream;
  5 import java.io.IOException;
  6 import java.io.InputStreamReader;
  7 import java.io.OutputStreamWriter;
  8 import java.io.UnsupportedEncodingException;
  9 import java.util.Enumeration;
 10 import java.util.HashMap;
 11 import java.util.Map;
 12 import java.util.Properties;
 13 /**
 14  * Java 操作Properties的工具类
 15  * 实现功能：
 16  * 1、Properties文件的增删查改功能
 17  * 2、解决读写中文乱码问题
 18  * @author Sean
 19  *
 20  */
 21 public class PropertiesUtil {
 22
 23     /**
 24      * Properties地址值，不需要加根标记"/"
 25      */
 26     private String src = "";
 27     private InputStreamReader inputStream = null;
 28     private OutputStreamWriter outputStream = null;
 29     private String encode="utf-8";
 30     public Properties properties ;
 31
 32     /**
 33      * 默认构造函数
 34      */
 35     public PropertiesUtil() {
 36     }
 37
 38     /**
 39      * 构造函数
 40      *
 41      * @param src        传入Properties地址值，不需要加根标记"/"
 42      */
 43     public PropertiesUtil(String src) {
 44         this.src = src;
 45     }
 46
 47
 48     /**
 49      * 构造函数，提供设置编码模式
 50      * @param src        传入Properties地址值，不需要加根标记"/"
 51      * @param encode    传入对应的编码模式，默认是utf-8
 52      */
 53     public PropertiesUtil(String src, String encode) {
 54         this(src);
 55         this.encode = encode;
 56     }
 57
 58     /**
 59      * 加载properties文件
 60      * @author Sean
 61      * @date 2015-6-5
 62      * @return 返回读取到的properties对象
 63      */
 64     public Properties load(){
 65         if(src.trim().equals("")){
 66             throw new RuntimeException("The path of Properties File is need");
 67         }
 68         try {
 69             inputStream=new InputStreamReader(ClassLoader.getSystemResourceAsStream(src),encode);
 70         } catch (UnsupportedEncodingException e1) {
 71             e1.printStackTrace();
 72         }
 73         properties=new Properties();
 74         try {
 75             properties.load(inputStream);
 76         } catch (IOException e) {
 77             e.printStackTrace();
 78         }
 79         return properties;
 80     }
 81
 82     /**
 83      * 将配置写入到文件
 84      * @author Sean
 85      * @date 2015-6-5
 86      * @throws Exception
 87      */
 88     public void write2File() throws Exception{
 89         //获取文件输出流
 90         outputStream=new OutputStreamWriter(new FileOutputStream(new File(ClassLoader.getSystemResource(src).toURI())),encode);
 91         properties.store(outputStream, null);
 92         close();
 93     }
 94
 95
 96     /**
 97      * 通过关键字获取值
 98      * @author Sean
 99      * @date 2015-6-5
100      * @param key    需要获取的关键字
101      * @return        返回对应的字符串，如果无，返回null
102      */
103     public String getValueByKey(String key){
104         properties=load();
105         String val =properties.getProperty(key.trim());
106         close();
107         return val;
108
109     }
110
111     /**
112      * 通过关键字获取值
113      * @author Sean
114      * @date 2015-6-5
115      * @param key            需要获取的关键字
116      * @param defaultValue    若找不到对应的关键字时返回的值
117      * @return                返回找到的字符串
118      */
119     public String getValueByKey(String key ,String defaultValue){
120         properties=load();
121         String val =properties.getProperty(key.trim(),defaultValue.trim());
122         close();
123         return val;
124     }
125
126     /**
127      * 关闭输入输出流
128      * @author Sean
129      * @date 2015-6-5
130      */
131     public void close(){
132         try {
133             if(inputStream!=null){inputStream.close();}
134             if(outputStream!=null){outputStream.close();}
135         } catch (IOException e) {
136             e.printStackTrace();
137         }
138     }
139
140     /**
141      * 获取Properties所有的值
142      * @author Sean
143      * @date 2015-6-5
144      * @return            返回Properties的键值对
145      */
146     public Map<String,String> getAllProperties(){
147         properties=load();
148         Map<String,String> map=new HashMap<String,String>();
149         //获取所有的键值
150         Enumeration enumeration=properties.propertyNames();
151         while(enumeration.hasMoreElements()){
152             String key=(String) enumeration.nextElement();
153             String value=getValueByKey(key);
154             map.put(key, value);
155         }
156         close();
157         return  map;
158     }
159
160     /**
161      * 往Properties写入新的键值
162      * @author Sean
163      * @date 2015-6-5
164      * @param key    对应的键
165      * @param value    对应的值
166      */
167     public void addProperties(String key,String value){
168         properties=load();
169         properties.put(key, value);
170         try {
171             write2File();
172         } catch (Exception e) {
173             e.printStackTrace();
174         }
175     }
176
177     /**
178      * 添加Map中所有的值
179      * @author Sean
180      * @date 2015-6-5
181      * @param map    对应的键值对集合
182      */
183     public void addAllProperties(Map<String,String> map){
184         properties=load();
185         properties.putAll(map);
186         try {
187             write2File();
188         } catch (Exception e) {
189             e.printStackTrace();
190             throw new RuntimeException("write fail");
191         }
192     }
193
194     /**
195      * 更新配置文件
196      * @author Sean
197      * 2015-6-5
198      * @param key    需要更新的键值
199      * @param value    对应的值
200      */
201     public void update(String key,String value){
202         properties=load();
203         if(!properties.containsKey(key)){
204             throw new RuntimeException("not such key");
205         }
206         properties.setProperty(key, value);
207         try {
208             write2File();
209         } catch (Exception e) {
210             e.printStackTrace();
211             throw new RuntimeException("write fail");
212         }
213     }
214
215     /**
216      * 删除某一键值对
217      * @author Sean
218      * 2015-6-5
219      * @param key    对应的键值
220      */
221     public void deleteKey(String key){
222         properties=load();
223         if(!properties.containsKey(key)){
224             throw new RuntimeException("not such key");
225         }
226         properties.remove(key);
227         try {
228             write2File();
229         } catch (Exception e) {
230             e.printStackTrace();
231             throw new RuntimeException("write fail");
232         }
233     }
234
235     /**
236      * 设置path值
237      * @author Sean
238      * @date 2015-6-5
239      * @param src    对应文件值
240      */
241     public void setSrc(String src) {
242         this.src = src;
243     }
244 }

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

http://www.cnblogs.com/Seanit/p/4555937.html

　我们在开发Java程序的时候，很多常量信息都存在配置文件中，比如数据库连接信息、ip黑名单，事件的超时时间等等。当需要该这些配置的值时都需要重新启动进程，改动的配置才会生效，有时候线上的应用不能容忍这种停服。

　　还好，Apache Common Configuration给我们提供了可以检测文件修改后配置可短时间生效的功能。具体用法如下：

package com.netease.test.commons;

import org.apache.commons.configuration.ConfigurationException;
import org.apache.commons.configuration.PropertiesConfiguration;
import org.apache.commons.configuration.reloading.FileChangedReloadingStrategy;
import org.apache.log4j.Logger;

/**
 * User: hzwangxx
 * Date: 14-3-13
 * Time: 17:20
 */
public class SystemConfig {
    private static Logger logger = Logger.getLogger(SystemConfig.class);

    private static  PropertiesConfiguration config;

    static {
        try {
            //实例化一个PropertiesConfiguration
            config = new PropertiesConfiguration("/Users/hzwangxx/IdeaProjects/app-test/src/main/resources/conf.properties");
            //设置reload策略，这里用当文件被修改之后reload（默认5s中检测一次）
            config.setReloadingStrategy(new FileChangedReloadingStrategy());
        } catch (ConfigurationException e) {
            logger.error("init static block error. ", e);
        }
    }

    public static synchronized String getProperty(String key) {
        return (String) config.getProperty(key);
    }

    public static void main(String[] args) throws InterruptedException {
        for (;;) {
            System.out.println(SystemConfig.getProperty("key"));
            Thread.sleep(2000);
        }
    }

}

http://www.cnblogs.com/nexiyi/p/how_to_reload_properties.html