Java实现文件变化监控

<?xml version="1.0" encoding="utf-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/xmlschema-instance" 
xmlns:tx="http://www.springframework.org/schema/tx" xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:context="http://www.springframework.org/schema/context" xmlns:dwr="http://www.directwebremoting.org/schema/spring-dwr"
xmlns:jaxrs="http://cxf.apache.org/jaxrs"
xsi:schemalocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.1.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.1.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.1.xsd
http://www.directwebremoting.org/schema/spring-dwr http://www.directwebremoting.org/schema/spring-dwr-3.0.xsd
http://cxf.apache.org/jaxrs http://cxf.apache.org/schemas/jaxrs.xsd">
<!-- 文件监测器 --> 
<bean id="monitor"
class="com.interfaces.file.monitor.filemonitorimpl">
<constructor-arg index="0" value="10000" /> <!-- 监测时间间隔，单位：毫秒 -->
<constructor-arg index="1" ref="observer" /> <!-- 文件观察器 -->
</bean> 
<!-- 文件观察器 --> 
<bean id="observer"
class="com.interfaces.file.monitor.fileobserverimpl">
<constructor-arg index="0" value="d:\\uploaddir"/> <!-- 观察的目录 -->
<constructor-arg index="1" ref="filter"/> <!-- 文件过滤器-->
<constructor-arg index="2" ref="listener"/> <!-- 文件监听器 -->
</bean>
<!-- 文件监听器 --> 
<bean id="listener"
class="com.interfaces.file.monitor.filelistener"/>
<!-- 文件过滤器 --> 
<bean id="filter"
class="com.interfaces.file.monitor.filefilterimpl"> 
<!-- 
指定文件扩展名，只有指定的扩展名文件会被处理。
不同的扩展名间以 "," 间隔，如：xml,txt,bak 
-->
<constructor-arg index="0" value="xml"/> 
</bean>
</beans>

import javax.servlet.servletcontextevent;
import org.springframework.web.context.contextloaderlistener;
public class springcontextloaderlistener extends contextloaderlistener{
@override
public void contextinitialized(servletcontextevent event) {
super.contextinitialized(event);
filemonitor scanner = getscanner();
// 启动目录扫描器
scanner.start();
}
@override
public void contextdestroyed(servletcontextevent event) {
filemonitor scanner = getscanner();
// 关闭目录扫描器
scanner.stop();
super.contextdestroyed(event);
}
/**
* 获取目录扫描器
* @return
*/
private filemonitor getscanner() {
return getcurrentwebapplicationcontext().getbean(filemonitor.class);
}
}

<?xml version="1.0" encoding="utf-8"?>
<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">
<context-param>
<param-name>contextconfiglocation</param-name>
<param-value>
classpath:application.xml
</param-value>
</context-param>
<listener>
<listener-class>com.web.springcontextloaderlistener</listener-class>
</listener>
</web-app>

import org.apache.commons.io.monitor.filealterationobserver;
/**
* 文件监测器角色
*/
public interface filemonitor {
/**
* 注册观察器
* @param observer 观察器
*/
void addobserver(filealterationobserver observer);
/**
* 删除观察器
* @param observer 观察器
*/
void removeobserver(filealterationobserver observer); 
/**
* 获取注册的所有观察器
* @return 观察器集合
*/
iterable<filealterationobserver> getobservers(); 
/**
* 启动监测器
*/
void start(); 
/**
* 停止监测器
*/
void stop(); 
/**
* 获取监测间隔时间
* @return 间隔时间（单位：毫秒）
*/
long getinterval(); 
}

import java.util.concurrent.threadfactory;
import org.apache.commons.io.monitor.filealterationmonitor;
import org.apache.commons.io.monitor.filealterationobserver;
import org.apache.commons.lang3.concurrent.basicthreadfactory;
/**
* 监测器，监测时间间隔，设置文件观察器
*/
public class filemonitorimpl implements filemonitor{
private final filealterationmonitor monitor;
/**
* 监测器线程名称
*/
private static final string monitor_thread_name = "file monitor daemon";
/**
* 监测器线程daemon标记
*/
private static final boolean daemon = false;
/**
* 定义监测时间间隔、文件观察器
* @param interval 监测时间间隔
* @param observer 文件观察者
*/
filemonitorimpl(int interval, final filealterationobserver observer) {
this(interval, observer, 
new basicthreadfactory.builder().
namingpattern(monitor_thread_name).daemon(daemon).build()); 
} 
/**
* 定义监测时间间隔、文件观察器和线程工厂
* @param interval 监测时间间隔
* @param observer 文件观察器
* @param factory 线程工厂
*/
filemonitorimpl(int interval, final filealterationobserver observer, 
final threadfactory factory) { 
this.monitor = new filealterationmonitor(interval, new filealterationobserver[] { observer });
monitor.setthreadfactory(factory); 
} 
/**
* 添加文件观察器
* @param observer
*/
@override
public void addobserver(filealterationobserver observer) {
monitor.addobserver(observer);
}
/**
* 删除文件观察器 
* @param observer
*/
@override
public void removeobserver(filealterationobserver observer) {
monitor.removeobserver(observer);
}
/**
* 获取注册的所有观察器
* @return
*/
@override
public iterable<filealterationobserver> getobservers() {
return monitor.getobservers();
}
/**
* 启动监测器
*/
@override
public void start() {
try {
monitor.start();
} 
catch (exception e) {
e.printstacktrace();
}
}
/**
* 停止监测器
*/
@override
public void stop() {
try {
monitor.stop();
} 
catch (exception e) {
e.printstacktrace();
}
}
/**
* 获取监测时间间隔
*/
@override
public long getinterval() {
return monitor.getinterval(); 
}
} 

import java.io.file;
import org.apache.commons.io.monitor.filealterationlistener;
/**
* 文件观察器角色
*/
public interface fileobserver {
/**
* 添加监听器
* @param listener
*/
void addlistener(final filealterationlistener listener);
/**
* 删除监听器
* @param listener
*/
void removelistener(final filealterationlistener listener);
/**
* 获取注册的监听器
* @return
*/
iterable<filealterationlistener> getlisteners(); 
/**
* 初始化观察器
* @throws exception
*/
void initialize() throws exception; 
/**
* 销毁观察器
* @throws exception
*/
void destroy() throws exception; 
/**
* 获取观察的目录
* @return
*/
file getdirectory();
/**
* 获取文件过滤器
* 
* @return
*/
public filefilter getfilter();
} 

import java.io.file;
import java.io.ioexception;
import org.apache.commons.io.fileutils;
import org.apache.commons.io.iocase;
import org.apache.commons.io.monitor.filealterationlistener;
import org.apache.commons.io.monitor.filealterationobserver;
/**
* 文件观察器
* 
* 当有文件创建、删除、或变更动作时，则消息通知监听器
*/
public class fileobserverimpl extends filealterationobserver implements fileobserver{
private static final long serialversionuid = -7239227289538993830l;
/**
* 文件过滤器
*/
private final filefilter filter;
/**
* 设置要监听观察的目录，并设置文件过滤器和监听器，用以观察指定具有指定扩展名的文件
* @param dir 观察监听的目录
* @param filter 文件过滤器
* @param listener 文件监听器
*/
public fileobserverimpl(string dir, final filefilter filter, 
filealterationlistener listener) {
super(dir, filter, (iocase) null);
addlistener(listener); 
this.filter = filter;
file directory = new file(dir);
// 如果目录不存在
if(!directory.exists()) {
try {
fileutils.forcemkdir(directory);
} 
catch (ioexception e) {
e.printstacktrace();
}
}
// 如果存在的是文件
else if(directory.exists() && directory.isfile()) {
try {
fileutils.forcedelete(directory);
fileutils.forcemkdir(directory);
} 
catch (ioexception e) {
e.printstacktrace();
}
}
}
/**
* 添加监听器
*/
@override
public void addlistener(final filealterationlistener listener) {
super.addlistener(listener);
}
/**
* 移除监听器
*/
@override
public void removelistener(final filealterationlistener listener) {
super.removelistener(listener);
}
/**
* 获取观察者对象的所有监听器
*/
@override
public iterable<filealterationlistener> getlisteners() {
return super.getlisteners();
}
/**
* 初始化文件观察者
*/
@override
public void initialize() throws exception {
super.initialize();
}
/**
* 销毁文件观察者
*/
@override
public void destroy() throws exception {
super.destroy();
}
/**
* 获取所观察的目录
*/
@override
public file getdirectory() {
return super.getdirectory();
}
/**
* 获取文件过滤器
* @return
*/
public filefilter getfilter() {
return filter;
} 
}

import java.io.file;
import org.apache.commons.io.monitor.filealterationlisteneradaptor;
import org.apache.commons.io.monitor.filealterationobserver;
/**
* 文件监听器
*/
public final class filelistener extends filealterationlisteneradaptor {
/**
* 文件创建时执行的动作
*/
@override
public void onfilecreate(file file) {
// to do something
}
/**
* 文件删除（转移）时执行的动作
*/
@override
public void onfiledelete(file file) {
// to do something
}
/**
* 文件内容改变时执行的动作
*/
@override
public void onfilechange(file file) {
// to do something
}
/**
* 开始执行监听时执行的动作
*/
@override
public void onstart(filealterationobserver observer) {
// to do something
}
/**
* 停止监听时执行的动作
*/
@override
public void onstop(filealterationobserver observer) {
// to do something
}
}

/**
* 文件过滤器角色，扩展自java.io.filefilter
*/
public interface filefilter extends java.io.filefilter {
/**
* 获取定义的扩展名
* 
* @return
*/
string[] getextensions();
}

import java.io.file;
import org.apache.commons.io.filenameutils;
/**
* 文件过滤器
*/
public class filefilterimpl implements filefilter{
private string[] extensions;
public filefilterimpl(string... extensions) {
this.extensions = extensions;
}
/**
* 是否接受该文件
*/
@override
public boolean accept(file pathname) {
return filenameutils.isextension(pathname.getname(), extensions); 
}
/**
* 获取定义的扩展名
* @return 
*/
@override
public string[] getextensions() {
return extensions;
}
}