JavaFX 官方文档翻译

官方文档地址：JavaFX

介绍

JavaFX 允许你创建具有现代、硬件加速的用户界面的 Java 应用程序，并且具有高度的可移植性。

JavaFX 有详细的参考文档，这个简短的教程将告诉你如何编写一个 JavaFX 15 应用程序。

关于如何在移动平台上运行 JavaFX 应用程序的信息，请参见《Gluon Mobile 入门》

关于 JavaFX 11 的长期支持（LTS）的信息，请参见 JavaFX 长期支持选项。

JavaFX 建立在 JDK 之上，是一个独立的组件。开发 JavaFX 应用程序有两种不同的选择。

• 使用 JavaFX SDK（选择 11 LTS、最新版本 15.0.1 或早期访问构建）。
• 使用构建系统（如 maven/gradle），从 Maven 中心下载所需的模块（也可在上述版本中选择）。

在任何情况下，对于这两个选项，都要求有最新版本的 JDK 15，或者至少是 JDK 11。

安装 Java

跳过，记得安装 Java11 ，或者 Java15

使用 JavaFX SDK 运行 HelloWorld

如果你想使用 JavaFX SDK 而不是构建工具，请为你的操作系统下载一个合适的 JavaFX 运行时，并将其解压到所需位置。在本教程中，我们将使用 JavaFX 15.0.1。

添加一个环境变量，指向运行时的 lib 目录。

windows 下

set PATH_TO_FX="path\to\javafx-sdk-15.0.1\lib"

linux/mac 下

export PATH_TO_FX=path/to/javafx-sdk-15.0.1/lib

现在你可以使用 JavaFX 运行时从命令行编译和运行 JavaFX 应用程序。

编译应用程序（例如，使用本示例中的 HelloFX.java），使用。

windows 下

javac --module-path %PATH_TO_FX% --add-modules javafx.controls HelloFX.java

linux/mac 下

javac --module-path $PATH_TO_FX --add-modules javafx.controls HelloFX.java

重要提示：请确保添加所需的模块，同时考虑到横向依赖关系的自动解决（例如，没有必要添加 javafx.graphics 模块，因为它是 javafx.controls 模块的过渡性需求）。但是如果你的应用程序使用 FXML，你将需要添加 javafx.fxml 模块，如下所示。

windows 下

javac --module-path %PATH_TO_FX% --add-modules javafx.controls,javafx.fxml HelloFX.java

linux 下

javac --module-path $PATH_TO_FX --add-modules javafx.controls,javafx.fxml HelloFX.java

最后，用以下方法运行该应用程序。

windows 下

java --module-path %PATH_TO_FX% --add-modules javafx.controls HelloFX

linux/mac 下

java --module-path $PATH_TO_FX --add-modules javafx.controls HelloFX

使用 Maven 运行 HelloWorld

如果您想使用 Maven 开发 JavaFX 应用程序，您不必下载 JavaFX SDK。只需在 pom.xml 中指定你想要的模块和版本，构建系统就会下载所需的模块，包括你所在平台的本地库。

这里有一个 pom.xml 文件，显示了如何实现这一目标，包括在这个例子中。

担心有的同学上不了 github,这里贴出来

pom 文件

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>org.openjfx</groupId>
  <artifactId>hellofx</artifactId>
  <packaging>jar</packaging>
  <version>1.0-SNAPSHOT</version>
  <name>demo</name>
  <url>http://maven.apache.org</url>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <javafx.version>16</javafx.version>
    <javafx.maven.plugin.version>0.0.6</javafx.maven.plugin.version>
  </properties>

  <dependencies>
    <dependency>
      <groupId>org.openjfx</groupId>
      <artifactId>javafx-controls</artifactId>
      <version>${javafx.version}</version>
    </dependency>
  </dependencies>
  <build>
    <plugins>
      <plugin>
        <groupId>org.openjfx</groupId>
        <artifactId>javafx-maven-plugin</artifactId>
        <version>${javafx.maven.plugin.version}</version>
        <configuration>
          <mainClass>HelloFX</mainClass>
        </configuration>
      </plugin>
    </plugins>
  </build>
</project>

另外，我们还创建了 JavaFX Maven Archetypes 来快速创建 Maven 项目。通过执行以下命令，可以创建一个简单的 JavaFX 项目。

mvn archetype:generate \
        -DarchetypeGroupId=org.openjfx \
        -DarchetypeArtifactId=javafx-archetype-simple \
        -DarchetypeVersion=0.0.3 \
        -DgroupId=org.openjfx \
        -DartifactId=sample \
        -Dversion=1.0.0 \
        -Djavafx-version=15.0.1

该 Pom 使用了 JavaFX Maven 插件。

<plugins>
    <plugin>
        <groupId>org.openjfx</groupId>
        <artifactId>javafx-maven-plugin</artifactId>
        <version>0.0.5</version>
        <configuration>
            <mainClass>HelloFX</mainClass>
        </configuration>
    </plugin>
</plugins>

添加 maven 依赖

<dependencies>
  <dependency>
    <groupId>org.openjfx</groupId>
    <artifactId>javafx-controls</artifactId>
    <version>15.0.1</version>
  </dependency>
</dependencies>

重要提示：请注意过渡性的依赖关系是自动解决的（例如，不需要为 javafx.graphics 模块添加依赖关系，因为它是由 javafx.controls 模块过渡解决的）。但是如果你的应用程序使用 FXML，你将需要为 javafx.fxml 模块添加一个依赖关系。

最后，运行应用程序（例如，基于参考样本中的 HelloFX.java）。

mvn clean javafx:run

注意：请确保将 JAVA_HOME 环境变量设置为正确的 JDK 位置。

使用 Gradle 运行 HelloWorld

与 Maven 类似，我们可以在 build.gradle 文件中声明需要的 JavaFX 模块。然而，对于 Gradle，我们需要应用 JavaFX gradle 插件。

plugins {
  id 'application'
  id 'org.openjfx.javafxplugin' version '0.0.9'
}

接下来，我们添加所需的模块。例如，如果我们只需要 javafx.controls 模块，我们将包括：

javafx {
    version = "15.0.1"
    modules = [ 'javafx.controls' ]
}

重要提示：请注意过渡性的依赖关系是自动解决的（例如，不需要为 javafx.graphics 模块添加依赖关系，因为它是由 javafx.controls 模块过渡解决的）。但是如果你的应用程序使用 FXML，你将需要同时添加 javafx.fxml 模块。

你可以指定一个不同的 JavaFX 版本。例如，如果你想坚持使用 JavaFX 11.0.2。

javafx {
    version = "11.0.2"
    modules = [ 'javafx.controls' ]
}

这里有一个 build.gradle 文件，显示了如何实现这一目标，它取自这个 sample.。

运行应用程序（例如，使用给定样本中的 HelloFX.java），使用：

windows 下

gradlew run

linux/mac 下

./gradlew run

注意：我们对每个 JDK 的最小 Gradle 版本的建议如下。

Runtime images

JavaFX 项目的运行时映像是一个自定义的 JRE，它只包含你的应用程序所需的平台模块。

如果你想为你的 JavaFX 项目创建一个运行时镜像，请遵循以下说明。

为你的操作系统下载一个合适的 JavaFX runtime and JavaFX jmods，并将其解压到一个想要的位置。

添加这些环境变量，指向运行时的 lib 目录和 jmods 目录。

windows 下

set PATH_TO_FX="path\to\javafx-sdk-15.0.1\lib"
set PATH_TO_FX_MODS="path\to\javafx-jmods-15.0.1"

linux/mac 下

export PATH_TO_FX=path/to/javafx-sdk-15.0.1/lib
export PATH_TO_FX_MODS=path/to/javafx-jmods-15.0.1

命令行

你可以从命令行中运行或创建你的 JavaFX 项目的 Runtime image。在这个 project 中可以找到一个简单的例子。

该应用程序有一个单一的 HelloFX.java 类，其 module-info 文件定义了 hellofx 模块。编译时可以使用 JavaFX SDK。

windows 下：

dir /s /b src\*.java > sources.txt & javac --module-path %PATH_TO_FX% -d mods/hellofx @sources.txt & del sources.txt

linux 下

javac --module-path $PATH_TO_FX -d mods/hellofx $(find src/ -name "*.java")

或使用 JavaFX 的 jmods。

windows 下

dir /s /b src\*.java > sources.txt & javac --module-path %PATH_TO_FX_MODS% -d mods/hellofx @sources.txt & del sources.txt

linux/mac 下

javac --module-path $PATH_TO_FX_MODS -d mods/hellofx $(find src/ -name "*.java")

注意：注意，为了方便，输出被放在 mods/hellofx 下，但它可以使用任何其他名称。

要用 java 命令运行模块化的应用程序，你需要 JavaFX SDK 模块和你的模块添加到模块路径中。

windows 下

java --module-path "%PATH_TO_FX%;mods" -m hellofx/hellofx.HelloFX

linux 下

java --module-path $PATH_TO_FX:mods -m hellofx/hellofx.HelloFX

jlink

通过一个模块化的项目，jlink 可以被用来创建一个使用 JavaFX jmods 的自定义 Runtime images

windows 下

jlink --module-path "%PATH_TO_FX_MODS%;mods" --add-modules hellofx --output hellofx

linux/mac 下

$JAVA_HOME/bin/jlink --module-path $PATH_TO_FX_MODS:mods --add-modules hellofx --output hellofx

而在 image 建立后，你可以运行它。

windows 下

hellofx\bin\java -m hellofx/hellofx.HelloFX

linux/mac 下

hellofx/bin/java -m hellofx/hellofx.HelloFX

注意：这个定制的 JRE 是特定平台的。

Maven

您可以运行或创建您的 JavaFX Maven 项目的 runtime。在这个 project.中可以找到一个简单的例子。

该应用程序有一个主类 MainApp.java，其 module-info 文件定义了 hellofx 模块。它还使用了 FXML，需要在 pom.xml 中添加 javafx.fxml 依赖项。

它可以在命令行上用 javac 编译和运行，但使用 Maven 我们可以简单地做到:

mvn clean javafx:run

要创建一个自定义 runtime，使用 JavaFX Maven 插件，你可以这样做：

mvn clean javafx:jlink

注意该插件允许像 jlink 命令一样的常规选项，以及创建一个启动器或带有自定义 image 的压缩包。

而在 image 建立后，你可以从命令行中运行它。

windows 下

target\hellofx\bin\launcher

linux 下

target/hellofx/bin/launcher

Gradle

你可以运行或创建一个你的 JavaFX Gradle 项目的 Runtime。在这个 project.中可以找到一个简单的例子。

这个应用程序有一个主类 HelloFX.java，它的 module-info 文件定义了 hellofx 模块，还有必要的 build.gradle 文件。

它可以在命令行上用 javac 编译和运行，但使用 Gradle 我们可以简单地做。

windows 下

gradlew run

linux/mac 下

./gradlew run

要创建一个自定义的运行时，可以使用上述步骤来生成一个 gradle 任务。另外，有一个插件可以为我们做这件事：org.beryx.jlink。它可以和 JavaFX 的 Gradle 插件相结合：

plugins {
  id 'application'
  id 'org.openjfx.javafxplugin' version '0.0.9'
  id 'org.beryx.jlink' version '2.23.1'
}

javafx {
    version = "15.0.1"
    modules = [ 'javafx.controls' ]
}

jlink {
    launcher {
        name = 'hellofx'
    }
}

来生成和运行自定义 image

windows

gradlew jlink
build\image\bin\hellofx

linux/mac

./gradlew jlink
build/image/bin/hellofx

自定义 JDK+JavaFX image

你可以使用 jlink 来创建一个包括部分或全部 JavaFX 模块的 runtime image，而不附在某个项目上。

有了这个 image，你就可以运行 JavaFX 模块化或非模块化项目，把它作为 IDE 中的新 JRE 来创建常规的 JavaFX 项目，甚至可以使用它的 jlink 命令来为你的项目创建一个新的自定义 image。

例如，你可以创建一个包含 java.se 模块和 JavaFX 模块的镜像，通过运行。

windows

set PATH_TO_FX_MODS="path\to\javafx-jmods-15.0.1"
%JAVA_HOME%\bin\jlink --module-path %PATH_TO_FX_MODS% \
    --add-modules java.se,javafx.fxml,javafx.web,javafx.media,javafx.swing \
    --bind-services --output \path\to\jdkfx-15.0.1

linux/mac

export PATH_TO_FX_MODS=path/to/javafx-jmods-15.0.1
$JAVA_HOME/bin/jlink --module-path $PATH_TO_FX_MODS \
    --add-modules java.se,javafx.fxml,javafx.web,javafx.media,javafx.swing \
    --bind-services --output /path/to/jdkfx-15.0.1.jdk

使用自定义的 image

通过这个自定义 image，你可以设置一个新的 JAVA_HOME。

windows

set JAVA_HOME="path\to\jdkfx-15.0.1"

linux/mac

export JAVA_HOME=/path/to/jdkfx-15.0.1.jdk

由于 JavaFX 模块已经是运行时的一部分，现在你可以运行 HelloFX 例子而不需要再添加 PATH_TO_FX，比如：

windows

dir /s /b src\*.java > sources.txt & javac -d mods/hellofx @sources.txt & del sources.txt
java --module-path mods -m hellofx/hellofx.HelloFX

linux/mac

javac -d mods/hellofx $(find src/ -name "*.java")
java --module-path mods -m hellofx/hellofx.HelloFX

或将 image 添加到你的 IDE 中。

并开始用 JavaFX 类创建 Java 项目。

并在没有任何额外选项的情况下运行它们。

注意：这个自定义的 JRE 是针对特定平台的，它不打算用于分发，如果有一个新的 JDK 或新的 JavaFX SDK，它必须重新创建。不过，它的 jlink 工具可以用来创建一个带有项目的自定义镜像，可以进行分发。而 jpackage tool 可用于分发带有 jlinked 项目的安装程序。

非模块化应用

从 Java 9 开始，应用程序应该是模块化的，并且用 jlink 这样的工具来分发。然而，如果你有一个非模块化的 JavaFX 项目，或者你不能使用 jlink，因为你有非模块化的依赖关系，而自动模块命名惯例并不适用，你仍然可以创建一个 fat jar。

正如这里所解释的，为了创建一个包含所有必要的 JavaFX 依赖项的可运行 jar，你需要使用一个不从 Application 扩展的启动器类。

这个问题的原因

Maven

如果你使用 Maven 开发 JavaFX 应用程序，你就不必下载 JavaFX SDK 了。只需在 pom.xml 文件中指定你想要的模块和版本，构建系统就会下载所需的模块，包括你所在平台的本地库。

在这个 project 中可以找到一个简单的 Maven 例子。pom.xml 文件展示了如何用 Maven shade 插件为这个 hellofx 项目创建可运行的 fat jar。

运行该插件以创建 fat jar。

mvn compile package

运行该应用程序，使用:

windows

java -jar shade\hellofx.jar

linux/mac

java -jar shade/hellofx.jar

跨平台 jar

你可以通过在你的 pom 文件中加入需要本地库的三个平台的依赖项来创建一个跨平台的 fat jar，在这个例子中只有 javafx.graphics 中的依赖项：

<dependencies>
        ...
        <dependency>
            <groupId>org.openjfx</groupId>
            <artifactId>javafx-graphics</artifactId>
            <version>15.0.1</version>
            <classifier>win</classifier>
        </dependency>
        <dependency>
            <groupId>org.openjfx</groupId>
            <artifactId>javafx-graphics</artifactId>
            <version>15.0.1</version>
            <classifier>linux</classifier>
        </dependency>
        <dependency>
            <groupId>org.openjfx</groupId>
            <artifactId>javafx-graphics</artifactId>
            <version>15.0.1</version>
            <classifier>mac</classifier>
        </dependency>
    </dependencies>

Gradle

如果你使用 Gradle 开发你的 JavaFX 应用程序，你不必下载 JavaFX SDK。只要在 build.gradle 文件中指定你想要的模块和版本，构建系统就会下载所需的模块，包括你平台的本地库。然而，对于 Gradle，我们需要找到并指定平台/操作系统作为分类器。

在这个 project 中可以找到一个简单的 Gradle 例子。为了用 Gradle 为这个项目创建一个可运行的 fat jar，请修改 build 文件中的 jar 任务，以包括启动器类:

mainClassName = 'hellofx.HelloFX'
jar {
    manifest {
        attributes 'Main-Class': 'hellofx.Launcher'
    }
    from {
        configurations.runtimeClasspath.collect { it.isDirectory() ? it : zipTree(it) }
    }
}

现在运行这个任务来创建 fat jar 并且运行它

windows

gradlew.bat jar

java -jar build\libs\hellofx.jar

linux/mac

./gradlew jar

java -jar build/libs/hellofx.jar

跨平台 jar

你可以通过在构建文件中添加需要本地库的三个平台的依赖项来创建一个跨平台的 fat jar，在这个例子中只有 javafx.graphics 中的依赖项。

runtimeOnly "org.openjfx:javafx-graphics:$javafx.version:win"
runtimeOnly "org.openjfx:javafx-graphics:$javafx.version:linux"
runtimeOnly "org.openjfx:javafx-graphics:$javafx.version:mac"

现在再次运行 jar 任务以创建跨平台的 fat jar。

命令行

最后，你也可以在命令行上为你的 JavaFX 项目创建一个可运行的 fat jar。

警告: 这是一个令人沮丧的、乏味的、容易出错的手工过程，在 jlink 不适用的情况下，应该使用 Maven 的 shade 插件或 Gradle 的 jar 任务来避免。

在这个 project.中可以找到一个例子。为你的操作系统下载相应的 JavaFX SDK，并将其解压到所需位置。

添加一个环境变量，指向运行时的 lib 目录

windows

set PATH_TO_FX="path\to\javafx-sdk-15.0.1\lib"

linux/mac

export PATH_TO_FX=/path/to/javafx-sdk-15.0.1/lib

编译这个项目

windows

dir /s /b src\main\java\*.java > sources.txt & javac --module-path %PATH_TO_FX% --add-modules=javafx.controls -d out @sources.txt & del sources.txt

linux

javac --module-path $PATH_TO_FX --add-modules=javafx.controls -d out $(find src/main/java -name "*.java")

并创建 fat jar，加入 JavaFX 需要的 jar 和特定平台的本地库。对于 hellofx 项目。

windows

cd out & jar xf "%PATH_TO_FX%\javafx.base.jar" & jar xf "%PATH_TO_FX%\javafx.graphics.jar" & jar xf "%PATH_TO_FX%\javafx.controls.jar" & cd ..
copy "%PATH_TO_FX%\..\bin\prism*.dll" out & copy "%PATH_TO_FX%\..\bin\javafx*.dll" out & copy "%PATH_TO_FX%\..\bin\glass.dll" out && copy "%PATH_TO_FX%\..\bin\decora_sse.dll" out
del out\META-INF\MANIFEST.MF & del out\module-info.class
mkdir libs
jar --create --file=libs/hellofx.jar --main-class=hellofx.Launcher -C out .

linux

find $PATH_TO_FX/{javafx.base.jar,javafx.graphics.jar,javafx.controls.jar} -exec unzip -nq {} -d out \;

#uncomment for Linux:
#cp $PATH_TO_FX/{libprism*.so,libjavafx*.so,libglass*.so,libdecora_sse.so} out

#uncomment for Mac:
#cp $PATH_TO_FX/{libprism*.dylib,libjavafx*.dylib,libglass.dylib,libdecora_sse.dylib} out

rm out/META-INF/MANIFEST.MF out/module-info.class
mkdir libs
jar --create --file=libs/hellofx.jar --main-class=hellofx.Launcher -C out .

而在 jar 建立后，你可以运行它。

java -jar libs\hellofx.jar

linux/mac

java -jar libs/hellofx.jar

注意：这个 JRE 是特定平台的。然而，如果每个平台的不同本地库都包含在内，它可以很容易地成为一个多平台的 jar。这需要下载所有平台的 JavaFX SDK，提取所有必要的 jar（例如，javafx.graphics 在每个平台都是不同的），并复制所有的本地库，如上所示。正如上面提到的，这个过程不应该手动完成。

JavaFX and IntelliJ IDEA

本节介绍如何在 IntelliJ IDEA 中创建一个 JavaFX 应用程序。在 IDE 的截图中使用了 JavaFX 15.0.1 和 IntelliJ IDEA 2020.1。

为你的操作系统下载一个合适的 JDK，并将 JAVA_HOME 设为 JDK 目录。更多信息请参考 Install Java 部分。

你可以创建一个 JavaFX 模块化或非模块化项目，并使用 IDE 工具、Maven 或 Gradle 构建工具。

非模块化应用

IDE

按照这些步骤创建一个 JavaFX 非模块化项目，并使用 IDE 工具来构建和运行它。或者，你也可以从这里下载一个类似的项目。

为你的操作系统下载相应的 JavaFX SDK，并将其解压到所需位置，例如 /Users/your-user/Downloads/javafx-sdk-15。

1. 创建 JavaFX project

为项目提供一个名称，如 HelloFX，和一个位置。当项目打开时，JavaFX 类是无法识别的。

2. Set JDK 15

进入 File -> Project Structure -> Project，并将项目的 SDK 设置为 15。你也可以把语言级别设置为 11 或更高。

3. Create a library

进入 File -> Project Structure -> Libraries，将 JavaFX 15 SDK 作为一个库添加到项目中。指向 JavaFX SDK 的 lib 文件夹。

一旦库被应用，JavaFX 类将被 IDE 识别。

警告:如果你现在运行该项目，它将被编译，但你会得到这个错误。

Caused by: java.lang.RuntimeException: Exception in Application start method
	at javafx.graphics/com.sun.javafx.application.LauncherImpl.launchApplication1(LauncherImpl.java:900)
...
Caused by: java.lang.IllegalAccessError: class com.sun.javafx.fxml.FXMLLoaderHelper (in unnamed module @0xXXXXX) cannot access class com.sun.javafx.util.Utils (in module javafx.graphics) because module javafx.graphics does not export com.sun.javafx.util to unnamed module @0xXXXXX
...

发生这个错误是因为 IntelliJ 只把 javafx.base 和 javafx.graphics 模块添加到模块路径中，但对于这个例子来说，还需要添加 javafx.controls 和 javafx.fxml 模块。

4. 添加 VM 选项

要解决这个问题，请点击 "Run -> Edit Configurations... "并添加这些虚拟机选项。

windows

--module-path "\path\to\javafx-sdk-15.0.1\lib" --add-modules javafx.controls,javafx.fxml

linux/mac

--module-path /path/to/javafx-sdk-15.0.1/lib --add-modules javafx.controls,javafx.fxml

注意: IntelliJ 创建的默认项目使用 FXML，所以 javafx.fxml 和 javafx.controls 是必需的。如果你的项目使用其他模块，你也需要添加它们。

点击应用并关闭对话框。

另外，你也可以定义一个全局变量，可以在未来的项目中使用。进入 Preferences (File -> Settings) -> Appearance & Behavior -> Path Variables，将变量的名称定义为 PATH_TO_FX，并浏览到 JavaFX SDK 的 lib 文件夹来设置其值，然后点击应用。

然后你可以在设置虚拟机选项时参考这个全局变量，如：

--module-path ${PATH_TO_FX} --add-modules javafx.controls,javafx.fxml

5. 运行项目

点击 Run -> Run... 来运行该项目，现在它应该可以正常工作了。

Maven

按照这些步骤创建一个 JavaFX 非模块化项目，并使用 Maven 工具来构建和运行它。另外，你也可以从这里下载一个类似的项目。

1. 创建一个 Maven 项目

选择 File -> New -> Project -> Maven 然后 选中 Create from archetype. 如果 JavaFX archetype 尚未安装，请选择 add archetype...并设置 groupId（org.openjfx）、artifactId（javafx-maven-archetypes）和版本（0.0.5），然后按下确定。

安装之后，选择这个 artifact,按 Next，并提供项目的名称，如 HelloFX 和项目的位置。也可以选择提供 groupId，比如 org.openjfx 和 artifactId，比如 hellofx

根据项目中是否使用 FXML，在 javafx-archetype-fxml 或 javafx-archetype-simple 之间选择 artifactId 的原型。

你也可以为 javafx-version 创建一个属性，并将其设置为 15.0.1。

2. 验证项目

你可以在这里找到生成的 pom 文件。

确认它包括 javafx.controls 和 javafx.fxml 依赖项，并包括 javafx-maven-plugin

打开 module-info 类，它包括了所需的模块 javafx.controls 和 javafx.fxml。由于 FXML 使用反射来访问模块中的控制器，它已经被打开到 javafx.fxml。

3. 运行项目

你可以打开 Maven 项目窗口，点击 HelloFX -> Plugins -> compiler -> compiler:compile 来编译项目，点击 HelloFX -> Plugins -> javafx -> javafx:run 来执行该项目。

注意：如果 JAVA_HOME 没有设置为 11 或更高，从 Maven 项目窗口运行可能会失败。为避免这种情况，您可以给 Maven Runner 添加一个环境变量。

或向 javafx-maven-plugin 设置正确的 java 命令。

<configuration>
	<executable>/path/to/jdk-15/bin/java</executable>
</configuration>

该项目也可以从终端运行。确保 JAVA_HOME 被设置为 15，然后运行 mvn clean javafx:run

4. 创建一个自定义 Runtime image

要创建一个自定义的运行时，使用 JavaFX Maven plugin，你可以点击 HelloFX -> Plugins -> javafx -> javafx:jlink，或者从终端将 JAVA_HOME 设置为 15 就可以运行。

mvn clean javafx:jlink

注意该插件允许像 jlink 命令一样的常规选项，以及创建一个启动器或带有自定义 image 的压缩包。

而在 image 建立后，你可以从命令行中运行它。

windows

target\hellofx\bin\launcher

linux/mac

target/hellofx/bin/launcher

Gradle

按照这些步骤来创建一个 JavaFX 模块化项目，并使用 Gradle 工具来构建和运行它。或者，你也可以从这里下载一个类似的项目。

1. 创建一个 Gradle 项目

用 Java 创建一个 Gradle 项目。为项目提供一个名字，比如 HelloFX 和项目的位置。可以选择提供 groupId，如 org.openjfx，artifactId，如 hellofx。当项目打开时，添加一个包 org.openjfx 和一个空的 MainApp 类。

2. 修改构建

编辑 build.gradle 文件，用这个 build 文件替换它，相应地将 mainClassName 设置为 org.openjfx.MainApp。

注意 org.openjfx.javafxplugin 插件的使用，它消除了添加 JavaFX 依赖项和为它们的编译和运行任务设置模块路径的必要性。

3. 添加模块信息类

添加 module-info 类，包括需要的模块 javafx.controls 和 javafx.fxml。因为 FXML 使用反射来访问模块中的控制器，所以必须将其开放给 javafx.fxml。最后，导出包 org.openjfx.com。

4. 添加源代码

Based on this MainApp class, add its content to the project main class. Then add the controller and the FXML and and the css files.

基于这个 MainApp 类，将其内容添加到项目主类中。然后添加 controller 和 FXML 和和 css 文件。

5.运行这个项目

你可以打开 Gradle 窗口，点击 hellofx->Tasks->build->build 来构建项目，点击 hellofx->Tasks->application->run 来执行该项目。你也可以打开终端并运行。

windows

gradlew run

linux/mac

./gradlew run

6. 创建一个自定义的 runtime image

要创建一个 runtime image，你可以使用 org.beryx.jlink 插件。它可以很容易地与 JavaFX Gradle 插件相结合：

plugins {
  id 'application'
  id 'org.openjfx.javafxplugin' version '0.0.9'
  id 'org.beryx.jlink' version '2.23.1'
}

javafx {
    version = "15.0.1"
    modules = [ 'javafx.controls', 'javafx.fxml' ]
}

jlink {
    launcher {
        name = 'hellofx'
    }
}

来生成自定义的 image。运行 hellofx -> Tasks -> build -> jlink 任务来创建 image

要运行该 image，请在终端上输入

windows

build\image\bin\hellofx

linux/mac

build/image/bin/hellofx

JavaFX 和 NetBeans

改日再更

JavaFX 和 Eclipse

改日再更

接下来的步骤

恭喜你成功创建并运行了你的第一个 JavaFX 应用程序。

如果您想为 JavaFX 做出贡献，请访问我们的 Github 资源库。

请通过我们的电子邮件支持与我们联系。我们很乐意听到您的意见!