java实现文件变更监控

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"   
 3     xmlns:tx="http://www.springframework.org/schema/tx" xmlns:aop="http://www.springframework.org/schema/aop"
 4     xmlns:context="http://www.springframework.org/schema/context" xmlns:dwr="http://www.directwebremoting.org/schema/spring-dwr"
 5     xmlns:jaxrs="http://cxf.apache.org/jaxrs"
 6     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd
 7         http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.1.xsd
 8         http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.1.xsd
 9         http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.1.xsd
10         http://www.directwebremoting.org/schema/spring-dwr http://www.directwebremoting.org/schema/spring-dwr-3.0.xsd
11         http://cxf.apache.org/jaxrs http://cxf.apache.org/schemas/jaxrs.xsd">
12     
13     <!-- 文件监测器  -->    
14     <bean id="monitor"
15         class="com.interfaces.file.monitor.FileMonitorImpl">
16     
17         <constructor-arg index="0" value="10000" />                    <!-- 监测时间间隔，单位：毫秒 -->
18         <constructor-arg index="1" ref="observer" />                <!-- 文件观察器  -->
19     </bean>        
20     
21     <!-- 文件观察器  -->        
22     <bean id="observer"
23         class="com.interfaces.file.monitor.FileObserverImpl">
24         
25         <constructor-arg index="0" value="D:\\UploadDir"/>            <!-- 观察的目录 -->
26         <constructor-arg index="1" ref="filter"/>                    <!-- 目录/文件过滤器-->
27         <constructor-arg index="2" ref="listener"/>                    <!-- 目录/文件监听器  -->
28     </bean>
29     
30     <!-- 文件监听器  -->    
31     <bean id="listener"
32         class="com.interfaces.file.monitor.FileListener"/>
33     
34     <!-- 文件过滤器  -->        
35     <bean id="filter"
36         class="com.interfaces.file.monitor.FileFilterImpl">        
37         <!-- 
38             指定文件扩展名，只有指定的扩展名文件会被处理。
39             不同的扩展名间以  "," 间隔，如：xml,txt,bak 
40         -->
41         <constructor-arg index="0" value="xml"/>        
42     </bean>
43 </beans>

 1 import javax.servlet.ServletContextEvent;
 2 
 3 import org.springframework.web.context.ContextLoaderListener;
 4 
 5 public class SpringContextLoaderListener extends ContextLoaderListener{
 6     
 7     @Override
 8     public void contextInitialized(ServletContextEvent event) {
 9         super.contextInitialized(event);
10         
11         FileMonitor scanner = getScanner();
12         
13         // 启动目录扫描器
14         scanner.start();
15     }
16     
17     @Override
18     public void contextDestroyed(ServletContextEvent event) {
19         FileMonitor scanner = getScanner();
20         
21         // 关闭目录扫描器
22         scanner.stop();
23         
24         super.contextDestroyed(event);
25     }
26     
27     /**
28      * 获取目录扫描器
29      * @return
30      */
31     private FileMonitor getScanner() {
32         return getCurrentWebApplicationContext().getBean(FileMonitor.class);
33     }
34 }

 1 import org.apache.commons.io.monitor.FileAlterationObserver;
 2 
 3 /**
 4  * 文件监测器角色
 5  */
 6 public interface FileMonitor {
 7 
 8     /**
 9      * 注册观察器
10      * @param observer    观察器
11      */
12     void addObserver(FileAlterationObserver observer);
13         
14     /**
15      * 删除观察器
16      * @param observer    观察器
17      */
18     void removeObserver(FileAlterationObserver observer);    
19     
20     /**
21      * 获取注册的所有观察器
22      * @return    观察器集合
23      */
24     Iterable<FileAlterationObserver> getObservers();    
25     
26     /**
27      * 启动监测器
28      */
29     void start();    
30     
31     /**
32      * 停止监测器
33      */
34     void stop();    
35     
36     /**
37      * 获取监测间隔时间
38      * @return    间隔时间（单位：毫秒）
39      */
40     long getInterval();    
41     
42 }

  1 import java.util.concurrent.ThreadFactory;
  2 
  3 import org.apache.commons.io.monitor.FileAlterationMonitor;
  4 import org.apache.commons.io.monitor.FileAlterationObserver;
  5 import org.apache.commons.lang3.concurrent.BasicThreadFactory;
  6 
  7 /**
  8  * 监测器，监测时间间隔，设置文件观察器
  9  */
 10 public class FileMonitorImpl implements FileMonitor{
 11 
 12     private final FileAlterationMonitor monitor;
 13     
 14     /**
 15      * 监测器线程名称
 16      */
 17     private static final String MONITOR_THREAD_NAME = "File MONITOR Daemon";
 18         
 19     /**
 20      * 监测器线程Daemon标记
 21      */
 22     private static final boolean DAEMON = false;
 23     
 24     
 25     /**
 26      * 定义监测时间间隔、文件观察器
 27      * @param interval    监测时间间隔
 28      * @param observer    文件观察者
 29      */
 30     FileMonitorImpl(int interval, final FileAlterationObserver observer) {
 31         this(interval, observer, 
 32             new BasicThreadFactory.Builder().
 33                     namingPattern(MONITOR_THREAD_NAME).daemon(DAEMON).build());        
 34     }    
 35     
 36     /**
 37      * 定义监测时间间隔、文件观察器和线程工厂
 38      * @param interval    监测时间间隔
 39      * @param observer    文件观察器
 40      * @param factory    线程工厂
 41      */
 42     FileMonitorImpl(int interval, final FileAlterationObserver observer, 
 43                            final ThreadFactory factory) {        
 44         this.monitor = new FileAlterationMonitor(interval, new FileAlterationObserver[] { observer });
 45         monitor.setThreadFactory(factory);        
 46     } 
 47     
 48     /**
 49      * 添加文件观察器
 50      * @param observer
 51      */
 52     @Override
 53     public void addObserver(FileAlterationObserver observer) {
 54         monitor.addObserver(observer);
 55     }
 56 
 57     /**
 58      * 删除文件观察器 
 59      * @param observer
 60      */
 61     @Override
 62     public void removeObserver(FileAlterationObserver observer) {
 63         monitor.removeObserver(observer);
 64     }
 65 
 66     /**
 67      * 获取注册的所有观察器
 68      * @return
 69      */
 70     @Override
 71     public Iterable<FileAlterationObserver> getObservers() {
 72         return monitor.getObservers();
 73     }
 74 
 75     /**
 76      * 启动监测器
 77      */
 78     @Override
 79     public void start() {
 80         try {
 81             monitor.start();
 82         } 
 83         catch (Exception e) {
 84             e.printStackTrace();
 85         }
 86     }
 87 
 88     /**
 89      * 停止监测器
 90      */
 91     @Override
 92     public void stop() {
 93         try {
 94             monitor.stop();
 95         } 
 96         catch (Exception e) {
 97             e.printStackTrace();
 98         }
 99     }
100 
101     /**
102      * 获取监测时间间隔
103      */
104     @Override
105     public long getInterval() {
106         return monitor.getInterval(); 
107     }
108 
109 }

 1 import java.io.File;
 2 
 3 import org.apache.commons.io.monitor.FileAlterationListener;
 4 
 5 /**
 6  * 文件观察器角色
 7  */
 8 public interface FileObserver {
 9     
10     /**
11      * 添加监听器
12      * @param listener
13      */
14     void addListener(final FileAlterationListener listener);
15         
16     /**
17      * 删除监听器
18      * @param listener
19      */
20     void removeListener(final FileAlterationListener listener);
21         
22     /**
23      * 获取注册的监听器
24      * @return
25      */
26     Iterable<FileAlterationListener> getListeners();    
27     
28     /**
29      * 初始化观察器
30      * @throws Exception
31      */
32     void initialize() throws Exception;    
33     
34     /**
35      * 销毁观察器
36      * @throws Exception
37      */
38     void destroy() throws Exception;    
39     
40     /**
41      * 获取观察的目录
42      * @return
43      */
44     File getDirectory();
45     
46     /**
47      * 获取文件过滤器
48      * 
49      * @return
50      */
51     public FileFilter getFilter();
52 }

  1 import java.io.File;
  2 import java.io.IOException;
  3 
  4 import org.apache.commons.io.FileUtils;
  5 import org.apache.commons.io.IOCase;
  6 import org.apache.commons.io.monitor.FileAlterationListener;
  7 import org.apache.commons.io.monitor.FileAlterationObserver;
  8 
  9 /**
 10  * 文件观察器
 11  * 
 12  * 当有文件创建、删除、或变更动作时，则消息通知监听器
 13  */
 14 public class FileObserverImpl extends FileAlterationObserver implements FileObserver{
 15     
 16     private static final long serialVersionUID = -7239227289538993830L;
 17     
 18     /**
 19      * 文件过滤器
 20      */
 21     private final FileFilter filter;
 22         
 23     /**
 24      * 设置要监听观察的目录，并设置文件过滤器和监听器，用以观察指定具有指定扩展名的文件
 25      * @param dir            观察监听的目录
 26      * @param filter        文件过滤器
 27      * @param listener        文件监听器
 28      */
 29     public FileObserverImpl(String dir, final FileFilter filter, 
 30                                    FileAlterationListener listener) {
 31         super(dir, filter, (IOCase) null);
 32         addListener(listener); 
 33         
 34         this.filter = filter;
 35         
 36         File directory = new File(dir);
 37         
 38         // 如果目录不存在
 39         if(!directory.exists()) {
 40             try {
 41                 FileUtils.forceMkdir(directory);
 42             } 
 43             catch (IOException e) {
 44                 e.printStackTrace();
 45             }
 46         }
 47         // 如果存在的是文件
 48         else if(directory.exists() && directory.isFile()) {
 49             try {
 50                 FileUtils.forceDelete(directory);
 51                 FileUtils.forceMkdir(directory);
 52             } 
 53             catch (IOException e) {
 54                 e.printStackTrace();
 55             }
 56         }
 57     }
 58     
 59     /**
 60      * 添加监听器
 61      */
 62     @Override
 63     public void addListener(final FileAlterationListener listener) {
 64         super.addListener(listener);
 65     }
 66 
 67     /**
 68      * 移除监听器
 69      */
 70     @Override
 71     public void removeListener(final FileAlterationListener listener) {
 72         super.removeListener(listener);
 73     }
 74 
 75     /**
 76      * 获取观察者对象的所有监听器
 77      */
 78     @Override
 79     public Iterable<FileAlterationListener> getListeners() {
 80         return super.getListeners();
 81     }
 82     
 83     /**
 84      * 初始化文件观察者
 85      */
 86     @Override
 87     public void initialize() throws Exception {
 88         super.initialize();
 89     }
 90 
 91     /**
 92      * 销毁文件观察者
 93      */
 94     @Override
 95     public void destroy() throws Exception {
 96         super.destroy();
 97     }
 98     
 99     /**
100      * 获取所观察的目录
101      */
102     @Override
103     public File getDirectory() {
104         return super.getDirectory();
105     }
106 
107     /**
108      *  获取文件过滤器
109      * @return
110      */
111     public FileFilter getFilter() {
112         return filter;
113     }    
114 }

 1 import java.io.File;
 2 
 3 import org.apache.commons.io.monitor.FileAlterationListenerAdaptor;
 4 import org.apache.commons.io.monitor.FileAlterationObserver;
 5 
 6 /**
 7  * 文件监听器
 8  */
 9 public final class FileListener extends FileAlterationListenerAdaptor {
10     
11     /**
12      * 文件创建时执行的动作
13      */
14     @Override
15     public void onFileCreate(File file) {
16         // To do something
17     }
18     
19     /**
20      * 文件删除（转移）时执行的动作
21      */
22     @Override
23     public void onFileDelete(File file) {
24         // To do something
25     }
26     
27     /**
28      * 文件内容改变时执行的动作
29      */
30     @Override
31     public void onFileChange(File file) {
32         // To do something
33     }
34     
35     /**
36      * 开始执行监听时执行的动作
37      */
38     @Override
39     public void onStart(FileAlterationObserver observer) {
40         // To do something
41     }
42     
43     /**
44      * 停止监听时执行的动作
45      */
46     @Override
47     public void onStop(FileAlterationObserver observer) {
48         // To do something
49     }
50 }

 1 /**
 2  * 文件过滤器角色，扩展自java.io.FileFilter
 3  */
 4 public interface FileFilter extends java.io.FileFilter {
 5     
 6     /**
 7      * 获取定义的扩展名
 8      * 
 9      * @return
10      */
11     String[] getExtensions();
12 }

 1 import java.io.File;
 2 
 3 import org.apache.commons.io.FilenameUtils;
 4 
 5 /**
 6  * 文件过滤器
 7  */
 8 public class FileFilterImpl implements FileFilter{
 9     
10     private String[] extensions;
11     
12     public FileFilterImpl(String... extensions) {
13         this.extensions = extensions;
14     }
15     
16     /**
17      * 是否接受该文件
18      */
19     @Override
20     public boolean accept(File pathname) {
21         return FilenameUtils.isExtension(pathname.getName(), extensions); 
22     }
23 
24     /**
25      * 获取定义的扩展名
26      * @return  
27      */
28     @Override
29     public String[] getExtensions() {
30         return extensions;
31     }
32 
33 }