java不重启服务动态加载properties文件

旧城等待， 2021-05-18 15:41 610阅读 0赞

一般情况下，配置文件是系统在启动时加载的，当配置文件发生改动后需要重新启动系统。但是，在多数业务里，需要动态加载配置文件已经成为了标配，那如何实现动态加载呢？我们一一列举。

**一、archaius**

archaius是Netflix公司开源项目之一，基于java的配置管理类库，主要用于多配置存储的动态获取。主要功能是对apache common configuration类库的扩展。在云平台开发中可以将其用作分布式配置管理依赖构件。同时，它有如下一些特性：

*  动态获取属性
 *  高效和线程安全的配置操作
 *  配置改变时提供回调机制
 *  可以通过jmx操作配置
 *  复合配置

示例：

<dependency>
      <groupId>com.netflix.archaius</groupId>
      <artifactId>archaius-core</artifactId>
      <version>0.7.4</version>
    </dependency>
    
    public class Main {
        //获取一个Long型的动态配置项，默认值是1000。
        private static DynamicLongProperty timeToWait =
                DynamicPropertyFactory.getInstance().getLongProperty("lock.waitTime", 1000);
    
        public static void main(String[] args) throws Exception {
            //设置回调
            timeToWait.addCallback(() -> {
                System.out.println("timeToWait callback, new value: " + timeToWait.get());
            });
            //每秒将timeToWait动态配置值打印到控制台，timeToWait.get()会动态的获取最新的配置
            for (int i = 0; i < 100000; i++) {
                Thread.sleep(1000);
                System.out.println("timeToWait: " + timeToWait.get());
            }
        }
    }

archaius默认读取classpath下的config.properties，所以在resources目录下增加config.properties文件，文件中增加配置：  
lock.waitTime=4

修改config.properties后，默认等1分钟后会生效，可以通过jvm参数修改：

-Darchaius.fixedDelayPollingScheduler.delayMills=2000 -Darchaius.fixedDelayPollingScheduler.initialDelayMills=2000

上述是读取Long型数据，同样还有：DynamicStringProperty、DynamicDoubleProperty...

详情参考：[http://techblog.ppdai.com/2018/05/08/20180508/][http_techblog.ppdai.com_2018_05_08_20180508]

**二、PropertiesConfiguration**

PropertiesConfiguration是Apache开元的一个配置文件的加载工具类，如下：

<dependency>
    	<groupId>commons-configuration</groupId>
    	<artifactId>commons-configuration</artifactId>
    	<version>1.6</version>
    </dependency>
    
    public class PropertyUtil {
    	private PropertyUtil() {
    	};
    
    	private static class SingletonHolder {
    		private static PropertiesConfiguration propertyUtil = init("config.properties");
    	}
    
    	public static PropertiesConfiguration getProps() {
    		return SingletonHolder.propertyUtil;
    	}
    
    	/**
    	 * 初始化
    	 * 
    	 * @param propertiesFile
    	 * @see
    	 */
    	private static PropertiesConfiguration init(String propertiesFile) {
    		PropertiesConfiguration PropertyUtil = null;
    		try {
    			PropertyUtil = new PropertiesConfiguration(propertiesFile);
    			// 自动重新加载
    			PropertyUtil
    					.setReloadingStrategy(new FileChangedReloadingStrategy());
    			// 自动保存
    			PropertyUtil.setAutoSave(true);
    		} catch (ConfigurationException e) {
    			e.printStackTrace();
    		}
    		return PropertyUtil;
    	}
    
    	/**
    	 * 根据Key获得对应的value
    	 *
    	 * @param key
    	 * @return
    	 * @see
    	 */
    	public static Object getProperty(String key) {
    		return getProps().getProperty(key);
    	}
    
    	/**
    	 * 设置属性
    	 *
    	 * @param key
    	 * @param value
    	 * @see
    	 */
    	public static void setProperty(String key, String value) {
    		getProps().setProperty(key, value);
    	}
    }

测试：

public static void main(String...strings) throws InterruptedException {
    		for (int i = 0; i < 100000; i++) {
                Thread.sleep(1000);
                System.out.println("timeToWait: " + PropertyUtil.getProperty("lock.waitTime"));
            }
    }

修改配置文件后立即生效。

**三、WatchService JDK7+**

该类的对象就是操作系统原生的文件系统监控器！我们都知道OS自己的文件系统监控器可以监控系统上所有文件的变化，这种监控是无需遍历、无需比较的，是一种基于信号收发的监控，因此效率一定是最高的。现在Java对其进行了包装，可以直接在Java程序中使用OS的文件系统监控器了。

1、ResourceListener ：

public class ResourceListener {
        
        private static ExecutorService fixedThreadPool = Executors
                .newFixedThreadPool(5);
        private WatchService ws;
        private String listenerPath;
        
        private ResourceListener(String path) {
            try {
                ws = FileSystems.getDefault().newWatchService();
                this.listenerPath = path;
                start();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    
        private void start() {
            fixedThreadPool.execute(new Listner(ws, this.listenerPath));
        }
    
        public static void addListener(String path) throws IOException {
            ResourceListener resourceListener = new ResourceListener(path);
            Path p = Paths.get(path);
            p.register(resourceListener.ws, StandardWatchEventKinds.ENTRY_MODIFY,
                    StandardWatchEventKinds.ENTRY_DELETE,
                    StandardWatchEventKinds.ENTRY_CREATE);
        }
    
        public static void main(String[] args) throws IOException {
            ResourceListener.addListener("E:/test");
        }
    }
    
    class Listner implements Runnable {
        private WatchService service;
        private String rootPath;
    
        public Listner(WatchService service, String rootPath) {
            this.service = service;
            this.rootPath = rootPath;
        }
    
        public void run() {
            try {
                while (true) {
                    WatchKey watchKey = service.take();
                    List<WatchEvent<?>> watchEvents = watchKey.pollEvents();
                    for (WatchEvent<?> event : watchEvents) {
                        String path = event.context().toString();
                        if(path.endsWith("config.properties")){
                            LogUtil.info("[" + rootPath + "/" + event.context()+ "]文件发生了[" + event.kind() + "]事件");
                            PropertyUtil.init();//配置变更初始化
                        }
                    }
                    watchKey.reset();
                }
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                try {
                    service.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

2、工具类 PropertyUtil.java

public class PropertyUtil {
        private PropertyUtil(){};
        
        private static class SingletonHolder{
            private static Properties props  = loadProps();
        }
        public static Properties getProps(){
            return SingletonHolder.props;
        }
        private static  Properties loadProps(){
            Properties props = new Properties();
            InputStream in = null;
            try {
                in = PropertyUtil.class.getClassLoader().getResourceAsStream("config.properties");
                props.load(in);
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                try {
                    if(null != in) {
                        in.close();
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return props;
        }
    
        public static String getProperty(String key){
            return getProps().getProperty(key);
        }
    
        public static String getProperty(String key, String defaultValue) {
            return getProps().getProperty(key, defaultValue);
        }
        public static void init(){//不要随便调用(不是私有的)
            SingletonHolder.props =  loadProps();
        }
    }

**四、手写PropertiesUtils：**

使用Properties时，每次get数据进行文件判断。

public class PropertiesUtil {
    	private static Properties prop;
    	private static Long lastModified = 0L;
    
    	/**
    	 * 加载文件
    	 */
    	private static void init(String configFile) {
    		prop = new Properties();
    		String filepath = new File(configFile).getPath();
    		try {
    			prop.load(PropertiesUtil.class.getClassLoader().getResourceAsStream(configFile.trim()));
    			//prop.load(new FileInputStream(configFile.trim()));
    		} catch (IOException e) {
    			e.printStackTrace();
    		} finally {
    			File f = new File(filepath);
    			lastModified = f.lastModified();
    		}
    	}
    
    	private static boolean isPropertiesModified(String configFile) {
    		boolean returnValue = false;
    		File file = new File(PropertiesUtil.class.getClassLoader().getResource(configFile).getPath());
    		//File file = new File(configFile);
    		if (file.lastModified() > lastModified) {
    			lastModified = file.lastModified();
    			returnValue = true;
    		}
    		return returnValue;
    	}
    	
    	public static String get(String configFile,String key) {
    
            if (prop == null || isPropertiesModified(configFile)) {
                init(configFile);
            }
            String value = prop.get(key).toString();
            return value;
        }
    }