【转载】Gradle学习 第二章：概述

转载地址：http://ask.android-studio.org/?/article/6

Here is a list of some of Gradle's features.
<翻译>以下是关于Gradle特点的描述

Declarative builds and build-by-convention 宣言和公约
At the heart of Gradle lies a rich extensible Domain Specific Language (DSL) based on Groovy. Gradle pushes declarative builds to the next level by providing declarative language elements that you can assemble as you like. Those elements also provide build-by-convention support for Java, Groovy, OSGi, Web and Scala projects. Even more, this declarative language is extensible. Add your own new language elements or enhance the existing ones, thus providing concise, maintainable and comprehensible builds.
<翻译>Gradle的核心是一个丰富的可扩展的基于Groovy的领域特定语言(DSL)。Gradle通过提供说明性语言元素将说明性构建推到下一层，您可以组装。这些元素也提供build-by-convention支持Java、Groovy、OSGi、Web和Scala项目。更多，这个说明性语言是可扩展的。添加自己的新语言元素或提高现有的，从而提供简洁、易于维护和理解构建。

Language for dependency based programming 依赖的编程语言
The declarative language lies on top of a general purpose task graph, which you can fully leverage in your builds. It provides utmost flexibility to adapt Gradle to your unique needs.
<翻译>说明性语言位于通用任务列表之上，所有你可以在工程里充分的利用。它提供了最大的灵活性，以适应你对Gradle的独特需求。

Structure your build 构建你的工程
The suppleness and richness of Gradle finally allows you to apply common design principles to your build. For example, it is very easy to compose your build from reusable pieces of build logic. Inline stuff where unnecessary indirections would be inappropriate. Don't be forced to tear apart what belongs together (e.g. in your project hierarchy). Avoid smells like shotgun changes or divergent change that turn your build into a maintenance nightmare. At last you can create a well structured, easily maintained, comprehensible build.
<翻译>

Deep API 深入的接口
From being a pleasure to be used embedded to its many hooks over the whole lifecycle of build execution, Gradle allows you to monitor and customize its configuration and execution behavior to its very core.
<翻译>

Gradle scales
Gradle scales very well. It significantly increases your productivity, from simple single project builds up to huge enterprise multi-project builds. This is true for structuring the build. With the state-of-art incremental build function, this is also true for tackling the performance pain many large enterprise builds suffer from.
<翻译>

Multi-project builds
Gradle's support for multi-project build is outstanding. Project dependencies are first class citizens. We allow you to model the project relationships in a multi-project build as they really are for your problem domain. Gradle follows your layout not vice versa.
<翻译>

Gradle provides partial builds. If you build a single subproject Gradle takes care of building all the subprojects that subproject depends on. You can also choose to rebuild the subprojects that depend on a particular subproject. Together with incremental builds this is a big time saver for larger builds.
<翻译>Gradle提供了局部项目的构建。

Many ways to manage your dependencies 多种方法来管理你的工程构建依赖
Different teams prefer different ways to manage their external dependencies. Gradle provides convenient support for any strategy. From transitive dependency management with remote Maven and Ivy repositories to jars or directories on the local file system.
<翻译>不同的团队喜欢通过不同的方法来管理工程的外部依赖。Gradle对不同的管理策略皆提供了支持。从依赖管理与远程Maven和lvy库到本地文件系统上的jar包或目录都被包含在内。

Gradle is the first build integration tool Gradle是第一个集成化的构建工具
Ant tasks are first class citizens. Even more interesting, Ant projects are first class citizens as well. Gradle provides a deep import for any Ant project, turning Ant targets into native Gradle tasks at runtime. You can depend on them from Gradle, you can enhance them from Gradle, you can even declare dependencies on Gradle tasks in your build.xml. The same integration is provided for properties, paths, etc ...
<翻译>

Gradle fully supports your existing Maven or Ivy repository infrastructure for publishing and retrieving dependencies. Gradle also provides a converter for turning a Maven pom.xml into a Gradle script. Runtime imports of Maven projects will come soon.
<翻译>

Ease of migration 便于迁移
Gradle can adapt to any structure you have. Therefore you can always develop your Gradle build in the same branch where your production build lives and both can evolve in parallel. We usually recommend to write tests that make sure that the produced artifacts are similar. That way migration is as less disruptive and as reliable as possible. This is following the best-practices for refactoring by applying baby steps.
<翻译>Gradle适用于你的任何工程结构。

Groovy
Gradle's build scripts are written in Groovy, not XML. But unlike other approaches this is not for simply exposing the raw scripting power of a dynamic language. That would just lead to a very difficult to maintain build. The whole design of Gradle is oriented towards being used as a language, not as a rigid framework. And Groovy is our glue that allows you to tell your individual story with the abstractions Gradle (or you) provide. Gradle provides some standard stories but they are not privileged in any form. This is for us a major distinguishing feature compared to other declarative build systems. Our Groovy support is not just sugar coating. The whole Gradle API is fully Groovy-ized. Adding Groovy results in an enjoyable and productive experience.
<翻译>

The Gradle wrapper Gradle外层
The Gradle Wrapper allows you to execute Gradle builds on machines where Gradle is not installed. This is useful for example for some continuous integration servers. It is also useful for an open source project to keep the barrier low for building it. The wrapper is also very interesting for the enterprise. It is a zero administration approach for the client machines. It also enforces the usage of a particular Gradle version thus minimizing support issues.
<翻译>

Free and open source 免费和开源
Gradle is an open source project, and is licensed under the ASL.
<翻译>

2.2. Why Groovy? 使用Groovy的原因
We think the advantages of an internal DSL (based on a dynamic language) over XML are tremendous when used in build scripts. There are a couple of dynamic languages out there. Why Groovy? The answer lies in the context Gradle is operating in. Although Gradle is a general purpose build tool at its core, its main focus are Java projects. In such projects the team members will be very familiar with Java. We think a build should be as transparent as possible to all team members.
<翻译>

In that case, you might argue why we don't just use Java as the language for build scripts. We think this is a valid question. It would have the highest transparency for your team and the lowest learning curve, but because of the limitations of Java, such a build language would not be as nice, expressive and powerful as it could be. [1] Languages like Python, Groovy or Ruby do a much better job here. We have chosen Groovy as it offers by far the greatest transparency for Java people. Its base syntax is the same as Java's as well as its type system, its package structure and other things. Groovy provides much more on top of that, but with the common foundation of Java.
<翻译>既然如此

For Java developers with Python or Ruby knowledge or the desire to learn them, the above arguments don't apply. The Gradle design is well-suited for creating another build script engine in JRuby or Jython. It just doesn't have the highest priority for us at the moment. We happily support any community effort to create additional build script engines.
<翻译>对于Java开发人员来说，以上的叙述并不适用于学习Pythen语言或Ruby语言的知识或者使用它们来开发。Gradle被设计为适用于使用JRuby或者Jython来开发的另一种脚本构建引擎。这只是我们在设计之初没有给予它最高的优先权。我们很乐意通过开发社区的力量来创造更多的脚本构建引擎。

原文地址：http://www.gradle.org/docs/cur ... .html
翻译者：PFei_He
邮箱：498130877@qq.com

如对翻译内容有异议，请在评论区提出或联系作者