semantic-void.net

XML wird in Java meist über DOM oder SAX bearbeitet. Im Falle von DOM wird ein Baum aufgebaut, der die Struktur und die Inhalte des XML Dokuments wiedergibt. Wie kommt man aber von einem XML String zu einem DOM Baum und vom DOM Baum wieder zurück zu einem String? Dafür habe ich ein kleines Helferlein programmiert…

import java.io.IOException;
import java.io.StringReader;
import java.io.StringWriter;
 
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.OutputKeys;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
 
import org.w3c.dom.Document;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;
 
/**
 * Utilities for parsing and converting XML DOMs.
 */
public class XMLUtilities {
 
	/**
	 * Parse a string containing XML.
	 *
	 * @param xmlString the XML string
	 * @return XML DOM document
	 * @throws ParserConfigurationException
	 * @throws SAXException
	 * @throws IOException
	 */
	public static Document parse(String xmlString) throws ParserConfigurationException, SAXException, IOException {
		// define inputs
		StringReader stringReader = new StringReader(xmlString);
		InputSource inputSource = new InputSource(stringReader);
		// parse inputs
		DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
		DocumentBuilder builder = factory.newDocumentBuilder();
		Document document = builder.parse(inputSource);
		return document;
	}
 
	/**
	 * Convert XML DOM document to a string.
	 *
	 * @param document XML DOM document
	 * @return XML string
	 * @throws TransformerException
	 */
	public static String toString(Document document) throws TransformerException {
        StringWriter stringWriter = new StringWriter();
        StreamResult streamResult = new StreamResult(stringWriter);
        TransformerFactory transformerFactory = TransformerFactory.newInstance();
        Transformer transformer = transformerFactory.newTransformer();
        transformer.setOutputProperty(OutputKeys.INDENT, "yes");
        transformer.setOutputProperty("{http://xml.apache.org/xslt}indent-amount", "2");
        transformer.setOutputProperty(OutputKeys.METHOD, "xml");
        transformer.transform(new DOMSource(document.getDocumentElement()), streamResult);
        return stringWriter.toString();
	}
 
}

Im letzten Eintrag habe ich bereits von den Videos zur JavaOne 2008 berichtet. Hier ist ein weiteres:

Der interessante Teil in Bezug auf JavaFX und RIAs beginnt bei ca. 24:30 Minuten. Hier wird das neue Plugin-Konzept der Java Runtime vorgestellt. Die JRE soll modularisiert werden um die Downloadgröße zu verringern und eine schnellere Installation zu ermöglichen. Über die Sinnhaftigkeit dieses Ziels kann man streiten. Wie werden fehlende Plugins in der JRE nachinstalliert? Geschieht dies für den Nutzer in einem transparenten Weg? Das müßte geklärt werden, um diese Neuerung zu beurteilen…

Was hingegen sehr interessant ist, ist die Neuerungen rund um Applets. Wie wahrscheinlich jeder weiß, sind Applets meist kleinere Java Applikationen, die in eine Webseite eingebunden werden. Bislang waren diese relativ beschränkt, was grafische Aufmachung, Multimediainhalte usw. anbelangt. Durch die neue JRE und JavaFX soll sich dies grundlegend ändern. Anscheinend wird JavaFX eine echte Adobe Flash / Flex Alternative. EDIT: Das Hauptargument gegnüber der Konkurrenz dürfte allerdings das Folgende sein: Sun will mit JavaFX Applets und Applitkationen sowohl auf den Desktop, als auch auf mobilen Endgeräten verfügbar machen. Hierbei sollen keine Änderungen am Code, Neukompilieren usw. nötig sein. Ob das realistisch ist?

Was mich besonders beeindruckt hat: Applets können per Drag & Drop aus der Webseite auf den Desktop gezogen werden. Sie laufen dann in einem eigenen Fenster (oder wie in der Demo ohne Rahmen). Der Entwickler kann das Verhalten spezifizieren, wie sich das Applet verhalten soll, wenn beispielsweise der Browser geschlossen wird. Soll es weiterlaufen oder ebenfalls beendet werden? Außerdem ist es möglich, dass das Applet auf Wunsch – ohne den Browser zu öffnen – gestartet werden kann. Hierzu wird ein Shortcut auf dem Desktop angelegt. Ist dies etwa eine neue Möglichkeit Applikationen auszurollen? Mir fallen beim nachdenken schon einige mögliche Anwendungsfälle ein… Man darf gespannt sein!

Rich Internet Applications (RIAs) sind (ursprünglich) Webapplikationen, die aber Benutzeroberflächen, Look & Feel und Funktionalitäten ähnlich einer Desktop-Applikation bieten. Stichworte sind kein neuerliches Laden einer Seite, wenn sich die Inhalte ändern, Drag & Drop, Animation usw.

Sun springt mit JavaFX auch auf diesen Zug auf. Ende Juli 2008 wurde eine erste Preview SDK auf der Produktseite veröffentlicht. Mit JavaFX möchte Sun eine komplette Produktlinie zur Verfügung stellen, um RIAs zu entwickeln. Hierzu gehören sowohl Tools zur Programmierung bzw. zum Skripten (Netbeans IDE), als auch Werkzeuge zur Content-Erstellung (Project Nile).

Einer der wichtigsten Bestandteile der Produktlinie ist JavaFX Script. Diese Skriptsprache dient der Definition des Aussehens und Verhaltens einer Benutzeroberfläche. JavaFX Script ist damit vergleichbar zu ActionScript, wie es in Adobe Flash / Flex / Air Verwendung findet. Zunächst stellt sich die Frage, warum man überhaupt eine neue Skriptsprache braucht. Schließlich wurde beispielsweise mit Groovy eine eingefügt. Einer der Hauptgründe ist wohl, dass es dem Benutzer möglichst einfach gemacht werden soll, dynamische Benutzeroberflächen zu definieren.

Dann wollen wir mal schauen, ob das Ganze was taugt

JavaFX Preview SDK und Netbeans herunterladen

Netterweise gibt es von Sun ein Paket, dass JavaFX und die Entwicklungsumgebung Netbeans bündelt. Einfach herunterladen und installieren. Zurzeit gibt es dieses Paket für Windows und Mac OS X.

Neues JavaFX Projekt anlegen

Nachdem Netbeans gestartet wurde, legt man ein neues Projekt über “File > New Project” an. Als Vorlage wählt man “JavaFX Script Application” in der Kategorie “JavaFX”. Noch schnell einen Projektnamen (z.B. TestdriveJavaFX) und schon geht’s ans Eingemachte. Wir erhalten nun ein leeres Projekt.

Leeres JavaFX Projekt

Weiter geht’s

Im Projekt wurde bereits eine Datei “Main.fx” angelegt. Dies ist das JavaFX Script. Zurzeit sollte die Datei ungefähr so aussehen:

/*
 * Main.fx
 *
 * Created on 21.08.2008, 17:14:46
 */
 
package testdrivejavafx;
 
import javafx.application.Frame;
import javafx.application.Stage;
import javafx.scene.text.Text;
import javafx.scene.Font;
import javafx.scene.FontStyle;
 
/**
 * @author Sebastian
 */
 
// place your code here

Auf der rechten Seite des Netbeans Fenster findet sich die Palette. Hier können visuelle Elemente per Drag & Drop dem Skript hinzugefügt werden. Zunächst benötigen wir ein Frame aus dem Bereich “Applications” der Palette. Dies definiert ein Fenster, in dem später die Inhalte der Applikation angezeigt werden. Durch ziehen des Frames in das Code-Fenster unter //place your code here wird das entsprechende Code-Segment eingefügt. Das Ganze sollte jetz so aussehen:

/*
 * Main.fx
 *
 * Created on 21.08.2008, 17:14:46
 */
 
package testdrivejavafx;
 
import javafx.application.Frame;
import javafx.application.Stage;
import javafx.scene.text.Text;
import javafx.scene.Font;
import javafx.scene.FontStyle;
 
/**
 * @author Sebastian
 */
 
// place your code here
Frame {
    title: "MyApplication"
    width: 200
    height: 200
    closeAction: function() {
        java.lang.System.exit( 0 );
    }
    visible: true
 
    stage: Stage {
        content: []
    }
}

Die Werte nach title, width und height beschreiben natürlich die Attribute Titel, Breite und Höhe des Fensters.

Ein Klick auf den Run-Button genügt zum Starten der Applikation. Ohne eine Zeile Code selbst zu schreiben, wurde ein Fenster geöffnet. Wer Swing kennt weiß, dass das ziemlich schnell ging für Java

Ein Fenster… und jetzt?

Jetzt könnte man anfangen, das Fenster mit Inhalt zu füllen. Versucht doch mal einige Elemente in die eckigen Klammern von content: [] aus der Palette zu ziehen. Auf diese Weise können sehr schnell Texte und einfache geometrische Formen in das Fenster plaziert werden. Experimentiert

Das ist natürlich noch ziemlich wenig. Interessant wird es erst, wenn es in den Bereich Animation und die Verzahnung mit regulären Java Code geht. Das hebe ich mir aber für später auf (muss das erstmal selbst lernen)…

Wie… das war’s schon?!

Na ja, so ziemlich. Wer sich Appetit holen will, dem empfehle ich das folgende Video von der diesjährigen JavaOne Konferenz. Es werden einige interessante JavaFX Demos gezeigt.

Weitere Videos zu JavaFX finden sich auf der entsprechenden Konferenzseite.

So long…

Zurzeit programmiere ich wieder viel in Java. Ein Problem das man immer mal wieder hat: Textdateien einlesen. Erstaunlicherweise kann man dabei wahnsinnig viele unterschiedliche Methoden verwenden. Die meisten sind schlecht, unschön und sehr, sehr langsam…

Ein modifiziertes Beispiel aus den Weiten des Internets, das zwar eine Textdatei einliest, sich aber dabei ziemlich viel Zeit lässt:

/**
 * Load a text file in a string.
 * @param file text file
 * @return string containing the text
 * @throws IOException
 */
public static String loadTextFile(File file) throws IOException {
        BufferedReader in = new BufferedReader(new FileReader(file));
        String result = "";
        boolean linesLeft = true;
        while (linesLeft) {
           String str = in.readLine();
           if (str != null) {
        	   result += str + "\n";
           }
           else {
        	   linesLeft = false;
           }
        }
        in.close();
        return result;
}

Da ich öfters Textdateien einlesen muss, habe ich mir eine kleine Klasse zu diesem Thema geschrieben. Das Einlesen geht wesentlich schneller als im oberen Beispiel. Ich schätze, dies ist so ziemlich das Maximum an Performance, was man mit relativ geringen Aufwand aus Java kitzeln kann. Nebenbei bemerkt ist die Methode auch wesentlich kompakter und lesbarer!

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
 
/**
 * Utility class for loading and saving text files.
 */
public class TextFileUtilities {
 
    /**
     * Write a string to a file.
     *
     * @param text text to save
     * @param file file to save text to
     * @throws IOException
     */
    public static void saveTextFile(String text, File file) throws IOException {
      FileWriter fileWriter = new FileWriter(file);
      fileWriter.write(text);
      fileWriter.flush();
      fileWriter.close();
    }
 
    /**
     * Read the content of a text file.
     *
     * @param file text file
     * @return content of text file
     * @throws IOException
     */
     public static String loadTextFile(File file) throws IOException {
       BufferedReader reader = new BufferedReader( new FileReader(file) );
       char[] chars = new char[ (int)file.length() ];
       reader.read(chars);
       reader.close();
       return new String(chars);
     }
}