Plik zmieniony w Javie

Pisałem już wcześniej monitor plików dziennika i stwierdziłem, że wpływ na wydajność systemu sprawdzania atrybutów pojedynczego pliku, kilka razy na sekundę, jest w rzeczywistości bardzo mały.

Java 7, jako część NIO.2 dodał WatchService API

Interfejs API WatchService jest przeznaczony dla aplikacji, które muszą być powiadamiane o zdarzeniach zmiany pliku.

Używam API VFS z Apache Commons, oto przykład jak monitorować plik bez większego wpływu na wydajność:

DefaultFileMonitor

Istnieje lib o nazwie jnotify , który zawija inotify na Linuksie i ma również wsparcie dla systemu windows. Nigdy go nie używałem i nie wiem, jak dobry jest, ale warto spróbować.

Java commons-io posiada FileAlterationObserver . robi ankiety w połączeniu z FileAlterationMonitor. Podobne do commons VFS. Zaletą jest to, że ma znacznie mniej zależności.

Edit: Less dependencies is not true, they are optional for VFS. Ale używa pliku java zamiast warstwy abstrakcji VFS.

"Więcej funkcji NIO" ma funkcjonalność file watch, z implementacją zależną od bazowego systemu operacyjnego. Powinien być w JDK7.

Uruchamiam ten fragment kodu za każdym razem, gdy idę do odczytu pliku właściwości, tylko w rzeczywistości odczytując plik, jeśli został zmodyfikowany od ostatniego czasu, kiedy go przeczytałem. Mam nadzieję, że to komuś pomoże.

private long timeStamp;
private File file;

private boolean isFileUpdated( File file ) {
  this.file = file;
  this.timeStamp = file.lastModified();

  if( this.timeStamp != timeStamp ) {
    this.timeStamp = timeStamp;
    //Yes, file is updated
    return true;
  }
  //No, file is not updated
  return false;
}

Podobne podejście jest stosowane w Log4J FileWatchdog.

Jeśli chcesz się rozstać z pieniędzmi JNIWrapper jest przydatną biblioteką z Winpack, będziesz mógł uzyskać zdarzenia systemu plików na niektórych plikach. Niestety tylko windows.

Http://www.teamdev.com/jniwrapper/index.jsf

W Przeciwnym Razie, uciekanie się do kodu natywnego nie zawsze jest złe, zwłaszcza gdy najlepszym w ofercie jest mechanizm ankietowania przeciwko zdarzeniu natywnemu.

Zauważyłem, że operacje systemu plików java mogą być powolne na niektórych komputerach i mogą łatwo wpływa na wydajność aplikacji, Jeśli nie jest dobrze obsługiwane.

Można również rozważyć Apache Commons JCI (Java Compiler Interface). Chociaż wydaje się, że API skupia się na dynamicznej kompilacji klas, zawiera również klasy w swoim API, które monitorują zmiany plików.

Przykład: http://commons.apache.org/jci/usage.html

Integracja Spring zapewnia ładny mechanizm do oglądania katalogów i plików: http://static.springsource.org/spring-integration/reference/htmlsingle/#files. całkiem pewien, że jest to cross platform (używałem go na mac, linux i windows).

Możesz słuchać zmian plików za pomocą programu FileReader. Plz zobacz przykład poniżej

// File content change listener 
private String fname;
private Object lck = new Object();
... 
public void run()
{
    try
    {
        BufferedReader br = new BufferedReader( new FileReader( fname ) );
        String s;
        StringBuilder buf = new StringBuilder();
        while( true )
        {
            s = br.readLine();
            if( s == null )
            {
                synchronized( lck )
                {
                    lck.wait( 500 );
                }
            }
            else
            {
               System.out.println( "s = " + s );
            }

        }
    }
    catch( Exception e )
    {
        e.printStackTrace();
    }
}

Istnieje komercyjna biblioteka dla przeglądania plików i folderów o nazwie JxFileWatcher. Można go pobrać stąd: http://www.teamdev.com/jxfilewatcher/

Również można go zobaczyć w akcji online: http://www.teamdev.com/jxfilewatcher/onlinedemo/

Podobnie jak inne odpowiedzi, oto jak zrobiłem to za pomocą pliku, timera i TimerTask, aby to działało jako ankieta wątku w tle w określonych odstępach czasu.

import java.io.File;
import java.util.Timer;
import java.util.TimerTask;

public class FileModifiedWatcher
{
  private static File file;
  private static int pollingInterval;
  private static Timer fileWatcher;
  private static long lastReadTimeStamp = 0L;

  public static boolean init(String _file, int _pollingInterval)
  {
    file =  new File(_file);
    pollingInterval = _pollingInterval; // In seconds

    watchFile();

    return true;
  }

  private static void watchFile()
  {
    if ( null == fileWatcher )
    {
      System.out.println("START");

      fileWatcher = new Timer();

      fileWatcher.scheduleAtFixedRate(new TimerTask()
      {
        @Override
        public void run()
        {

          if ( file.lastModified() > lastReadTimeStamp )
          {
            System.out.println("File Modified");
          }

          lastReadTimeStamp = System.currentTimeMillis();
        }
      }, 0, 1000 * pollingInterval);
    }

  }
}

Sprawdzenie ostatnio zmodyfikowanej właściwości pliku jest jednak prostym, ale skutecznym rozwiązaniem. Po prostu zdefiniuj klasę rozszerzającą mój FileChangedWatcher i zaimplementuj metodę onModified():

import java.io.File;

public abstract class FileChangedWatcher
{
    private File file;

    public FileChangedWatcher(String filePath)
    {
        file = new File(filePath);
    }

    public void watch() throws InterruptedException
    {
        long currentModifiedDate = file.lastModified();

        while (true)
        {
            long newModifiedDate = file.lastModified();

            if (newModifiedDate != currentModifiedDate)
            {
                currentModifiedDate = newModifiedDate;
                onModified();
            }

            Thread.sleep(100);
        }
    }

    public String getFilePath()
    {
        return file.getAbsolutePath();
    }

    protected abstract void onModified();
}