java实现文件变化监控的方法(推荐)
程序员文章站
2024-03-13 14:24:51
一. spring配置文件:application.xml
一. spring配置文件:application.xml
<?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>
二. spring上下文加载监听器:springcontextloaderlistener.class
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); } }
三. web工程配置文件:web.xml
<?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>
四. 文件监测器
1. 接口:filemonitor.class
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(); }
2. 实现类:filemonitorimpl.class
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(); } }
五. 文件观察器
1. 接口:fileobserver.class
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(); }
2. 实现类:fileobserverimpl.class
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; } }
六. 文件监听器:filelistener.class
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 } }
七. 文件过滤器
1. 接口:filefilter.class
/** * 文件过滤器角色,扩展自java.io.filefilter */ public interface filefilter extends java.io.filefilter { /** * 获取定义的扩展名 * * @return */ string[] getextensions(); }
2. 实现类:filefilterimpl.class
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; } }
以上这篇java实现文件变化监控的方法(推荐)就是小编分享给大家的全部内容了,希望能给大家一个参考,也希望大家多多支持。