在Java中跟踪文件夹更改的最简单方法是什么？

Question

I have a set of source folders. I use a Java class to build the distribution file out of these folders. I'd like to write another little class in Java which runs every half a second, checks if any of the files in the folders have changed, and if yes, run the building class.

So, how do I detect easily that a folder has been modified ?

Answer 1

I think you will need to check the directory and subdirectory modfication times (for files being added/removed) and the file modification times (for the changes in each file).

Write a recursive routine that checks a directory for it's modification time and if it's changed, plus each files. Then checks the directory contents, and call recursively for any subdirectories. You should just be able to check for any modification times greater than when you last ran the check.

See File.lastModified()

EDIT: Since I wrote the above, Java 7 came out with its directory watching capability .

Answer 2

这里列出了可能的解决方案和简单文件/文件夹观察器的示例。

Answer 3

If you can are allowed to use Java 7, it has support for platform independent directory/file change notifications.

JNA has a sample for cross platform change notification here . Not sure how easy you might find it.

Answer 4

I don't know if it's any good, but here's one person's take on the problem.

Sounds like .NET has something built-in: FileSystemWatcher

UPDATE: Thanks to kd304, I just learned that Java 7 will have the same feature . Won't do you much good today, unless you can use the preview release .

Answer 5

您需要观察每个文件并跟踪File.lastModified属性并检查File.exists标志以及一些简单的递归来遍历目录结构。

Answer 6

with NIO2 (Java7) it will be very easy. With Java6 you could call list() and compare with previous list once a second? (a poor man watching service)

Answer 7

Yes, there are a number of available listeners for directories, but they're all relatively complicated and most involve threads.

A few days ago I ended up in an almost heated discussion with one of our engineers over whether it was a permissible creating a new thread (in a web application) simply to monitor a directory tree. In the end I agreed with him, but by virtue of coming up with something so fast that having a listener is unnecessary. Note: the solution described below only works if you don't need to know which file has changed, only that a file has changed.

You provide the following method with a Collection of Files (eg, obtained via Apache IO's FileUtils.listFiles() method) and this returns a hash for the collection. If any file is added, deleted, or its modification date changed, the hash will change.

In my tests, 50K files takes about 750ms on a 3Ghz Linux box. Touching any of the files alters the hash. In my own implementation I'm using a different hash algorithm (DJB) that's a bit faster but that's the gist of it. We now just store the hash and check each time as it's pretty painless, especially for smaller file collections. If anything changes we then re-index the directory. The complexity of a watcher just wasn't worth it in our application.

/**
 *  Provided a directory and a file extension, returns
 *  a hash using the Adler hash algorithm.
 *   
 * @param files  the Collection of Files to hash.
 * @return       a hash of the Collection.
 */
public static long getHash( Collection<File> files )
{
    Adler32 adler = new Adler32();
    StringBuilder sb = new StringBuilder();
    for ( File f : files ) {
        String s = f.getParent()+'/'+f.getName()+':'+String.valueOf(f.lastModified());
        adler.reset();
        adler.update(s.getBytes());
        sb.append(adler.getValue()+' ');
    }
    adler.reset();
    adler.update(sb.toString().getBytes());
    return adler.getValue();
}

And yes, there's room for improvement (eg, we use a hash method rather than inlining it). The above is cut down from our actual code but should give you a good idea what we did.