30. July 2015

JavaFX mit Scala

JavaFX with Scala

Guten Morgen,

einer der großen Vorteile von Scala ist die sehr gute Interoperabilität mit Java. Wäre es nicht toll, wenn man eine JavaFX Applikation mit Scala schreiben könnte? Nun, man kann (sonst wäre dieser Artikel auch arg kurz). Im Folgenden zeige ich, was man beachten muss, wenn man JavaFX und Scala verheiraten will.

Ziel ist es, eine kleine JavaFX Applikation zu schreiben, deren Oberfläche in FXML-Dateien definiert ist, und daher mittels SceneBuilder erstellt werden kann. Weiterhin wollen wir den Komfort der Dependency Injection mittels @FXML Attribut nutzen können, was dank der guten Interoperabilität glücklicherweise relativ problemlos funktioniert. Der Einfachheit halber nutzen wir den View-First Ansatz, d.h. die View bestimmt welcher Controller zu laden ist und der FXMLLoader kümmert sich darum diesen Controller zu initialisieren.

Zunächst müssen wir JavaFX laden. Hierzu wird analog zu Java eine Klasse erstellt, die von Application erbt.

// File: eu.derprogrammierer.jfx.FxApp.scala
package eu.derprogrammierer.jfx

import javafx.application.Application
import javafx.stage.Stage

class FxApp extends Application {
override def start(primaryStage: Stage): Unit = {
primaryStage.setTitle("Fx App")
primaryStage.show()
}
}

In diesem Beispiel wird der Fenstertitel gesetzt und das Fenster geöffnet - später werden wir es auch noch mit Inhalt füllen.

In einer üblichen JavaFX Anwendung gibt es zudem eine statische main()-Funktion. Da Scala aber keine statischen Funktionen kennt, werden wir stattdessen ein Companion Object für die FxApp-Klasse erstellen. Dabei ist zu beachten, dass ein Companion Object nicht automatisch die Funktionen der Basisklasse implementiert. Daher funktioniert die folgende direkte Übersetzung des normalen Java-Codes nicht.

object FxApp extends Application {
def main (args: Array[String]): Unit = {
launch(args:_*) // Cannot resolve symbol launch
}
}

Glücklicherweise bietet Application eine Funktion an, die für unsere Zwecke genutzt werden kann. Sie erlaubt es uns, launch() auf der Basisklasse aufzurufen und den Typ unserer FxApp anzugeben.

// File: eu.derprogrammierer.jfx.FxApp.scala

...

object FxApp {
def main (args: Array[String]): Unit = {
Application.launch(classOf[FxApp], args:_*)
}
}

Die Applikation kann nun gestartet werden und zeigt ein leeres JavaFX(!) Fenster. Das ist schön ung gut, aber wir wollen das Fenster noch mit leben füllen und dann war da auch noch die Sache mit FXML, nicht oder?

Nun, bevor wir uns mit FXML beschäftigen können, müssen wir aber einen Controller anlegen, den wir dann in der View nutzen können. Eine einfache Controller-Implementierung ist der Java-Version sehr ähnlich.

// File: eu.derprogrammierer.jfx.view.MainViewController.scala
package eu.derprogrammierer.jfx.view

import javafx.fxml.FXML
import javafx.scene.control.{Label}

class MainViewController {
@FXML private var testLabel: Label = _

def initialize(): Unit = {
testLabel.setText("Initialized!")
}

def handleTest(): Unit = {
testLabel.setText("Test successful!")
}
}

Wie man sieht, wird die View ein Label "testLabel" beinhalten. Dessen Text wird in der initialize()-Funktion verändert. Zudem gibt es den Handler handleTest(), der den Text erneut verändert. Dieser soll durch einen Button ausgelöst werden.

IntelliJ IDEA meint man könnte testLabel zu einem val umwandeln, allerdings funktioniert die JavaFX Injection dann nicht mehr. Zudem sei an dieser Stelle erwähnt, dass es in Scala nicht möglich ist, das @FXML Attribut für Felder wegzulassen, wenn man sie public macht. Das ist der Fall, weil Scala für ein public Field in Wirklichkeit Getter- und Setter-Methoden implementiert, die auf ein privates Feld zugreifen. Dieser für normale Programmierung unmerksame Unterschied hat bei Reflection, wie sie für FMXL genutzt wird, große Auswirkungen!

Main.fxml in SceneBuilder

Da unser Controller jetzt fertig ist, können wir die View erstellen. Hierzu wird im Package "view" eine Datei "MainView.fxml" angelegt. Im SceneBuilder wird eine AnchorPane in das leere Fenster gezogen. Mittig in diese werden nun ein Button und ein Label platziert.

Action handleTestLabel fxid

Der Button erhält die Action "handleTest", das Label wird mit der fx:id "testLabel" versehen.

MainView Controller ClassAußerdem möchte unsere View noch einen Controller haben. Wir geben den gesamten Namen unseres Controllers in das Feld Controller class mit.

Was jetzt noch bleibt, ist das Laden der View in unserer FxApp-Klasse. Dazu wird die start()-Funktion wie folgt angepasst:

override def start(primaryStage: Stage): Unit = {
primaryStage.setTitle("Fx App")

val fxmlLoader = new FXMLLoader(getClass.getResource("view/MainView.fxml"))
val mainViewRoot: Parent = fxmlLoader.load()

val scene = new Scene(mainViewRoot)
primaryStage.setScene(scene)
primaryStage.show() }

Dazu sind weitere Imports erforderlich:

import javafx.fxml.FXMLLoader
import javafx.scene.{Scene, Parent}

Wird das Programm jetzt gestartet, sieht man, dass das Label korrekt initialisiert wurde. Ein Klick auf den Button ändert den Text des Labels auf "Test successful!". Wahrlich ein erfolgreicher Test!

Wir haben nun eine vollwertige JavaScalaFX Applikation. Hieraus eine "Hello World!"-App zu machen, überlasse ich als Übung dem Leser.