Archiv der Kategorie: Java 7

Das Ende vom Java-Plugin für Web-Browser

Oracle hat angekündigt, dass das Java-Plugin für Web-Browser mit dem Erscheinen von Java 9 im nächsten Jahr nicht mehr weiterentwickelt wird.

Nachdem Mozilla Firefox und auch Google Chrome ankündigten, das Java-Plugin nicht mehr weiter unterstützen zu wollen, sind das offenbar u. a. Gründe für den Abschied vom Browser-Plugin.

Der Anteil von Java-Applets ist ohnehin kaum noch „messbar“, spätestens mit dem Java 7 Update 51, mit dem die Sicherheitsmechanismen für Java-Applets noch einmal deutlich überarbeitet wurden, sind Java-Applets in „freier Wildbahn“ kaum noch zu finden.

Oracle empfiehlt als Ersatz Java WebStart, das ohne das Plugin auskommt.

Keine (öffentlichen) Oracle JDK 7 Updates mehr

So wie es Oracle schreibt: http://www.oracle.com/technetwork/java/javase/overview/index.html:

Coincident with the January 2015 CPU release users with the auto-update feature enabled will be migrated from Oracle JRE 7 to Oracle JRE 8. Also, please note the April 2015 CPU release will be the last Oracle JDK 7 publicly available update. For more information, and details on how to receive longer term support for Oracle JDK 7, please see the Oracle Java SE Support Roadmap.

Interessanter Sicherheits-Bug in 7u51 gefixed

Details unter http://weblog.ikvm.net/2014/01/16/PubliclyReportedOpenJDKVulnerabilityFixedIn7u51.aspx:

import java.lang.invoke.*;
class test extends java.io.FileOutputStream {
  static test t;
  test() throws Exception {
    super(„“);
  }
  protected void finalize() {
    t = this;
  }
  public static void main(String[] args) throws Throwable {
    MethodHandle mh = MethodHandles.lookup().findVirtual(test.class, „open“,
                        MethodType.methodType(void.class, String.class, boolean.class));
    System.out.println(mh);
    try { new test(); } catch (Exception _) { }
    System.gc();
    System.runFinalization();
    mh.invokeExact(t, „oops.txt“, false);
  }
}

Rekursives Ablaufen des Verzeichnisbaums mit Stream oder FileVisitor

Die Utility-Klasse Files bietet vier statische Methoden (zwei mehr in Java 8), die, bei einem Startordner beginnend, die Verzeichnisse rekursiv ablaufen.

final class java.nio.file.Files

  • static Stream<Path> walk(Path start, FileVisitOption… options) throws IOException
  • static Stream<Path> walk(Path start, int maxDepth, FileVisitOption… options) throws IOException
  • static Path walkFileTree(Path start, FileVisitor<? super Path> visitor)
  • static Path walkFileTree(Path start, Set<FileVisitOption> options, int maxDepth, FileVisitor<? super Path> visitor)

Bei allen Varianten bestimmt der erste Parameter den Startordner. Während walk(…)einen java.util.stream.Stream liefert (die Methoden sind neu in Java 8), erwarten die anderen beiden walkFileTree(…)-Methoden ein Objekt mit Callback-Methoden, die walkFileTree(…) beim Ablaufen des Verzeichnisbaums aufruft

Verzeichnislistings (DirectoryStream/Stream) holen

In der Klasse Files finden sich vier Methoden (eine mehr unter Java 8), um zu einem gegebenen Verzeichnis alle Dateien und Unterverzeichnisse aufzulisten:

final class java.nio.file.Files

  • static Stream<Path> list(Path dir) throws IOException (neu in Java 8)
  • static DirectoryStream<Path> newDirectoryStream(Path dir) throws IOException
  • static DirectoryStream<Path> newDirectoryStream(Path dir,
    DirectoryStream.Filter<? super Path> filter) throws IOException
  • static DirectoryStream<Path> newDirectoryStream(Path dir, String glob) throws IOException

Die Rückgabe DirectoryStream<T> ist ein Closeable (und somit AutoCloseable) sowie Iterable<T>, und so unterscheidet sich die Möglichkeit zur Anfrage der Dateien im Ordner grundsätzlich von der Methode list(…) in der Klasse File, die immer alle Dateien in einem Feld auf einmal zurückliefert. Bei einem DirectoryStream wird Element für Element über den Iterator geholt; trotz des Namensanhangs „Stream“ ist der DirectoryStream kein Strom im Sinne von java.util.stream. Ein Stream<String> hingegen liefert die kompakte Methode list(Path), sie nutzt intern einen DirectoryStream.

try ( DirectoryStream<Path> files =
Files.newDirectoryStream( Paths.get( „c:/“ ) ) ) {
  for ( Path path : files )
    System.out.println( path.getFileName() );
}

Aus der Tatsache, dass die Dateien und Unterverzeichnisse nicht in einem Rutsch geholt werden, leitet sich die Konsequenz ab, dass der DirectoryStream/Stream<String> geschlossen werden muss, da nicht klar ist, ob der Benutzer wirklich alle Dateien abholt oder nach den ersten 10 Einträgen aufhört. Die Schnittstelle DirectoryStream erweitert die Schnittstelle Closeable (und die ist AutoCloseable, weshalb unser Beispiel ein try-mit-Ressourcen nutzt) und Stream implementiert AutoCloseable, daher ist es guter Stil, den DirectoryStream/Stream am Ende zu schließen, um blockierte Ressourcen freizugeben. try-mit-Ressourcen gibt immer etwaige Ressourcen frei, auch wenn es beim Ablaufen des Verzeichnisses zu einer Ausnahme kam.

Dateiinhalte lesen/schreiben mit Utility-Klasse Files

Da die Klasse Path nur Pfade, aber keine Dateiinformationen wie die Länge oder Änderungszeit repräsentiert und Path auch keine Möglichkeit bietet, Dateien anzulegen und zu löschen, übernimmt die Klasse Files diese Aufgaben.

Einfaches Einlesen und Schreiben von Dateien

Mit den Methoden readAllBytes(…), readAllLines(…), lines(…) bzw. write(…) kann Files einfach ein Dateiinhalt einlesen oder Strings bzw. ein Byte-Feld schreiben.

URI uri = ListAllLines.class.getResource( „/lyrics.txt“ ).toURI();
Path path = Paths.get( uri );
System.out.printf( „Datei ‚%s‘ mit Länge %d Byte(s) hat folgende Zeilen:%n“, path.getFileName(), Files.size( path ) );
int lineCnt = 1;
for ( String line : Files.readAllLines( path /*, StandardCharsets.UTF_8 vor Java 8 */) )
  System.out.println( lineCnt++ + „: “ + line );

final class java.nio.file.Files

  • static long size(Path path) throws IOException
    Liefert die Größe der Datei.
  • static byte[] readAllBytes(Path path) throws IOException
    Liest die Datei komplett in ein Byte-Feld ein.
  • static List<String> readAllLines(Path path) throws IOException (Java 8)
    static List<String> readAllLines(Path path, Charset cs) throws IOException
  • Liest Zeile für Zeile die Datei ein und liefert eine Liste dieser Zeilen. Optional ist die Angabe einer Kodierung, standardmäßig ist es StandardCharsets.UTF_8.
  • static Path write(Path path, byte[] bytes, OpenOption… options) throws IOException
    Schreibt eine Byte-Feld in eine Datei.
  • static Path write(Path path, Iterable<? extends CharSequence> lines,
    OpenOption… options) throws IOException (Java 8)
  • static Path write(Path path, Iterable<? extends CharSequence> lines, Charset cs,
    OpenOption… options) throws IOException
    Schreibt alle Zeilen aus dem Iterable in eine Datei. Optional ist die Kodierung, die StandardCharsets.UTF_8 ist, wenn nicht anders angegeben.
  • static Stream<String> lines(Path path)
  • Stream<String> lines(Path path, Charset cs)
    Liefert einen Stream von Zeilen einer Datei. Optional ist die Angabe der Kodierung, die sonst standardmäßig StandardCharsets.UTF_8 ist. Beide Methoden sind neu in Java 8.

Die Aufzählung OpenOption ist ein Vararg, und daher sind Argumente nicht zwingend nötig. StandardOpenOption ist eine Aufzählung vom Typ OpenOption mit Konstanten wie APPEND, CREATE, …

Hinweis: Auch wenn es naheliegt, die Files-Methode zum Einlesen mit einem Path-Objekt zu füttern, das ein HTTP-URI repräsentiert, funktioniert dies nicht. So liefert schon die erste Zeile des Programms eine Ausnahme des Typs »java.nio.file.FileSystemNotFoundException: Provider „http“ not installed«.

Path path = Paths.get( new URI „http://tutego.de/javabuch/aufgaben/bond.txt“ ) );
List<String> content = Files.readAllBytes( path );
System.out.println( content );

Vielleicht kommt in der Zukunft ein Standard-Provider von Oracle, doch es ist davon auszugehen, dass quelloffene Lösungen diese Lücke schließen werden. Schwer zu programmieren sind Dateisystem-Provider nämlich nicht.

Datenströme kopieren

Sollen die Daten nicht direkt aus einer Datei in eine byte-Feld/String-Liste gehen bzw. aus einer byte-Feld/String-Sammlung in eine Datei, sondern von einer Datei in einen Datenstrom, so bieten sich zwei copy(…)-Methoden an:

final class java.nio.file.Files

  • static long copy(InputStream in, Path target, CopyOption… options)
    Entleert den Eingabestrom und kopiert die Daten in die Datei.
  • static long copy(Path source, OutputStream out)
    Kopiert alle Daten aus der Datei in den Ausgabestrom.

Oracle Java SE 7u45 Update

Neu ist: A JDK for Linux ARM is also available in this release. Das kann man auf der Download-Seite auch ablesen:

Linux ARM v6/v7 Hard Float ABI
67.67 MB  
jdk-7u45-linux-arm-vfp-hflt.tar.gz

Linux ARM v6/v7 Soft Float ABI
67.68 MB  
jdk-7u45-linux-arm-vfp-sflt.tar.gz

Linux x86
115.62 MB  
jdk-7u45-linux-i586.rpm

Linux x86
132.9 MB  
jdk-7u45-linux-i586.tar.gz

Linux x64
116.91 MB  
jdk-7u45-linux-x64.rpm

Linux x64
131.7 MB  
jdk-7u45-linux-x64.tar.gz

Mac OS X x64
183.84 MB  
jdk-7u45-macosx-x64.dmg

Solaris x86 (SVR4 package)
139.93 MB  
jdk-7u45-solaris-i586.tar.Z

Solaris x86
95.02 MB  
jdk-7u45-solaris-i586.tar.gz

Solaris x64 (SVR4 package)
24.6 MB  
jdk-7u45-solaris-x64.tar.Z

Solaris x64
16.23 MB  
jdk-7u45-solaris-x64.tar.gz

Solaris SPARC (SVR4 package)
139.38 MB  
jdk-7u45-solaris-sparc.tar.Z

Solaris SPARC
98.17 MB  
jdk-7u45-solaris-sparc.tar.gz

Solaris SPARC 64-bit (SVR4 package)
23.91 MB  
jdk-7u45-solaris-sparcv9.tar.Z

Solaris SPARC 64-bit
18.26 MB  
jdk-7u45-solaris-sparcv9.tar.gz

Windows x86
123.49 MB  
jdk-7u45-windows-i586.exe

Windows x64
125.31 MB  
jdk-7u45-windows-x64.exe

try-mit-Ressourcen auf null-Ressourcen

Das immer zum Abschluss eines try-mit-Ressourcen-Blocks ein close() aufgerufen wird ist nicht ganz korrekt; es gibt nur dann ein Schließversuch, wenn die Ressource ungleich null ist.

Beispiel

Der Codebaustein compiliert und führt zu einer Konsolenausgabe.

try ( Scanner scanner1 = null; Scanner scanner2 = null ) {

  System.out.println( "Ok" );

}

Bei Konstruktoren ist ein Objekt ja immer gegeben, aber es gibt auch Fabrikaufrufe, bei denen vielleicht null herauskommen kann, und für diese Fälle ist es ganz praktisch, dass try-mit-Ressourcen dann nichts macht, um eine NullPointerException beim close() zu vermeiden.

Thema der Woche: Collections-Update in Java 7

Überblick: Aktuelle Versionen der Java EE 7 Technologien

Von https://blogs.oracle.com/theaquarium/entry/java_ee_7_platform_completes:

JSRs:

  • Java Platform, Enterprise Edition 7 (JSR 342)
  • Concurrency Utilities for Java EE 1.0 (JSR 236)
  • Java Persistence 2.1 (JSR 338)
  • JAX-RS: The Java API for RESTful Web Services 2.0 (JSR 339)
  • Java Servlet 3.1 (JSR 340)
  • Expression Language 3.0 (JSR 341)
  • Java Message Service 2.0 (JSR 343)
  • JavaServer Faces 2.2 (JSR 344)
  • Enterprise JavaBeans 3.2 (JSR 345)
  • Contexts and Dependency Injection for Java EE 1.1 (JSR 346)
  • Bean Validation 1.1 (JSR 349)
  • Batch Applications for the Java Platform 1.0 (JSR 352)
  • Java API for JSON Processing 1.0 (JSR 353)
  • Java API for WebSocket 1.0 (JSR 356)

MRs:

  • Web Services for Java EE 1.4 (JSR 109)
  • Java Authorization Service Provider Contract for Containers 1.5 (JACC 1.5) (JSR 115)
  • Java Authentication Service Provider Interface for Containers 1.1 (JASPIC 1.1) (JSR 196)
  • JavaServer Pages 2.3 (JSR 245)
  • Common Annotations for the Java Platform 1.2 (JSR 250)
  • Interceptors 1.2 (JSR 318)
  • Java EE Connector Architecture 1.7 (JSR 322)
  • Java Transaction API 1.2 (JSR 907)
  • JavaMail 1.5 (JSR 919)

MR steht für “Maintenance Releases”.

Thema der Woche: Paketierung mit <fx:deploy>

Seit Neustem kann man mit Java auch ausführbare Dateien bzw. Installer bauen. Ließ dazu http://docs.oracle.com/javafx/2/deployment/self-contained-packaging.htm bzw. suche nach weiterer Dokumentation im Netz.

  • Teste das an einer eigenen kleinen Hello-World-Anwendung.
  • Wie groß ist das Ergebnis mit JRE?
  • Welche Zielformate sind möglich und kann man alle etwa auf einem Linux-Build-Server bauen?
  • Nutze log4j und nimm die Jar mit in das Zielformat mit auf. Lassen sich auch native Dateien einbinden?
  • Gilt diese Möglichkeit nur für JavaFX oder auch für für AWT/Swing oder SWT?

How to put files in a ZIP file with NIO.2

URI p = Paths.get( "c:/Users/Christian/Dropbox/jokes.zip" ).toUri();
URI uri = URI.create( "jar:" + p );

Map<String, String> env = new HashMap<>();
env.put( "create", "true" );
try ( FileSystem zipfs = FileSystems.newFileSystem( uri, env ) ) {
  Files.write( zipfs.getPath( "/j1.txt" ), "The truth is out there. Anybody got the URL?".getBytes() );
  Files.write( zipfs.getPath( "/j2.txt" ), "The more I C, the less I see.".getBytes() );
}