blocks|key|1007186|text|您可以使用Maven依赖插件构建类路径，然后重用它：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1007187|$+mvn+dependency:build-classpath+-Dmdep.outputFile=cp.txt
$+export+CLASSPATH=target/classes:`cat+cp.txt`
...
$+mvn+compile+&&+java+-cp+$CLASSPATH+example.Main|code-block|syntax|javascript|1007188|entityMap|0|LINK|mutability|MUTABLE|url|http://maven.apache.org/plugins/maven-dependency-plugin/build-classpath-mojo.html^0|5|9|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

You can build a classpath with <a href="http://maven.apache.org/plugins/maven-dependency-plugin/build-classpath-mojo.html" rel="nofollow">Maven Dependency Plugin</a>, and then reuse it:

<pre><code>$ mvn dependency:build-classpath -Dmdep.outputFile=cp.txt
$ export CLASSPATH=target/classes:`cat cp.txt`
...
$ mvn compile &amp;&amp; java -cp $CLASSPATH example.Main
</code></pre>

blocks|key|2563293|text|你可以试试Maven壳牌。脱口贴上写着：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|2563294|"Maven+Shell是Maven的一个CLI接口，它支持更快的周转，以及与存储库和项目的更智能交互。使用Maven+Shell，您将能够加快构建速度，因为项目信息和Maven插件被加载到单个随时准备好的JVM实例中，后者可以执行Maven构建。“|blockquote|2563295|entityMap|0|LINK|mutability|MUTABLE|url|http://shell.sonatype.org/^0|5|7|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@$A|P|B|Q|1|R]]|C|$]]|$1|D|3|E|5|F|7|S|8|@]|9|@]|C|$]]|$1|G|3|-4|5|6|7|T|8|@]|9|@]|C|$]]]|H|$I|$5|J|K|L|C|$M|N]]]]

You could try the <a href="http://shell.sonatype.org/" rel="nofollow">Maven Shell</a>. The blurb says this:

<blockquote>
 "Maven Shell is a CLI interface for Maven that enabled faster turn-around, and a more intellifent interaction with repositories and projects. Using Maven Shell, you will be able to speed up your builds because project information and Maven plugins are loaded into a single, always-ready JVM instance which can execute a Maven build."
</blockquote>

blocks|key|2563183|text|减少使用mvn命令行的频率，而是使用Eclipse这样的IDE快速测试增量更改。|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|2563184|Eclipse是增量构建的--它只构建更改，因此速度要快得多。|2563185|entityMap^0|I|M|0|0|V|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|H|3|-4|5|6|7|P|8|@]|D|@]|E|$]]]|I|$]]

Use mvn command-line less frequently, and instead use an IDE like Eclipse for quickly testing out incremental changes.

Eclipse builds incrementally i.e. it builds only changes, so is much faster.

blocks|key|2563210|text|通过传递选项：-Dmaven.test.skip=true，您可以跳过测试。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2563211|为什么要假设启动一个新JVM比在Maven的JVM中运行程序要快呢？更有可能正好相反。|2563212|编辑:加快开发周期的另一种简单方法:使用--offline选项，除非您正在更改依赖项。|2563213|entityMap^0|7|M|0|0|K|9|0^^$0|@$1|2|3|4|5|6|7|L|8|@$9|M|A|N|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|O|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|P|8|@$9|Q|A|R|B|C]]|D|@]|E|$]]|$1|J|3|-4|5|6|7|S|8|@]|D|@]|E|$]]]|K|$]]

You can skip the tests by passing the option: <code>-Dmaven.test.skip=true</code>.

And why do you assume that starting a new JVM will be quicker than running the program within Maven's JVM? It's more likely to be just the opposite.

EDIT: another easy way to speed up the development cycle: use the <code>--offline</code> option, except when you're changing the dependencies.

blocks|key|2204346|text|上次创建命令行工具时，我使用依赖插件将所有依赖关系Jar复制到一个目录(例如，target/dist/lib)，在Manifest文件(Maven+Jar插件)中配置了类路径和主类。然后我就可以通过以下方式执行该应用程序：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2204347|java+-jar+myJar.jar|2204348|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

The last time I created a command line tool, I used the dependency plugin to copy all dependency jars to a directory (e.g. target/dist/lib), configured the classpath and main class in the Manifest file (Maven Jar Plugin). Then I could execute the app with:

java -jar myJar.jar

blocks|key|1007153|text|除了Eclipse之外，另一个选项是使用JRebel，这将有效地热交换您的代码，这样您就可以一直运行您的程序。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1007154|不幸的是，除非您的开放源码或使用Scala，否则JRebel是不免费的。|1007155|如果您使用Eclipse+(或IntelliJ)并在调试模式下运行您的程序，您也可以使用代码进行热交换，但是不能添加或删除方法。|1007156|如果您需要立即反馈，我发现这两种方法在Java环境中是最有效率的。|1007157|最后一种选择是配置使用Eclipse编译器的Maven，它比openjdk编译器更快(据说)。|1007158|entityMap|0|LINK|mutability|MUTABLE|url|http://www.zeroturnaround.com/jrebel/|1|2|http://maven.apache.org/plugins/maven-compiler-plugin/non-javac-compilers.html^0|K|6|0|0|O|6|1|0|0|0|9|I|2|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@$A|X|B|Y|1|Z]]|C|$]]|$1|D|3|E|5|6|7|10|8|@]|9|@$A|11|B|12|1|13]]|C|$]]|$1|F|3|G|5|6|7|14|8|@]|9|@]|C|$]]|$1|H|3|I|5|6|7|15|8|@]|9|@]|C|$]]|$1|J|3|K|5|6|7|16|8|@]|9|@$A|17|B|18|1|19]]|C|$]]|$1|L|3|-4|5|6|7|1A|8|@]|9|@]|C|$]]]|M|$N|$5|O|P|Q|C|$R|S]]|T|$5|O|P|Q|C|$R|S]]|U|$5|O|P|Q|C|$R|V]]]]

The other option besides Eclipse is to use <a href="http://www.zeroturnaround.com/jrebel/" rel="nofollow">JRebel</a> which will effectively hot swap your code so you can keep your program running all the time.

Unfortunately <a href="http://www.zeroturnaround.com/jrebel/" rel="nofollow">JRebel</a> is not free unless your opensource or using Scala.

If you use Eclipse (or IntelliJ) and run your program in Debug Mode you can also hot swap with your code but you can't add or delete methods.

I found these two methods to be the most productive in Java environment if you want immediate feedback.

One final option is to configure <a href="http://maven.apache.org/plugins/maven-compiler-plugin/non-javac-compilers.html" rel="nofollow">Maven to use the Eclipse compiler</a> which is faster (supposedly) than the openjdk compiler.

blocks|key|2563368|text|如果需要实现命令行工具，只需查看maven+appassembler+plugin，这在这种情况下非常有用。在与maven程序集的关系中，您可以创建一个.tar.gz/zip归档文件，可以解压缩并启动应用程序。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|2563369|entityMap|0|LINK|mutability|MUTABLE|url|http://mojo.codehaus.org/appassembler/appassembler-maven-plugin/^0|G|O|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

If you need to implement a command line tool just take a look to the <a href="http://mojo.codehaus.org/appassembler/appassembler-maven-plugin/" rel="nofollow">maven appassembler plugi</a>n which is very helpful in this kind of situations. In relationship with maven-assembly you can create a .tar.gz/zip archive which can be decompressed and the application can be started.

blocks|key|1007239|text|为所有的构建时间依赖项(注释、嵌入式tomcat、代码生成器等)创建一个模块。构建此模块一次并附加到编译器插件上，以便它们位于所有模块的构建路径上。|type|unordered-list-item|depth|inlineStyleRanges|entityRanges|data|1007240|创建一个小的共享配置，并在构建时在每个模块中解压缩它(检查样式配置、日志配置等)|1007241|将maven插件放到自己的个人配置文件中，可以根据需要及时地导入。例如检查风格，查找错误，JavaDoc，万无一失，故障安全，代码签名等。你的正常构建应该使用尽可能少的插件。这确实有助于故障排除，因为可以使用-P命令行选项单独启用任何插件。|1007242|避免在编译器插件上的叉配置，它可以使您的构建时间翻倍。如果您需要-parameters，那么只为需要它的类分叉一次。|1007243|编写测试，以便它们可以并行运行。任何测试都不应该超过一秒钟。|1007244|使用-T+1C选项并行构建|1007245|使用tomcat的嵌入式版本，而不是tomcat插件，启动tomcat进行集成测试。避免启动猫不止一次。|1007246|排除不需要在tomcat配置属性中扫描的任何jars。|1007247|将项目构造为平衡树，将相关组件分组到它们自己的父pom下。|1007248|最上面是BOM+POM模块、共享资源模块、共享构建路径模块。一旦你把所有的事情都组织起来，你就很少会建立这些东西。|unstyled|1007249|接下来是您的顶级应用程序pom，它包括以下父poms|1007250|没有依赖关系的-Common低级别模块。|1007251|-Gateway模块，包括http客户机库和接口模块。|1007252|-Biz服务模块|1007253|-Containers+-+tomcat，Spring，DropWizzard等。|1007254|-Packages+-圆柱形瓶，拉链|1007255|-Runtimes+-+Rpms，可执行jars|1007256|Poms依赖项应始终指向较高级别的poms，以避免循环依赖。|1007257|较慢的构建工件应该是最后的，这样您就可以工作而不必等待缓慢的打包。|1007258|您应该能够在大约5秒内构建任何组，在5秒内构建您的war，在10秒内用spring启动tomcat，最坏的情况是20秒的迭代。|1007259|maven编译器是快速和增量的，因此尽量避免生成强制重新编译的任何代码。|1007260|为您的测试创建一个小型DSL和解释器。我们看到这种方法的运行速度是junit的两倍。|1007261|我只是使用这些技术从5分到45秒完成了我们的大型完整的构建。这是一个很大的工程，但值得。这种方法与标准的maven发布插件一起工作，使故障排除变得更加容易。|1007262|祝好运。它永远都不够快|1007263|PS+PCIe+SSDs也是一个很大的帮助。|1007264|entityMap^0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1R|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|1S|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|1T|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|1U|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|1V|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|1W|8|@]|9|@]|A|$]]|$1|N|3|O|5|6|7|1X|8|@]|9|@]|A|$]]|$1|P|3|Q|5|6|7|1Y|8|@]|9|@]|A|$]]|$1|R|3|S|5|T|7|1Z|8|@]|9|@]|A|$]]|$1|U|3|V|5|T|7|20|8|@]|9|@]|A|$]]|$1|W|3|X|5|T|7|21|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|T|7|22|8|@]|9|@]|A|$]]|$1|10|3|11|5|T|7|23|8|@]|9|@]|A|$]]|$1|12|3|13|5|T|7|24|8|@]|9|@]|A|$]]|$1|14|3|15|5|T|7|25|8|@]|9|@]|A|$]]|$1|16|3|17|5|T|7|26|8|@]|9|@]|A|$]]|$1|18|3|19|5|T|7|27|8|@]|9|@]|A|$]]|$1|1A|3|1B|5|T|7|28|8|@]|9|@]|A|$]]|$1|1C|3|1D|5|T|7|29|8|@]|9|@]|A|$]]|$1|1E|3|1F|5|6|7|2A|8|@]|9|@]|A|$]]|$1|1G|3|1H|5|6|7|2B|8|@]|9|@]|A|$]]|$1|1I|3|1J|5|T|7|2C|8|@]|9|@]|A|$]]|$1|1K|3|1L|5|T|7|2D|8|@]|9|@]|A|$]]|$1|1M|3|1N|5|T|7|2E|8|@]|9|@]|A|$]]|$1|1O|3|-4|5|T|7|2F|8|@]|9|@]|A|$]]]|1P|$]]

<ul>
<li>Create a single module for all your build time dependencies (annotations, embedded tomcat, code generators, etc. Build this once and attach to the compiler plugin so they are on the build path for all modules</li>
<li>create a small shared config and unzip it in each module at build time (check style config, logging config, etc)</li>
<li>place maven plugins into their own individual profiles that can be brought in just-in-time as needed. Eg check style, findbugs, JavaDoc, surefire, failsafe, code signing, etc. Your normal build should use as few plugins as possible. This really helps with troubleshooting since any plugin can be individually enabled with a -P command line option </li>
<li>avoid the fork config on the compiler plugin, it can double your build time. If you need -parameters then only fork once for the classes that need it.</li>
<li>write tests so they can run in parallel. No test should take more than a second.</li>
<li>use the -T 1C option to build in parallel</li>
<li>use the embedded version of tomcat, instead of the tomcat plugin, for launching tomcat for integration tests. Avoid starting tomcat more than once.</li>
<li>exclude any jars that don't need to be scanned in tomcat config properties.</li>
<li>structure your project into a balanced tree grouping related components under their own parent pom. </li>
</ul>

The very top is your BOM POM module, shared resource module, shared build path module. You rarely build these once you get everything organized.

Next is your top app pom that includes the following parent poms

-Common low-level modules with no dependencies. 

-Gateway module that includes http client libs and interface modules. 

-Biz service modules

-Containers - tomcat, Spring, DropWizzard,Etc. 

-Packages - ubber jars, zips

-Runtimes - Rpms, executable jars

Poms dependencies should always point to higher level poms to avoid circular dependencies

The slower build artifacts should be last so you can work without having to wait on slow packaging.

You should be able to build any group in about 5 seconds, build your war in 5 seconds, start tomcat with spring in 10 seconds for a worst case of 20 second iteration. 

<ul>
<li>the maven compiler is fast and incremental, so try to avoid generating any code that forces a recompile</li>
<li>create a small DSL and interpreter for your tests. We've seen this approach run twice as fast as junit.</li>
</ul>

I just took our large full build from 5 minutes to 45 seconds using these techniques. It is a lot of engineering, but worth it. This approach works with the standard maven release plugin and makes troubleshooting much easier.

Good luck.
It's never fast enough

PS PCIe SSDs are a big help too

Until now I found two ways to run my program with maven3:

<ol>
<li><code>$ mvn exec:exec -Dexec.args='...'</code></li>
<li><code>$ mvn assembly:assembly &amp;&amp; java -cp all-with-dependecies.jar example.Main ...</code></li>
</ol>

The former uses mvn's JVM which traps exceptions and starts very slow. The later is very slow too because it has to build a big jar and to run tests.

I would something like <code>$ mvn compile &amp;&amp; java -cp $CLASSPATH example.Main</code>. Since usually <code>CLASSPATH</code> is constant between runs I have to worry about it only once.

My question is how do you speed up compile in the development cycle change, compile, test?

Speedup development with maven3

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

到目前为止，我找到了两种使用maven3运行程序的方法：$ mvn exec:exec -Dexec.args='...'$ mvn assembly:assembly && java -cp all-with-dependecies.jar example.Main ...前者使用mvn的JVM，它捕获异常并启动非常慢。后者也非常慢，因为它必须构建一个大jar并运行测试。我会像$ mvn com

问用maven3加速开发
EN

回答 8

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问用maven3加速开发EN

回答 8

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问用maven3加速开发
EN