Este guia detalha o processo de empacotamento de aplicações JavaFX para distribuição em múltiplos sistemas operacionais (Windows, macOS, Linux) utilizando a ferramenta packr. O objetivo é criar executáveis independentes, mais amigáveis para o usuário final do que a execução via java -jar.

Para cenários mais simplificados, especialmente no ambiente IntelliJ IDEA, considere a utilização de ferramentas mais diretas para a criação de executáveis para Windows. Este tutorial foca em uma abordagem mais robusta e multiplataforma.

Configuração do Ambiente e Projeto Demo

Este exemplo utiliza JDK 17 e JavaFX 17. É recomendado para usuários com um conhecimento prévio de Java.

1. Criação do Projeto JavaFX

Utilizaremos um projeto Maven padrão. Adicione as seguintes dependências ao seu pom.xml:

<properties>
   <maven.compiler.source>17</maven.compiler.source>
   <maven.compiler.target>17</maven.compiler.target>
   <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>

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

Crie o arquivo FXML src/main/resources/fxml/demo.fxml:

<?xml version="1.0" encoding="UTF-8"?>

<?import javafx.scene.control.Button?>
<?import javafx.scene.control.Label?>
<?import javafx.scene.control.TextField?>
<?import javafx.scene.layout.AnchorPane?>

<AnchorPane maxHeight="-Infinity" maxWidth="-Infinity" minHeight="-Infinity" minWidth="-Infinity" prefHeight="209.0"
           prefWidth="250.0" xmlns="http://javafx.com/javafx/16" xmlns:fx="http://javafx.com/fxml/1"
           fx:controller="com.example.demo.controller.FXMLController">
   <children>
       <Button fx:id="actionButton" layoutX="46.0" layoutY="51.0" mnemonicParsing="false" text="Obter Data/Hora Atual"/>
       <TextField fx:id="dateTimeField" layoutX="46.0" layoutY="86.0"/>
       <Label fx:id="statusLabel" layoutX="46.0" layoutY="129.0" text="Status"/>
   </children>
</AnchorPane>
   

Implemente o Controller src/main/java/com/example/demo/controller/FXMLController.java:

package com.example.demo.controller;

import javafx.event.ActionEvent;
import javafx.fxml.FXML;
import javafx.fxml.Initializable;
import javafx.scene.control.Button;
import javafx.scene.control.Label;
import javafx.scene.control.TextField;

import java.net.URL;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.ResourceBundle;

public class FXMLController implements Initializable {
   @FXML
   private Button actionButton;
   @FXML
   private TextField dateTimeField;
   @FXML
   public Label statusLabel;

   @Override
   public void initialize(URL url, ResourceBundle resourceBundle) {
       actionButton.setOnAction(event -> {
           SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
           String currentDateTime = formatter.format(new Date());
           dateTimeField.setText(currentDateTime);
           statusLabel.setText(currentDateTime);
       });
   }
}
   

Crie a classe de entrada principal src/main/java/com/example/demo/MainApp.java:

package com.example.demo;

import javafx.application.Application;
import javafx.fxml.FXMLLoader;
import javafx.scene.Scene;
import javafx.scene.layout.AnchorPane;
import javafx.stage.Stage;

import java.net.URL;

public class MainApp extends Application {
   @Override
   public void start(Stage primaryStage) throws Exception {
       URL fxmlResource = getClass().getResource("/fxml/demo.fxml");
       if (fxmlResource == null) {
           throw new RuntimeException("Recurso FXML não encontrado");
       }
       AnchorPane root = FXMLLoader.load(fxmlResource);
       primaryStage.setScene(new Scene(root));
       primaryStage.setTitle("JavaFX Demo");
       primaryStage.show();
   }

   public static void main(String[] args) {
       launch(args);
   }
}
   

Configuração do OpenJFX

JavaFX foi separado do JDK a partir do Java 11. Baixe o SDK do OpenJFX correspondente à sua plataforma (ex: 17.0.1 para Windows) em https://openjfx.cn/dl/. Descompacte o SDK em um local acessível, por exemplo, C:\Program Files\Java\javafx-sdk-17.0.1.

Para executar a aplicação no IntelliJ IDEA, configure os parâmetros de VM na configuração de execução:

--module-path "C:\Program Files\Java\javafx-sdk-17.0.1\lib" --add-modules javafx.controls,javafx.fxml
   

Empacotamento em JAR com DLLs

O empacotamento de aplicações JavaFX em um JAR requer a inclusão das bibliotecas nativas (DLLs no Windows).

Crie uma classe de entrada simples que chama a classe principal do JavaFX:

package com.example.demo;

public class AppLauncher {
   public static void main(String[] args) {
       MainApp.main(args);
   }
}
   

No IntelliJ IDEA, configure a estrutura do projeto (File > Project Structure > Libraries):

1. Remova as dependências do Maven para JavaFX.
2. Adicione as bibliotecas do OpenJFX (as DLLs e JARs do diretório lib do SDK descompactado).

Configure o artefato JAR (File > Project Structure > Artifacts):

1. Crie um novo JAR a partir dos módulos.
2. Selecione a classe de entrada AppLauncher.
3. Certifique-se de que todas as dependências necessárias, incluindo as bibliotecas nativas do OpenJFX, estejam incluídas.

Compile o artefato para gerar o JAR executável.

Se estiver utilizando modularização com module-info.java, o conteúdo seria similar a:

module com.example.demo {
   requires javafx.controls;
   requires javafx.fxml;

   opens com.example.demo to javafx.fxml;
   exports com.example.demo;
}
   

Empacotamento com Packr

Packr é uma ferramenta versátil para empcaotar aplicações Java em executáveis nativos para Windows, macOS e Linux.

1. Download e Configuração

• Baixe o packr: https://github.com/libgdx/packr (ex: packr-all-4.0.0.jar).
• Baixe um JRE (Java Runtime Environment) compatível, como o OpenJDK 17 para Windows 64 bits.

Organize os arquivos: coloque o packr-all-4.0.0.jar, o JAR da sua aplicação e o JRE baixado em um diretório comum.

2. Criação do Arquivo de Configuração (JSON)

Crie um arquivo de configuração, por exemplo, packr-config.json:

{
   "platform": "windows64",
   "jdk": "./openjdk-17-jre-win64",
   "executable": "MinhaAppJavaFX",
   "classpath": [
       "sua-aplicacao.jar"
   ],
   "mainclass": "com.example.demo.AppLauncher",
   "vmargs": [
      "Xms32m",
      "Xmx512m",
      "-Dfile.encoding=utf-8"
   ],
   "minimizejre": "soft",
   "output": "build/windows64"
}
   

• platform: Sistema operacional alvo (windows64, linux64, mac).
• jdk: Caminho para o diretório do JRE.
• executable: Nome do executável final.
• classpath: Lista de JARs da sua aplicação.
• mainclass: Classe de entrada.
• vmargs: Argumentos da JVM. -Dfile.encoding=utf-8 é útil para evitar problemas com caracteres.
• minimizejre: Estratégia para incluir o JRE (soft tenta remover classes não utilizadas).
• output: Diretório de saída.

3. Execução do Packr

Abra o terminal no diretório onde estão o packr.jar, o JAR da aplicação e o JRE. Execute o comando:

java -jar packr-all-4.0.0.jar packr-config.json
   

Aguarde a conclusão do processo. O executável será gerado no diretório de saída especificado.

4. Solução de Problemas

• Recuross não encontrados: Se o executável não encontrar recursos (como FXML), pode ser necessário ajustar o classpath no JSON ou carregar os recursos de um diretório externo à aplicação empacotada.
• Tamanho do arquivo: A inclusão de um JRE completo pode resultar em executáveis grandes. O parâmetro minimizejre ajuda a reduzir o tamanho, mas a eficácia pode variar. Utilizar versões mais antigas do Java (como Java 11) pode gerar pacotes menores.
• Erros de execução: Execute o arquivo .exe diretamente do terminal (cmd) para visualizar mensagens de erro detalhadas da JVM.