java javafx javafx-11 openjfx

Cómo implementar una aplicación de escritorio JavaFX 11 con un JRE



javafx-11 openjfx (3)

Tengo una aplicación empresarial de escritorio JavaFX (JDK 8), que utiliza Java Web Start para la implementación. Los usuarios tienen Java 8 instalado, y simplemente van a la URL (una URL pública en mi servidor AWS Linux) y la aplicación se descarga / inicia (usando Web Start). También puedo actualizar fácilmente la aplicación al implementar nuevos archivos JAR en el servidor. Todo funciona bien

Sin embargo, Oracle ha descontinuado Web Start con Java 11, y en su documento técnico "Actualización de Java Client Roadmap", marzo de 2018, recomiendan agrupar un JRE con la aplicación ("La noción de una aplicación que se distribuye por separado de un JRE independiente es, por lo tanto, se desvanece rápidamente ". No puedo confiar en que mis usuarios permanezcan en Java 8 para Web Start, e incluso si permanecen en 8, Oracle requiere una licencia para continuar usando Java 8 (que no tengo, puede ser muy costoso y prefiero De todos modos para moverse con la comunidad hacia JavaFX 11 y OpenJDK).

Me gustaría migrar a JavaFX 11. He seguido los "Primeros pasos con JavaFX11" de OpenJFX ( https://openjfx.io/openjfx-docs/ ), utilizando OpenJDK 11.0.1 con JavaFX SDK 11.0.1 de Gluon (en Netbeans 10vc2 ), y he podido ejecutar las aplicaciones de muestra (y me parece que debería poder portar mi código JavaFX 8 a JavaFX 11, muy fácilmente).

Sin embargo, aquí es donde estoy atascado para la dirección. ¿Cómo puedo empaquetar esto con el JRE e implementarlo en mis usuarios finales (y proporcionar actualizaciones de la aplicación)? ¿Hay un camino fácil para salir (o incluso un camino difícil, con algunas direcciones / guías)?

Puedo pasar cientos de horas escribiendo aplicaciones empresariales de escritorio expresivas, ricas y útiles en JavaFX 11, pero ¿qué hago entonces?

¿Los kits de herramientas de implementación, como JWrapper, InstallAnywhere, etc., son adecuados para esta nueva era de Java 11? ¿Gluon / openjfx.io quizás tenga alguna recomendación o guía que no pude ver? Parece que no puedo encontrar recomendaciones o guías de fuentes confiables, en la forma en que los desarrolladores, que se centran en escribir el código de front-end, implementamos las aplicaciones.

Gracias por cualquier ayuda u orientación.

La forma en que funciona ahora es que usted convierte su programa en un módulo, luego lo "vincula" a todos los demás módulos que requiere.

El resultado de este proceso de vinculación es lo que se conoce como una imagen. Una imagen es en realidad un árbol de archivos, que incluye un directorio bin con uno o más ejecutables listos para ejecutar. Este árbol es lo que distribuyes, normalmente como zip o tar.gz.

Los pasos son:

  1. Crear un módulo-info.java
  2. Compilar con una ruta de módulo en lugar de una ruta de clase
  3. Crea un tarro de clases, como de costumbre.
  4. Convierta jar a jmod con la herramienta jmod de JDK
  5. Enlace ese jmod y los módulos de los que depende, en una imagen

Escribir un descriptor de módulo

El primer paso es convertir la aplicación en un módulo. Como mínimo, esto requiere crear un module-info.java en la parte superior del árbol de origen (es decir, en el paquete vacío). Cada módulo tiene un nombre, que a menudo es el mismo que el nombre de un paquete pero no tiene que serlo. Entonces, tu module-info.java puede verse así:

module com.mcs75.businessapp { exports com.mcs75.desktop.businessapp; requires java.logging; requires transitive javafx.graphics; requires transitive javafx.controls; }

edificio

Cuando construyes, no especificas un classpath en absoluto. En su lugar, especifica una ruta de módulo.

Una ruta de módulo es una lista de directorios, no archivos. Cada directorio contiene, como es lógico, módulos. El directorio jmods del JDK está incluido implícitamente. Todo lo que necesita incluir es directorios que contengan los módulos que no sean JDK que necesita. En su caso, al menos eso significa JavaFX de Gluon:

javac -Xlint -g -d build/classes --module-path /opt/gluon-javafx/lib / src/java/com/mcs75/desktop/businessapp/*.java

Luego creas un tarro de la forma habitual:

jar -c -f build/mybusinessapp.jar -C build/classes .

Un archivo jar con un módulo-info.class en él se considera un jar modular.

Haciendo un jmod

Crear un jmod suele ser un proceso simple:

mkdir build/modules jmod create --class-path build/mybusinessapp.jar / --main-class com.mcs75.desktop.businessapp.BuinessApplication / build/modules/mybusinessapp.jmod

Enlace

Finalmente, utiliza el comando jlink del JDK para ensamblar todo:

jlink --output build/image / --module-path build/modules:/opt/gluon-javafx/lib / --add-modules com.mcs75.businessapp / --launcher MyBusinessApp=com.mcs75.businessapp

jlink crea un JRE mínimo, que contiene solo los módulos que agregas explícitamente (y los módulos que esos módulos explícitos requieren). --add-modules es la opción requerida que especifica qué agregar.

Al igual que con otras herramientas JDK, --module-path especifica directorios que contienen módulos.

La opción --launcher hace que el árbol de imágenes final tenga un script ejecutable adicional en su directorio bin con el nombre dado (la parte antes de los iguales). Entonces, MyBusinessApp=com.mcs75.businessapp significa "crear un ejecutable llamado MyBusinessApp, que ejecuta el módulo com.mcs75.businessapp".

Debido a que el comando jmod create incluye una opción --main-class , Java sabrá qué ejecutar, al igual que declarar un atributo Main-Class en un manifiesto. También es posible declarar explícitamente una clase para que se ejecute en la opción --launcher si se desea.

Distribuido

Lo que querrá distribuir es un zip o tar.gz de todo el árbol de archivos de imagen. El ejecutable que el usuario debe ejecutar está en el directorio bin la imagen. Por supuesto, eres libre de agregar tus propios ejecutables. También es libre de colocar esto en cualquier tipo de instalador, siempre y cuando se conserve la estructura del árbol de imágenes.

Un futuro JDK tendrá una herramienta de empaquetado para crear instaladores nativos completos.

Construcción cruzada

Dado que la imagen incluye binarios nativos, deberá crear una imagen para cada plataforma. Obviamente, una opción es construir la imagen en un sistema Linux, y nuevamente en un sistema Windows, y nuevamente en una Mac, etc.

Pero también puedes usar jmod y jlink para crear imágenes para otras plataformas, independientemente de donde estés construyendo.

Sólo se necesitan unos pocos pasos adicionales. Primero, necesitarás los JDK para esas otras plataformas. Descárguelos como archivos comprimidos (zip o tar.gz), no como instaladores, y descomprímalos en los directorios de su elección.

Cada JDK define una cadena de plataforma . Esto es normalmente de la forma <os> - <arch>. La plataforma es una propiedad del módulo java.base ; Puedes ver la plataforma de cualquier JDK examinando ese módulo:

jmod describe path-to-foreign-jdk/jmods/java.base.jmod | grep ''^platform''

Pase la cadena de la plataforma a su comando jmod usando la opción --target-platform :

mkdir build/modules jmod create --target-platform windows-amd64 / --class-path build/mybusinessapp.jar / --main-class com.mcs75.desktop.businessapp.BuinessApplication / build/modules/mybusinessapp.jmod

Finalmente, al vincular, desea incluir explícitamente el directorio jmods del otro JDK, por lo que jlink no incluirá implícitamente sus propios módulos de JDK:

jlink --output build/image / --module-path path-to-foreign-jdk/jmods:build/modules:/opt/gluon-javafx/lib / --add-modules com.mcs75.businessapp / --launcher MyBusinessApp=com.mcs75.businessapp