文件监视器

最新推荐文章于 2024-04-15 21:44:59 发布
最新推荐文章于 2024-04-15 21:44:59 发布
阅读量137 收藏
点赞数
分类专栏： Java 文章标签： Java C C++ C# Servlet
1.在web.xml配置文件监视器。 
  <listener>
     <listener-class>com.wgj.filter.FileModifyListener
     </listener-class>
  </listener>

2.监视器实现FileModifyListener.java 
package com.wgj.filter;

import javax.servlet.ServletContext;
import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;

import org.apache.log4j.Logger;

public class FileModifyListener implements ServletContextListener {

	FileThread fileThread;
	Logger log = Logger.getLogger(FileModifyListener.class);
	public FileModifyListener() {
	}
	@Override
	public void contextDestroyed(ServletContextEvent sce) {
	}

	@Override
	public void contextInitialized(ServletContextEvent sce) {
		fileThread = new FileThread();
		fileThread.setDaemon(true);//作为后台线程运行
		log.debug("File Listener Initialized: OK" );
		try {
//			System.out.println("File Listener Initialized: OK");
			fileThread.start();
		} catch(Exception e) {
			log.debug("File Listener contextInitialized:",e);
		}
	}

}


3.线程实现类FileThread.java 
package com.wgj.home;

import java.io.File;

import javax.servlet.ServletContext;

public class FileThread extends Thread {
	private File fileDir = null;
	private String monitorPath = null;
	private String storePath = null;
	FileMonitor monitorFileDir =null;
	FileMonitor monitorFile =null;

	public FileThread() {
		monitorPath = "c:\\";
		storePath =  "e:\";
		FileMonitor monitorFileDir = new FileMonitor(1000);
		FileMonitor monitorFile = new FileMonitor(1000);
		fileDir = new File(monitorPath);
		monitorFileDir.addFile(fileDir);
		monitorFileDir.addListener(new MonitorFileDirChanger(monitorFile, fileDir));
		File[] files = fileDir.listFiles();
		for (int i = 0; i < files.length; i++) {
			monitorFile.addFile(files[i]);
			monitorFile.addListener(new MonitorFileChanger());
		}
	}

	public void run() {
		while (!false)
		{
			try {
				Thread.sleep(2000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}

		}
	}

	private class MonitorFileChanger implements FileListener {
		public void fileChanged(File file) {
			FileOperator fileCopy = new FileOperator();
			fileCopy.copyFile(monitorPath + "\\" + file.getName(), storePath + file.getName());
		}
	}

	private class MonitorFileDirChanger implements FileListener {
		FileMonitor monitorFile;
		File fileDir;

		public MonitorFileDirChanger(FileMonitor monitorFile, File fileDir) {
			this.monitorFile = monitorFile;
			this.fileDir = fileDir;
		}

		public void fileChanged(File file) {
			monitorFile.removeAllListener();
			File[] files = fileDir.listFiles();
			for (int i = 0; i < files.length; i++) {
				monitorFile.addFile(files[i]);
				monitorFile.addListener(new MonitorFileChanger());
			}
			FileOperator fileCopy = new FileOperator();
			fileCopy.copyFolder(monitorPath, storePath);
		}
	}
}


4.其他工具类
4.1 FileListener.java 
package com.wgj.home;

import java.io.File;

/**
 * Interface for listening to disk file changes.
 * @see FileMonitor
 * 
 * @author <a href="mailto:jacob.dreyer@geosoft.no">Jacob Dreyer</a>
 */   
public interface FileListener
{
  /**
   * Called when one of the monitored files are created, deleted
   * or modified.
   * 
   * @param file  File which has been changed.
   */
  void fileChanged (File file);
}


4.2 FileMonitor.java 
package com.wgj.home;

import java.util.*;
import java.io.File;
import java.lang.ref.Reference;//WeakReference;


/**
 * Class for monitoring changes in disk files.
 * Usage:
 *
 *    1. Implement the FileListener interface.
 *    2. Create a FileMonitor instance.
 *    3. Add the file(s)/directory(ies) to listen for.
 *
 * fileChanged() will be called when a monitored file is created,
 * deleted or its modified time changes.
 *
 * @author <a href="mailto:jacob.dreyer@geosoft.no">Jacob Dreyer</a>
 */   
public class FileMonitor
{
  private Timer       timer_;
  private HashMap     files_;       // File -> Long
  private Collection  listeners_;   // of WeakReference(FileListener)


  /**
   * Create a file monitor instance with specified polling interval.
   * 
   * @param pollingInterval  Polling interval in milli seconds.
   */
  public FileMonitor (long pollingInterval)
  {
    files_     = new HashMap();
    listeners_ = new ArrayList();

    timer_ = new Timer (true);
    timer_.schedule (new FileMonitorNotifier(), 0, pollingInterval);
  }



  /**
   * Stop the file monitor polling.
   */
  public void stop()
  {
    timer_.cancel();
  }


  /**
   * Add file to listen for. File may be any java.io.File (including a
   * directory) and may well be a non-existing file in the case where the
   * creating of the file is to be trepped.
   * <p>
   * More than one file can be listened for. When the specified file is
   * created, modified or deleted, listeners are notified.
   * 
   * @param file  File to listen for.
   */
  public void addFile (File file)
  {
    if (!files_.containsKey (file)) {
      long modifiedTime = file.exists() ? file.lastModified() : -1;
      files_.put (file, new Long (modifiedTime));
    }
  }



  /**
   * Remove specified file for listening.
   * 
   * @param file  File to remove.
   */
  public void removeFile (File file)
  {
    files_.remove (file);
  }



  /**
   * Add listener to this file monitor.
   * 
   * @param fileListener  Listener to add.
   */
  public void addListener (FileListener fileListener)
  {
    // Don't add if its already there
    for (Iterator i = listeners_.iterator(); i.hasNext(); ) {
     // Reference reference = (Reference) i.next();

      FileListener listener = (FileListener)  i.next();//reference.get();
      if (listener == fileListener)
        return;
    }

    // Use WeakReference to avoid memory leak if this becomes the
    // sole reference to the object.
    listeners_.add (fileListener);//new Reference (
  }



  /**
   * Remove listener from this file monitor.
   * 
   * @param fileListener  Listener to remove.
   */
  public void removeListener (FileListener fileListener)
  {
    for (Iterator i = listeners_.iterator(); i.hasNext(); ) {
    // Reference reference = (Reference) i.next();
      FileListener listener = (FileListener)  i.next();//reference.get();
      if (listener == fileListener) {
        i.remove();
        break;
      }
    }
  }

  /**
   * Remove listener from this file monitor.
   * 
   * @param fileListener  Listener to remove.
   */
  public void removeAllListener ()
  {
    for (Iterator i = listeners_.iterator(); i.hasNext(); ) {
    // Reference reference = (Reference) i.next();
      FileListener listener = (FileListener)  i.next();//reference.get();
      i.remove();
    }
  }



  /**
   * This is the timer thread which is executed every n milliseconds
   * according to the setting of the file monitor. It investigates the
   * file in question and notify listeners if changed.
   */
  private class FileMonitorNotifier extends TimerTask
  {
    public void run()
    {
      // Loop over the registered files and see which have changed.
      // Use a copy of the list in case listener wants to alter the
      // list within its fileChanged method.
      Collection files = new ArrayList (files_.keySet());

      for (Iterator i = files.iterator(); i.hasNext(); ) {
        File file = (File) i.next();
        long lastModifiedTime = ((Long) files_.get (file)).longValue();
        long newModifiedTime  = file.exists() ? file.lastModified() : -1;

        // Chek if file has changed
        if (newModifiedTime != lastModifiedTime) {

          // Register new modified time
          files_.put (file, new Long (newModifiedTime));

          // Notify listeners
          for (Iterator j = listeners_.iterator(); j.hasNext(); ) {
            //Reference reference = (Reference) j.next();
            FileListener listener = (FileListener) j.next();

            // Remove from list if the back-end object has been GC'd
            if (listener == null)
              j.remove();
            else
              listener.fileChanged (file);
          }
        }
      }
    }
  }


  /**
   * Test this class.
   * 
   * @param args  Not used.
   */
  public static void main (String args[])
  {
    // Create the monitor
    FileMonitor monitor = new FileMonitor (1000);
    // Add some files to listen for
    monitor.addFile (new File ("E:\\deploy\\test"));    
    monitor.addFile (new File ("E:\\deploy\\test\\1.txt")); 
    // Add a dummy listener
    monitor.addListener (monitor.new TestListener());
    // Avoid program exit
    while (!false) 
    {

    	try {
			Thread.sleep(20);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
    }
  }


  private class TestListener implements FileListener {
	  public void fileChanged (File file) {
		  System.out.println ("File changed: " + file);
	  }
  }
}


4.3 FileOperator.java 

package com.wgj.home;

import java.io.*; 


public class FileOperator {

	  public FileOperator() {
	  }

	  /**
	   * 新建目录
	   * @param folderPath String 如 c:/fqf
	   * @return boolean
	   */
	  public void newFolder(String folderPath) {
	    try {
	      String filePath = folderPath;
	      filePath = filePath.toString();
	      java.io.File myFilePath = new java.io.File(filePath);
	      if (!myFilePath.exists()) {
	        myFilePath.mkdir();
	      }
	    }
	    catch (Exception e) {
	      System.out.println("新建目录操作出错");
	      e.printStackTrace();
	    }
	  }

	  /**
	   * 新建文件
	   * @param filePathAndName String 文件路径及名称 如c:/fqf.txt
	   * @param fileContent String 文件内容
	   * @return boolean
	   */
	  public void newFile(String filePathAndName, String fileContent) {

	    try {
	      String filePath = filePathAndName;
	      filePath = filePath.toString();
	      File myFilePath = new File(filePath);
	      if (!myFilePath.exists()) {
	        myFilePath.createNewFile();
	      }
	      FileWriter resultFile = new FileWriter(myFilePath);
	      PrintWriter myFile = new PrintWriter(resultFile);
	      String strContent = fileContent;
	      myFile.println(strContent);
	      resultFile.close();

	    }
	    catch (Exception e) {
	      System.out.println("新建目录操作出错");
	      e.printStackTrace();

	    }

	  }

	  /**
	   * 删除文件
	   * @param filePathAndName String 文件路径及名称 如c:/fqf.txt
	   * @param fileContent String
	   * @return boolean
	   */
	  public void delFile(String filePathAndName) {
	    try {
	      String filePath = filePathAndName;
	      filePath = filePath.toString();
	      java.io.File myDelFile = new java.io.File(filePath);
	      myDelFile.delete();

	    }
	    catch (Exception e) {
	      System.out.println("删除文件操作出错");
	      e.printStackTrace();

	    }

	  }

	  /**
	   * 删除文件夹
	   * @param filePathAndName String 文件夹路径及名称 如c:/fqf
	   * @param fileContent String
	   * @return boolean
	   */
	  public void delFolder(String folderPath) {
	    try {
	      delAllFile(folderPath); //删除完里面所有内容
	      String filePath = folderPath;
	      filePath = filePath.toString();
	      java.io.File myFilePath = new java.io.File(filePath);
	      myFilePath.delete(); //删除空文件夹

	    }
	    catch (Exception e) {
	      System.out.println("删除文件夹操作出错");
	      e.printStackTrace();

	    }

	  }

	  /**
	   * 删除文件夹里面的所有文件
	   * @param path String 文件夹路径 如 c:/fqf
	   */
	  public void delAllFile(String path) {
	    File file = new File(path);
	    if (!file.exists()) {
	      return;
	    }
	    if (!file.isDirectory()) {
	      return;
	    }
	    String[] tempList = file.list();
	    File temp = null;
	    for (int i = 0; i < tempList.length; i++) {
	      if (path.endsWith(File.separator)) {
	        temp = new File(path + tempList[i]);
	      }
	      else {
	        temp = new File(path + File.separator + tempList[i]);
	      }
	      if (temp.isFile()) {
	        temp.delete();
	      }
	      if (temp.isDirectory()) {
	        delAllFile(path+"/"+ tempList[i]);//先删除文件夹里面的文件
	        delFolder(path+"/"+ tempList[i]);//再删除空文件夹
	      }
	    }
	  }

	  /**
	   * 复制单个文件
	   * @param oldPath String 原文件路径 如：c:/fqf.txt
	   * @param newPath String 复制后路径 如：f:/fqf.txt
	   * @return boolean
	   */
	  public void copyFile(String oldPath, String newPath) {
	    try {
	      int bytesum = 0;
	      int byteread = 0;
	      File oldfile = new File(oldPath);
	      if (oldfile.exists()) { //文件存在时
	        InputStream inStream = new FileInputStream(oldPath); //读入原文件
	        FileOutputStream fs = new FileOutputStream(newPath);
	        byte[] buffer = new byte[1444];
	        int length;
	        while ( (byteread = inStream.read(buffer)) != -1) {
	          bytesum += byteread; //字节数 文件大小
	          fs.write(buffer, 0, byteread);
	        }
	        inStream.close();
	      }
	    }
	    catch (Exception e) {
	      System.out.println("复制单个文件操作出错");
	      e.printStackTrace();
	    }
	  }

	  /**
	   * 复制整个文件夹内容
	   * @param oldPath String 原文件路径 如：c:/fqf
	   * @param newPath String 复制后路径 如：f:/fqf/ff
	   * @return boolean
	   */
	  public void copyFolder(String oldPath, String newPath) {

	    try {
	      (new File(newPath)).mkdirs(); //如果文件夹不存在 则建立新文件夹
	      File a=new File(oldPath);
	      //System.out.println("oldPath:"+oldPath);
	      String[] file=a.list();
	      File temp=null;
	      for (int i = 0; i < file.length; i++) {
	        if(oldPath.endsWith(File.separator)){
	          temp=new File(oldPath+file[i]);
	        }
	        else{
	          temp=new File(oldPath+File.separator+file[i]);
	        }

	        if(temp.isFile()){
	          FileInputStream input = new FileInputStream(temp);
	          FileOutputStream output = new FileOutputStream(newPath + "/" +
	              (temp.getName()).toString());
	          byte[] b = new byte[1024 * 5];
	          int len;
	          while ( (len = input.read(b)) != -1) {
	            output.write(b, 0, len);
	          }
	          output.flush();
	          output.close();
	          input.close();
	        }
	        if(temp.isDirectory()){//如果是子文件夹
	          copyFolder(oldPath+"/"+file[i],newPath+"/"+file[i]);
	        }
	      }
	    }
	    catch (Exception e) {
	      System.out.println("copying all file error");//复制整个文件夹内容操作出错
	      e.printStackTrace();

	    }
	  }

	  /**
	   * 移动文件到指定目录
	   * @param oldPath String 如：c:/fqf.txt
	   * @param newPath String 如：d:/fqf.txt
	   */
	  public void moveFile(String oldPath, String newPath) {
	    copyFile(oldPath, newPath);
	    delFile(oldPath);

	  }

	  /**
	   * 移动文件到指定目录
	   * @param oldPath String 如：c:/fqf.txt
	   * @param newPath String 如：d:/fqf.txt
	   */
	  public void moveFolder(String oldPath, String newPath) {
	    copyFolder(oldPath, newPath);
	    delFolder(oldPath);

	  }
}
danwind
关注
专栏目录
文件系统监视器(Filemon) v7.0.2绿色汉化版.rar
07-09
Filemon（汉化中文版）一款出色的文件监控制软件，它可以监视应用程序进行的文件读写操作。将所有与文件操作(如读取修改等)记录全部记下来，用户保存、过滤、查找这些记录，为系统的维护提供了极大的便利。
文件系统监视器
qq_45303986的博客
12-05 402
QFileSystemWatcher类通过监视指定路径的列表来监视文件系统对文件和目录的更改。构造函数： 常用函数：常用的信号：例子：在Widget.h文件中添加： 在WIdget.cpp构造函数中添加： 槽函数的实现： 当你修改目录和文件时，会在控制台输出目录改变或文件改变
Directory Monitor：全方位监控文件系统变动的专业利器
最新发布
IT技术分享社区
04-15 1955
Directory Monitor是一款强大易用的实时文件系统监视工具，它由Michael Humpa开发，专为满足用户监控特定目录下文件和子目录变化的需求。无论是为了保障系统安全、追踪日志文件更新，还是实施自动化任务，Directory Monitor都能够提供全面的支持。这款跨平台的应用程序可以在Windows环境下运行，通过持续监测选定的文件夹，实时反馈任何类型的文件操作行为，从而让用户能够及时了解并应对任何可能影响文件系统的变化。
QT：文件监视
misikamikirto的博客
06-08 499
文件监视需要包含QFileSystemWatcher，用QFileSystemWatcher来创建一个myWatcher，用myWatcher来产生出这个信号。图中显示了当前的绝对路径，和当前路径下的所有文件，.代表当前文件夹…
文件、目录实时监控工具inotify-tools
小へ斌斌丶呀~的博客
12-26 1121
文件、目录实时监控工具inotify-tools。
Windows文件监视器
07-24
Windows文件监视器,能监视指定目录的文件生成、修改、删除、重命名，监视程序对系统文件的操作，程序需要.net 2.0的支持才能运行。
windows exe可执行文件监视器
04-21
对于需要监视的某个exe可执行文件，确保它一直在运行，或宕掉后需要自动启动该进程，则可以通过进程监视器程序，实时监视该进程是否存在，不存在则进程监视器会将此进程启动。示例中用windows自带的画图作为监视进程...
Windows文件服务器监控和审核
ITmoster的博客
03-23 1147
ADAudit Plus审核文件、文件夹和共享的Windows文件服务器权限更改。持续记录机密文件/文件夹并获得有关授权/未授权访问的即时告警。
文件监视工具ProcessActivityView(文件监视器)
06-18
Windows文件监视器程序可以对指定的某个盘符或某个目录进行监视，监视的内容包括任何文件及子文件夹的新建、删除、重命令、大小修改等等，并显示监视的结果。
文件夹监视器(Directory Monitor) v2.12.0.3 汉化绿色版.rar
07-09
Directory Monitor 监视文件夹中文件的变化：它会对文件更改，删除，修改，新建文件，文件更改进行通知，修改，删除，新的文件监控目录。监控本地目录或网络共享。快速判断一个目录可用，并且被监视。每当气球通知事件被触发。自动更新导入/导出。 主要功能： 实时监控文件夹的一切改动，如重命名、移动、复制、删除、访问等 监控本地的网络共享(包括隐藏及私人共享) 监控信息可通过气泡弹出通知用户 选项来检测子目录中的所有文件和更改文件属性 选择当一个事件发生时执行应用程序/脚本 排除、过滤目录 可自定义插件扩展功能
文件监控（文件的创建、修改、删除、重命名的操作监视）
06-07
监视文件夹里面的文件的创建、修改、删除、重命名。支持对特定文件类型进行监视。
Java 文件监控，实时监控文件加载
04-12
NULL 博文链接：https://sziitjiang.iteye.com/blog/1701660
文件监控服务（检测文件变化后执行程序）
05-25
编写背景：公司要求整一个语音播放的网页，通过web界面在文本框内输入文字后，将这些文字转换成语音，然后播放到广播系统，于是就写了这么一个windows小服务 功能说明：检测一个或者多个文件的变化，一旦变化，立刻执行对应的程序或者脚本。 程序配置文件说明 AppCfg.dat 说明：扫描频率（秒） 监视列表："/"换行，等号之前为条件执行程序，等号之后为监视文件路径，可以设置多个。冒号可加，可不加 例子："E:\test.bat"="E:\4.txt",E:\3.txt;/ "执行文件路径"="监视文件路径"（支持UNC路径） 配置文件示例： 扫描频率=5 监视列表=/ D:\语音播报\播放内容\临时通知.vbs=D:\语音播报\播放内容\临时通知.txt;/ D:\语音播报\播放内容\临时通知.vbs=\\192.168.1.200\播放内容\临时通知.txt; 环境依赖： .net 4.0 程序安装后，运行services.msc，会有一项“语音服务”，是以服务形式安装的，需要允许桌面交互，程序本身没有操作界面，修改配置文件可以达到你想要的目的，修改配置文件后重启该服务生效。 完美支持操作系统：win2003以下， 可兼容支持WIN7以上：因win7以上系统权限的缘故，会导致指定的执行程序出现权限问题，若你的执行程序能绕过这问题，那就没什么了
Java实现文件监控之二
captian_900331的博客
09-08 2719
承接上文，用commons-IO2.4jar实现文件监控的简单的dome，代码量比之前要简洁很多。 1、文件监视器：package watchFileTest2;import org.apache.commons.io.monitor.FileAlterationListenerAdaptor; import org.apache.commons.io.monitor.FileAlterationO
实现对文件的实时监控--使用Inotify方法
谢谢考拉的专栏
04-21 6173
linux系统下监控文件更改–Inotify API使用方法1.简介： 1.inotify机制可用于监控文件或目录。当监控目录时，与该目录自身以及该目录下面的文件都会被监控，其上有事件发生时都会通知给应用程序 2.otify监控机制为非递归，若应用程序有意监控整个目录子树内的事件，则需对该树中的每个目录发起inotify_add_watch()调用 可使用select(),poll(),epoll(）
Process Monitor监控目录 - 监控文件被哪个进程操作了。
热门推荐
zhang_sinner的专栏
02-11 2万+
转载请注明: 用Process Monitor监控目录 | 薤叶芸香's blog http://plumgo.cc/trace-folder-using-process-monitor/ 利用之前Windows API的知识，可以实现目录监控的功能，实际上我也实现了，但是如文中所述，当指定目录下操作过多时，会损失部分通知。多少算多呢，解压一个eclipse开发环境的压缩包到监控目录下，
FileSystemWatcher的使用--文件更改监视器
YoYo's Blog
04-05 1082
   昨天S1被我刷成砖头，在网上狂找官方原版的ROM，但是下下来是一体化的EXE，我想把里面的.nbh文件提取出来放到SD卡上装，看到执行EXE时，有“正在解压RUU_signed.nbh...”字样，应该是把这个文件解压到临时目录了，怎么找到这个目录呢？想到"FileSystemWatcher"这个组件，可以监视文件的创建，删除已经更改，于是就花了点时间写了这么个小工具。我现在想这个工具在其他
目录文件监控
最爱吹吹风
10-14 818
// 监视文件夹中文件变化.cpp : Defines the entry point for the console application. // #include "stdafx.h" #include #include #include using namespace std; int _tmain(int argc, _TCHAR* argv[]) { //监控主文件夹变化
C# 实现文件系统监视器详解
"C#文件监视器是一款使用C#编程语言编写的程序，它能够监控指定目录下的文件系统变动，包括文件的添加、修改和删除等事件。此资源提供了源代码，供学习者研究和参考，以理解如何在C#中实现文件监控功能。" 在C#中，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值