Comment regarder un dossier et des sous-dossiers pour les changements

Im essayant de regarder un dossier spécifique pour les modifications, puis si tout ajout/édition/suppression se produit à l'intérieur de ça, je dois obtenir le type de modification de tous les fichiers dans ce dossier et de ses sous-dossiers. Je suis en utilisant WatchService pour cela, mais il ne voit un seul chemin, il ne gère pas les sous-dossiers.

Voici ma démarche:

try {
        WatchService watchService = pathToWatch.getFileSystem().newWatchService();
        pathToWatch.register(watchService, StandardWatchEventKinds.ENTRY_CREATE,
                StandardWatchEventKinds.ENTRY_MODIFY, StandardWatchEventKinds.ENTRY_DELETE);

        //loop forever to watch directory
        while (true) {
            WatchKey watchKey;
            watchKey = watchService.take(); //This call is blocking until events are present

            //Create the list of path files
            ArrayList<String> filesLog = new ArrayList<String>();
            if(pathToWatch.toFile().exists()) {
                File fList[] = pathToWatch.toFile().listFiles();
                for (int i = 0; i < fList.length; i++) { 
                    filesLog.add(fList[i].getName());
                }
            }

            //Poll for file system events on the WatchKey
            for (final WatchEvent<?> event : watchKey.pollEvents()) {
                printEvent(event);
            }

            //Save the log
            saveLog(filesLog);

            if(!watchKey.reset()) {
                System.out.println("Path deleted");
                watchKey.cancel();
                watchService.close();
                break;
            }
        }

    } catch (InterruptedException ex) {
        System.out.println("Directory Watcher Thread interrupted");
        return;
    } catch (IOException ex) {
        ex.printStackTrace();  //Loggin framework
        return;
    }

Comme je l'ai dit avant, je reçois le journal uniquement pour les fichiers dans le chemin d'accès sélectionné, et je veux regarder tous les dossiers et sous-dossiers, fichiers, quelque chose comme:

Exemple 1:

FileA (Created)
FileB
FileC
FolderA FileE
FolderA FolderB FileF

Exemple 2:

FileA
FileB (Modified)
FileC
FolderA FileE
FolderA FolderB FileF

Est-il une meilleure solution?

source d'informationauteur Yuri Heupa

java watchservice

Un WatchService seulement les montres de la Paths de vous inscrire. Il ne passe pas par les chemins de manière récursive.

Donné /Root comme un chemin d'accès inscrit

/Root
    /Folder1
    /Folder2
        /Folder3

Si il y a un changement dans Folder3il ne sera pas attraper.

Vous pouvez enregistrer les chemins d'accès aux répertoires de manière récursive-vous avec

private void registerRecursive(final Path root) throws IOException {
    //register all subfolders
    Files.walkFileTree(root, new SimpleFileVisitor<Path>() {
        @Override
        public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs) throws IOException {
            dir.register(watchService, ENTRY_CREATE, ENTRY_DELETE, ENTRY_MODIFY);
            return FileVisitResult.CONTINUE;
        }
    });
}

Maintenant la WatchService avisera toutes les modifications dans tous les sous-dossiers de Path rootc'est à dire. le Path argument que vous lui transmettez.

9

L'enregistrement de manière récursive fonctionnera comme Sotirios a indiqué. Effectivement cela enregistre chaque répertoire/sous-répertoire qui existe actuellement.

Vous pouvez importer et d'utilisation *com.soleil.nio.fichier.ExtendedWatchEventModifier.FILE_TREE* comme dans:
```
dir.register(watcher, standardEventsArray, ExtendedWatchEventModifier.FILE_TREE);
```
Cela montre toute la sous-arborescence pour le changement ET compte les répertoires et sous-répertoires.

Sinon, vous devrez vous surveiller pour les nouveaux répertoires/sous-répertoires et les inscrire aussi. Il peut aussi y avoir un problème avec la suppression de certaines parties de la hiérarchie de répertoire depuis chaque enregistré répertoire a une poignée en la regardant ainsi, le (la plus basse) sous-répertoires doivent d'abord être retiré lors de la suppression de certaines parties de la structure.

J'ai mis en place quelque chose comme ceci à l'aide de Java 8 ruisseaux et les lambdas.

Les dossiers récursive de la découverte est mise en œuvre comme un Consommateurs @FunctionalInterface:

    final Map<WatchKey, Path> keys = new HashMap<>();

    Consumer<Path> register = p -> {
        if (!p.toFile().exists() || !p.toFile().isDirectory()) {
            throw new RuntimeException("folder " + p + " does not exist or is not a directory");
        }
        try {
            Files.walkFileTree(p, new SimpleFileVisitor<Path>() {
                @Override
                public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs) throws IOException {
                    LOG.info("registering " + dir + " in watcher service");
                    WatchKey watchKey = dir.register(watcher, new WatchEvent.Kind[]{ENTRY_CREATE}, SensitivityWatchEventModifier.HIGH);
                    keys.put(watchKey, dir);
                    return FileVisitResult.CONTINUE;
                }
            });
        } catch (IOException e) {
            throw new RuntimeException("Error registering path " + p);
        }
    };

Le code ci-dessus est appelée à chaque fois qu'un nouveau dossier est créé dynamiquement ajouter des dossiers à des stades ultérieurs.
Solution complète et plus de détails ici.

Vous devez vous connecter pour publier un commentaire.