What is a “Node” in JavaFx/FXML?

Question

What is meant by the word "Node" within context of JavaFx/FXML? If I search for this question, all I find are people using the term discussing something else, but no explanation. For example, this answer to the question: How do I open the JavaFX FileChooser from a controller class? :

For any node in your scene (for example, the root node; but any node you have injected with @FXML will do), do

chooser.showOpenDialog(node.getScene().getWindow());

What would the node be, and how for that matter would I "inject it with @FXML"?

Answer 1

Before you understand what a Node is, it is also important to first of all understand what a Scene Graph is in JavaFX .

JavaFX applications consist of a Stage and a Scene or several scenes. The stage being the top-level container of your application. The Scene(s) on the other hand, contains all the content (User Interface elements) of your application (if your application has only one "page") or the content of one of the "pages" of your application, and exists in/on a stage. (To be clear here, by page I mean what the user interacts with, for instance, a login page.)

The Scene Graph is a graphical illustration of how all the stuff in your scene are laid out. This graph is represented in the form of a tree data structure.

A Node is an item in the scene graph.

I think this image explains this clearly.

Example of a Node is a Control , which is anything that can be manipulated by the user Eg, TextField, Button, TextArea

Photo Credit

Answer 2

A Node is the abstract superclass of the graphical elements the scenegraph are "made of".

Some examples of classes inheriting from Node :

• TextField
• AnchorPane
• Canvas
• Group
• VBox
• Button
• Label
• ...

Injecting a Node with the FXMLLoader id done this way:

1. Create a field in the controller associated with the fxml with a appropriate type (ie any type the element you want to inject can be assigned to). This field must be accessible by the FXMLLoader which means it has to be public or annotated with the @FXML annotation.
2. Add the id attribute from the fxml namespace (most likely using the prefix fx ) to the element in the fxml file that should be injected. The value of that attribute is the name of the field in the controller.

Example

fxml

....
<TextField fx:id="myTextField" ....>
....

Controller

....
@FXML
private TextField myTextField;
....

The FXMLLoader uses this information to assign the object it creates for that fxml element to the field before the controller's initialize method is called.

A full example/extendend tutorial including injection can be can be found here: https://docs.oracle.com/javase/8/javafx/fxml-tutorial/fxml_tutorial_intermediate.htm#JFXMG153

Answer 3

This is an old question, but it is answered abstractly. "What is a node?" and "in order to understand what is a node you must first understand what is a scene-graph". A node is the highest level abstract class from which nearly all that is graphically displayed in a GUI, is derived. Its super class is Object. In the image displayed by Ojonugwa Ochalifu there is one stage that contains one scene which contains several nodes that contain other nodes. The image shown of a GUI begs the question "How is this created?".

For general understanding here are the JavaDocs for Stage, Scene, and EventTarget.
In javafx doc Stage https://docs.oracle.com/javase/8/javafx/api/javafx/stage/Stage.html

and Scene https://docs.oracle.com/javase/8/javafx/api/javafx/scene/Scene.html

Both Stage and Scene inherit the same interface, EventTarget as well as Pane, and Control and a long list of classes. https://docs.oracle.com/javase/8/javafx/api/javafx/event/EventTarget.html

I also recommend looking at the source code for classes that you are using. It will help provide insight into the behavior of classes that inherit from node. For example, JavaFX documentation mentions that a bug could exist when displaying an Image. Ensuring that this bug does not occur in a UI requires thorough testing. Other insight such as how to access the graph with multi-threaded techniques requires understanding the "how" and "What" a class uses.

The Scene-Graph is contained by the Stage and is comprised of any subclass of node. Some nodes such as Panes may have children. A child is still a node. Children are contained in a structure which may contain other nodes that may also have children. Thus the graph is much like a multi-dimensional array or non-binary tree. It's also important to understand that: The Scene-Graph is a Non-Directional Graph meaning that a child can access its parent; a child can have only one parent; but can have an unlimited number of children. The getParent() method provides access to a nodes parent.

Image of scene-graph

Note that essentially the graph structure is a multi-dimensional array. Or in other words, an array that may contain either other arrays of items that inherit from Node, or Nodes such as ImageViews, Buttons, etc. Array like Nodes are Panes, Canvas's etc... which may contain other nodes.

This is important to understand when it comes to test automation & reliably assuring that a UI is displaying what it should show.

A good book to get started with JavaFX is "Learn JavaFX 8" by Kishori Sharan. https://www.amazon.com/Learn-JavaFX-Building-Experience-Interfaces/dp/148421143X/ref=asc_df_148421143X/?tag=bingshoppinga-20&linkCode=df0&hvadid= {creative}&hvpos={adposition}&hvnetw=o&hvrand={random}&hvpone=&hvptwo=&hvqmt=e&hvdev=c&hvdvcmdl={devicemodel}&hvlocint=&hvlocphy=&hvtargid=pla-4584413736126928&psc=1