Java如何监控文件目录的变化

Java 如何监控文件目录的变化

Java如何监控某个目录下文件的变化，如文件增加、删除、修改，也包括子文件夹中的文件，有人建议使用jni,由于要跨平台，最好是纯java的

提供个想法，也不知道算不算是最笨的。
利用File的listFiles() ，lastModified() ，isDirectory() 等方法
0.写个类用于记录目录结构
1.循环遍历需要监视的文件夹，记录下整个目录结构
2.隔个5秒，10秒的，再遍历一遍
3.比较两次取得的目录结构，是否相同

修改文件夹是通过java吗？如果是的话就很简单了
写事件类，写监听器，使用Proxy代理下就OK了！
如果不是通过java的话那就是用jni吧，或者只能是 线程扫描了。 
 

想到一个貌似简单的方法，不过是区别OS的，也就是你底层要设计得好。
1.利用command列出文件夹结构（包括子文件夹）， 例如： widnows用 dir /S； solaris用 ls -r（具体参数记不清了），保存文件
2.隔段时间，再列一遍
3.然后比较两个文件

代码如下

Java code

基类RunThread.java
public abstract class RunThread implements Runnable
{
    
    private int second;
    private String filePath;
    Thread runner;
    /**
     * @param second   时间间隔
     * @param filePath 文件路径
     */
    public RunThread(int second,String filePath)
    {
        this.second = second*1000;
        this.filePath = filePath;
    }
    public void onStart()
    {
        runner = new Thread(this);
        runner.start();
    }
    public void run() {
        // TODO Auto-generated method stub
        Thread.currentThread().setPriority(Thread.MIN_PRIORITY);
        while(true)
        {
        try {
            watch(filePath);
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        }
        
    }
    public abstract void watch(String file);

}

子类 MonitorDir.java

Java code

import java.io.File;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Vector;


/**
 * 监控文件目录
 * @author han
 * @date 2009-10-10
 */
public class MonitorDir  extends RunThread
{
    public Map prevFiles = new HashMap();//存储原来文件路径和最后修改时间
    public Map currentFiles = new HashMap();//存储当前文件路径和最后修改时间
    public Map tmpCurrFiles = new HashMap();
    public Map tmpPrevFiles = new HashMap();
    public static Vector vList = new Vector();
    public Vector vtList = new Vector();
    
    /**
     * @param second  定时扫描间隔
     * @param filePath 目录路径
     */
    public MonitorDir(int second, String filePath) 
    {
        super(second, filePath);
        File dirFile = new File(filePath);
        if(dirFile.isDirectory())
        {
            System.out.println("start to watch " + dirFile.getAbsolutePath());
        }
        
        
    }
    
    /**
     * 获取文件的信息
     * @param dirPath
     */
    public void getFilesInfo(String dirPath)
    {
        File dirFile = new File(dirPath);
        
        prevFiles.clear();
        prevFiles.putAll(currentFiles);
        currentFiles.clear();
    
        File []fileList = dirFile.listFiles();
        for(int i = 0; i < fileList.length; i++)
        {
            File tmpFile = fileList[i];
            if(tmpFile.isFile())//文件
            {
                currentFiles.put(tmpFile.getAbsolutePath(), tmpFile.lastModified());
                
            }
            else//子目录则递归
            {
                String tmpPath = tmpFile.getAbsolutePath();
                getFilesInfo(tmpPath);
            }

        }
        
    }
    public void addFile(String file)
    {
        System.out.println(file+" is add");
    }
    public void changed(String file)
    {
        System.out.println(file+" is changed");
    }
    public void delete(String file)
    {
        System.out.println(file+" is delete");
    }
    
    /*
     * 监控
     */
    public void watch(String dirPath)
    {
        
        getFilesInfo(dirPath);
        Iterator currentIt =  currentFiles.keySet().iterator();
        while(currentIt.hasNext())
        {
            String filePath = (String)currentIt.next();
            Long currentModify = (Long) currentFiles.get(filePath);
            if(!prevFiles.containsKey(filePath))//假如原来的hashmap中不存在当前键，则为增加的
            {
                addFile(filePath);
                //if()
            }
            else if(prevFiles.containsKey(filePath))
            {
                Long prevModify = (Long)prevFiles.get(filePath);
                if(prevModify.compareTo(currentModify)!=0)//最后修改时间不同，则为改变的
                {
                    changed(filePath);
                }
            }
            //System.out.println("当前------"+filePath+","+currentModify);
        }
        Iterator prevIt = prevFiles.keySet().iterator();
        while(prevIt.hasNext())
        {
            String prevFilePath = prevIt.next().toString();
            if(!currentFiles.containsKey(prevFilePath))//原来的键不在当前hashmap中，则为删除的
            {
                delete(prevFilePath);
            }
            //System.out.println("原来------"+prevFilePath+","+tmpPrevFiles.get(prevFilePath));
        }
        
    }
    
    public static void main(String args[])
    {
        MonitorDir md = new MonitorDir(5,"D:/data/");
        md.onStart();    
        
    }
    
}

假如屏蔽递归那一句，能够监控根目录下文件的变化，使用递归时一直都在变化，是数据存储的问题，但是还找不到解决方法

希望你能用下面方法做:
1,判断是哪类操作系统(win,lin)
2,如果是win用dir命令,如果lin用ls命令扫描指定目录的所有文件的修改时间
3,将所有扫描文件信息保存到文件中去
4,比较刚保存的文件与旧文件的不同就可以得到增加、删除、修改
使用dir命令或者ls命令扫描是非常快的,是比较费时的

操作系统都带有一个底层库，该底层库提供一个接口，可以捕获文件变动的事件，并发出通知。
可以通过这种方式来实现，以前的时候做过这种东西，不过代码已经都没有了，你可以网上查一下应该有相关的资料。
基本的方式只有两种一种是轮询；另外一种就是基于事件；
轮询效率是个问题，另外实时性也不高。基于事件的的坏处就是不同的操作系统提供的接口不一致你需要针对不同的操作平台进行开发。