java實現文件變化監控，java實現監控
一. spring配置文件：application.xml
![]()
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>
View Code
二. spring上下文加載監聽器：SpringContextLoaderListener.class
![]()
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 }
View Code
三. web工程配置文件：web.xml
![]()
1 <?xml version="1.0" encoding="UTF-8"?>
2 <web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:web="http://xmlns.jcp.org/xml/ns/javaee" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_4.xsd http://xmlns.jcp.org/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" version="2.4">
3 <context-param>
4 <param-name>contextConfigLocation</param-name>
5 <param-value>
6 classpath:application.xml
7 </param-value>
8 </context-param>
9 <listener>
10 <listener-class>com.web.SpringContextLoaderListener</listener-class>
11 </listener>
12
13 </web-app>
View Code
四. 文件監測器
1. 接口：FileMonitor.class
![]()
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 }
View Code
2. 實現類：FileMonitorImpl.class
![]()
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 }
View Code
五. 文件觀察器
1. 接口：FileObserver.class
![]()
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 }
View Code
2. 實現類：FileObserverImpl.class
![]()
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 }
View Code
六. 文件監聽器：FileListener.class
![]()
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 }
View Code
七. 文件過濾器
1. 接口：FileFilter.class
![]()
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 }
View Code
2. 實現類：FileFilterImpl.class
![]()
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 }
View Code
