javaweb中Maven的思想，Maven的好处 - 送吗网
javaweb中Maven的思想，Maven的好处
javaweb程序员 阅读:4
1. 前言Maven是apache的一个顶级项目，它的出现越来越影响着现在的众多的开源项目，不仅如此，很多公司的很多新项目都采使用Maven提倡的方式进行管理。Maven正逐步侵入我们原价的管理项目的习惯，对于团队的管理，项目的构建，都是一种质的飞跃。当然是我个人的少量项目经验而说的这话。假如原价的团队老大本身的管理非常科学，也有一套其余软件辅助项目的构建、打包、发布等等一系列机制保证。那么Maven可能对其并没有实质性的影响或者者是质的飞跃。当然在此也并不是说咱们中国人做出来的项目就管理不善……只是说利使用Maven帮助我们构建项目更科学、更有可维护性、更加板块化、板块功能更加职能单一、做出来的项目更加具备可复使用性等等好处。当然笔者也是个刚学习Maven的人，我们一起来学习Maven究竟为我们带来了什么好处。2. Maven的思想原本想看完了实战整本，再写总结的，后来觉得还是先写出来吧。哪怕有什么不对的地方再纠正都不晚，就怕到时候看完了一点心得都没有，全忘了就太……所以先将学习的点点滴滴感受写下来，之后结合实例咱们可以反复的推敲。目前笔者看到的Maven的主要功能是：项目构建；项目构建；项目依赖管理；软件项目持续集成；版本管理；项目的站点形容信息管理；由此可以看出Maven最主要的表现在了哪2个词？――对了，“项目”和“管理”！加在一起就是项目管理。项目管理是一个很笼统的概念。项目管理既可以指技术上的管理手段，也可以指“以人为本”的非技术因素。固然，无论是技术还是非技术，项目的成败最大的责任人其实就是项目经理。这里我们抛开人为因素不提，仅就技术上来说，Maven提供了一种思想让团队更科学的管理、构建项目。使用配置文件的方式对项目的形容、名称、版本号、项目依赖等等信息进行形容。使之项目形容结构清晰，任何人接手的成本比较低。在项目构建时，利使用Maven的“商定大于配置”的思想，可以比Ant脚本构建项目省去不少配置文件的内容。而且一个项目可能依赖于其余的项目和第三方的组件才能顺利完成，Maven提供了仓库的概念，让这些依赖项放进仓库中，项目想要从仓库中去取，其余项目组也需要，OK，从仓库中去取，不必每个人去开源项目的站点去苦苦搜寻了。如此人员的成本、软件维护的成本、沟通的成本、硬件的成本都降下来了。用户笑了、公司老板也笑了、项目经理笑了、团队里面的人员也笑了、Apache社区看到这么多人在使用也笑了。给笔者的感觉，现在的开源东西越来越向“敏捷开发”、“极限编程”的方向靠拢。通过Maven辅助管理项目，更能发现项目中哪些板块是重复的轮子。后言：更多干货！请关注小编！一起探讨研究java构建工具的选择，是该选择Maven？还是该选择Gradle？还是其他？23人已关注
萌萌的计算机科技小达人旧时代的Java世界，构建工具等同于两个词Ant和MavenAnt源自Make，同JUnit一样，它也是一个航班产物（参见《Ant权威指南》序）。不过，Make的基础注定了它的起点不高，所有一切都要手工打造。我还依稀记得曾几何时，每每开始一个项目都要重新复制一份Ant脚本，修修改改。Maven给了人们新的希望，目录结构的约定、依赖管理、IDE集成，那时看来，几近完美。是的，几近，还差了那么一点点。就是那么一点点，却是致命伤。只要一个项目进行一段时间，一个必然遇到的问题就是，编写新的自动化脚本。因为每个项目都有自己的特定需求，标准做法必然是无法满足的。扩展Maven对任何新手都是一件头疼的事，我们要学会编写插件，要搞清楚生命周期，这时，突然会唤起一丝丝对于ANT的怀念，虽然它做简单事不容易，但做复杂事却也没这么困难。如果那些日子，我们不得不忍受Ant和Maven的不完美，那现在，是时候抛弃它们了。新时代Java构建有两个很好的候选：Gradle和Buildr。在我看来，它们真正比Maven更强大的地方，编写自己的任务更加容易。更值得兴奋的一点是，我们终于可以抛弃冗长的XML，选择一种更优雅的程序设计语言来写代码了，这几乎意味着你可以做到想做的一切。Buildr是Apache出品的构建工具，它以Ruby作为构建脚本。《软件开发地基》讨论软件项目应该具备一些基础构建项，就是以Buildr为基础的。有兴趣的话，可以参考一下。这里就不再赘述。顺便说一下，那篇文章里的内容，除了某些写法现在需要做一些微调，大部分内容依然是适用于大多数Java项目。Gradle现在是整个Java社区的构建新宠，它采用Groovy作为自己的构建语言。如果你知道，Groovy是一门诞生自JVM平台的语言，这就决定了它要比其它移植到JVM上的语言能更好的适应JVM平台，它可以采用更符合Java世界的方式无缝地整合Java既有的程序库，而不必像移植语言那样削足适履。初涉Gradle，最让人吃惊的一点莫过于它详尽的文档，涵盖了Gradle使用的方方面面，这是许多开源软件项目无法媲美，即便早在它的1.0版本尚未发布之时。当然，能做到这一点是因为它背后有一个公司在支撑：GradleWare，这意味着如果你需要商业支持，也是可以的。Gradle 1.0尚未发布之，它就捧回2010年的Spring大奖和入围了2011年的JAX大奖。如果你还需要更多的信心，作为Java开发人员，你不可能不知道Spring，那Spring转投Gradle怀抱，应该是对Gradle最有利的支持了。说了这么多，程序员最喜欢看到的东西还是代码。首先，请自行下载安装Gradle，然后，按照常见的Java项目布局把代码准备好（感谢Maven为我们给予我们约定），比如：src/main/java，源代码文件目录src/main/resources，资源文件目录src/test/java，测试代码目录下面是一个简单的Gradle构建脚本，将其存放于build.gradleapply plugin: 'java'repositories {
mavenCentral()}dependencies {
'com.google.guava:guava:13.0.1',
'joda-time:joda-time:2.1'
testCompile(
'junit:junit:4.10',
'org.mockito:mockito-all:1.9.0'
)}（build.gradle）接下来的事情就很简单了，在命令行里键入
gradle build如果一切正常，我们应该会看到构建成功的字样，然后，到build/lib，你就看到自己构建出来的JAR文件了。当然，这只是一个简单得不能再简单的例子，如果需要了解更多，Gradle那详尽的文档便是最好的去处。旧时代的Java世界，构建工具等同于两个词Ant和MavenAnt源自Make，同JUnit一样，它也是一个航班产物（参见《Ant权威指南》序）。不过，Make的基础注定了它的起点不高，所有一切都要手工打造。我还依稀记得曾几何时，每每开始一个项目都要重新复制一份Ant脚本，修修改改。Maven给了人们新的希望，目录结构的约定、依赖管理、IDE集成，那时看来，几近完美。是的，几近，还差了那么一点点。就是那么一点点，却是致命伤。只要一个项目进行一段时间，一个必然遇到的问题就是，编写新的自动化脚本。因为每个项目都有自己的特定需求，标准做法必然是无法满足的。扩展Maven对任何新手都是一件头疼的事，我们要学会编写插件，要搞清楚生命周期，这时，突然会唤起一丝丝对于ANT的怀念，虽然它做简单事不容易，但做复杂事却也没这么困难。如果那些日子，我们不得不忍受Ant和Maven的不完美，那现在，是时候抛弃它们了。新时代Java构建有两个很好的候选：Gradle和Buildr。在我看来，它们真正比Maven更强大的地方，编写自己的任务更加容易。更值得兴奋的一点是，我们终于可以抛弃冗长的XML，选择一种更优雅的程序设计语言来写代码了，这几乎意味着你可以做到想做的一切。Buildr是Apache出品的构建工具，它以Ruby作为构建脚本。《软件开发地基》讨论软件项目应该具备一些基础构建项，就是以Buildr为基础的。有兴趣的话，可以参考一下。这里就不再赘述。顺便说一下，那篇文章里的内容，除了某些写法现在需要做一些微调，大部分内容依然是适用于大多数Java项目。Gradle现在是整个Java社区的构建新宠，它采用Groovy作为自己的构建语言。如果你知道，Groovy是一门诞生自JVM平台的语言，这就决定了它要比其它移植到JVM上的语言能更好的适应JVM平台，它可以采用更符合Java世界的方式无缝地整合Java既有的程序库，而不必像移植语言那样削足适履。初涉Gradle，最让人吃惊的一点莫过于它详尽的文档，涵盖了Gradle使用的方方面面，这是许多开源软件项目无法媲美，即便早在它的1.0版本尚未发布之时。当然，能做到这一点是因为它背后有一个公司在支撑：GradleWare，这意味着如果你需要商业支持，也是可以的。Gradle 1.0尚未发布之，它就捧回2010年的Spring大奖和入围了2011年的JAX大奖。如果你还需要更多的信心，作为Java开发人员，你不可能不知道Spring，那Spring转投Gradle怀抱，应该是对Gradle最有利的支持了。说了这么多，程序员最喜欢看到的东西还是代码。首先，请自行下载安装Gradle，然后，按照常见的Java项目布局把代码准备好（感谢Maven为我们给予我们约定），比如：src/main/java，源代码文件目录src/main/resources，资源文件目录src/test/java，测试代码目录下面是一个简单的Gradle构建脚本，将其存放于build.gradleapply plugin: 'java'repositories {
mavenCentral()}dependencies {
'com.google.guava:guava:13.0.1',
'joda-time:joda-time:2.1'
testCompile(
'junit:junit:4.10',
'org.mockito:mockito-all:1.9.0'
)}（build.gradle）接下来的事情就很简单了，在命令行里键入
gradle build如果一切正常，我们应该会看到构建成功的字样，然后，到build/lib，你就看到自己构建出来的JAR文件了。当然，这只是一个简单得不能再简单的例子，如果需要了解更多，Gradle那详尽的文档便是最好的去处。
西北大学（中国）
心向阳光的果粉儿刚刚巧，我最近刚查了与这个问题相关的资料，我就以我所看到的资料，现学现卖为你简单的横向比较一下Maven, Ivy, Gradle, sbt这四个构建工具吧，希望对你有所帮助：Maven当今最为流行的构建工具，提供了项目构建、测试、发布等一整套流程的管理。当年非常有预见性的提供了一套包依赖的解决方案，但是这个方案设计不够好，也一直被人们诟病。提供了比较强的规约，有人认为这很不自由，但是我觉得这样的规范更好，特别是目录结构有个统一标准，这样非常清晰。但是他的配置文件写起来确实有点麻烦，特别是一个ant工程要转过来，真的要花不少工夫。IvyApache提供的一个ant的子项目，和ant完全兼容，用起来倒是方便了。提供了一套更合理的包依赖解决方案，还可以直接使用Maven的包依赖库，真是充分利用已有资源啊，难道这样不侵权？其他方面都是一些对ant的简单扩充，其实并没有太多新的特性。Gradle用了Grails感觉他的配置还是很清爽的，其调用的就是Gradle。最大的特点就是用Groovy脚本来代替了XML，同时也处理了包依赖问题。但用的人貌似不是很多，属于潜力股。sbt全称是simple build tool，是在Ivy基础上进行的封装，引入了Maven的目录结构，具体配置又是直接使用Scala，算是各种的综合体。在Scala项目中使用应该还是不错的，可惜目前的版本只支持Scala2.7.7，而且看了下demo感觉配置起来也有点麻烦。看来看去，感觉其实只使用ant也没有什么特别大的问题。如果非要用替换，使用Ivy感觉风险最小，项目组接受程度会高点。现在项目的ant脚本已经写好了，等有空引入Ivy吧～，目录结构还是用Maven的好了。刚刚巧，我最近刚查了与这个问题相关的资料，我就以我所看到的资料，现学现卖为你简单的横向比较一下Maven, Ivy, Gradle, sbt这四个构建工具吧，希望对你有所帮助：Maven当今最为流行的构建工具，提供了项目构建、测试、发布等一整套流程的管理。当年非常有预见性的提供了一套包依赖的解决方案，但是这个方案设计不够好，也一直被人们诟病。提供了比较强的规约，有人认为这很不自由，但是我觉得这样的规范更好，特别是目录结构有个统一标准，这样非常清晰。但是他的配置文件写起来确实有点麻烦，特别是一个ant工程要转过来，真的要花不少工夫。IvyApache提供的一个ant的子项目，和ant完全兼容，用起来倒是方便了。提供了一套更合理的包依赖解决方案，还可以直接使用Maven的包依赖库，真是充分利用已有资源啊，难道这样不侵权？其他方面都是一些对ant的简单扩充，其实并没有太多新的特性。Gradle用了Grails感觉他的配置还是很清爽的，其调用的就是Gradle。最大的特点就是用Groovy脚本来代替了XML，同时也处理了包依赖问题。但用的人貌似不是很多，属于潜力股。sbt全称是simple build tool，是在Ivy基础上进行的封装，引入了Maven的目录结构，具体配置又是直接使用Scala，算是各种的综合体。在Scala项目中使用应该还是不错的，可惜目前的版本只支持Scala2.7.7，而且看了下demo感觉配置起来也有点麻烦。看来看去，感觉其实只使用ant也没有什么特别大的问题。如果非要用替换，使用Ivy感觉风险最小，项目组接受程度会高点。现在项目的ant脚本已经写好了，等有空引入Ivy吧～，目录结构还是用Maven的好了。
东北大学（中国）
就是喜欢表情包~╭(╯^╰)╮这是我在网上看到的关于这个问题的一个博客，贴过来，希望对你有所帮助。创世之初，世上只有Make一种构建工具，后来，其发展为GNU Make。但是，由于需求的不断涌现，码农的世界里逐渐演化出了千奇百怪的构建工具。当前，JVM生态圈由三大构建工具所统治：Apache Ant带着IvyMavenGradelAntAnt是第一个“现代”构建工具，在很多方面它有些像Make。2000年发布，在很短时间内成为Java项目上最流行的构建工具。它的学习曲线很缓，因此不需要什么特殊的准备就能上手。它基于过程式编程的idea。在最初的版本之后，逐渐具备了支持插件的功能。主要的不足是用XML作为脚本编写格式。 XML，本质上是层次化的，并不能很好地贴合Ant过程化编程的初衷。Ant的另外一个问题是，除非是很小的项目，否则它的XML文件很快就大得无法管理。后来，随着通过网络进行依赖管理成为必备功能，Ant采用了Apache Ivy。Ant的主要优点在于对构建过程的控制上。MavenMaven发布于2004年。目的是解决码农使用Ant所带来的一些问题。Maven仍旧使用XML作为编写构建配置的文件格式，但是，文件结构却有巨大的变化。Ant需要码农将执行task所需的全部命令都一一列出，然而Maven依靠约定（convention）并提供现成的可调用的目标（goal）。不仅如此，有可能最重要的一个补充是，Maven具备从网络上自动下载依赖的能力（Ant后来通过Ivy也具备了这个功能），这一点革命性地改变了我们开发软件的方式。但是，Maven也有它的问题。依赖管理不能很好地处理相同库文件不同版本之间的冲突（Ivy在这方面更好一些）。XML作为配置文件的格式有严格的结构层次和标准，定制化目标（goal）很困难。因为Maven主要聚焦于依赖管理，实际上用Maven很难写出复杂、定制化的构建脚本，甚至不如Ant。用XML写的配置文件会变得越来越大，越来越笨重。在大型项目中，它经常什么“特别的”事还没干就有几百行代码。Maven的主要优点是生命周期。只要项目基于一定之规，它的整个生命周期都能够轻松搞定，代价是牺牲了灵活性。在对DSL（Domain Specific Languages)的热情持续高涨之时，通常的想法是设计一套能够解决特定领域问题的语言。在构建这方面，DSL的一个成功案例就是。GradleGradle结合了前两者的优点，在此基础之上做了很多改进。它具有Ant的强大和灵活，又有Maven的生命周期管理且易于使用。最终结果就是一个工具在2012年华丽诞生并且很快地获得了广泛关注。例如，Google采用Gradle作为Android OS的默认构建工具。Gradle不用XML，它使用基于Groovy的专门的DSL，从而使Gradle构建脚本变得比用Ant和Maven写的要简洁清晰。Gradle样板文件的代码很少，这是因为它的DSL被设计用于解决特定的问题：贯穿软件的生命周期，从编译，到静态检查，到测试，直到打包和部署。它使用Apache Ivy来处理Jar包的依赖。Gradle的成就可以概括为：约定好，灵活性也高。代码事例我们写一段构建脚本来完成从编译、静态检查、单元测试到最终打Jar包的过程。我们分别使用三个框架（Ant，Maven和Gradle）来完成这件事情，比较一下语法。通过比较每一个任务的代码，我们能够对差异有一个更好的理解，并对选择构建工具做出一个周全的决策。事有先后，如果你自己按照本文来学习样例，需要安装Ant，Ivy，Maven和Gradle，请根据相应工具的安装指导进行操作。你也可以不用自己跑样例，也统统不用安装，代码片段应该足够让你明白这些工具是如何工作的。代码库 包含有代码（两个简单的类和测试代码），checkstyle配置文件和Ant，Ivy，Maven以及Gradle的配置文件。先从Ant带着Ivy开始Ant带着IvyIvy的依赖需要在ivy.xml中指定。我们的例子很简单，只需要依赖JUnit和Hamcrest。ivy.xml[html]
现在我们来创建Ant脚本，任务只是编译一个Jar文件。最终文件是下面的build.xml。build.xml[html]
首先，我们设置了几个属性，然后是一个接一个的task。我们用Ivy来处理依赖，清理，编译和打包，这是几乎所有的Java项目都会进行的task，配置有很多。运行Ant task来生成Jar文件，执行下面的命令。[plain] ant jar
我们来看Maven如何完成同样的工作。Mavenpom.xml[html] "
xmlns:xsi=""
xsi:schemaLocation=
com.technologyconversations
java-build-tools
org.hamcrest
hamcrest-all
org.apache.maven.plugins
maven-compiler-plugin
通过执行下面的命令来运行Maven goal生成Jar文件。[plain] mvn package
主要的区别在于Maven不需要指定执行的操作。我们没有创建task，而是设置了一些参数（有哪些依赖，用哪些插件...). Maven推行使用约定并提供了开箱即用的goals。Ant和Maven的XML文件都会随时间而变大，为了说明这一点，我们加入CheckStyle，FindBugs和PMD插件来进行静态检查，三者是Java项目中使用很普遍的的工具。我们希望将所有静态检查的执行以及单元测试一起作为一个单独的targetVerify。当然我们还应该指定自定义的checkstyle配置文件的路径并且确保错误时能够提示。更新后的Maven代码如下：pom.xml[plain]
org.apache.maven.plugins
maven-checkstyle-plugin
config/checkstyle/checkstyle.xml
org.codehaus.mojo
findbugs-maven-plugin
org.apache.maven.plugins
maven-pmd-plugin
通过执行下面的命令来运行Maven goal，包括单元测试，静态检查，如CheckStyle，FindBugs和PMD。[plain]mvn verify
我们需要写很多XML来进行基本的常用的任务。在实际项目中有更多的依赖和task，Maven的pom.xml很容易就有成百上千行的配置。下面看看Gradle如何完成同样的任务。Gradlebuild.gradle[html] apply plugin: 'java'
apply plugin: 'checkstyle'
apply plugin: 'findbugs'
apply plugin: 'pmd'
version = '1.0'
repositories {
mavenCentral()
dependencies {
testCompile group: 'junit', name: 'junit', version: '4.11'
testCompile group: 'org.hamcrest', name: 'hamcrest-all', version: '1.3'
Gradle不仅代码少了很多，对于熟悉的人来说，比Maven要更容易理解，而且它还包括很多Maven代码没有覆盖的有用的task。请执行下面的命令来得到Gradle在当前配置下能够支持的task列表。[plain]gradle tasks --all
清晰型、复杂度对于初学者，Ant是最清晰的。只要读懂XML配置文件你就能够理解它干了些什么，但是，Ant文件很容易变复杂。Maven和Gradle，尤其是Gradle，有很多开箱即用的插件。例如，下面这行代码可能会令那些对Gradle一知半解的人有些困惑，不知道通过这句话就能够使用哪些task。build.gradle[plain]apply plugin: 'java'
简单的这一行增加了20多个可用的任务.Ant的可读性和Maven的简单性，在我看来，是伪命题，只适用于Gradle学习曲线的初级阶段。一旦用上了Gradle的DSL，就会发现语法比Ant和Maven更加短小精悍、易于理解。不仅如此，只有Gradle既提供了约定也提供了自定义命令。如果说Maven可以通过Ant task来扩展，这似乎有些滑稽可笑，而且低效，Groovy写的Gradle将其提升了一个层次。原文链接：这是我在网上看到的关于这个问题的一个博客，贴过来，希望对你有所帮助。创世之初，世上只有Make一种构建工具，后来，其发展为GNU Make。但是，由于需求的不断涌现，码农的世界里逐渐演化出了千奇百怪的构建工具。当前，JVM生态圈由三大构建工具所统治：Apache Ant带着IvyMavenGradelAntAnt是第一个“现代”构建工具，在很多方面它有些像Make。2000年发布，在很短时间内成为Java项目上最流行的构建工具。它的学习曲线很缓，因此不需要什么特殊的准备就能上手。它基于过程式编程的idea。在最初的版本之后，逐渐具备了支持插件的功能。主要的不足是用XML作为脚本编写格式。 XML，本质上是层次化的，并不能很好地贴合Ant过程化编程的初衷。Ant的另外一个问题是，除非是很小的项目，否则它的XML文件很快就大得无法管理。后来，随着通过网络进行依赖管理成为必备功能，Ant采用了Apache Ivy。Ant的主要优点在于对构建过程的控制上。MavenMaven发布于2004年。目的是解决码农使用Ant所带来的一些问题。Maven仍旧使用XML作为编写构建配置的文件格式，但是，文件结构却有巨大的变化。Ant需要码农将执行task所需的全部命令都一一列出，然而Maven依靠约定（convention）并提供现成的可调用的目标（goal）。不仅如此，有可能最重要的一个补充是，Maven具备从网络上自动下载依赖的能力（Ant后来通过Ivy也具备了这个功能），这一点革命性地改变了我们开发软件的方式。但是，Maven也有它的问题。依赖管理不能很好地处理相同库文件不同版本之间的冲突（Ivy在这方面更好一些）。XML作为配置文件的格式有严格的结构层次和标准，定制化目标（goal）很困难。因为Maven主要聚焦于依赖管理，实际上用Maven很难写出复杂、定制化的构建脚本，甚至不如Ant。用XML写的配置文件会变得越来越大，越来越笨重。在大型项目中，它经常什么“特别的”事还没干就有几百行代码。Maven的主要优点是生命周期。只要项目基于一定之规，它的整个生命周期都能够轻松搞定，代价是牺牲了灵活性。在对DSL（Domain Specific Languages)的热情持续高涨之时，通常的想法是设计一套能够解决特定领域问题的语言。在构建这方面，DSL的一个成功案例就是。GradleGradle结合了前两者的优点，在此基础之上做了很多改进。它具有Ant的强大和灵活，又有Maven的生命周期管理且易于使用。最终结果就是一个工具在2012年华丽诞生并且很快地获得了广泛关注。例如，Google采用Gradle作为Android OS的默认构建工具。Gradle不用XML，它使用基于Groovy的专门的DSL，从而使Gradle构建脚本变得比用Ant和Maven写的要简洁清晰。Gradle样板文件的代码很少，这是因为它的DSL被设计用于解决特定的问题：贯穿软件的生命周期，从编译，到静态检查，到测试，直到打包和部署。它使用Apache Ivy来处理Jar包的依赖。Gradle的成就可以概括为：约定好，灵活性也高。代码事例我们写一段构建脚本来完成从编译、静态检查、单元测试到最终打Jar包的过程。我们分别使用三个框架（Ant，Maven和Gradle）来完成这件事情，比较一下语法。通过比较每一个任务的代码，我们能够对差异有一个更好的理解，并对选择构建工具做出一个周全的决策。事有先后，如果你自己按照本文来学习样例，需要安装Ant，Ivy，Maven和Gradle，请根据相应工具的安装指导进行操作。你也可以不用自己跑样例，也统统不用安装，代码片段应该足够让你明白这些工具是如何工作的。代码库 包含有代码（两个简单的类和测试代码），checkstyle配置文件和Ant，Ivy，Maven以及Gradle的配置文件。先从Ant带着Ivy开始Ant带着IvyIvy的依赖需要在ivy.xml中指定。我们的例子很简单，只需要依赖JUnit和Hamcrest。ivy.xml[html]
现在我们来创建Ant脚本，任务只是编译一个Jar文件。最终文件是下面的build.xml。build.xml[html]
首先，我们设置了几个属性，然后是一个接一个的task。我们用Ivy来处理依赖，清理，编译和打包，这是几乎所有的Java项目都会进行的task，配置有很多。运行Ant task来生成Jar文件，执行下面的命令。[plain] ant jar
我们来看Maven如何完成同样的工作。Mavenpom.xml[html] "
xmlns:xsi=""
xsi:schemaLocation=
com.technologyconversations
java-build-tools
org.hamcrest
hamcrest-all
org.apache.maven.plugins
maven-compiler-plugin
通过执行下面的命令来运行Maven goal生成Jar文件。[plain] mvn package
主要的区别在于Maven不需要指定执行的操作。我们没有创建task，而是设置了一些参数（有哪些依赖，用哪些插件...). Maven推行使用约定并提供了开箱即用的goals。Ant和Maven的XML文件都会随时间而变大，为了说明这一点，我们加入CheckStyle，FindBugs和PMD插件来进行静态检查，三者是Java项目中使用很普遍的的工具。我们希望将所有静态检查的执行以及单元测试一起作为一个单独的targetVerify。当然我们还应该指定自定义的checkstyle配置文件的路径并且确保错误时能够提示。更新后的Maven代码如下：pom.xml[plain]
org.apache.maven.plugins
maven-checkstyle-plugin
config/checkstyle/checkstyle.xml
org.codehaus.mojo
findbugs-maven-plugin
org.apache.maven.plugins
maven-pmd-plugin
通过执行下面的命令来运行Maven goal，包括单元测试，静态检查，如CheckStyle，FindBugs和PMD。[plain]mvn verify
我们需要写很多XML来进行基本的常用的任务。在实际项目中有更多的依赖和task，Maven的pom.xml很容易就有成百上千行的配置。下面看看Gradle如何完成同样的任务。Gradlebuild.gradle[html] apply plugin: 'java'
apply plugin: 'checkstyle'
apply plugin: 'findbugs'
apply plugin: 'pmd'
version = '1.0'
repositories {
mavenCentral()
dependencies {
testCompile group: 'junit', name: 'junit', version: '4.11'
testCompile group: 'org.hamcrest', name: 'hamcrest-all', version: '1.3'
Gradle不仅代码少了很多，对于熟悉的人来说，比Maven要更容易理解，而且它还包括很多Maven代码没有覆盖的有用的task。请执行下面的命令来得到Gradle在当前配置下能够支持的task列表。[plain]gradle tasks --all
清晰型、复杂度对于初学者，Ant是最清晰的。只要读懂XML配置文件你就能够理解它干了些什么，但是，Ant文件很容易变复杂。Maven和Gradle，尤其是Gradle，有很多开箱即用的插件。例如，下面这行代码可能会令那些对Gradle一知半解的人有些困惑，不知道通过这句话就能够使用哪些task。build.gradle[plain]apply plugin: 'java'
简单的这一行增加了20多个可用的任务.Ant的可读性和Maven的简单性，在我看来，是伪命题，只适用于Gradle学习曲线的初级阶段。一旦用上了Gradle的DSL，就会发现语法比Ant和Maven更加短小精悍、易于理解。不仅如此，只有Gradle既提供了约定也提供了自定义命令。如果说Maven可以通过Ant task来扩展，这似乎有些滑稽可笑，而且低效，Groovy写的Gradle将其提升了一个层次。原文链接：在Java码农的世界里，构建工具一直是一个不可或缺的元素。一开始，世上是只有一个构建工具的那就是Make后来发展为GNU Make。但是由于需求的不断涌现，这个小 圈子里又逐渐衍生出其他千奇百怪的构建工具。在这个小圈子中影响力最大的角色莫过于Maven了。它使用XML作为配置文件，改进了前辈Ant的复杂的构建配置，提供了一些现成的目标，而不需要我们一个个的将构建任务的每个命令一一列出。另外它提供了一个杀手锏功能，那就是依赖管理，它通过简单的配置就可以自动从网络上下载项目所需的依赖，这革命性的改变了我们开发软件的方式。可以想象，如果你是一个大型软件开发项目组的成员，如果使用代码仓库管理依赖jar包会令仓库变得多么庞大！Maven的制品仓库设计实现了制品与代码间的解耦，为基于制品的协作提供了可能。可是软件行业新旧交替的速度之快往往令人咋舌，不用多少时间，你就会发现曾经大红大紫的技术已经成了昨日黄花。在Java构建领域，我们能够看到一些新兴的工具在涌现。比如基于Groovy的Gradle。Hibernate就将自己的项目从Maven迁移到了Gradle，Google官方Android开发的IDE Android Studio也默认使用了Gradle进行构建。这些事件令Gradle吸引了不少眼球。Gradle真的要替代Maven了么？当然没有，Maven在如今仍然是Java构建技术的事实标准。Gradle也仍然使用了Maven的制品库来做依赖管理。但是从Gradle身上，我们确实看到了进步。简洁的Groovy语法和灵活的配置令我们眼前一亮。那Maven和Gradle到底有何不同呢？就请读者和我一起探寻吧。安装在安装上两者大同小易。我们都需要从官网下载解压到本地目录。配置好MAVEN_HOME或Gradle_Home环境变量，并加入PATH环境变量中。我们就可以在命令行中使用maven和gradle了。主流的Java IDE： Eclipse可以安装Maven和Gradle的插件。Intellij有内置的Gradle和Maven可以使用。二者均有详尽的文档供用户参考。别看gradle是个新来的小子，它的文档也是有70章，500多页的内容的！在这里附上Maven和Gradle的下载地址：maven: Maven – Welcome to Apache Mavengradle: 依赖管理Maven的配置文件是.pom文件。POM是项目对象模型(Project Object Model)的简称，它是Maven项目中的文件，使用XML表示。其中包含项目的基本信息，构建过程，环境信息，依赖信息等。我们可以看下面这个简单的例子：&project xmlns=""& & & & &xmlns:xsi=""& & & & &xsi:schemaLocation="& & & & & & &"&& & &modelVersion&4.0.0&/modelVersion&& & &groupId&com.vs&/groupId&& & &artifactId&com.vs.maven.gradle&/artifactId&& & &version&1.0&/version&& & &parent&& & & & &groupId&org.springframework.boot&/groupId&& & & & &artifactId&spring-boot-starter-parent&/artifactId&& & & & &version&1.2.6.RELEASE&/version&& & &/parent&& & &dependencies&& & & & &dependency&& & & & & & &groupId&org.springframework.boot&/groupId&& & & & & & &artifactId&spring-boot-starter-web&/artifactId&& & & & &/dependency&& & & & &dependency&& & & & & & &groupId&org.springframework.boot&/groupId&& & & & & & &artifactId&spring-boot-starter-security&/artifactId&& & & & &/dependency&& & & & &dependency&& & & & & & &groupId&org.springframework.boot&/groupId&& & & & & & &artifactId&spring-boot-starter-data-jpa& & & & & & &/artifactId&& & & & &/dependency&& & & & &dependency&& & & & & & &groupId&mysql&/groupId&& & & & & & &artifactId&mysql-connector-java&/artifactId&& & & & & & &version&5.1.25&/version&& & & & &/dependency&& & &/dependencies&& & &properties&& & & & &java.version&1.8&/java.version&& & &/properties&& & &build&& & & & &plugins&& & & & & & &plugin&& & & & & & & & &groupId&org.springframework.boot&/groupId&& & & & & & & & &artifactId&spring-boot-maven-plugin&/artifactId&& & & & & & &/plugin&& & & & &/plugins&& & &/build&&/project&这个例子构建了一个简单的spring-boot项目， 最开始定义了一些项目的基本信息，包括组名、制品名、版本等。parent标签表示我们继承了一个spring定义的一个制品的配置，这样我们不需要配置很多依赖的版本就可以引入依赖。dependencies标签间配置该项目所依赖的其他制品，分别配置每个依赖制品的groupId, artifactId和version。当我们执行mvn insall时，maven就会自动下载依赖，并帮我们将它编译打包放入本地仓库之中。我们就可以在用户目录下的.m2文件夹中找到我们的制品。那如果我们使用Gradle来构建这个项目，我们该如何做呢？buildscript {& & repositories {& & & & mavenCentral()& & }& & dependencies {& & & & classpath("org.springframework.boot:spring-boot-gradle-plugin:1.2.6.RELEASE")& & }}dependencies {& & compile("org.springframework.boot:spring-boot-starter-web") {& & & & exclude module: "spring-boot-starter-tomcat"& & }& & compile("org.springframework.boot:spring-boot-starter-security")& & compile("org.springframework.boot:spring-boot-starter-data-jpa")& & testCompile("mysql:mysql-connector-java:5.1.25")}咦？冗长的代码怎么突然少了这么多？^？仔细阅读下你会发现，原来是依赖管理所需的配置长度变短了。在pom.xml中我们需要引入一个依赖时需要将它的groupId, artifactId和version都用标签引起来。但是在build.gradle中你会发现，仅仅需要将三者的value用:连起来，并"调用compile函数"就可以啦。比如，我们要引用spring-boot的starter-security，maven的配置是这样写的：&dependencies&& & &dependency&& & & & &groupId&org.springframework.boot&/groupId&& & & & &artifactId&spring-boot-starter-security&/artifactId&& & &/dependency&&/dependencies&在gradle中的配置却是这样的：dependencies {& & compile("org.springframework.boot:spring-boot-starter-security")}觉得怎么样？我反正感觉和写代码一样清爽！Gradle使用了groovy作为它的DSL，非常的易用。如果你使用了很久的Maven，你也许会发现Gradle的配置写起来实在是太爽了！构建生命周期管理除了依赖管理以外，构建工具的另一个主要用途就是构建的生命周期管理。Maven有三个生命周期，每个生命周期又分为多个阶段:Clean:包含3个阶段，与清理上次构建生成的文件相关Default：Maven的核心生命周期，包含多个阶段如预处理、编译、测试、打包、安装到本地仓库、发布到远程仓库等。Site: 包含4个阶段，与生成项目报告，站点，发布站点相关。这些生命周期都是系统自定义好的，如果我们需要修改现有的构建生命周期的话，我们就要编写一个Maven插件。因为Maven是通过插件发来完成大多数的构建任务。每个插件可以绑定一个生命周期。配置好绑定生命周期后，我们需要定义插件的任务，在Maven中每个任务的goal称作Mojo，每个Mojo我们都需要实现org.apache.maven.plugin.Mojo接口。也就是我们需要定义一个类来实现这个接口。使用时我们需要引入这个插件，并配置需要执行的goal。比如我们要完成输出Hello world这个需求的话，我们需要：新建GreeingMojo类：package sample.import org.apache.maven.plugin.AbstractMimport org.apache.maven.plugin.MojoExecutionEimport org.apache.maven.plugins.annotations.M/**&* Says "Hi" to the user.&*&*/@Mojo( name = "sayhi")public class GreetingMojo extends AbstractMojo{& & public void execute() throws MojoExecutionException& & {& & & & getLog().info( "Hello, world." );& & }}定义pom文件：&project&& &modelVersion&4.0.0&/modelVersion&& &groupId&sample.plugin&/groupId&& &artifactId&hello-maven-plugin&/artifactId&& &version&1.0-SNAPSHOT&/version&& &packaging&maven-plugin&/packaging&& &name&Sample Parameter-less Maven Plugin&/name&& &dependencies&& & &dependency&& & & &groupId&org.apache.maven&/groupId&& & & &artifactId&maven-plugin-api&/artifactId&& & & &version&2.0&/version&& & &/dependency&& & &!-- dependencies to annotations --&& & &dependency&& & & &groupId&org.apache.maven.plugin-tools&/groupId&& & & &artifactId&maven-plugin-annotations&/artifactId&& & & &version&3.4&/version&& & & &scope&provided&/scope&& & &/dependency&& &/dependencies&&/project&在项目pom文件目录运行install命令将插件安装到本地仓库在使用插件的项目加入配置：& &build&& & &plugins&& & & &plugin&& & & & &groupId&sample.plugin&/groupId&& & & & &artifactId&hello-maven-plugin&/artifactId&& & & & &version&1.0-SNAPSHOT&/version&& & & &/plugin&& & &/plugins&& &/build&执行：mvn groupId:artifactId:version:goal即可完成Hello，world的输出。那么在Gradle中我们该怎么做呢？Gradle中有一个基本概念叫Task，我们可以使用Task来完成这个需求：task hello && {& & println "hello world"}执行Gradle hello，即可完成Hello, World的输出。是不是很简单？像写代码一样~当然实际工程我们要完成的构建任务不仅仅是输出一个info这么简单，我们很可能会去做一些其他复杂的操作，比如初始化文件、数据库，检测系统环境等等。但由于Gradle使用了Groovy作为配置文件，在使用时会比Maven的xml配置灵活许多，更适合我们码农进行使用。制品发布在制品发布这个操作上，Maven要扳回一局。Maven原生支持maven jar的格式，发布很简单；而Gradle虽说既支持Maven又支持Gradle，但是就要我们自己做很多额外的工作。比如Maven要发布制品，只需要配置远程仓库的参数：& &distributionManagement&& & &repository&& & & &id&internal&/id&& & & &name&Internal Release Repository&/name&& & & &url&&/url&& & &/repository&& &/distributionManagement&而gradle发布制品，还需要生成pom文件：uploadArchives {& & repositories {& & & & mavenDeployer {& & & & & & //为Pom文件做数字签名& & & & & & beforeDeployment { MavenDeployment deployment -& signing.signPom(deployment) }& & & & & & repository(url: "") {& & & & & & & & authentication(userName: username, password: password)& & & & & & }& & & & & & //构造项目的Pom文件& & & & & & pom.project {& & & & & & & & name project.name& & & & & & & & packaging 'jar'& & & & & & & & description 'description'& & & & & & }& & & & }& & }}总结因为时间关系，简单介绍了这么多，可能读者也对Gradle与Maven的差别有了一些了解。Gradle与Maven相比更为灵活，简单。但是Maven相比于Gradle的不灵活，是否也是它的优点呢？这就需要读者在工程中自己进行思考了。除此之外Gradle的官方网站专门给出了一个专栏来讲Gradle与Maven的区别: Maven vs Gradle: Feature Comparison。有耐心的读者可以看看这些对比。如果说你要说我没耐心看完这些，只想快点挑个构建工作开始我的项目！ 那么我要说的是：Just have a try! Maven和Gradle都是非常优秀的构建工具，增加二者的使用经验不是一个很亏的事情。当然如果你要开发Android应用的话，还是推荐你使用Gradle做构建工具，因为Google官方推的Android Studio就使用了Gradle作为原生构建工具，这使得Gradle对Android各版本软件的构建支持得更好一些。其他项目的话，二者选其一吧~在Java码农的世界里，构建工具一直是一个不可或缺的元素。一开始，世上是只有一个构建工具的那就是Make后来发展为GNU Make。但是由于需求的不断涌现，这个小 圈子里又逐渐衍生出其他千奇百怪的构建工具。在这个小圈子中影响力最大的角色莫过于Maven了。它使用XML作为配置文件，改进了前辈Ant的复杂的构建配置，提供了一些现成的目标，而不需要我们一个个的将构建任务的每个命令一一列出。另外它提供了一个杀手锏功能，那就是依赖管理，它通过简单的配置就可以自动从网络上下载项目所需的依赖，这革命性的改变了我们开发软件的方式。可以想象，如果你是一个大型软件开发项目组的成员，如果使用代码仓库管理依赖jar包会令仓库变得多么庞大！Maven的制品仓库设计实现了制品与代码间的解耦，为基于制品的协作提供了可能。可是软件行业新旧交替的速度之快往往令人咋舌，不用多少时间，你就会发现曾经大红大紫的技术已经成了昨日黄花。在Java构建领域，我们能够看到一些新兴的工具在涌现。比如基于Groovy的Gradle。Hibernate就将自己的项目从Maven迁移到了Gradle，Google官方Android开发的IDE Android Studio也默认使用了Gradle进行构建。这些事件令Gradle吸引了不少眼球。Gradle真的要替代Maven了么？当然没有，Maven在如今仍然是Java构建技术的事实标准。Gradle也仍然使用了Maven的制品库来做依赖管理。但是从Gradle身上，我们确实看到了进步。简洁的Groovy语法和灵活的配置令我们眼前一亮。那Maven和Gradle到底有何不同呢？就请读者和我一起探寻吧。安装在安装上两者大同小易。我们都需要从官网下载解压到本地目录。配置好MAVEN_HOME或Gradle_Home环境变量，并加入PATH环境变量中。我们就可以在命令行中使用maven和gradle了。主流的Java IDE： Eclipse可以安装Maven和Gradle的插件。Intellij有内置的Gradle和Maven可以使用。二者均有详尽的文档供用户参考。别看gradle是个新来的小子，它的文档也是有70章，500多页的内容的！在这里附上Maven和Gradle的下载地址：maven: Maven – Welcome to Apache Mavengradle: 依赖管理Maven的配置文件是.pom文件。POM是项目对象模型(Project Object Model)的简称，它是Maven项目中的文件，使用XML表示。其中包含项目的基本信息，构建过程，环境信息，依赖信息等。我们可以看下面这个简单的例子：&project xmlns=""& & & & &xmlns:xsi=""& & & & &xsi:schemaLocation="& & & & & & &"&& & &modelVersion&4.0.0&/modelVersion&& & &groupId&com.vs&/groupId&& & &artifactId&com.vs.maven.gradle&/artifactId&& & &version&1.0&/version&& & &parent&& & & & &groupId&org.springframework.boot&/groupId&& & & & &artifactId&spring-boot-starter-parent&/artifactId&& & & & &version&1.2.6.RELEASE&/version&& & &/parent&& & &dependencies&& & & & &dependency&& & & & & & &groupId&org.springframework.boot&/groupId&& & & & & & &artifactId&spring-boot-starter-web&/artifactId&& & & & &/dependency&& & & & &dependency&& & & & & & &groupId&org.springframework.boot&/groupId&& & & & & & &artifactId&spring-boot-starter-security&/artifactId&& & & & &/dependency&& & & & &dependency&& & & & & & &groupId&org.springframework.boot&/groupId&& & & & & & &artifactId&spring-boot-starter-data-jpa& & & & & & &/artifactId&& & & & &/dependency&& & & & &dependency&& & & & & & &groupId&mysql&/groupId&& & & & & & &artifactId&mysql-connector-java&/artifactId&& & & & & & &version&5.1.25&/version&& & & & &/dependency&& & &/dependencies&& & &properties&& & & & &java.version&1.8&/java.version&& & &/properties&& & &build&& & & & &plugins&& & & & & & &plugin&& & & & & & & & &groupId&org.springframework.boot&/groupId&& & & & & & & & &artifactId&spring-boot-maven-plugin&/artifactId&& & & & & & &/plugin&& & & & &/plugins&& & &/build&&/project&这个例子构建了一个简单的spring-boot项目， 最开始定义了一些项目的基本信息，包括组名、制品名、版本等。parent标签表示我们继承了一个spring定义的一个制品的配置，这样我们不需要配置很多依赖的版本就可以引入依赖。dependencies标签间配置该项目所依赖的其他制品，分别配置每个依赖制品的groupId, artifactId和version。当我们执行mvn insall时，maven就会自动下载依赖，并帮我们将它编译打包放入本地仓库之中。我们就可以在用户目录下的.m2文件夹中找到我们的制品。那如果我们使用Gradle来构建这个项目，我们该如何做呢？buildscript {& & repositories {& & & & mavenCentral()& & }& & dependencies {& & & & classpath("org.springframework.boot:spring-boot-gradle-plugin:1.2.6.RELEASE")& & }}dependencies {& & compile("org.springframework.boot:spring-boot-starter-web") {& & & & exclude module: "spring-boot-starter-tomcat"& & }& & compile("org.springframework.boot:spring-boot-starter-security")& & compile("org.springframework.boot:spring-boot-starter-data-jpa")& & testCompile("mysql:mysql-connector-java:5.1.25")}咦？冗长的代码怎么突然少了这么多？^？仔细阅读下你会发现，原来是依赖管理所需的配置长度变短了。在pom.xml中我们需要引入一个依赖时需要将它的groupId, artifactId和version都用标签引起来。但是在build.gradle中你会发现，仅仅需要将三者的value用:连起来，并"调用compile函数"就可以啦。比如，我们要引用spring-boot的starter-security，maven的配置是这样写的：&dependencies&& & &dependency&& & & & &groupId&org.springframework.boot&/groupId&& & & & &artifactId&spring-boot-starter-security&/artifactId&& & &/dependency&&/dependencies&在gradle中的配置却是这样的：dependencies {& & compile("org.springframework.boot:spring-boot-starter-security")}觉得怎么样？我反正感觉和写代码一样清爽！Gradle使用了groovy作为它的DSL，非常的易用。如果你使用了很久的Maven，你也许会发现Gradle的配置写起来实在是太爽了！构建生命周期管理除了依赖管理以外，构建工具的另一个主要用途就是构建的生命周期管理。Maven有三个生命周期，每个生命周期又分为多个阶段:Clean:包含3个阶段，与清理上次构建生成的文件相关Default：Maven的核心生命周期，包含多个阶段如预处理、编译、测试、打包、安装到本地仓库、发布到远程仓库等。Site: 包含4个阶段，与生成项目报告，站点，发布站点相关。这些生命周期都是系统自定义好的，如果我们需要修改现有的构建生命周期的话，我们就要编写一个Maven插件。因为Maven是通过插件发来完成大多数的构建任务。每个插件可以绑定一个生命周期。配置好绑定生命周期后，我们需要定义插件的任务，在Maven中每个任务的goal称作Mojo，每个Mojo我们都需要实现org.apache.maven.plugin.Mojo接口。也就是我们需要定义一个类来实现这个接口。使用时我们需要引入这个插件，并配置需要执行的goal。比如我们要完成输出Hello world这个需求的话，我们需要：新建GreeingMojo类：package sample.import org.apache.maven.plugin.AbstractMimport org.apache.maven.plugin.MojoExecutionEimport org.apache.maven.plugins.annotations.M/**&* Says "Hi" to the user.&*&*/@Mojo( name = "sayhi")public class GreetingMojo extends AbstractMojo{& & public void execute() throws MojoExecutionException& & {& & & & getLog().info( "Hello, world." );& & }}定义pom文件：&project&& &modelVersion&4.0.0&/modelVersion&& &groupId&sample.plugin&/groupId&& &artifactId&hello-maven-plugin&/artifactId&& &version&1.0-SNAPSHOT&/version&& &packaging&maven-plugin&/packaging&& &name&Sample Parameter-less Maven Plugin&/name&& &dependencies&& & &dependency&& & & &groupId&org.apache.maven&/groupId&& & & &artifactId&maven-plugin-api&/artifactId&& & & &version&2.0&/version&& & &/dependency&& & &!-- dependencies to annotations --&& & &dependency&& & & &groupId&org.apache.maven.plugin-tools&/groupId&& & & &artifactId&maven-plugin-annotations&/artifactId&& & & &version&3.4&/version&& & & &scope&provided&/scope&& & &/dependency&& &/dependencies&&/project&在项目pom文件目录运行install命令将插件安装到本地仓库在使用插件的项目加入配置：& &build&& & &plugins&& & & &plugin&& & & & &groupId&sample.plugin&/groupId&& & & & &artifactId&hello-maven-plugin&/artifactId&& & & & &version&1.0-SNAPSHOT&/version&& & & &/plugin&& & &/plugins&& &/build&执行：mvn groupId:artifactId:version:goal即可完成Hello，world的输出。那么在Gradle中我们该怎么做呢？Gradle中有一个基本概念叫Task，我们可以使用Task来完成这个需求：task hello && {& & println "hello world"}执行Gradle hello，即可完成Hello, World的输出。是不是很简单？像写代码一样~当然实际工程我们要完成的构建任务不仅仅是输出一个info这么简单，我们很可能会去做一些其他复杂的操作，比如初始化文件、数据库，检测系统环境等等。但由于Gradle使用了Groovy作为配置文件，在使用时会比Maven的xml配置灵活许多，更适合我们码农进行使用。制品发布在制品发布这个操作上，Maven要扳回一局。Maven原生支持maven jar的格式，发布很简单；而Gradle虽说既支持Maven又支持Gradle，但是就要我们自己做很多额外的工作。比如Maven要发布制品，只需要配置远程仓库的参数：& &distributionManagement&& & &repository&& & & &id&internal&/id&& & & &name&Internal Release Repository&/name&& & & &url&&/url&& & &/repository&& &/distributionManagement&而gradle发布制品，还需要生成pom文件：uploadArchives {& & repositories {& & & & mavenDeployer {& & & & & & //为Pom文件做数字签名& & & & & & beforeDeployment { MavenDeployment deployment -& signing.signPom(deployment) }& & & & & & repository(url: "") {& & & & & & & & authentication(userName: username, password: password)& & & & & & }& & & & & & //构造项目的Pom文件& & & & & & pom.project {& & & & & & & & name project.name& & & & & & & & packaging 'jar'& & & & & & & & description 'description'& & & & & & }& & & & }& & }}总结因为时间关系，简单介绍了这么多，可能读者也对Gradle与Maven的差别有了一些了解。Gradle与Maven相比更为灵活，简单。但是Maven相比于Gradle的不灵活，是否也是它的优点呢？这就需要读者在工程中自己进行思考了。除此之外Gradle的官方网站专门给出了一个专栏来讲Gradle与Maven的区别: Maven vs Gradle: Feature Comparison。有耐心的读者可以看看这些对比。如果说你要说我没耐心看完这些，只想快点挑个构建工作开始我的项目！ 那么我要说的是：Just have a try! Maven和Gradle都是非常优秀的构建工具，增加二者的使用经验不是一个很亏的事情。当然如果你要开发Android应用的话，还是推荐你使用Gradle做构建工具，因为Google官方推的Android Studio就使用了Gradle作为原生构建工具，这使得Gradle对Android各版本软件的构建支持得更好一些。其他项目的话，二者选其一吧~
天下第一又如何分享一篇干货：Java世界中主要有三大构建工具：Ant、Maven和Gradle。经过几年的发展，Ant几乎销声匿迹、Maven也日薄西山，而Gradle的发展则如日中天。笔者有幸见证了Maven的没落和Gradle的兴起。Maven的主要功能主要分为5点，分别是依赖管理系统、多模块构建、一致的项目结构、一致的构建模型和插件机制。我们可以从这五个方面来分析一下Gradle比起Maven的先进之处。依赖管理系统Maven为Java世界引入了一个新的依赖管理系统。在Java世界中，可以用groupId、artifactId、version组成的Coordination（坐标）唯一标识一个依赖。任何基于Maven构建的项目自身也必须定义这三项属性，生成的包可以是Jar包，也可以是war包或者ear包。一个典型的依赖引用如下所示：从上面可以看出当引用一个依赖时，version可以省略掉，这样在获取依赖时会选择最新的版本。而存储这些组件的仓库有远程仓库和本地仓库之分。远程仓库可以使用世界公用的central仓库，也可以使用Apache Nexus自建私有仓库；本地仓库则在本地计算机上。通过Maven安装目录下的settings.xml文件可以配置本地仓库的路径，以及采用的远程仓库的地址。Gradle在设计的时候基本沿用了Maven的这套依赖管理体系。不过它在引用依赖时还是进行了一些改进。首先引用依赖方面变得非常简洁。第二，Maven和Gradle对依赖项的scope有所不同。在Maven世界中，一个依赖项有6种scope，分别是complie(默认)、provided、runtime、test、system、import。而grade将其简化为了4种，compile、runtime、testCompile、testRuntime。那么如果想在gradle使用类似于provided的scope怎么办？别着急，由于gradle语言的强大表现力，我们可以轻松编写代码来实现类似于provided scope的概念。第三点是Gradle支持动态的版本依赖。在版本号后面使用+号的方式可以实现动态的版本管理。第四点是在解决依赖冲突方面Gradle的实现机制更加明确。使用Maven和Gradle进行依赖管理时都采用的是传递性依赖；而如果多个依赖项指向同一个依赖项的不同版本时就会引起依赖冲突。而Maven处理这种依赖关系往往是噩梦一般的存在。而Gradle在解决依赖冲突方面相对来说比较明确。多模块构建在SOA和微服务的浪潮下，将一个项目分解为多个模块已经是很通用的一种方式。在Maven中需要定义个parent POM作为一组module的聚合POM。在该POM中可以使用&modules&标签来定义一组子模块。parent POM不会有什么实际构建产出。而parent POM中的build配置以及依赖配置都会自动继承给子module。而Gradle也支持多模块构建。而在parent的build.gradle中可以使用allprojects和subprojects代码块来分别定义里面的配置是应用于所有项目还是子项目。对于子模块的定义是放置在setttings.gradle文件中的。在gradle的设计当中，每个模块都是Project的对象实例。而在parent build.gradle中通过allprojects或subprojects可以对这些对象进行各种操作。这无疑比Maven要灵活的多。比如在parent的build.gradle中有以下代码：执行命令gradle -q hello会依次打印出父module以及各个submodule的项目名称。这种强大的能力能让gradle对各个模块具有更强的定制化。一致的项目结构在Ant时代大家创建Java项目目录时比较随意，然后通过Ant配置指定哪些属于source，那些属于testSource等。而Maven在设计之初的理念就是Conversion over configuration（约定大于配置）。其制定了一套项目目录结构作为标准的Java项目结构。一个典型的Maven项目结构如下：Gradle也沿用了这一标准的目录结构。如果你在Gradle项目中使用了标准的Maven项目结构的话，那么在Gradle中也无需进行多余的配置,只需在文件中包含apply plugin:'java',系统会自动识别source、resource、test srouce、 test resource等相应资源。不过Gradle作为JVM上的构建工具，也同时支持groovy、scala等源代码的构建，甚至支持Java、groovy、scala语言的混合构建。虽然Maven通过一些插件也能达到相同目的，但配置方面显然Gradle要更优雅一些。一致的建构模型为了解决Ant中对项目构建活动缺乏标准化的问题，Maven特意设置了标准的项目构建周期，其默认的构建周期如下所示：而这种构建周期也是Maven最为人诟病的地方。因为Maven将项目的构建周期限制的太死，你无法在构建周期中添加新的phase，只能将插件绑定到已有的phase上。而现在项目的构建过程变得越来越复杂，而且多样化，显然Maven对这种复杂度缺少足够的应变能力。比如你想在项目构建过程中进行一项压缩所有javascript的任务，那么就要绑定到Maven的现有的某个phase上，而显然貌似放在哪个phase都不太合适。而且这些phase都是串行的，整个执行下来是一条线，这也限制了Maven的构建效率。而Gradle在构建模型上则非常灵活。在Gradle世界里可以轻松创建一个task，并随时通过depends语法建立与已有task的依赖关系。甚至对于Java项目的构建来说，Gradle是通过名为java的插件来包含了一个对Java项目的构建周期，这等于Gradle本身直接与项目构建周期是解耦的。插件机制Maven和Gradle设计时都采用了插件机制。但显然Gradle更胜一筹。主要原因在于Maven是基于XML进行配置。所以其配置语法太受限于XML。即使实现很小的功能都需要设计一个插件，建立其与XML配置的关联。比如想在Maven中执行一条shell命令，其配置如下：而在Gradle中则一切变得非常简单。在创建自定义插件方面，Maven和Gradle的机制都差不多，都是继承自插件基类，然后实现要求的方法。这里就不展开说明。从以上五个方面可以看出Maven和Gradle的主要差异。Maven的设计核心Convention Over Configuration被Gradle更加发扬光大，而Gradle的配置即代码又超越了Maven。在Gradle中任何配置都可以作为代码被执行的，我们也可以随时使用已有的Ant脚本（Ant task是Gradle中的一等公民）、Java类库、Groovy类库来辅助完成构建任务的编写。这种采用本身语言实现的DSL对本身语言项目进行构建管理的例子比比皆是。比如Rake和Ruby、Grunt和JavaScript、Sbt和Ruby…..而Gradle之所以使用Groovy语言实现，是因为Groovy比Java语言更具表现力，其语法特性更丰富，又兼具函数式的特点。这几年兴起的语言（比如Scala、Go、Swift）都属于强类型的语言，兼具面向对象和函数式的特点。最后想说的Gradle的命令行比Maven的要强大的多。分享一篇干货：Java世界中主要有三大构建工具：Ant、Maven和Gradle。经过几年的发展，Ant几乎销声匿迹、Maven也日薄西山，而Gradle的发展则如日中天。笔者有幸见证了Maven的没落和Gradle的兴起。Maven的主要功能主要分为5点，分别是依赖管理系统、多模块构建、一致的项目结构、一致的构建模型和插件机制。我们可以从这五个方面来分析一下Gradle比起Maven的先进之处。依赖管理系统Maven为Java世界引入了一个新的依赖管理系统。在Java世界中，可以用groupId、artifactId、version组成的Coordination（坐标）唯一标识一个依赖。任何基于Maven构建的项目自身也必须定义这三项属性，生成的包可以是Jar包，也可以是war包或者ear包。一个典型的依赖引用如下所示：从上面可以看出当引用一个依赖时，version可以省略掉，这样在获取依赖时会选择最新的版本。而存储这些组件的仓库有远程仓库和本地仓库之分。远程仓库可以使用世界公用的central仓库，也可以使用Apache Nexus自建私有仓库；本地仓库则在本地计算机上。通过Maven安装目录下的settings.xml文件可以配置本地仓库的路径，以及采用的远程仓库的地址。Gradle在设计的时候基本沿用了Maven的这套依赖管理体系。不过它在引用依赖时还是进行了一些改进。首先引用依赖方面变得非常简洁。第二，Maven和Gradle对依赖项的scope有所不同。在Maven世界中，一个依赖项有6种scope，分别是complie(默认)、provided、runtime、test、system、import。而grade将其简化为了4种，compile、runtime、testCompile、testRuntime。那么如果想在gradle使用类似于provided的scope怎么办？别着急，由于gradle语言的强大表现力，我们可以轻松编写代码来实现类似于provided scope的概念。第三点是Gradle支持动态的版本依赖。在版本号后面使用+号的方式可以实现动态的版本管理。第四点是在解决依赖冲突方面Gradle的实现机制更加明确。使用Maven和Gradle进行依赖管理时都采用的是传递性依赖；而如果多个依赖项指向同一个依赖项的不同版本时就会引起依赖冲突。而Maven处理这种依赖关系往往是噩梦一般的存在。而Gradle在解决依赖冲突方面相对来说比较明确。多模块构建在SOA和微服务的浪潮下，将一个项目分解为多个模块已经是很通用的一种方式。在Maven中需要定义个parent POM作为一组module的聚合POM。在该POM中可以使用&modules&标签来定义一组子模块。parent POM不会有什么实际构建产出。而parent POM中的build配置以及依赖配置都会自动继承给子module。而Gradle也支持多模块构建。而在parent的build.gradle中可以使用allprojects和subprojects代码块来分别定义里面的配置是应用于所有项目还是子项目。对于子模块的定义是放置在setttings.gradle文件中的。在gradle的设计当中，每个模块都是Project的对象实例。而在parent build.gradle中通过allprojects或subprojects可以对这些对象进行各种操作。这无疑比Maven要灵活的多。比如在parent的build.gradle中有以下代码：执行命令gradle -q hello会依次打印出父module以及各个submodule的项目名称。这种强大的能力能让gradle对各个模块具有更强的定制化。一致的项目结构在Ant时代大家创建Java项目目录时比较随意，然后通过Ant配置指定哪些属于source，那些属于testSource等。而Maven在设计之初的理念就是Conversion over configuration（约定大于配置）。其制定了一套项目目录结构作为标准的Java项目结构。一个典型的Maven项目结构如下：Gradle也沿用了这一标准的目录结构。如果你在Gradle项目中使用了标准的Maven项目结构的话，那么在Gradle中也无需进行多余的配置,只需在文件中包含apply plugin:'java',系统会自动识别source、resource、test srouce、 test resource等相应资源。不过Gradle作为JVM上的构建工具，也同时支持groovy、scala等源代码的构建，甚至支持Java、groovy、scala语言的混合构建。虽然Maven通过一些插件也能达到相同目的，但配置方面显然Gradle要更优雅一些。一致的建构模型为了解决Ant中对项目构建活动缺乏标准化的问题，Maven特意设置了标准的项目构建周期，其默认的构建周期如下所示：而这种构建周期也是Maven最为人诟病的地方。因为Maven将项目的构建周期限制的太死，你无法在构建周期中添加新的phase，只能将插件绑定到已有的phase上。而现在项目的构建过程变得越来越复杂，而且多样化，显然Maven对这种复杂度缺少足够的应变能力。比如你想在项目构建过程中进行一项压缩所有javascript的任务，那么就要绑定到Maven的现有的某个phase上，而显然貌似放在哪个phase都不太合适。而且这些phase都是串行的，整个执行下来是一条线，这也限制了Maven的构建效率。而Gradle在构建模型上则非常灵活。在Gradle世界里可以轻松创建一个task，并随时通过depends语法建立与已有task的依赖关系。甚至对于Java项目的构建来说，Gradle是通过名为java的插件来包含了一个对Java项目的构建周期，这等于Gradle本身直接与项目构建周期是解耦的。插件机制Maven和Gradle设计时都采用了插件机制。但显然Gradle更胜一筹。主要原因在于Maven是基于XML进行配置。所以其配置语法太受限于XML。即使实现很小的功能都需要设计一个插件，建立其与XML配置的关联。比如想在Maven中执行一条shell命令，其配置如下：而在Gradle中则一切变得非常简单。在创建自定义插件方面，Maven和Gradle的机制都差不多，都是继承自插件基类，然后实现要求的方法。这里就不展开说明。从以上五个方面可以看出Maven和Gradle的主要差异。Maven的设计核心Convention Over Configuration被Gradle更加发扬光大，而Gradle的配置即代码又超越了Maven。在Gradle中任何配置都可以作为代码被执行的，我们也可以随时使用已有的Ant脚本（Ant task是Gradle中的一等公民）、Java类库、Groovy类库来辅助完成构建任务的编写。这种采用本身语言实现的DSL对本身语言项目进行构建管理的例子比比皆是。比如Rake和Ruby、Grunt和JavaScript、Sbt和Ruby…..而Gradle之所以使用Groovy语言实现，是因为Groovy比Java语言更具表现力，其语法特性更丰富，又兼具函数式的特点。这几年兴起的语言（比如Scala、Go、Swift）都属于强类型的语言，兼具面向对象和函数式的特点。最后想说的Gradle的命令行比Maven的要强大的多。
=====.=====应该选择Gradle，理由如下：1.为什么选择Gradle2.&简单入门2.1&使用Intellij Idea创建gradle项目首先在Idea中启用Gradle支持：Settings-&Plugins: Gradle；然后创建一个gradle项目或模块，会发现目录结构和maven的很像，其中build.gradle是gradle的配置文件，类似于maven中pom.xml文件，以下是build.gradle的简单示例：apply plugin: 'java'group = 'org.yousharp'version = '1.0-SNAPSHOT'&sourceCompatibility = 1.7targetCompatibility = 1.7repositories {&&&&&&&&&mavenCentral()&&&&&&&&&maven{ url "" }}dependencies {&&&&&&&&&compilegroup: 'com.google.guava', name: 'guava', version:'17.0'&&&&&&&&&compilegroup: 'redis.clients', name: 'jedis', version:'2.6.0'&&&&&&&&&testCompilegroup: 'junit', name: 'junit', version:'4.11'}插件(plugin)：是gradle的一种扩展，gradle预定义了很多插件，常见的如java插件、war插件等；java插件中定义了一些有用的task，如编译源码、执行单元测试、生成jar包、约定默认的目录结构等；&repositories定义仓库，dependencies定义项目的依赖，比maven的XML定义更简洁；那么，如何编译、测试，以及运行gradle的项目呢？&刚才说到java插件预定义了很多task，其中就包括编译、测试、生成jar包等task，可以在命令行通过&$ gradle tasks&查看项目已定义的所有task以及含义，如java插件中常用的task有：+ assemble:&编译+ build：编译并执行测试+ clean：删除build目录+ jar：&生成jar包+ test：执行单元测试2.2&将Java项目从maven迁移到gradle如何将一个java项目从maven迁移到gradle呢？gradle集成了一个很方便的插件：Build Init Plugin，使用这个插件可以很方便地创建一个新的gradle项目，或者将其它类型的项目转换为gradle项目。要将maven项目转换为gradle项目，只需要在项目的pom文件所在的目录下执行以下命令：$ gradle init --type pom上面的命令会根据pom文件自动生成gradle项目所需的文件和配置，然后以gradle项目重新导入即可。应该选择Gradle，理由如下：1.为什么选择Gradle2.&简单入门2.1&使用Intellij Idea创建gradle项目首先在Idea中启用Gradle支持：Settings-&Plugins: Gradle；然后创建一个gradle项目或模块，会发现目录结构和maven的很像，其中build.gradle是gradle的配置文件，类似于maven中pom.xml文件，以下是build.gradle的简单示例：apply plugin: 'java'group = 'org.yousharp'version = '1.0-SNAPSHOT'&sourceCompatibility = 1.7targetCompatibility = 1.7repositories {&&&&&&&&&mavenCentral()&&&&&&&&&maven{ url "" }}dependencies {&&&&&&&&&compilegroup: 'com.google.guava', name: 'guava', version:'17.0'&&&&&&&&&compilegroup: 'redis.clients', name: 'jedis', version:'2.6.0'&&&&&&&&&testCompilegroup: 'junit', name: 'junit', version:'4.11'}插件(plugin)：是gradle的一种扩展，gradle预定义了很多插件，常见的如java插件、war插件等；java插件中定义了一些有用的task，如编译源码、执行单元测试、生成jar包、约定默认的目录结构等；&repositories定义仓库，dependencies定义项目的依赖，比maven的XML定义更简洁；那么，如何编译、测试，以及运行gradle的项目呢？&刚才说到java插件预定义了很多task，其中就包括编译、测试、生成jar包等task，可以在命令行通过&$ gradle tasks&查看项目已定义的所有task以及含义，如java插件中常用的task有：+ assemble:&编译+ build：编译并执行测试+ clean：删除build目录+ jar：&生成jar包+ test：执行单元测试2.2&将Java项目从maven迁移到gradle如何将一个java项目从maven迁移到gradle呢？gradle集成了一个很方便的插件：Build Init Plugin，使用这个插件可以很方便地创建一个新的gradle项目，或者将其它类型的项目转换为gradle项目。要将maven项目转换为gradle项目，只需要在项目的pom文件所在的目录下执行以下命令：$ gradle init --type pom上面的命令会根据pom文件自动生成gradle项目所需的文件和配置，然后以gradle项目重新导入即可。一点拙见，帮助谈不上，希望对你能有点启发：时至今日，如果你的Java项目依然需要启动一个特定的工具，比如IDE，才能编译部署，那你的项目不在本文的讨论之中，因为实在落后得太让人无语了。好，回归正题。旧时代的Java世界，构建工具等同于两个词Ant 和 Maven。Ant源自Make，同JUnit一样，它也是一个航班产物（参见《Ant权威指南》序）。不过，Make的基础注定了它的起点不高，所有一切都要手工打造。我还依稀记得曾几何时，每每开始一个项目都要重新复制一份Ant脚本，修修改改。 Maven给了人们新的希望，目录结构的约定、依赖管理、IDE集成，那时看来，几近完美。是的，几近，还差了那么一点点。就是那么一点点，却是致命伤。只要一个项目进行一段时间，一个必然遇到的问题就是，编写新的自动化脚本。因为每个项目都有自己的特定需求，标准做法必然是无法满足的。扩展 Maven对任何新手都是一件头疼的事，我们要学会编写插件，要搞清楚生命周期，这时，突然会唤起一丝丝对于ANT的怀念，虽然它做简单事不容易，但做复杂事却也没这么困难。如果那些日子，我们不得不忍受Ant和Maven的不完美，那现在，是时候抛弃它们了。新时代Java构建有两个很好的候选：Gradle 和 Buildr。在我看来，它们真正比Maven更强大的地方，编写自己的任务更加容易。更值得兴奋的一点是，我们终于可以抛弃冗长的XML，选择一种更优雅的程序设计语言来写代码了，这几乎意味着你可以做到想做的一切。Buildr是Apache出品的构建工具，它以Ruby作为构建脚本。我曾在InfoQ发表过一篇很长的文章《软件开发地基》，讨论软件项目应该具备一些基础构建项，就是以Buildr为基础的。有兴趣的话，可以参考一下。这里就不再赘述。顺便说一下，那篇文章里的内容，除了某些写法现在需要做一些微调，大部分内容依然是适用于大多数Java项目。Gradle现在是整个Java社区的构建新宠，它采用Groovy作为自己的构建语言。如果你知道，Groovy是一门诞生自JVM平台的语言，这就决定了它要比其它移植到JVM上的语言能更好的适应JVM平台，它可以采用更符合Java世界的方式无缝地整合Java既有的程序库，而不必像移植语言那样削足适履。初涉Gradle，最让人吃惊的一点莫过于它详尽的文档，涵盖了Gradle使用的方方面面，这是许多开源软件项目无法媲美，即便早在它的1.0版本尚未发布之时。当然，能做到这一点是因为它背后有一个公司在支撑：GradleWare，这意味着如果你需要商业支持，也是可以的。Gradle 1.0尚未发布之，它就捧回2010年的Spring大奖和入围了2011年的JAX大奖。如果你还需要更多的信心，作为Java开发人员，你不可能不知道Spring，那Spring转投Gradle怀抱，应该是对Gradle最有利的支持了。说了这么多，程序员最喜欢看到的东西还是代码。首先，请自行下载安装Gradle，然后，按照常见的Java项目布局把代码准备好（感谢Maven为我们给予我们约定），比如：src/main/java，源代码文件目录src/main/resources，资源文件目录src/test/java，测试代码目录下面是一个简单的Gradle构建脚本，将其存放于build.gradleapply plugin: 'java'repositories {&&&mavenCentral()}&dependencies {&compile(&&&'com.google.guava:guava:13.0.1',&&&'joda-time:joda-time:2.1'& )&&testCompile(&&&'junit:junit:4.10',&&&'org.mockito:mockito-all:1.9.0'& )}（build.gradle）接下来的事情就很简单了，在命令行里键入gradle build如果一切正常，我们应该会看到构建成功的字样，然后，到build/lib，你就看到自己构建出来的JAR文件了。一点拙见，帮助谈不上，希望对你能有点启发：时至今日，如果你的Java项目依然需要启动一个特定的工具，比如IDE，才能编译部署，那你的项目不在本文的讨论之中，因为实在落后得太让人无语了。好，回归正题。旧时代的Java世界，构建工具等同于两个词Ant 和 Maven。Ant源自Make，同JUnit一样，它也是一个航班产物（参见《Ant权威指南》序）。不过，Make的基础注定了它的起点不高，所有一切都要手工打造。我还依稀记得曾几何时，每每开始一个项目都要重新复制一份Ant脚本，修修改改。 Maven给了人们新的希望，目录结构的约定、依赖管理、IDE集成，那时看来，几近完美。是的，几近，还差了那么一点点。就是那么一点点，却是致命伤。只要一个项目进行一段时间，一个必然遇到的问题就是，编写新的自动化脚本。因为每个项目都有自己的特定需求，标准做法必然是无法满足的。扩展 Maven对任何新手都是一件头疼的事，我们要学会编写插件，要搞清楚生命周期，这时，突然会唤起一丝丝对于ANT的怀念，虽然它做简单事不容易，但做复杂事却也没这么困难。如果那些日子，我们不得不忍受Ant和Maven的不完美，那现在，是时候抛弃它们了。新时代Java构建有两个很好的候选：Gradle 和 Buildr。在我看来，它们真正比Maven更强大的地方，编写自己的任务更加容易。更值得兴奋的一点是，我们终于可以抛弃冗长的XML，选择一种更优雅的程序设计语言来写代码了，这几乎意味着你可以做到想做的一切。Buildr是Apache出品的构建工具，它以Ruby作为构建脚本。我曾在InfoQ发表过一篇很长的文章《软件开发地基》，讨论软件项目应该具备一些基础构建项，就是以Buildr为基础的。有兴趣的话，可以参考一下。这里就不再赘述。顺便说一下，那篇文章里的内容，除了某些写法现在需要做一些微调，大部分内容依然是适用于大多数Java项目。Gradle现在是整个Java社区的构建新宠，它采用Groovy作为自己的构建语言。如果你知道，Groovy是一门诞生自JVM平台的语言，这就决定了它要比其它移植到JVM上的语言能更好的适应JVM平台，它可以采用更符合Java世界的方式无缝地整合Java既有的程序库，而不必像移植语言那样削足适履。初涉Gradle，最让人吃惊的一点莫过于它详尽的文档，涵盖了Gradle使用的方方面面，这是许多开源软件项目无法媲美，即便早在它的1.0版本尚未发布之时。当然，能做到这一点是因为它背后有一个公司在支撑：GradleWare，这意味着如果你需要商业支持，也是可以的。Gradle 1.0尚未发布之，它就捧回2010年的Spring大奖和入围了2011年的JAX大奖。如果你还需要更多的信心，作为Java开发人员，你不可能不知道Spring，那Spring转投Gradle怀抱，应该是对Gradle最有利的支持了。说了这么多，程序员最喜欢看到的东西还是代码。首先，请自行下载安装Gradle，然后，按照常见的Java项目布局把代码准备好（感谢Maven为我们给予我们约定），比如：src/main/java，源代码文件目录src/main/resources，资源文件目录src/test/java，测试代码目录下面是一个简单的Gradle构建脚本，将其存放于build.gradleapply plugin: 'java'repositories {&&&mavenCentral()}&dependencies {&compile(&&&'com.google.guava:guava:13.0.1',&&&'joda-time:joda-time:2.1'& )&&testCompile(&&&'junit:junit:4.10',&&&'org.mockito:mockito-all:1.9.0'& )}（build.gradle）接下来的事情就很简单了，在命令行里键入gradle build如果一切正常，我们应该会看到构建成功的字样，然后，到build/lib，你就看到自己构建出来的JAR文件了。Knowledge and patience. The only counter to greater skill.果断Gradle，选择Gradle可是整个Java社区的大趋势啊！！！果断Gradle，选择Gradle可是整个Java社区的大趋势啊！！！用途不同，就会选择不同的构建工具啊，以下是java十种工具的常用情况，你可以“对症下药”：Apache Maven& ——主要用于构建Java项目的自动化工具。Hudson&——用Java编写的持续集成（CI）工具。Jenkins&——用Java编写的一个开源持续集成工具。项目是在和Oracle发生争执后的来自于Hudson 的分支。Gradle&——一个开源的自动化构建系统，建立在Apache Ant和Maven Apache概念的基础上，并引入了基于Groovy的特定领域语言（DSL），而不是使用Apache Maven宣布的项目配置XML形式。Apache&Ant&——用于自动化软件构建过程的软件工具，源于2000年初的的Apache Tomcat项目。SBT&——用于Scala和Java项目的开源构建工具，类似于Java的Maven和Ant。Atlassian Bamboo&——持续集成和交付工具，它将自动化构建、测试和发布捆绑到单个流程中。TeamCity&——来自于JetBrains的一个基于Java构建的管理和持续集成服务器。Grape&——嵌入到Groovy的JAR依赖项管理器。Ivy&——Apache Ant项目的一个子项目，一个可传递的依赖项管理器。Leiningen&——一个自动化构建和依赖性管理工具，用于使用Clojure编程语言写的软件项目。用途不同，就会选择不同的构建工具啊，以下是java十种工具的常用情况，你可以“对症下药”：Apache Maven& ——主要用于构建Java项目的自动化工具。Hudson&——用Java编写的持续集成（CI）工具。Jenkins&——用Java编写的一个开源持续集成工具。项目是在和Oracle发生争执后的来自于Hudson 的分支。Gradle&——一个开源的自动化构建系统，建立在Apache Ant和Maven Apache概念的基础上，并引入了基于Groovy的特定领域语言（DSL），而不是使用Apache Maven宣布的项目配置XML形式。Apache&Ant&——用于自动化软件构建过程的软件工具，源于2000年初的的Apache Tomcat项目。SBT&——用于Scala和Java项目的开源构建工具，类似于Java的Maven和Ant。Atlassian Bamboo&——持续集成和交付工具，它将自动化构建、测试和发布捆绑到单个流程中。TeamCity&——来自于JetBrains的一个基于Java构建的管理和持续集成服务器。Grape&——嵌入到Groovy的JAR依赖项管理器。Ivy&——Apache Ant项目的一个子项目，一个可传递的依赖项管理器。Leiningen&——一个自动化构建和依赖性管理工具，用于使用Clojure编程语言写的软件项目。
相关标签：
关注我们咨询服务合作法律法规京ICP备号
下载申请方APP
即刻拥有你的学业规划助手}