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扩展的启动器类。

这个问题的原因

缺少 JavaFX 运行时组件, 需要使用该组件来运行此应用程序

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资源库。

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