`
chen_yongkai
  • 浏览: 61907 次
  • 性别: Icon_minigender_1
  • 来自: 福州
文章分类
社区版块
存档分类
最新评论

jnotify实现文件监控

 
阅读更多
package bluechip.jnotify;

import java.io.File;
import java.util.HashMap;

import net.contentobjects.jnotify.JNotify;
import net.contentobjects.jnotify.JNotifyException;
import net.contentobjects.jnotify.JNotifyListener;

public class FileMonitor {
	private final HashMap<File, FileMonitorConfig> configs;
	private JNotifyListener listener;
	private boolean running;
	private final Object waiter = new Object();
	private long minWatchedInterval = 100;
	private File lastWatchedFile;
	private long lastWatchedTime;

	public FileMonitor() {
		configs = new HashMap<File, FileMonitorConfig>();
		listener = new JNotifyListener() {
			public void fileRenamed(int wd, String parent, String oldName, String newName) {
				if (accept(parent, oldName, newName)) {
					renamed(parent, oldName, newName);
				}
			}

			public void fileModified(int wd, String parent, String name) {
				if (accept(parent, name)) {
					modified(parent, name);
				}
			}

			public void fileDeleted(int wd, String parent, String name) {
				if (accept(parent, name)) {
					deleted(parent, name);
				}
			}

			public void fileCreated(int wd, String parent, String name) {
				if (accept(parent, name)) {
					created(parent, name);
				}
			}
		};
	}

	public boolean addWatch(FileMonitorConfig config) {
		configs.put(config.getFile(), config);
		try {
			config.watchId = (JNotify.addWatch(config.getPath(), config.getMask(), config
					.isWatchSubtree(), listener));
		} catch (JNotifyException e) {
			return false;
		}
		return true;
	}

	private boolean accept(String parent, String name) {
		File file = new File(parent, name);
		if (file.equals(lastWatchedFile)
				&& System.currentTimeMillis() - lastWatchedTime < minWatchedInterval) {
			return false;
		}
		FileMonitorConfig config = configs.get(file);
		if (config == null) {
			config = configs.get(new File(parent));
		}
		if (config != null && config.accept(file)) {
			lastWatchedFile = file;
			lastWatchedTime = System.currentTimeMillis();
			return true;
		} else
			return false;
	}

	private boolean accept(String parent, String oldName, String newName) {
		File file = new File(parent, oldName);
		FileMonitorConfig config = configs.get(file);
		boolean isFile = true;
		if (config == null) {
			config = configs.get(new File(parent));
			isFile = false;
		}
		if (config != null && config.accept(file)) {
			lastWatchedFile = new File(parent, newName);
			if (isFile) {
				configs.remove(file);
				config.file = lastWatchedFile;
				configs.put(lastWatchedFile, config);
			}
			lastWatchedTime = System.currentTimeMillis();
			return true;
		} else
			return false;
	}

	public void start() throws JNotifyException {
		running = true;
		Thread t = new Thread() {
			public void run() {
				while (running) {
					synchronized (waiter) {
						try {
							waiter.wait();
						} catch (InterruptedException e) {
						}
					}
				}
			}
		};
		t.setDaemon(true);
		t.start();
	}

	public void stop() {
		running = false;
		synchronized (waiter) {
			waiter.notify();
		}
	}

	public boolean removeWatch(File file) {
		FileMonitorConfig config = configs.remove(file);
		if (config == null)
			return false;
		try {
			JNotify.removeWatch(config.watchId);
		} catch (JNotifyException e) {
			return false;
		}
		return true;
	}

	protected void renamed(String parent, String oldName, String newName) {
	}

	protected void modified(String parent, String name) {
	}

	protected void deleted(String parent, String name) {
	}

	protected void created(String parent, String name) {
	}

	/**
	 * @return the minWatchedInterval
	 */
	public long getMinWatchedInterval() {
		return minWatchedInterval;
	}

	/**
	 * @param minWatchedInterval
	 *            the minWatchedInterval to set
	 */
	public void setMinWatchedInterval(long minWatchedInterval) {
		this.minWatchedInterval = minWatchedInterval;
	}

	/**
	 * @return the lastWatchedFile
	 */
	public File getLastWatchedFile() {
		return lastWatchedFile;
	}

	/**
	 * @return the lastWatchedTime
	 */
	public long getLastWatchedTime() {
		return lastWatchedTime;
	}
}


以下方法由子类实现:
引用
protected void renamed(String parent, String oldName, String newName) {
}

protected void modified(String parent, String name) {
}

protected void deleted(String parent, String name) {
}

protected void created(String parent, String name) {
}


package bluechip.jnotify;

import java.io.File;
import java.io.FileFilter;

import net.contentobjects.jnotify.JNotify;

public final class FileMonitorConfig {
	public enum MASK {
		/**
		 * A file created
		 */
		CREATED(JNotify.FILE_CREATED),
		/**
		 * A file deleted
		 */
		DELETED(JNotify.FILE_DELETED),
		/**
		 * A file modified
		 */
		MODIFIED(JNotify.FILE_MODIFIED),
		/**
		 * A file renamed
		 */
		RENAMED(JNotify.FILE_RENAMED);
		private final int mask;

		private MASK(int mask) {
			this.mask = mask;
		}

		/**
		 * @return the mask
		 */
		public int getMask() {
			return mask;
		}
	}

	final String path;
	final boolean watchSubtree;
	int mask;
	FileFilter filter;
	int watchId;
	File file;

	public FileMonitorConfig(String filename, MASK... masks) {
		file = new File(filename);
		if (!file.isFile()) {
			throw new IllegalArgumentException("Not a file: " + filename);
		}
		this.filter = new FileFilter() {
			public boolean accept(File file1) {
				return file.equals(file1);
			}
		};
		this.path = file.getParent();
		this.watchSubtree = false;
		if (masks == null || masks.length == 0) {
			this.mask = JNotify.FILE_ANY;
		} else {
			for (MASK m : masks) {
				mask |= m.getMask();
			}
		}
	}

	public FileMonitorConfig(String path, boolean watchSubtree, MASK... masks) {
		file = new File(path);
		if (!file.isDirectory())
			throw new IllegalArgumentException("Not a directory: " + path);
		this.path = path;
		this.watchSubtree = watchSubtree;
		if (masks == null || masks.length == 0) {
			this.mask = JNotify.FILE_ANY;
		} else {
			for (MASK m : masks) {
				mask |= m.getMask();
			}
		}
	}

	/**
	 * @return the filter
	 */
	public FileFilter getFilter() {
		return filter;
	}

	/**
	 * Tests whether or not the specified abstract pathname should be monitored.
	 * 
	 * @param pathname
	 * @return
	 * @see java.io.FileFilter#accept(java.io.File)
	 */
	public boolean accept(File pathname) {
		return filter == null ? true : filter.accept(pathname);
	}

	/**
	 * @param filter
	 *            the filter to set
	 */
	public void setFilter(FileFilter filter) {
		if (file.isFile())
			throw new UnsupportedOperationException("It is a file,set filter for a directory.");
		this.filter = filter;
	}

	/**
	 * @return the mask
	 */
	public int getMask() {
		return mask;
	}

	/**
	 * @return the path
	 */
	public String getPath() {
		return path;
	}

	/**
	 * @return the watchSubtree
	 */
	public boolean isWatchSubtree() {
		return watchSubtree;
	}

	/**
	 * @return the file
	 */
	public File getFile() {
		return file;
	}
}

0
0
分享到:
评论

相关推荐

    java文件监控例子--jnotify

    在Java中,实现文件监控的一种流行库是`jnotify`。`jnotify`是一个轻量级的库,它提供了一个简单的方式来监控文件系统的变化。这个例子将深入探讨如何使用`jnotify`来实现文件监控。 `jnotify`库通过JNI(Java ...

    java实现文件监控.docx

    本文将详细介绍如何利用Java结合JNotify库来实现文件监控的功能。 #### 二、基础知识介绍 1. **Java Native Interface (JNI)** - JNI 是 Java 平台标准的一部分,它允许 Java 代码和其他语言(如 C 和 C++)编写...

    java文件监控例子

    在Java中实现文件监控,可以利用JNotify库,这是一个强大的文件系统变动通知库,支持Windows、Linux和Mac OS X操作系统。标题中的"java文件监控例子"就是关于如何使用JNotify来实现文件监控的示例。 JNotify库的...

    JNotify监控文件夹及文件变化.zip

    本压缩包中的代码示例应该包含以上步骤的实现,你可以参考这些代码来快速地在你的项目中实现文件和文件夹的监控。在实际应用中,你可能需要根据业务需求调整`JNotifyListener`的实现,比如将事件记录到日志文件,...

    文件实时监控

    实现文件实时监控的方法多种多样,例如使用操作系统的文件变更通知服务(如Windows的ReadDirectoryChangesW,Linux的inotify),或者使用第三方库如Python的watchdog。这些工具或API能够捕获文件系统事件,然后通过...

    Jnotify-0.94源码

    总的来说,Jnotify-0.94源码包提供了深入了解Java文件系统监控的一个机会,无论是对学习JNI、操作系统交互,还是对优化文件系统监控应用都极具价值。通过阅读源码,你可以学习到如何利用底层系统服务,以及如何编写...

    jnotify(包含dll与so).rar

    《jnotify:跨平台文件系统监控利器》 在IT领域,高效管理和监控文件系统变动是一项重要的任务,尤其在开发和运维场景中。jnotify就是这样一款工具,它为Java开发者提供了跨平台的文件系统变动监控功能。这个压缩包...

    FileSync 文件监控同步工具

    在FileSync中,JNotify可能被用来实现实时的文件监控功能,使得当文件发生变化时,软件能立即执行相应的同步操作。 FileSync的多任务文件夹监控意味着用户可以设定多个不同的同步任务,每个任务可以有不同的监控...

    基于java的文件监控程序设计与实现.zip

    在Java编程环境中,设计并实现一个文件监控程序是一项实用的技术任务。这个程序的主要目标是能够实时监测指定目录下的文件变化,如文件的创建、修改、删除等操作,并根据这些变化执行相应的处理逻辑。以下是对这一...

    文件内容监控程序

    源码可以帮助我们了解实现文件监控的具体技术和设计思路,这对于开发者来说是一份宝贵的参考资料,可以通过阅读和学习来提升自己的编程能力。同时,如果遇到问题,可以通过提供的网址与开发者进行交流,获取技术支持...

    jnotify-lib-0.93

    2. **libjnotify.dylib**:适用于Mac OS X系统的动态链接库,同样用于实现文件系统监控。 3. **libjnotify.so**:对于Linux系统,此文件作为动态链接库,确保了在Unix-like环境中jnotify的正常运行。 4. **jnotify-...

    jnotify-lib-0.93.rar

    5. **性能优化**:jnotify采用了底层系统级别的文件监控机制,如Windows的ReadDirectoryChangesW,Linux的inotify,以实现高效的事件检测,减少了资源消耗。 6. **安装与集成**:jnotify-lib-0.93是一个独立的库,...

    文件同步代码

    在Java中,我们可以使用`java.io`包中的`FileInputStream`和`FileOutputStream`来实现文件的复制。首先打开源文件的输入流,然后创建目标文件的输出流,接着读取源文件的数据并写入目标文件,最后关闭流。此外,Java...

    监视指定文件的变化.rar

    通过实例化`FileSystemWatcher`对象,设置相应的属性(如过滤器、路径和通知类型),并订阅事件,我们可以实现对特定文件的实时监控。 二、Linux的inotify 在Linux系统中,内核提供了名为inotify的机制,它能监控...

    java实现tail功能

    使用Java的`WatchService`或者第三方库如`JNotify`或`FileAlterationObserver`来监听文件的变化。当文件发生变化时,更新文件指针并重新读取最后N行。 6. **实时输出** 实时打印出读取到的最后N行内容。可以考虑...

    jnotify-api:从 code.google.compjnotify-api 导出

    值得注意的是,由于jnotify-api是通过底层系统调用来实现文件监控的,因此可能会有性能影响,特别是在大量文件变动或者频繁监控的情况下。开发者需要根据具体的应用场景权衡是否使用此类库,以及如何优化使用方式以...

    java缓存[归类].pdf

    JNotify是一个Java库,通过JNI(Java Native Interface)技术实现了跨平台的文件系统事件监控。它允许Java代码监听指定文件或目录的变化,如创建、删除、修改等操作。在Java Web应用中,如果需要缓存静态文件(如CSS...

    通知消息插件

    在Java开发中,有多种库可以帮助创建通知,如JNotify,它是一个文件系统监控库,可以监听文件或目录的创建、删除、修改事件,然后通过发送通知来告知开发者。这样的工具对于需要实时响应文件系统变化的应用尤其有用...

    study_jh.rar

    它使得开发者能够实时响应文件系统的变化,这对于文件监控、日志分析、自动备份等场景非常有用。了解JNotify,你可以更好地实现跨平台的文件系统监控功能,提高应用程序的响应性。 4. **Spider**:这里的"spider...

    classloader 热部署

    2. **类文件监控(File Watcher)**:使用Java的WatchService或者第三方库如JNotify、FileChangeMonitor等监控类文件的改动,一旦检测到变化,触发重新加载机制。 3. **重定义类(Re-definition)**:Java提供了一...

Global site tag (gtag.js) - Google Analytics