As shown in the last article, passing parameters between a JavaFX script and Java code is fairly simple, if the parameters are native to the Java language. But if we want to pass a JavaFX-object, things are different. The main obstacle is the fact, that the Java compiler is not able to read JavaFX scripts directly to extract the needed information. But JavaFX objects can be shared between a JavaFX and Java code by using one of these approaches:
- Java interfaces
- JSR 223 – Scripting for the Java Platform
- com.sun.tools.javafx.ui.FXBean
- Using the Java classes created by the JavaFX compiler directly
- (JavaFX Reflection)
The last two approaches are mentioned just for completeness. It requires some detailed knowledge of how a JavaFX class is translated into Java code to use the classes directly and it is more cumbersome than the other approaches. For these reasons I’ll skip it in this article, but plan to dedicate an entire article on an overview of how JavaFX classes get translated to Java code. JavaFX Reflection is not implemented yet, but planned. I will add a description for this approach as soon as the details are decided.
Code sample 1 shows a class, which needs to be passed to Java. It has a public function printProperty, which we want to call from Java code.
import java.lang.System;
public class MyJavaFXClass {
public attribute property: String;
public function printProperty() {
System.out.println(property);
}
}
Code Sample 1: Definition of MyJavaFXClass
Java interfaces
The first approach (and my favorite one) is to use Java interfaces for passing JavaFX classes to Java code. This approach requires to define a Java interface, let the JavaFX-class implement the interface and reference the interface in the Java code. For our little example, we define the interface Printable which is shown in Code Sample 2.
public interface Printable {
void printProperty();
}
Code Sample 2: The interface Printable
Now we can write a Java class, which takes an implementation of the interface Printable and calls its method printProperty (code sample 3).
public class MyLibraryByInterface {
public static void print (Printable p) {
p.printProperty();
}
}
Code Sample 3: Using an interface to access JavaFX code
The last step is to modify the JavaFX class from code sample 1, so it implements the interface Printable. Also I added some code to create an instance of this class and pass it to the Java library.
import java.lang.System;
public class MyJavaFXClass extends Printable {
public attribute property: String;
public function printProperty() {
System.out.println(property);
}
}
var o = MyJavaFXClass {
property: "Hello JavaFX by Interface"
};
MyLibraryByInterface.print(o);
Code Sample 4: Implementing a Java interface with JavaFX Script
This approach has some major advantages. As you can see, the Java code contains no JavaFX-specific code at all. The very same code could handle a Java-object which implements the interface Printable. As a side effect, you can easily write Java-code which can be used with JavaFX-code and Java-code at the same time. Or if you want to migrate parts of an existing Java-application, you can simply switch to use interfaces and then exchange class after class. (Well, it’s probably not going to be THAT simple, but you get the idea.) 🙂
The drawback of this approach is, that one cannot instantiate objects directly as usual when using interfaces. You either need to pass the objects to the Java code or use factory-methods. But the very first factory still needs to be passed to the Java code – or created with the next approach.
JSR 223 – Scripting for the Java Platform
JSR 223 – Scripting for the Java Platform defines mechanisms to access scripting languages from Java code. An implementation for JavaFX Script is available and part of the JavaFX Runtime. With the provided scripting engine, you can read JavaFX-files, compile, and run them. And because the engine for JavaFX Script implements the interface Invocable, it is even possible to call members of JavaFX objects.
In code sample 5, a class is defined, which takes an arbitrary object and tries to call its method printProperty with the help of the JavaFX Scripting Engine. The first two lines of the method get the ScriptingEngineManager, which manages the available scripting engines. The engine for JavaFX Script is requested and casted to the interface Invocable. The line in the try-block invokes the function printproperty of the object that was given as parameter.
import javax.script.*;
public class MyLibraryByScriptEngine {
public static void print (Object o) {
ScriptEngineManager manager = new ScriptEngineManager();
Invocable fxEngine = (Invocable) manager.getEngineByName("javafx");
try {
fxEngine.invokeMethod(o, "printProperty");
} catch (Exception ex) {
ex.printStackTrace();
}
}
}
Code sample 5: Using the JavaFX Script engine
For this approach we do not need to change the JavaFX class at all. The following two lines will create the object and pass it to the Java library.
import MyJavaFXClass;
var o = MyJavaFXClass {
property: "Hello JavaFX by ScriptEngine"
};
MyLibraryByScriptEngine.print(o);
Code Sample 6: Calling MyLibraryByScriptEngine
As you can see, the Java code to handle a JavaFX object is slighty more complicated than in the first approach. The major drawback is, that the compiler is not able to check the code. Instead you will receive a runtime exception if for example you have a typing error in the method-name printProperty, like I did. 😉
But on the other hand this approach is the most powerful one of these three aproaches, as you are able to access JavaFX-files directly. We have just scratched the possibilities here; if you want to read more, I recommend this general introduction or this article specific to JavaFX Script.
com.sun.tools.javafx.ui.FXBean
The last approach, to use the class FXBean within the JavaFX Runtime, differs from the other approaches, because it does not give you access to the functions of a JavaFX object but to its attributes. The code sample 7 receives an arbitrary object, reads its attribute property with the help of the class FXBean, and prints the attribute.
First an FXBean is constructed using the class of the given object as parameter. The next line requests an attribute with the name property and the type string. Actually the FXBean does not return a String immeadiately, but an ObjectVariable<String>. This is the internal representation of a String-attribute mapped to Java code. We get the value of the attribute by calling the method get, which is printed in the last line of the try-block.
import com.sun.tools.javafx.ui.FXBean;
import com.sun.javafx.runtime.location.ObjectVariable;
public class MyLibraryByFXBean {
public static void print (Object o) {
try {
FXBean bean = new FXBean(o.getClass());
ObjectVariable<String> attribute =
(ObjectVariable<String>)bean.getObject(o, "property");
String property = attribute.get();
System.out.println(property);
} catch (Exception ex) {
ex.printStackTrace();
}
}
}
Code Sample 7: Using the class FXBean
The next two lines of JavaFX code create an object and pass it to the Java library.
import MyJavaFXClass;
var o = MyJavaFXClass {
property: "Hello JavaFX by FXBean"
};
MyLibraryByFXBean.print(o);
Code Sample 8: Calling MyLibraryByFXBean
As already mentioned above does this approach differ from the others and can therefore not be compared. Using the FXBean you are able to read and modify attributes directly. There are a number of methods to simplify acces to attributes of type Number, Integer, Boolean, and sequences.
After considering the primitive datatypes and Java objects in the last article, we took a look at JavaFX objects in this article. The next article will focus on dealing with sequences in Java code.