!Farbkontrast – KW05

Thema der 5. Kalenderwoche war Farbkontrast. Dass dieser auch mal fehlen kann zeigt mein Bild von Ordnerrücken. Der Name für das Bild lautet übrigends !Farbkontrast, für die Entwickler unter uns ;)

Thema der 5. Kalenderwoche war Farbkontrast. Dass dieser auch mal fehlen kann zeigt mein Bild von Ordnerrücken. Der Name für das Bild lautet übrigends !Farbkontrast, für die Entwickler unter uns ;)

Farbkontrast - KW05

Ähnliche Artikel:

Java 7 Tage NIO.2 – Dateien und Verzeichnisse überwachen

NIO2 stellt eine Erweiterung der File API in der Java Welt dar. Was davon in Java 7 auf uns zukommt, und wie wie man damit Verzeichnisse überwacht steht hier.

Als letztes in der Java 7 NIO.2 Reihe möchte ich eine neue Möglichkeit vorstellen, wie man Dateiänderungen bzw Verzeichnisänderungen überwachen kann. Bisher war dies nur über Polling möglich. Man hat den Timestamp der Datei/des Verzeichnisses überwacht, das CRC verglichen oder ähnliches. Neu ist nun ein Service der einem diese Arbeit abnimmt:

Der neue WatchService dient dazu Objete die das Watchable Interface implementieren zu überwachen. Die neue Path Klasse ist bisher das einzige solche Objekt, doch ist der WatchService somit offen für eigene Implementierungen.

Am WatchService registrieren sich Watchable Objekte zur Überwachung mittels der register() Methode

WatchService watcher = FileSystems.getDefault().newWatchService();
Path p = new Path("/home/");
WatchKey key = p.register(watcher, ENTRY_CREATE);

dabei hat man die Möglichkeit die Events auf die geachtet werden soll per varargs Parameter zu deklarieren und kann aus folgenden wählen:

  • StandardWatchEventKinds.ENTRY_CREATE
  • StandardWatchEventKinds.ENTRY_MODIFY
  • StandardWatchEventKinds.ENTRY_DELETE

z.B. um alle arten zu überwachen

WatchKey key = p.register(watcher, ENTRY_CREATE, ENTRY_MODIFY, ENTRY_DELETE);

Nun kann man auf zwei Arten auf das Ergebnis des WatchServices zugreifen: take() oder poll()

take() – arbeitet blockierend und wartet darauf dass ein Event geworfen wird
poll() – liest direkt aus ob ein Event vorhanden ist. Findet der Aufruf kein solches liefert es null zurück. Es ist somit nicht blockierend.

Die beiden Methoden zum Abfragen nach Events liefern bei einem Treffer jeweils ein Ojekt vom Typ WatchKey zurück. Dieser kann einen oder mehrere WatchEvents beinhalten die man mittels pollEvents() Methode als List abrufen kann. Die Art des einzelnen WatchEvent kann mittels kind() Methode erfragt werden, während context() das auslösende Objekt zurückliefert. Im Falle eines überwachten Paths sollte hier stehts ein weiterer Path zurückgegeben werden.

while(true){
    WatchKey key = watcher.take();
    for(WatchEvent event : key.pollEvents()){
        if(event.kind() = ENTRY_CREATE){
            Path result = (Path)event.context();
            System.out.println(result.getName());
        }
    }
    key.reset();
}

Das WatchService implementiert Closable und AutoClosable und ist somit mit close() wieder schließbar bzw. erspart man sich das im neuen TryCatchblock.

key.reset(); ist notwendig um den Thread wieder freizugeben, denn der WatchService ist während des ganzen Aufrufes blockiert.

Happy NIOing :)

Ähnliche Artikel:

Java 7 Tage NIO.2 – File Attributes

NIO2 stellt eine Erweiterung der File API in der Java Welt dar. Was davon in Java 7 auf uns zukommt, und wie man mit NIO2 Datei Attribute ausliest gibts hier.

Nachdem wir im gestrigen Java 7 Artikel über NIO.2 die Hilfsklasse Files kennengelernt haben, dreht sich der heutige Artikel gänzlich um die Datei Attribute. Gestern haben wir gesehen, dass Files Methoden wie

Files.getOwner(Path p);
Files.size(Path p);

bereitstellt mit denen man die ersten Attribute auslesen kann. Heute wollen wir uns ansehen wie man noch an andere Attribute einer Datei gelangt. Dafür bietet NIO.2 mit dem Paket java.nio.file.attribute sehr flexible Möglichkeiten. Darin wird dem Programmierer eine Schnittstelle geboten, die ihm Zugriff auf verschiedenste Dateisysteme lässt. Das ist wichtig, denn jedes Filesystem kann diverse Attribute unterschiedlich verwalten. Für jedes dieser Dateisysteme gibt es nun eine Sicht – eine View-Klasse die den zugriff lesend oder schreibend erlaubt. So gibt es um auf Attribute eines DOS-Dateisystems zuzugreifen eine DosFileAttributeView.

Jede dieser FileAttributeView Klassen liefert liefert dem Programmiere eine FileAttributes Klasse die Methoden zum Auslesen der Eigenschaften bereitstellen. Bei der DosFileAttributeView wäre das die DosFileAttribute Klasse. Diese wird über die getAttribute() Methode zurückgeliefert.

Path p = Paths.get(“nullpointer.txt”);
DosFileAttributes attrs = Files.readAttributes(p, DosFileAttributes.class);

//Klassenspezifische Attribute
attrs.isArchive();
attrs.isHidden();
attrs.isReadOnly();
attrs.isSystem();

//von BaseFileAttributes vererbt
attrs.creationTime();
attrs.fileKey();
attrs.isDirectory();
attrs.isOther();
attrs.isRegularFile();
attrs.isSymbolicLink();
attrs.lastAccessTime();
attrs.lastModifiedTime();
attrs.size();

siehe auch: http://openjdk.java.net/projects/nio/javadoc/java/nio/file/attribute/DosFileAttributes.html

Neben DosFileSystem existiert bereits eine Implementierung des Portable Operating System Interface – PosixFileAttributes die die Methoden

attrs.group();
attrs.owner();
attrs.permissions();

neben den von BaseFileAttributes vererbten zur Verfügung stehen. Um die Zugriffsrechte auf die Dateien leicht verwalten zu können liefert einerseits die permission() Methode ein Set<PosixFilePermission> zurück, welches als ein Enum realisiert ist: GROUP_EXECUTE, GROUP_READ, GROUP_WRITE, OTHER_EXECUTE, …, OWNER_EXECUTE, … Daneben steht eine neue Util Klasse zur Verfügung mit deren man Rechteangaben in der Unix-Notation konvertieren kann

Set<PosixFilePermission> perms = PosifFilePermissions.fromString(“rwxrwxr—“);
String unixNot = PosixFilePermissions.toString(Perms);

Dabei geht die Files Klasse zum Auslesen der Attribute einen schnellen Weg und liefert direkt die Attributs Klasse, will man hingegen Attribute auch schreiben benötigt man die vorher angesprochene FileAttributeView, welche entsprechende Setter zur Verfügung stellt.

z.B.

DosFileAttributeView view = Files.getFileAttributeView(p, DosFileAttributeView.class);
view.setHidden(true);

Auch können diese Attribute direkt per String referenziert werden, so dass das System für die zukünftigen Entwicklungen in den Dateisystemen flexibel bleibt. Näheres dazu in der Javadoc.

Files.getAttribute(p, “dos:hidden”);

Happy NIOing :D

Ähnliche Artikel:

Java 7 Tage NIO.2 – Dateimanipulation mit Files

NIO2 stellt eine Erweiterung der File API in der Java Welt dar. Was davon in Java 7 auf uns zukommt, und wie man mit NIO2 Datein manipuliert hier.

Gestern haben wir von der neuen Path Klasse in NIO.2 erfahren. Diese repräsentiert jedoch nur den Pfad zu einer Datei, nicht aber die Datei. Möglichkeiten zur Dateimanipulation findet man daher in dieser Klasse vergeblich. Stattdessen bietet Oracle in Java 7 nun die Utiltiy-Klasse Files an.

Eine neue Datei erstellen

Um eine neue Datei zu erstellen bietet die Files Klasse eine Methode createFile(Path pfad, FileAttribute… attrs) an. Über den simplen Aufruf von

try {
    Files.createFile(file);
} catch (FileAlreadyExistsException x) {
    //..
} catch (IOException x) {
    //..
}

wird eine Datei mit Standard Attributen wie zB die Zugriffsberechtigungen angelegt.

Eine Datei öffnen und lesen, schreiben, kopieren, …

Will man eine erstellte Datei nun mit Inhalt füllen geht ebenfalls durchaus schnell von der Hand.

Path path = ...
byte[] bytes = ...
Files.write(path, bytes);

Ganz ohne Streams. Man kann auch in mehreren Schritten die write() Methode aufrufen. Dafür kann man zusätzliche Optionen als dritten Varargs Parameter mitgeben, wie zB einen StandardOpenOption Enum APPEND.

Will man eine Datei auslesen gibt es z.B. folgende Möglichkeit:

for (String line : Files.readAllLines( path, Charset.forName( "UTF-8" )))
System.out.println(line);

Dies sind nur einfache Varianten, es gibt je nach Anwendungsfall noch zusätzliche Vorgehensweisen. Einen Auszug davon findet man unter http://download.oracle.com/javase/tutorial/essential/io/file.html

Außerdem gibt es noch Methoden die sich klassiche Dateioperationen im Dateisystem wiederspiegeln:

Files.copy(Path source, Path destination);
Files.move(Path source, Path destination);
Files.delete(Path p);

Diese Operationen blockieren den aufrufenden Thread bis sie abgearbeitet sind. Sollte während der Verarbeitung ein Fehler passieren können Dateireste zurückbleiben mit die man noch behandeln muss.

File Attribute

Zu guter Letzt noch ein kurz eine Übersicht über einige der neuen Möglichkeiten Standard Dateiattribute wie die Dateigröße, der Besitzer oder das Änderungsdarum auszulesen:

Files.getLastModifiedTime(Path p);
Files.getOwner(Path p);
Files.getPosixFilePermissions(Path p);
Files.isDirectory(Path p);
Files.isExecutable(Path p);
Files.size(Path p);
//...

Happy NIOing

Ähnliche Artikel:

Java 7 Tage NIO.2 – FileSystem & Path

NIO2 stellt eine Erweiterung der File API in der Java Welt dar. Was davon in Java 7 auf uns zukommt, und wie mit FileSystem und Path.umgeht hier

Neben dem Project Coin wird NIO.2 in Java 7 vermutlich die zweite große Änderung sein, die von einem Großteil der Java-Entwickler, aber vor allem auch von Anfängern wahrgenommen werden wird. Wobei Anfänger werden es nicht als Änderung bemerken, solange sie nicht über die ganzen veralteten Codebeispiele stolpern. NIO.2 steht recht simpel für new i/o Teil 2 und bringt einige Basisfunktionen mit sich, von denen man meinen sollte eine fortgeschrittene Sprache wie Java sollte diese eigentlich längst beinhalten. Doch hierbei gilt, besser spät als nie und bevor ich auf die Möglichkeiten von NIO.2 zurückzukommen möchte noch ein Wort zur alten Implementierung. Bisher waren in Java Filezugriffe über java.io.* und spezifischer java.io.File möglich. Ohne adäquates Exceptionhandling und mit einer Menge aus zu programmierenden Funktionalität war es durchaus recht mühsam ans Ziel zu kommen. NIO.2 setzt hier an und bietet unter java.nio.* eine neue Herangehensweise an.

FileSystem

Die neue abstrakte Klasse FileSystem repräsentiert ein Dateisystem. Konkrete Implementierungen sind zB das lokale Filesystem oder aber auch ein ZIP oder JAR Archiv. Um das aktuelle Dateisystem auszulesen gibt es eine Helferklasse: FileSystems welches die statische Methode getDefault() zur verfügung stellt.

FileSystem fs = FileSystems.getDefault();

Path

Mittels der Path Klasse versucht man das alte java.io.File abzulösen. Ein Path repräsentiert dabei einen relativen oder aber absoluten Pfad, File hingegen die Datei oder das Verzeichnis. Dabei können die Pfadangaben je nach Betriebssystem unterschiedlich erfolgen. Der Pfad kann aus einem String, einer URI oder sogar einem File erzeugt werden und ist immutable.

Path p = fs.getPath("C:/windows/");

Auch hierbei gibt es eine Utilityklasse die einem den Aufruf über das FileSystem abnimmt: Paths#get(); Auch kann man sich wieder einen String eine URI oder ein File Objekt zur Weiterverarbeitung über die Path Klasse erzeugen lassen.

p.toString();
p.toUri();
p.toFile();

Zugriffe auf die einzelnen Elemente des Pfades ermöglicht Path da es eine hierarchische Liste der Namen hält. Zur weitern Verarbeitung dieser Elemente bietet Path einige Methoden

p.getRoot();
p.getParent();
p.getNameCount();
p.getName(int index);
p.subpath(int beginIndex, int endIndex);

Da Path das Interface Iterable implementiert kann er auch in foreach Schleifen verwendet werden um die einzelnen Subelemente zu erhalten. Um den Path mit anderen vergleichen zu können implementiert die Klasse das Interface Compareable und bietet Funktionen wie

p.compareTo(Path otherPath); // aus dem Compareable Interface
p.startsWith(Path otherPath);
p.endsWith(Path otherPath);

Pfade lassen sich außerdem mittels

p.resolve(“system32”);

zusammenhängen. Oder aber über

p.toRealPath(LinkOption… options);
p.toAbsolutePath);

Für mehr Details zu FileSystem oder Path am besten einen Blick ins API werfen: http://download.java.net/jdk7/docs/api/ Happy NIOing

Ähnliche Artikel: