# Datei zugriffe erkennen



## Ich123456789 (15. Mai 2017)

Ich würde gerne ein mal eine Frage stellen und zwar: ob es eine möglichkeit gibt in Java zu überprüfen ob eine Datei auf ein File zugreift und wenn ja welcher.
Ich weiß dass man so etwas mit dem FileLok machen kann aber ich kann da mit nicht herausfinden welcher process darauf zugreift hat evtl. jemand eine Idee ?
Meine Schlimme Rechtschreibung tut mir leid.
Ich danke euch schon im Voraus !


----------



## Xyz1 (15. Mai 2017)

Ich123456789 hat gesagt.:


> ob eine Datei auf ein File zugreift


Fehler in der Matrix.


----------



## Ich123456789 (15. Mai 2017)

Das habe ich nicht ganz verstanden ?
Hast du einen Fehler bei dem versuch es umzusetzen ?

Danke für deine Antwort


----------



## Xyz1 (16. Mai 2017)

Ich123456789 hat gesagt.:


> Hast du einen Fehler bei dem versuch es umzusetzen


Naja, das geht mit Bordmitteln nicht.

Und in deiner Beschreibung oben steht, wenn A auf A zugreift... Darüber habe ich mich lustig gemacht. Sorry


----------



## mrBrown (16. Mai 2017)

DerWissende hat gesagt.:


> Naja, das geht mit Bordmitteln nicht.
> 
> Und in deiner Beschreibung oben steht, wenn A auf A zugreift... Darüber habe ich mich lustig gemacht. Sorry


Naja, unter Unix kannst 'man Prozess auch als Datei sehen, von daher...


----------



## Ich123456789 (16. Mai 2017)

mrBrown hat gesagt.:


> Naja, unter Unix kannst 'man Prozess auch als Datei sehen, von daher...


Ok aber Unix kann ich nicht


----------



## mrBrown (16. Mai 2017)

Ich123456789 hat gesagt.:


> Ok aber Unix kann ich nicht


Das ist auch nur ein Witz auf Kosten deiner Frage nach "überprüfen ob eine Datei auf ein File zugreift"


----------



## AndyJ (17. Mai 2017)

Nicht jeder kann gut Deutsch...
Die Frage kann man aber schon beantworten:


DerWissende hat gesagt.:


> Naja, das geht mit Bordmitteln nicht.



Mit Bordmitteln kann man schon so einiges machen. In Java gibt's den WatchService, der erlaubt ein Directory zu ueberwachen (Lesezugriff kann man aber nicht damit feststellen, leider). Folgender Codeschnipsel ueberwacht das Verzeichnis, das als Programmargument uebergeben wurde:


```
package info.junius.test;

import static java.nio.file.LinkOption.NOFOLLOW_LINKS;
import static java.nio.file.StandardWatchEventKinds.ENTRY_CREATE;
import static java.nio.file.StandardWatchEventKinds.ENTRY_DELETE;
import static java.nio.file.StandardWatchEventKinds.ENTRY_MODIFY;
import static java.nio.file.StandardWatchEventKinds.OVERFLOW;

import java.io.IOException;
import java.nio.file.FileSystems;
import java.nio.file.FileVisitResult;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.SimpleFileVisitor;
import java.nio.file.WatchEvent;
import java.nio.file.WatchKey;
import java.nio.file.WatchService;
import java.nio.file.attribute.BasicFileAttributes;
import java.util.HashMap;
import java.util.Map;

/**
 * Example to watch a directory (or tree) for changes to files.
 */

public class WatchDir {

 private final WatchService watcher;
 private final Map<WatchKey, Path> keys;
 private final boolean recursive;
 private boolean trace = false;

 @SuppressWarnings("unchecked")
 static <T> WatchEvent<T> cast(WatchEvent<?> event) {
  return (WatchEvent<T>) event;
 }

 /**
  * Register the given directory with the WatchService
  */
 private void register(Path dir) throws IOException {
  WatchKey key = dir.register(watcher, ENTRY_CREATE, ENTRY_DELETE, ENTRY_MODIFY);
  if (trace) {
   Path prev = keys.get(key);
   if (prev == null) {
    System.out.format("register: %s\n", dir);
   } else {
    if (!dir.equals(prev)) {
     System.out.format("update: %s -> %s\n", prev, dir);
    }
   }
  }
  keys.put(key, dir);
 }

 /**
  * Register the given directory, and all its sub-directories, with the
  * WatchService.
  */
 private void registerAll(final Path start) throws IOException {
  // register directory and sub-directories
  Files.walkFileTree(start, new SimpleFileVisitor<Path>() {
   @Override
   public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs) throws IOException {
    register(dir);
    return FileVisitResult.CONTINUE;
   }
  });
 }

 /**
  * Creates a WatchService and registers the given directory
  */
 WatchDir(Path dir, boolean recursive) throws IOException {
  this.watcher = FileSystems.getDefault().newWatchService();
  this.keys = new HashMap<WatchKey, Path>();
  this.recursive = recursive;

  if (recursive) {
   System.out.format("Scanning %s ...\n", dir);
   registerAll(dir);
   System.out.println("Done.");
  } else {
   register(dir);
  }

  // enable trace after initial registration
  this.trace = true;
 }

 /**
  * Process all events for keys queued to the watcher
  */
 void processEvents() {
  for (;;) {

   // wait for key to be signalled
   WatchKey key;
   try {
    key = watcher.take();
   } catch (InterruptedException x) {
    return;
   }

   Path dir = keys.get(key);
   if (dir == null) {
    System.err.println("WatchKey not recognized!!");
    continue;
   }

   for (WatchEvent<?> event : key.pollEvents()) {
    WatchEvent.Kind<?> kind = event.kind();

    // TBD - provide example of how OVERFLOW event is handled
    if (kind == OVERFLOW) {
     continue;
    }

    // Context for directory entry event is the file name of entry
    WatchEvent<Path> ev = cast(event);
    Path name = ev.context();
    Path child = dir.resolve(name);

    // print out event
    System.out.format("%s: %s\n", event.kind().name(), child);

    // if directory is created, and watching recursively, then
    // register it and its sub-directories
    if (recursive && (kind == ENTRY_CREATE)) {
     try {
      if (Files.isDirectory(child, NOFOLLOW_LINKS)) {
       registerAll(child);
      }
     } catch (IOException x) {
      // ignore to keep sample readbale
     }
    }
   }

   // reset key and remove from set if directory no longer accessible
   boolean valid = key.reset();
   if (!valid) {
    keys.remove(key);

    // all directories are inaccessible
    if (keys.isEmpty()) {
     break;
    }
   }
  }
 }

 static void usage() {
  System.err.println("usage: java WatchDir [-r] dir");
  System.exit(-1);
 }

 public static void main(String[] args) throws IOException {
  // parse arguments
  if (args.length == 0 || args.length > 2)
   usage();
  boolean recursive = false;
  int dirArg = 0;
  if (args[0].equals("-r")) {
   if (args.length < 2)
    usage();
   recursive = true;
   dirArg++;
  }

  // register directory and process its events
  Path dir = Paths.get(args[dirArg]);
  new WatchDir(dir, recursive).processEvents();
 }
}
```

Wenn man dann eine Datei in dem Verzeichnis erzeugt, aendert und wieder speichert und dann loescht, sieht der Output so aus:

Scanning c:\Users\JuniusA\Documents\tmp ...
Done.
ENTRY_CREATE: c:\Users\JuniusA\Documents\tmp\neueDatei.txt
ENTRY_MODIFY: c:\Users\JuniusA\Documents\tmp\neueDatei.txt
ENTRY_MODIFY: c:\Users\JuniusA\Documents\tmp\neueDatei.txt
ENTRY_DELETE: c:\Users\JuniusA\Documents\tmp\neueDatei.txt

Der WatchService ist relativ neu, seit Java 7.

Cheers,
Andy


----------



## Ich123456789 (17. Mai 2017)

Es liegt nur an mir ab wie soll man das zum laufen kriegen ohne pfad ?


----------



## mrBrown (17. Mai 2017)

Ich123456789 hat gesagt.:


> Es liegt nur an mir ab wie soll man das zum laufen kriegen ohne pfad ?


Jona Pfad geht es nicht, den musst du in dem Beispiel als Argument übergeben


----------



## Ich123456789 (17. Mai 2017)

ich finde nicht die position wo ich den link ändern soll außerdem bringt es mir nichts



Gibt es dafür vielecihht eine externe Jar ?


----------



## mrBrown (17. Mai 2017)

Welchen Link willst du wo ändern?


----------



## Xyz1 (17. Mai 2017)

AndyJ hat gesagt.:


> Mit Bordmitteln kann man schon so einiges machen.


Ist mir bekannt. Aber ich sehe nirgendwo den dafür verantwortlichen Prozess.

Gehts um Dateisystemänderungen - oder wer welche Datei ändert? Letztes nicht möglich.

Und ich habe mich doch schon dafür entschuldigt, sich über seine Aussage lustig gemacht zu haben.


----------



## Ich123456789 (17. Mai 2017)

Gibt es den externe möglichkeiten


----------



## mrBrown (17. Mai 2017)

Ich123456789 hat gesagt.:


> Gibt es den externe möglichkeiten


Externe Möglichkeiten wofür? Um Lesezugriffe auf Dateien festzustellen?
Beantworte doch einfach mal die alten Fragen, bevor du neue Stellst


----------



## Ich123456789 (18. Mai 2017)

Ist das eine neue Frage ? 
Vieleicht habe ich mich nich richtig ausgedrückt !
Tut mir leid !!!!


----------



## Neumi5694 (22. Mai 2017)

Kurz: Nein, externe Prozesse sind systemspezifisch, Java bietet so was von sich aus nicht. Hierfür musst du auf die entsprechenden DLLs (oder was auch immer Linux dafür verwendet) verweisen und über JNA oder JNI zugreifen.
Vielleicht wirst du auch über NIO fündig.
https://en.wikipedia.org/wiki/New_I/O_(Java)
Allerdings glaube ich das nicht. Lesezugriff zu überwachen ist leichter Overkill, eine Datei oder ihre Eigenschaften werden ständig von irgend jemandem gelesen (Virenscanner, Index-Erstellung, Datei-Explorer). Interessanter ist natürlich zu wissen, wer exklusiven Zugriff anfordert und die Datei blockiert. Weil der Bedarf dafür kaum besteht, gibt's da auch keine wirklichen Standards, eher Richtlinien.


----------



## Ich123456789 (24. Mai 2017)

Zu aller erst danke für deine hilfe !!


Neumi5694 hat gesagt.:


> Allerdings glaube ich das nicht. Lesezugriff zu überwachen ist leichter Overkill, eine Datei oder ihre Eigenschaften werden ständig von irgend jemandem gelesen (Virenscanner, Index-Erstellung, Datei-Explorer). Interessanter ist natürlich zu wissen, wer exklusiven Zugriff anfordert und die Datei blockiert. Weil der Bedarf dafür kaum besteht, gibt's da auch keine wirklichen Standards, eher Richtlinien.


Das stimmt aber ich erwarte nicht dass das mit Java möglich ist !
wenn es doch eine möglichkeit gibt würde sie mich interesieren !


----------



## mrBrown (24. Mai 2017)

Naja, vermutlich wird man dafür naiven Code benutzen müssen, den kann man zwar aus Java aufrufen, aber wirklich Java ist es dann nicht mehr...


----------



## Ich123456789 (24. Mai 2017)

wenn mir da jemand da helfen kann würde ich mich sehr freuen denn ich kann  nur Java !


----------



## JStein52 (25. Mai 2017)

Oder du nutzt ein Unix-Kommando und parsed dessen Ergebnis:
https://unix.stackexchange.com/questions/85994/how-to-list-processes-locking-file?rq=1


----------



## Ich123456789 (26. Mai 2017)

Danke aber ich weiß nicht wie man unix benutz !
Muss man sich einen compiler downloaden ?


----------



## mrBrown (26. Mai 2017)

Unix ist eine Menge von Betriebssystemen, du müsstest dir also irgendein Linux, macOS, BSD etc installieren - vermutlich ist das aber nicht der zielführende Weg, um zu erreichen was du willst...


----------



## JStein52 (26. Mai 2017)

mrBrown hat gesagt.:


> vermutlich ist das aber nicht der zielführende Weg, um zu erreichen was du willst...


@Ich123456789 vielleicht kannst du nochmal sagen was du denn jetzt noch möchtest was mit dem bisher gesagten nicht abgedeckt wird


----------



## Ich123456789 (26. Mai 2017)

Ich versuche zu beispiel heraus finden wer eine datei gelöscht oder geändert hat ?
Danke für eure Aufmerksamkeit !


----------



## Ich123456789 (28. Mai 2017)

JStein52 hat gesagt.:


> Oder du nutzt ein Unix-Kommando und parsed dessen Ergebnis:
> https://unix.stackexchange.com/questions/85994/how-to-list-processes-locking-file?rq=1


Es soll auf Windows gehen !


----------

