如何加快 JavaFX 应用程序的 Maven 构建？答案

【问题标题】：How can I speed up maven builds of JavaFX application?如何加快 JavaFX 应用程序的 Maven 构建？
【发布时间】：2014-09-27 22:27:40
【问题描述】：

我的问题可以通过在 Netbeans 8 中创建一个新项目来重现：

新项目 >> Maven >> JavaFX 应用程序

然后添加 org.springframework spring-context 依赖。

构建时间从几秒钟增加到半分钟以上，其中大部分是由于运行 javafxpackager。

我可以忍受缓慢的发布版本，但如何加快我的开发版本？

这是我的 pom.xml：

<?xml version="1.0" encoding="UTF-8"?>
<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/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>

<groupId>com.mycompany</groupId>
<artifactId>mavenproject1</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>jar</packaging>

<name>mavenproject1</name>

<properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <mainClass>com.mycompany.mavenproject1.MainApp</mainClass>
</properties>

<organization>
    <!-- Used as the 'Vendor' for JNLP generation -->
    <name>Your Organisation</name>
</organization>

<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-dependency-plugin</artifactId>
            <version>2.6</version>
            <executions>
                <execution>
                    <id>unpack-dependencies</id>
                    <phase>package</phase>
                    <goals>
                        <goal>unpack-dependencies</goal>
                    </goals>
                    <configuration>
                        <excludeScope>system</excludeScope>
                        <excludeGroupIds>junit,org.mockito,org.hamcrest</excludeGroupIds>
                        <outputDirectory>${project.build.directory}/classes</outputDirectory>
                    </configuration>
                </execution>
            </executions>
        </plugin>
        <plugin>
            <groupId>org.codehaus.mojo</groupId>
            <artifactId>exec-maven-plugin</artifactId>
            <version>1.2.1</version>
            <executions>
                <execution>
                    <id>unpack-dependencies</id>

                    <phase>package</phase>
                    <goals>
                        <goal>exec</goal>
                    </goals>
                    <configuration>
                        <executable>${java.home}/../bin/javafxpackager</executable>
                        <arguments>
                            <argument>-createjar</argument>
                            <argument>-nocss2bin</argument>
                            <argument>-appclass</argument>
                            <argument>${mainClass}</argument>
                            <argument>-srcdir</argument>
                            <argument>${project.build.directory}/classes</argument>
                            <argument>-outdir</argument>
                            <argument>${project.build.directory}</argument>
                            <argument>-outfile</argument>
                            <argument>${project.build.finalName}.jar</argument>
                        </arguments>
                    </configuration>
                </execution>
                <execution>
                    <id>default-cli</id>
                    <goals>
                        <goal>exec</goal>                            
                    </goals>
                    <configuration>
                        <executable>${java.home}/bin/java</executable>
                        <commandlineArgs>${runfx.args}</commandlineArgs>
                    </configuration>
                </execution>
            </executions>  
        </plugin>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <version>3.1</version>
            <configuration>
                <source>1.7</source>
                <target>1.7</target>
                <compilerArguments>
                    <bootclasspath>${sun.boot.class.path}${path.separator}${java.home}/lib/jfxrt.jar</bootclasspath>
                </compilerArguments>
            </configuration>
        </plugin>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-surefire-plugin</artifactId>
            <version>2.16</version>
            <configuration>
                <additionalClasspathElements>
                    <additionalClasspathElement>${java.home}/lib/jfxrt.jar</additionalClasspathElement>
                </additionalClasspathElements>
            </configuration>
        </plugin>
    </plugins>
</build>
<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>4.0.6.RELEASE</version>
    </dependency>
</dependencies>

谢谢！丹尼尔

【问题讨论】：

标签： java spring maven netbeans javafx

【解决方案1】：

您还可以使用并行 maven 构建功能来加快速度。

默认情况下，Maven 不会利用硬件的全部功能。它按顺序而不是并行构建所有模块。但是，您的项目设置通常不需要它是连续的。通常，您可以命令 Maven 分析您的项目，包括依赖关系图，并在可能的情况下并行构建项目。您可以指定用于构建项目的确切线程数，也可以使用参数的可移植版本并根据机器上可用的 CPU 指定线程数。

mvn -T 4 install -- will use 4 threads
mvn -T 1C install -- will use 1 thread per available CPU core

查看详情：https://zeroturnaround.com/rebellabs/your-maven-build-is-slow-speed-it-up/

【讨论】：

【解决方案2】：

TL;DR：

为了避免解包依赖，你根本不需要修改默认的 pom.xml。只需更改按运行（或调试）时 Netbeans 调用的内容。在 nbactions.xml 中更改：

runfx.args：将-jar "${project.build.directory}/${project.build.finalName}.jar" 替换为-cp %classpath ${mainClass}。这样，exec 目标将不会尝试执行任何 jar，而是从 target/classes 目录运行您的项目。所以根本不需要构建 jar。
goals：将“package”目标替换为“process-classes”（或“test”或您想要的任何阶段）。我们不需要 jar，所以不需要运行 package 阶段。没有包装阶段也意味着没有拆包/重新包装等。

如果您需要包含所有依赖项的 jar 文件，只需在 Netbeans 中选择“清理并构建”或运行 mvn clean install。

背景：

在标准 Netbeans JavaFX maven 项目中按下运行时会发生什么：

clean package exec - 在 nbactions.xml 中定义，在 pom.xml 中配置：
- clean：像往常一样 - 删除目标目录
- 包：
  - 首先像往常一样 - 复制资源并将源编译到目标/类，然后将所有内容打包到一个 jar 中，而无需依赖
  - maven-dependency-plugin 将所有依赖 jar 文件解压到目标/类
  - exec-maven-plugin:unpack-dependencies（id "unpack-dependencies" 具有误导性，应该类似于 "jar-with-dependencies"）执行 javapackager，它构建一个 jar 并覆盖第一个 jar 的依赖项
- 执行：
  - 使用 ${runfx.args} 作为参数（在 nbactions.xml 中定义）执行 java，即运行 jar

上述更改后会发生什么：

clean process-classes exec - 在 nbactions.xml 中定义，在 pom.xml 中配置：
- clean：像往常一样 - 删除目标目录
- 进程类：
  - 像往常一样 - 复制资源并将源编译到目标/类
- 执行：
  - 使用 ${runfx.args} 作为参数（在 nbactions.xml 中定义）执行 java，即运行类 target/classes/path/to/your/MainClass

更好：

您可能希望从 nbactions.xml 中删除“干净”目标。这样，所有资源文件就不会每次都被一遍又一遍地复制（尽管资源插件仍然会一直说“复制 X 资源” - 请参阅https://stackoverflow.com/a/33700970/3519572 下的 cmets）。

现在，您可能还希望通过添加 useIncrementalCompilation=false（例如 <goal>org.codehaus.mojo:exec-maven-plugin:1.2.1:exec -Dmaven.compiler.useIncrementalCompilation=false</goal>）只重新编译更改的类而不是整个项目。但请务必阅读https://stackoverflow.com/a/49700942/3519572！

因此，您可能还希望向“干净”目标添加一个工具栏按钮，以便能够随时轻松地手动运行它：https://stackoverflow.com/a/26546551/3519572。

顺便说一句：

最后，您可能还想更改 NetBeans 生成的 pom.xml。至少我的 NB 8.2 指的是已弃用的 javafxpackager（重命名为 javapackager）。此外，<bootclasspath>..../lib/jfxrt.jar</bootclasspath> 部分似乎对于 java 8 不是必需的。如果我从终端运行它，它实际上会破坏我的构建。删除它似乎可以修复它，如果从 NB 开始似乎不会造成任何问题。

【讨论】：

【解决方案3】：

上述解决方案不起作用。该问题与 javafxpackager 无关。原因在于maven标准配置。默认情况下，在每个项目运行时，Maven 都会执行项目清理。这将删除目标/类/文件夹。那是放置依赖项的所有解压缩 jar 文件的同一个文件夹。如果这些在每次新运行时都被删除，那么它们必须一遍又一遍地解包。无论如何，这是防止清理发生的方法：

    <plugin>
  <artifactId>maven-clean-plugin</artifactId>
  <version>2.4.1</version>
  <configuration>
    <skip>true</skip>
  </configuration>
</plugin>

将此添加到您的 POM.xml。确保您获得正确的版本您可以在有效的 pom 中检查您的 maven clean 插件的版本（即父 pom + 项目 POM 的组合）。在 netbeans 中，打开项目的 pom.xml 文件后，您可以在有效选项卡下查看只读有效的 pom.xml。

请给我几个 +1 我想得到 50 分，以便我最终可以评论其他人的答案。谢谢！

编辑：

还可以在 default-cli 中添加跳过以避免错误

                <execution>
                    <id>default-cli</id>
                    <goals>
                        <goal>exec</goal>                            
                    </goals>
                    <configuration>
                                <skip>true</skip>
                        <executable>${java.home}/bin/java</executable>
                        <commandlineArgs>${runfx.args}</commandlineArgs>
                    </configuration>
                </execution>

编辑 2：

对于那些希望保留清理功能的人，这里有另一种方法来防止 maven 插件删除所有 jar 文件：

<plugin>
<artifactId>maven-clean-plugin</artifactId>
     <version>2.4.1</version>
<configuration>
    <excludeDefaultDirectories>true</excludeDefaultDirectories>
    <filesets>
        <!-- delete directories that will be generated when you 
             start the develpment server/client in eclipse  
        -->
        <fileset>
            <directory>target/classes</directory>
            <excludes>
                <exclude>**/*</exclude>
            </excludes>
        </fileset>
    </filesets>
</configuration>

再次确认是正确的

【讨论】：

【解决方案4】：

您可以在默认情况下处于非活动状态的配置文件中定义插件。然后，为了进行生产构建，您必须手动指定该配置文件的激活（或activate 以任何其他标准方式）。

你的 pom 会是这样的（只显示差异）：

<?xml version="1.0" encoding="UTF-8"?>
<project ...>
    ...
    <build>
        <plugins>
            <plugin>
                <groupId>org.codehaus.mojo</groupId>
                <artifactId>exec-maven-plugin</artifactId>
                ...
                <executions>
                    <!-- take this out of here
                    <execution>
                        <id>unpack-dependencies</id>
                        ...
                    </execution>
                    -->
                    <execution>
                        ...
                    </execution>
                </executions>
            </plugin>
            ...
        </plugins>
    </build>
    <profiles>
        <profile>
            <id>javafxpackager</id>
            <build>
                <plugins>
                    <!-- INSERT THE exec-maven-plugin HERE, ONLY
                         WITH THE unpack-dependencies EXECUTION -->
                </plugins>
            </build>
        </profile>
    </profiles>
</project>

生产中运行mvn ... -Pjavafxpackager

【讨论】：

感谢 Nikos，这成功了。使用 maven-assembly-plugin 我能够为正常构建生成一个可执行的 jar 文件。

【解决方案5】：

为了完成 Nikos 的回答，这是 maven-assembly-plugin 的配置，它为正常构建创建存档。

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-assembly-plugin</artifactId>
    <configuration>
        <appendAssemblyId>false</appendAssemblyId>
        <archive>
            <manifest>
                <mainClass>${mainClass}</mainClass>
            </manifest>
        </archive>
        <descriptorRefs>
            <descriptorRef>jar-with-dependencies</descriptorRef>
        </descriptorRefs>
    </configuration> 
    <executions>
        <execution>
            <id>my-assembly</id>
            <phase>package</phase>
            <goals>
                <goal>assembly</goal>
            </goals>
        </execution>
    </executions>
</plugin>

【讨论】：