[JAVA] Hinweise zur Verwendung von WatchService

Beachten Sie, wie Sie mit "WatchService" Ordner- und Dateiänderungen in Java überwachen.

Umgebung

OS Window 10

Java

java version "1.8.0_151"
Java(TM) SE Runtime Environment (build 1.8.0_151-b12)
Java HotSpot(TM) 64-Bit Server VM (build 25.151-b12, mixed mode)

Hello World

package sample.watch;

import java.io.IOException;
import java.nio.file.FileSystems;
import java.nio.file.Paths;
import java.nio.file.WatchEvent;
import java.nio.file.WatchKey;
import java.nio.file.WatchService;
import java.nio.file.Watchable;

import static java.nio.file.StandardWatchEventKinds.*;
import static java.nio.file.WatchEvent.*;

public class Main {

    public static void main(String[] args) {
        WatchService watcher;
        try {
            watcher = FileSystems.getDefault().newWatchService();

            Watchable path = Paths.get("./build");
            path.register(watcher, ENTRY_CREATE, ENTRY_DELETE, ENTRY_MODIFY);
        } catch (IOException e) {
            e.printStackTrace();
            return;
        }

        while (true) {
            WatchKey watchKey;
            try {
                watchKey = watcher.take();
            } catch (InterruptedException e) {
                System.err.println(e.getMessage());
                return;
            }

            for (WatchEvent<?> event : watchKey.pollEvents()) {
                Kind<?> kind = event.kind();
                Object context = event.context();
                System.out.println("kind=" + kind + ", context=" + context);
            }
            
            if (!watchKey.reset()) {
                System.out.println("WatchKey ist deaktiviert");
                return;
            }
        }
    }
}

** Ausführungsergebnis **

Erläuterung

• Sie können "WatchService" verwenden, um Änderungen im angegebenen "Pfad" zu überwachen.

        WatchService watcher;
        try {
            watcher = FileSystems.getDefault().newWatchService();

            ...
        } catch (IOException e) {
            e.printStackTrace();
            return;
        }

• Holen Sie sich zuerst eine Instanz von "WatchService" mit "FileSystems.getDefault (). NewWatchService ()"

import static java.nio.file.StandardWatchEventKinds.*;

...

            Watchable path = Paths.get("./build");
            path.register(watcher, ENTRY_CREATE, ENTRY_DELETE, ENTRY_MODIFY);

• Als nächstes beginnt die Überwachung mit der Übergabe von "WatchService" an die "register ()" -Methode der "Watchable", die Sie überwachen möchten. --Path erbt Watchable, sodass es als Überwachungsziel verwendet werden kann.
• Geben Sie das Ereignis an, das Sie nach dem zweiten Argument überwachen möchten
• Geben Sie die in [StandardWatchEventKinds] definierten Konstanten an (https://docs.oracle.com/javase/jp/8/docs/api/java/nio/file/StandardWatchEventKinds.html).
• "OVERFLOW" muss jedoch nicht angegeben werden (Details werden später beschrieben).

        while (true) {
            WatchKey watchKey;
            try {
                watchKey = watcher.take();
            } catch (InterruptedException e) {
                System.err.println(e.getMessage());
                return;
            }

            ...
        }

• Wenn Sie die take () -Methode von WatchService ausführen, wartet sie auf die Verarbeitung, bis das zu überwachende Ereignis eintritt.
• Ein WatchKey-Objekt wird zurückgegeben, wenn ein überwachtes Ereignis auftritt --WatchKey ist ein Objekt, das erstellt wird, wenn Sie ein Überwachungsziel mitregister ()of Watchable registrieren. Sie können den Überwachungsstatus steuern, z. B. auf Ereignisinformationen verweisen, die für jedes Überwachungsziel aufgetreten sind, und die Überwachung abbrechen. es kann

            for (WatchEvent<?> event : watchKey.pollEvents()) {
                Kind<?> kind = event.kind();
                Object context = event.context();
                System.out.println("kind=" + kind + ", context=" + context);
            }

• Mit pollEvents () von WatchKey können Sie Informationen über das aufgetretene Ereignis (WatchEvent) abrufen.
• Die folgenden Informationen erhalten Sie bei WatchEvent --kind: Art des aufgetretenen Ereignisses --context: Path-Objekt mit einem relativen Pfad zum erstellten / geänderten / gelöschten Eintrag (Datei oder Ordner) --count: Häufigkeit, mit der diese Art von Ereignis aufgetreten ist

            if (!watchKey.reset()) {
                System.out.println("WatchKey ist deaktiviert");
                return;
            }

• Führen Sie abschließend reset () von WatchKey aus
• Warum müssen Sie später "reset ()" aufrufen?
• Der Rückgabewert von "reset ()" ist "boolean", was Ihnen sagt, ob "WatchKey" noch gültig ist. --Wenn "false", ist der "WatchKey" deaktiviert und die Überwachung kann nicht fortgesetzt werden.
• Eine der folgenden drei Bedingungen gilt für die Ungültigerklärung

1. Mit WatchKey.cancel () explizit abgebrochen
2. Das überwachte Objekt (Verzeichnis usw.) wurde gelöscht und war nicht mehr zugänglich und wurde implizit abgebrochen.
3. WatchService.close () hat die Überwachung von WatchService abgebrochen

WatchKey-Statusänderung

• "WatchKey" hat zwei Zustände, "READY" und "SIGNALLED".
• Wenn es von Watchable.register () generiert wird, befindet es sich im Status READY.
• Wechselt zu "SIGNALLED", wenn ein Ereignis erkannt wird
• Wenn Sie "WatchKey.reset ()" ausführen, kehrt es wieder in den Status "BEREIT" zurück.

Beziehung zwischen WatchService und WatchKey

--WatchService speichert den WatchKey, der beim Ausführen von Watchable.register () erstellt wurde

• Außerdem enthält es eine Warteschlange, die nur mit "WatchKey" gefüllt ist und dessen Status "SIGNALLED" lautet.
• Der WatchKey befindet sich unmittelbar nach seiner Erstellung im Status READY, befindet sich also nicht in der Warteschlange.
• Wenn ein überwachtes Ereignis erkannt wird, wird der Status des entsprechenden "WatchKey" von "READY" in "SIGNALLED" geändert.
• Der "WatchKey" mit dem Status "SIGNALLED" wird zur Warteschlange von "WatchService" hinzugefügt.
• Clientseitige Implementierungen mit "WatchService" können "WatchKey" am Anfang der Warteschlange mithilfe der Methoden "WatchService.take ()" oder "poll ()" (aus der Warteschlange entfernt) abrufen. Ru) --take () blockiert die Verarbeitung, wenn die Warteschlange leer ist, und wartet, bis WatchKey zur Warteschlange hinzugefügt wird --poll () gibt null zurück, ohne zu blockieren, wenn die Warteschlange leer ist --Für poll () können Sie die Timeout-Zeit als Argument angeben und bis dahin warten lassen.
• Der mit take () oder poll ()aus der Warteschlange genommeneWatchKey` wird nicht erneut in die Warteschlange gestellt, wenn er nicht berührt wird.
• Der Status von "WatchKey", der aus der Warteschlange entfernt wurde, ist immer noch "SIGNALLED"
• Wenn ein zusätzliches überwachtes Ereignis auftritt, wenn "WatchKey" "SIGNALLED" ist, wird es nicht erneut in die Warteschlange gestellt.
• Die aufgetretenen Ereignisinformationen selbst werden ordnungsgemäß zu "WatchKey" hinzugefügt --WatchKey ist threadsicher. Selbst wenn während der Ereignisverarbeitung Ereignisinformationen hinzugefügt werden, wird der interne Status nicht beschädigt. --pollEvents () gibt eine Kopie der Ereignisinformationen zurück, die WatchKey zu diesem Zeitpunkt hatte.
• Außerdem wurden die von pollEvents () erfassten Ereignisinformationen aus dem Inneren von WatchKey gelöscht. --Zusamenfassend
• Sobald WatchKey aus der Warteschlange entfernt wurde, wird es nicht erneut in die Warteschlange gestellt, wenn es nicht berührt wird. --Wenn Sie sich nicht in der Warteschlange befinden, können Sie sie nicht mit "take ()" oder "poll ()" abrufen Das bedeutet
• Der Status muss auf "BEREIT" zurückgesetzt werden, damit "WatchKey" erneut in die Warteschlange gestellt wird.
• Um den Status von "WatchKey" auf "READY" zurückzusetzen, führen Sie die Methode "reset ()" von "WatchKey" aus. --Wenn die von WatchKey gehaltenen Ereignisinformationen leer sind (keine unverarbeiteten Ereignisse), kehrt der Status zu READY zurück.
• Danach, wenn ein anderes Ereignis eintritt, wird es "SIGNALLED" und wird der Warteschlange hinzugefügt.
• Wenn die Ereignisinformationen nicht leer sind (es gibt unverarbeitete Ereignisse), werden sie im Status "SIGNALLED" zur Warteschlange hinzugefügt.

Zusammenfassung,

• Der "WatchKey" befindet sich unmittelbar nach der Erstellung im Status "BEREIT".
• Wenn ein Ereignis erkannt und in "SIGNALLED" geändert wird, wird es der Warteschlange in "WatchService" hinzugefügt.
• Sie können "WatchKey" mit "take ()", "poll ()" aus der Warteschlange abrufen
• Sobald sich ein WatchKey außerhalb der Warteschlange befindet, kehrt er nicht ohne Erlaubnis in die Warteschlange zurück, es sei denn, Sie führen reset () aus.
• Wenn es unverarbeitete Ereignisse gibt, können sie als "SIGNALLED" in die Warteschlange gestellt werden Wenn keine unverarbeiteten Ereignisse vorhanden sind, befindet es sich im Status "BEREIT". Wenn das überwachte Ereignis das nächste Mal auftritt, wird es erneut "SENGALLIERT" und in die Warteschlange gestellt.

Überlaufereignis

package sample.watch;

...

public class Main {

    public static void main(String[] args) {
        ...

        while (true) {
            WatchKey watchKey;
            try {
                watchKey = watcher.take();
                Thread.sleep(1000);★ Ergänzung
            } catch (InterruptedException e) {
                ...
            }

            ...
        }
    }
}

** Ausführungsergebnis **

Erläuterung

• Ein spezielles Ereignis namens "OVERFLOW" wird verwendet, wenn ein Ereignis aus irgendeinem Grund verloren geht oder zerstört wird.
• Abhängig von der Ausführungsumgebung kann die Anzahl der in WatchKey gespeicherten Ereignisse begrenzt sein. Wenn ein Ereignis auftritt, das diese Grenze überschreitet, wird das Ereignis OVERFLOW verwendet.
• Warten Sie im obigen Beispiel 1 Sekunde, bevor Sie das Ereignis (pollEvents ()) abrufen, speichern Sie alle Ereignisse einer großen Anzahl von Dateierzeugungen in WatchKey und generieren Sie zwangsweise OVERFLOW. Ist
• Das Ereignis "OVERFLOW" wird benachrichtigt, wenn die Bedingungen erfüllt sind, auch wenn es in der Registrierung bei "Watchable.register ()" nicht als überwachtes Ereignis angegeben ist.
• Daher ist es besser, die Verarbeitung immer zu berücksichtigen, wenn "OVERFLOW" auftritt.
• Wenn Sie es ignorieren können, ignorieren Sie es, wenn Sie einen Fehler machen, machen Sie einen Fehler (es hängt von der Anwendung ab, die Sie machen)

Überwachen Sie mehrere Ordner

package sample.watch;

import java.io.IOException;
import java.nio.file.FileSystems;
import java.nio.file.Paths;
import java.nio.file.WatchEvent;
import java.nio.file.WatchKey;
import java.nio.file.WatchService;
import java.nio.file.Watchable;

import static java.nio.file.StandardWatchEventKinds.*;
import static java.nio.file.WatchEvent.*;

public class Main {

    public static void main(String[] args) {
        WatchService watcher;
        WatchKey fooKey;
        WatchKey barKey;
        try {
            watcher = FileSystems.getDefault().newWatchService();

            Watchable foo = Paths.get("./build/foo");
            fooKey = foo.register(watcher, ENTRY_CREATE, ENTRY_DELETE, ENTRY_MODIFY);

            Watchable bar = Paths.get("./build/bar");
            barKey = bar.register(watcher, ENTRY_CREATE, ENTRY_DELETE, ENTRY_MODIFY);
        } catch (IOException e) {
            e.printStackTrace();
            return;
        }

        while (true) {
            WatchKey watchKey;
            try {
                watchKey = watcher.take();
            } catch (InterruptedException e) {
                System.err.println(e.getMessage());
                return;
            }

            for (WatchEvent<?> event : watchKey.pollEvents()) {
                Kind<?> kind = event.kind();
                
                if (kind == OVERFLOW) {
                    continue;
                }

                Object context = event.context();

                String directory;
                if (watchKey == fooKey) {
                    directory = "foo";
                } else if (watchKey == barKey) {
                    directory = "bar";
                } else {
                    directory = "unknown";
                }

                System.out.println("directory=" + directory + ", kind=" + kind + ", context=" + context);
            }
            
            if (!watchKey.reset()) {
                System.out.println("WatchKey ist deaktiviert");
                return;
            }
        }
    }
}

** Ausführungsergebnis **

Erläuterung

• Ein WatchService kann mehrere Ordner überwachen
• In diesem Fall muss angegeben werden, auf welchen Ordner der von WatchService.take () erhaltene WatchKey verweist.
• Wenn Sie den zurückgegebenen "WatchKey" als Rückgabewert von "Watchable.register ()" speichern, können Sie ihn vergleichen, um festzustellen, in welchem Ordner sich das Ereignis befindet.

Referenz

• Überwachung von Verzeichnisänderungen (Java? Tutorial> Wichtige Klassen> Grundlegende E / A)
• WatchDir.java
• WatchService (Java Platform SE 8 )
• Watchable (Java Platform SE 8 )
• WatchKey (Java Platform SE 8 )
• WatchEvent (Java Platform SE 8 )
• StandardWatchEventKinds (Java Platform SE 8 )
• java - In jdk7 watch service API, when will the OVERFLOW event be thrown? - Stack Overflow