动态加载资源文件

问题

对于java应用中的一些配置文件每次都需要重新启动服务才能重新加载，非常麻烦，故做了一个动态加载资源的程序。

可选方案

使用监听线程监听文件变化，当文件变化时通知程序重新加载配置文件，用到了事件委托模型和观察者模式类似，如下

公共部分

 

1.Listener接口

Java代码

1. package com.hrtc.monitor;   
2.   
3. /**  
4.  * 监听器接口  
5.  * Jul 30, 2008 3:02:28 PM  
6.  */  
7. public interface IMonitorListener {   
8.     public void update(MonitorEvent event);   
9. }  

package com.hrtc.monitor;

/**
 * 监听器接口
 * Jul 30, 2008 3:02:28 PM
 */
public interface IMonitorListener {
	public void update(MonitorEvent event);
}

 2.Event监听事件顶层类

Java代码

1. package com.hrtc.monitor;   
2.   
3. import java.util.ArrayList;   
4. import java.util.Iterator;   
5. import java.util.List;   
6.   
7. /**  
8.  * 监听事件  
9.  * Jul 30, 2008 3:03:12 PM  
10.  */  
11. public class MonitorEvent {   
12.     private Object lock = new Object();   
13.     private List monitorListenerList = new ArrayList();   
14.   
15.     public void addListener(IMonitorListener listener) {   
16.         synchronized (lock) {   
17.             if (!monitorListenerList.contains(listener)) {   
18.                 monitorListenerList.add(listener);   
19.             }   
20.         }   
21.     }   
22.   
23.     public void removeListener(IMonitorListener listener) {   
24.         synchronized (lock) {   
25.             if (monitorListenerList.contains(listener)) {   
26.                 monitorListenerList.remove(listener);   
27.             }   
28.         }   
29.     }   
30.   
31.     public void removeAllListener() {   
32.         synchronized (lock) {   
33.             monitorListenerList.clear();   
34.         }   
35.     }   
36.   
37.     /**  
38.      * 触发事件可由子类重载  
39.      */  
40.     public void fireEvent() {   
41.         synchronized (lock) {   
42.             for (Iterator it = monitorListenerList.iterator(); it.hasNext();) {   
43.                 IMonitorListener listener = (IMonitorListener) it.next();   
44.                 listener.update(this);   
45.             }   
46.         }   
47.     }   
48. }  

package com.hrtc.monitor;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

/**
 * 监听事件
 * Jul 30, 2008 3:03:12 PM
 */
public class MonitorEvent {
	private Object lock = new Object();
	private List monitorListenerList = new ArrayList();

	public void addListener(IMonitorListener listener) {
		synchronized (lock) {
			if (!monitorListenerList.contains(listener)) {
				monitorListenerList.add(listener);
			}
		}
	}

	public void removeListener(IMonitorListener listener) {
		synchronized (lock) {
			if (monitorListenerList.contains(listener)) {
				monitorListenerList.remove(listener);
			}
		}
	}

	public void removeAllListener() {
		synchronized (lock) {
			monitorListenerList.clear();
		}
	}

	/**
	 * 触发事件可由子类重载
	 */
	public void fireEvent() {
		synchronized (lock) {
			for (Iterator it = monitorListenerList.iterator(); it.hasNext();) {
				IMonitorListener listener = (IMonitorListener) it.next();
				listener.update(this);
			}
		}
	}
}

 3.主线程监听类

Java代码

1. package com.hrtc.monitor;   
2.   
3. import java.util.ArrayList;   
4. import java.util.Iterator;   
5. import java.util.List;   
6.   
7. /**  
8.  * 监听线程类  
9.  *   
10.  * Jul 30, 2008 3:03:55 PM  
11.  */  
12. public class MonitorThread extends Thread {   
13.     private List monitorEventList = new ArrayList();   
14.     private long interval;   
15.     private boolean isMonitor = false;   
16.     private Object lock = new Object();   
17.     private static MonitorThread monitor;   
18.   
19.     synchronized public static MonitorThread getInstance(long intervalSecond) {   
20.         if (monitor == null) {   
21.             monitor = new MonitorThread(intervalSecond);   
22.         }else{   
23.             monitor.setInterval(intervalSecond);   
24.         }   
25.         return monitor;   
26.     }   
27.   
28.     synchronized public static MonitorThread getInstance() {   
29.         if (monitor == null) {   
30.             monitor = new MonitorThread(1);   
31.         }   
32.         return monitor;   
33.     }   
34.   
35.     /**  
36.      * 构造方法  
37.      *   
38.      * @param intervalSecond  
39.      *            监听间隔时间  
40.      */  
41.     public MonitorThread(long intervalSecond) {   
42.         this.interval = intervalSecond * 1000;   
43.     }   
44.   
45.     public void addEvent(MonitorEvent event) {   
46.         synchronized (lock) {   
47.             if (!monitorEventList.contains(event)) {   
48.                 monitorEventList.add(event);   
49.             }   
50.         }   
51.     }   
52.   
53.     public void removeEvent(MonitorEvent event) {   
54.         synchronized (lock) {   
55.             if (monitorEventList.contains(event)) {   
56.                 monitorEventList.remove(event);   
57.             }   
58.         }   
59.     }   
60.   
61.     public void removeAllEvent() {   
62.         synchronized (lock) {   
63.             monitorEventList.clear();   
64.         }   
65.     }   
66.   
67.     /**  
68.      * 监听主方法，每隔一段间隔触发事件列表  
69.      */  
70.     public void run() {   
71.         if (isMonitor) {   
72.             return;   
73.         }   
74.         isMonitor = true;   
75.         try {   
76.             while (isMonitor) {   
77.   
78.                 synchronized (lock) {   
79.                     for (Iterator it = monitorEventList.iterator(); it   
80.                             .hasNext();) {   
81.                         MonitorEvent event = (MonitorEvent) it.next();   
82.                         event.fireEvent();   
83.                     }   
84.                 }   
85.                 Thread.sleep(interval);   
86.   
87.             }   
88.         } catch (InterruptedException e) {   
89.             e.printStackTrace();   
90.         } finally {   
91.             isMonitor = false;   
92.         }   
93.     }   
94.   
95.     /**  
96.      * 结束监听，并不是马上结束只是把标致设为结束  
97.      */  
98.     public void end() {   
99.         isMonitor = false;   
100.     }   
101.   
102.     /**  
103.      * 是否正在监听  
104.      *   
105.      * @return  
106.      */  
107.     public boolean isMonitor() {   
108.         return isMonitor;   
109.     }   
110.   
111.     public long getInterval() {   
112.         return interval;   
113.     }   
114.   
115.     public void setInterval(long interval) {   
116.         this.interval = interval;   
117.     }   
118.   
119. }  

package com.hrtc.monitor;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

/**
 * 监听线程类
 * 
 * Jul 30, 2008 3:03:55 PM
 */
public class MonitorThread extends Thread {
	private List monitorEventList = new ArrayList();
	private long interval;
	private boolean isMonitor = false;
	private Object lock = new Object();
	private static MonitorThread monitor;

	synchronized public static MonitorThread getInstance(long intervalSecond) {
		if (monitor == null) {
			monitor = new MonitorThread(intervalSecond);
		}else{
			monitor.setInterval(intervalSecond);
		}
		return monitor;
	}

	synchronized public static MonitorThread getInstance() {
		if (monitor == null) {
			monitor = new MonitorThread(1);
		}
		return monitor;
	}

	/**
	 * 构造方法
	 * 
	 * @param intervalSecond
	 *            监听间隔时间
	 */
	public MonitorThread(long intervalSecond) {
		this.interval = intervalSecond * 1000;
	}

	public void addEvent(MonitorEvent event) {
		synchronized (lock) {
			if (!monitorEventList.contains(event)) {
				monitorEventList.add(event);
			}
		}
	}

	public void removeEvent(MonitorEvent event) {
		synchronized (lock) {
			if (monitorEventList.contains(event)) {
				monitorEventList.remove(event);
			}
		}
	}

	public void removeAllEvent() {
		synchronized (lock) {
			monitorEventList.clear();
		}
	}

	/**
	 * 监听主方法，每隔一段间隔触发事件列表
	 */
	public void run() {
		if (isMonitor) {
			return;
		}
		isMonitor = true;
		try {
			while (isMonitor) {

				synchronized (lock) {
					for (Iterator it = monitorEventList.iterator(); it
							.hasNext();) {
						MonitorEvent event = (MonitorEvent) it.next();
						event.fireEvent();
					}
				}
				Thread.sleep(interval);

			}
		} catch (InterruptedException e) {
			e.printStackTrace();
		} finally {
			isMonitor = false;
		}
	}

	/**
	 * 结束监听，并不是马上结束只是把标致设为结束
	 */
	public void end() {
		isMonitor = false;
	}

	/**
	 * 是否正在监听
	 * 
	 * @return
	 */
	public boolean isMonitor() {
		return isMonitor;
	}

	public long getInterval() {
		return interval;
	}

	public void setInterval(long interval) {
		this.interval = interval;
	}

}

 应用案例1：可自动检查文件变化的Properties

1.首先定义一个“文件改变事件监听类”继承自MonitorEvent

Java代码

1. package com.hrtc.monitor.file;   
2.   
3. import java.io.File;   
4. import java.io.IOException;   
5.   
6. import com.hrtc.monitor.MonitorEvent;   
7.   
8. /**  
9.  * 文件改变监听类  
10.  * Jul 30, 2008 3:07:05 PM  
11.  */  
12. public class FileChangeMonitorEvent extends MonitorEvent {   
13.     private File f;   
14.     private long lastModifiedTime;   
15.     private long lastLength;   
16.     private boolean isChanged = false;   
17.   
18.     /**  
19.      *   
20.      * @param f 需要监听的文件  
21.      */  
22.     public FileChangeMonitorEvent(File f) {   
23.         if (!f.exists()) {   
24.             try {   
25.                 throw new IllegalArgumentException("Path "  
26.                         + f.getCanonicalPath() + " dose't exist.");   
27.             } catch (IOException e) {   
28.                 e.printStackTrace();   
29.             }   
30.         }   
31.         this.f = f;   
32.         getFileInfo();   
33.     }   
34.   
35.     private void getFileInfo(){   
36.         lastModifiedTime = f.lastModified();   
37.         lastLength = f.length();   
38.     }   
39.        
40.     /**  
41.      * 如果文件已改变则触发事件  
42.      */  
43.     @Override  
44.     public void fireEvent() {   
45.         try {   
46.             f = f.getCanonicalFile();   
47.             isChanged = lastModifiedTime != f.lastModified() || lastLength != f.length();   
48.             if (isChanged) {   
49.                 super.fireEvent();   
50.                 getFileInfo();   
51.                 isChanged = false;   
52.             }   
53.         } catch (IOException e) {   
54.             e.printStackTrace();   
55.         }   
56.     }   
57.   
58.     /**  
59.      * 获得监听的文件  
60.      * @return  
61.      */  
62.     public File getF() {   
63.         return f;   
64.     }   
65.   
66. }  

package com.hrtc.monitor.file;

import java.io.File;
import java.io.IOException;

import com.hrtc.monitor.MonitorEvent;

/**
 * 文件改变监听类
 * Jul 30, 2008 3:07:05 PM
 */
public class FileChangeMonitorEvent extends MonitorEvent {
	private File f;
	private long lastModifiedTime;
	private long lastLength;
	private boolean isChanged = false;

	/**
	 * 
	 * @param f 需要监听的文件
	 */
	public FileChangeMonitorEvent(File f) {
		if (!f.exists()) {
			try {
				throw new IllegalArgumentException("Path "
						+ f.getCanonicalPath() + " dose't exist.");
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		this.f = f;
		getFileInfo();
	}

	private void getFileInfo(){
		lastModifiedTime = f.lastModified();
		lastLength = f.length();
	}
	
	/**
	 * 如果文件已改变则触发事件
	 */
	@Override
	public void fireEvent() {
		try {
			f = f.getCanonicalFile();
			isChanged = lastModifiedTime != f.lastModified() || lastLength != f.length();
			if (isChanged) {
				super.fireEvent();
				getFileInfo();
				isChanged = false;
			}
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	/**
	 * 获得监听的文件
	 * @return
	 */
	public File getF() {
		return f;
	}

}

 2.定义PropertiesEx类，以及内部类ReloadPropertiesListener

Java代码

1. package com.hrtc.util;   
2.   
3. import java.io.File;   
4. import java.io.FileInputStream;   
5. import java.io.FileNotFoundException;   
6. import java.io.IOException;   
7. import java.util.Properties;   
8.   
9. import com.hrtc.monitor.IMonitorListener;   
10. import com.hrtc.monitor.MonitorEvent;   
11. import com.hrtc.monitor.MonitorThread;   
12. import com.hrtc.monitor.file.FileChangeMonitorEvent;   
13.   
14. /**  
15.  * 可自动加载属性变化的属性类  
16.  * Jul 30, 2008 3:10:32 PM  
17.  */  
18. public class PropertiesEx {   
19.     /**  
20.      *   
21.      */  
22.     private static final long serialVersionUID = -6708397622206255544L;   
23.   
24.     private MonitorThread monitor;   
25.     private Properties p;   
26.        
27.     /**  
28.      *   
29.      * @param intervalSecond 监听变化间隔  
30.      */  
31.     public PropertiesEx(long intervalSecond) {   
32.         monitor = MonitorThread.getInstance(intervalSecond);   
33.     }   
34.        
35.     /**  
36.      * 默认更新间隔为1s  
37.      */  
38.     public PropertiesEx() {   
39.         this(1);   
40.     }   
41.   
42.     /**  
43.      * 加载配置文件  
44.      * @param f  
45.      * @throws FileNotFoundException  
46.      * @throws IOException  
47.      */  
48.     public void load(File f) throws FileNotFoundException, IOException {   
49.         p = new Properties();   
50.         p.load(new FileInputStream(f));   
51.         MonitorEvent event = new FileChangeMonitorEvent(f);   
52.         ReloadPropertiesListener listener = new ReloadPropertiesListener();   
53.         event.addListener(listener);   
54.         monitor.addEvent(event);   
55.         if(!monitor.isMonitor()){   
56.             monitor.start();   
57.         }   
58.            
59.     }   
60.   
61.     public String getProperty(String key){   
62.         return p.getProperty(key);   
63.     }   
64.   
65.     public Properties getProperties(){   
66.         return p;   
67.     }   
68.        
69.     /**  
70.      * 当发生属性文件改变时重新加载属性文件<br>  
71.      * listener为内部类，为了访问包含类中p成员变量和静止外部访问该类  
72.      * @author xuwei  
73.      * Jul 30, 2008 3:11:38 PM  
74.      */  
75.     private class ReloadPropertiesListener implements IMonitorListener {   
76.   
77.         public void update(MonitorEvent event) {   
78.             FileChangeMonitorEvent fcmEvent = (FileChangeMonitorEvent) event;   
79.             try {   
80.                 p.load(new FileInputStream(fcmEvent.getF()));   
81.             } catch (IOException e) {   
82.                 throw new RuntimeException(e);   
83.             }   
84.         }   
85.   
86.     }   
87.   
88. }  

package com.hrtc.util;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.Properties;

import com.hrtc.monitor.IMonitorListener;
import com.hrtc.monitor.MonitorEvent;
import com.hrtc.monitor.MonitorThread;
import com.hrtc.monitor.file.FileChangeMonitorEvent;

/**
 * 可自动加载属性变化的属性类
 * Jul 30, 2008 3:10:32 PM
 */
public class PropertiesEx {
	/**
	 * 
	 */
	private static final long serialVersionUID = -6708397622206255544L;

	private MonitorThread monitor;
	private Properties p;
	
	/**
	 * 
	 * @param intervalSecond 监听变化间隔
	 */
	public PropertiesEx(long intervalSecond) {
		monitor = MonitorThread.getInstance(intervalSecond);
	}
	
	/**
	 * 默认更新间隔为1s
	 */
	public PropertiesEx() {
		this(1);
	}

	/**
	 * 加载配置文件
	 * @param f
	 * @throws FileNotFoundException
	 * @throws IOException
	 */
	public void load(File f) throws FileNotFoundException, IOException {
		p = new Properties();
		p.load(new FileInputStream(f));
		MonitorEvent event = new FileChangeMonitorEvent(f);
		ReloadPropertiesListener listener = new ReloadPropertiesListener();
		event.addListener(listener);
		monitor.addEvent(event);
		if(!monitor.isMonitor()){
			monitor.start();
		}
		
	}

	public String getProperty(String key){
		return p.getProperty(key);
	}

	public Properties getProperties(){
		return p;
	}
	
	/**
	 * 当发生属性文件改变时重新加载属性文件<br>
	 * listener为内部类，为了访问包含类中p成员变量和静止外部访问该类
	 * @author xuwei
	 * Jul 30, 2008 3:11:38 PM
	 */
	private class ReloadPropertiesListener implements IMonitorListener {

		public void update(MonitorEvent event) {
			FileChangeMonitorEvent fcmEvent = (FileChangeMonitorEvent) event;
			try {
				p.load(new FileInputStream(fcmEvent.getF()));
			} catch (IOException e) {
				throw new RuntimeException(e);
			}
		}

	}

}

 3.测试类

Java代码

1. package com.hrtc.util;   
2.   
3. import java.io.File;   
4. import java.io.FileNotFoundException;   
5. import java.io.IOException;   
6.   
7. import junit.framework.TestCase;   
8.   
9. import com.hrtc.monitor.MonitorThread;   
10.   
11. public class PropertiesExTest extends TestCase {   
12.   
13.     protected void setUp() throws Exception {   
14.         super.setUp();   
15.     }   
16.   
17.        //测试PropertiesEx中的load方法   
18.         public void testLoad() throws FileNotFoundException, IOException {   
19.         System.out.println("test reload method========");   
20.         PropertiesEx p = new PropertiesEx();   
21.         File f = new File(PropertiesTest.class.getResource("").getPath()   
22.                 + "test.properties");   
23.         p.load(f);   
24.         long t1 = System.currentTimeMillis();   
25.         int count = 10;   
26.         int i = 0;   
27.         try {   
28.                        //循环10秒，在此时间内手动修改配置文件   
29.             while (i < count) {   
30.   
31.                 String name = p.getProperty("name");   
32.                 System.out.println(i + ": name===" + name);   
33.                 Thread.sleep(1000);   
34.   
35.                 i++;   
36.             }   
37.         } catch (InterruptedException e) {   
38.             e.printStackTrace();   
39.         }   
40.         long t2 = System.currentTimeMillis();   
41.         System.out.println(t2 - t1);   
42.     }   
43.        
44.        //测试多个PropertiesEx公用同一MonitorThread   
45.     public void testLoadMultiple() throws FileNotFoundException, IOException {   
46.         System.out.println("test reload multiple========");   
47.         PropertiesEx p1 = new PropertiesEx();   
48.         File f1 = new File(PropertiesTest.class.getResource("").getPath()   
49.                 + "test.properties");   
50.         p1.load(f1);   
51.         PropertiesEx p2 = new PropertiesEx();   
52.         File f2 = new File(PropertiesTest.class.getResource("").getPath()   
53.                 + "test1.properties");   
54.         p2.load(f2);   
55.         long t1 = System.currentTimeMillis();   
56.         int count = 10;   
57.         int i = 0;   
58.         try {   
59.             while (i < count) {   
60.   
61.                 String name = p1.getProperty("name");   
62.                 String value = p2.getProperty("value");   
63.                 System.out.println(i + ": " + name + "=" + value);   
64.                 Thread.sleep(1000);   
65.   
66.                 i++;   
67.             }   
68.         } catch (InterruptedException e) {   
69.             e.printStackTrace();   
70.         }   
71.         long t2 = System.currentTimeMillis();   
72.         System.out.println(t2 - t1);   
73.                //结束监听，清除监听事件    
74.         MonitorThread.getInstance().end();   
75.         MonitorThread.getInstance().removeAllEvent();   
76.     }   
77.   
78. }  

package com.hrtc.util;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;

import junit.framework.TestCase;

import com.hrtc.monitor.MonitorThread;

public class PropertiesExTest extends TestCase {

	protected void setUp() throws Exception {
		super.setUp();
	}

       //测试PropertiesEx中的load方法
     	public void testLoad() throws FileNotFoundException, IOException {
		System.out.println("test reload method========");
		PropertiesEx p = new PropertiesEx();
		File f = new File(PropertiesTest.class.getResource("").getPath()
				+ "test.properties");
		p.load(f);
		long t1 = System.currentTimeMillis();
		int count = 10;
		int i = 0;
		try {
                       //循环10秒，在此时间内手动修改配置文件
			while (i < count) {

				String name = p.getProperty("name");
				System.out.println(i + ": name===" + name);
				Thread.sleep(1000);

				i++;
			}
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		long t2 = System.currentTimeMillis();
		System.out.println(t2 - t1);
	}
	
       //测试多个PropertiesEx公用同一MonitorThread
	public void testLoadMultiple() throws FileNotFoundException, IOException {
		System.out.println("test reload multiple========");
		PropertiesEx p1 = new PropertiesEx();
		File f1 = new File(PropertiesTest.class.getResource("").getPath()
				+ "test.properties");
		p1.load(f1);
		PropertiesEx p2 = new PropertiesEx();
		File f2 = new File(PropertiesTest.class.getResource("").getPath()
				+ "test1.properties");
		p2.load(f2);
		long t1 = System.currentTimeMillis();
		int count = 10;
		int i = 0;
		try {
			while (i < count) {

				String name = p1.getProperty("name");
				String value = p2.getProperty("value");
				System.out.println(i + ": " + name + "=" + value);
				Thread.sleep(1000);

				i++;
			}
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		long t2 = System.currentTimeMillis();
		System.out.println(t2 - t1);
               //结束监听，清除监听事件 
		MonitorThread.getInstance().end();
		MonitorThread.getInstance().removeAllEvent();
	}

}

 

配置文件内容,与PropertiesExTest放在同一文件夹下

test.properties

  name=name1

test1.properties

  value=value1

 

总结

上面的同一个MonitorThread甚至可以用到多个不同的事件中，比如除了Properties外还可以定义如xml等其他事件监听，而只用同一个MonitorThread。另一种方案是使用代理每次访问属性时查看文件是否修改，但是效率上比不上这种。