第七章. Java 快速入门

Java插件向你的项目中添加了不少的任务。但是，在构建项目时只有其中的一部分任务才使用到。最常用的是这个 build 任务，它会对项目做一次完整的构建。当运行 gradle build时，Gradle会编译并执行测试，然后将你的主要类文件和资源文件打成JAR包。
The Java plugin adds quite a few tasks to your project. However, there are only a handful of tasks that you will need to use to build the project. The most commonly used task is the build task, which does a full build of the project. When you run gradle build, Gradle will compile and test your code, and create a JAR file containing your main classes and resources:

> gradle build
:compileJava
:processResources
:classes
:jar
:assemble
:compileTestJava
:processTestResources
:testClasses
:test
:check
:build

BUILD SUCCESSFUL

Total time: 1 secs

其他一些有用的任务是：
Some other useful tasks are:

通常一个Java项目都会依赖一些外部JAR文件。如果想在项目里引用这些JAR文件，你需要告诉Gradle如何找到这们。在Gradle中，像JAR文件这样的工件都存在于 仓库。仓库可以用于获取项目中的依赖，或是发布项目的工件。在下面的例子中，我们将使用公共的Maven仓库：
Usually, a Java project will have some dependencies on external JAR files. To reference these JAR files in the project, you need to tell Gradle where to find them. In Gradle, artifacts such as JAR files, are located in a repository. A repository can be used for fetching the dependencies of a project, or for publishing the artifacts of a project, or both. For this example, we will use the public Maven repository:

repositories {
    mavenCentral()
}

让我们来添加一些依赖。在这里，我们将声明我们的生产类对commons collection具有编译时依赖，我们的测试类对junit具有需要编译时依赖：
Let's add some dependencies. Here, we will declare that our production classes have a compile-time dependency on commons collections, and that our test classes have a compile-time dependency on junit:

dependencies {
    compile group: 'commons-collections', name: 'commons-collections', version: '3.2'
    testCompile group: 'junit', name: 'junit', version: '4.+'
}

更多的信息请参阅《第八章，依赖管理基础》
You can find out more in Chapter 8, Dependency Management Basics.

Java插件向你的项目添加了许多属性。这些属性都具有默认值，足以让项目快速开始。如果不符合要求，修改这些值也很简单。让我们在例子中来看。这里，我们会指定我们的Java项目的版本号，以及我们的源码所使用Java版本。我们也会向JAR包的清单文件中添加一些属性。
The Java plugin adds a number of properties to your project. These properties have default values which are usually sufficient to get started. It's easy to change these values if they don't suit. Let's look at this for our sample. Here we will specify the version number for our Java project, along with the Java version our source is written in. We also add some attributes to the JAR manifest.

sourceCompatibility = 1.5
version = '1.0'
jar {
    manifest {
        attributes 'Implementation-Title': 'Gradle Quickstart', 'Implementation-Version': version
    }
}

Java插件所添加的任务都是一些普通任务，与在构建文件里声明的完全一样。这也就是说，你可以利用前面的章节所说的任何机制来自定义这些任务。比如你可以设置一个任务的属性，给它添加一些行为，修改一个任务的依赖，或者是完全地替换掉一个任务。在下面的例子中，我们会配置一个Test类型的 test 任务，使得当执行测试的时候添加一个系统属性：
The tasks which the Java plugin adds are regular tasks, exactly the same as if they were declared in the build file. This means you can use any of the mechanisms shown in earlier chapters to customize these tasks. For example, you can set the properties of a task, add behaviour to a task, change the dependencies of a task, or replace a task entirely. In our sample, we will configure the test task, which is of type Test, to add a system property when the tests are executed:

test {
    systemProperties 'property': 'value'
}

通常，JAR文件都需要发布到某个地方。为此，你需要告诉Gradle要把JAR文件发布到哪里。在Gradle里，诸如JAR文件这样的工件会被发布到仓库中。在我们的示例中，将发布到一个本地仓库里。当然，你也可以发布到一个远程的位置，或者是多个位置。
Usually the JAR file needs to be published somewhere. To do this, you need to tell Gradle where to publish the JAR file. In Gradle, artifacts such as JAR files are published to repositories. In our sample, we will publish to a local directory. You can also publish to a remote location, or multiple locations.

uploadArchives {
    repositories {
       flatDir {
           dirs 'repos'
       }
    }
}

执行 gradle uploadArchives以发布JAR文件。
To publish the JAR file, run gradle uploadArchives.

要想导入项目到Eclipse中，你需要在你的构建文件中添加另一个插件：
To import your project into Eclipse, you need to add another plugin to your build file:

apply plugin: 'eclipse'

现在执行gradle eclipse 命令将生成Eclipse的项目文件。有关Eclipse插件的更多信息请参阅《第三十八章，Eclipse插件》。
Now execute gradle eclipse command to generate Eclipse project files. More on Eclipse task can be found in Chapter 38, The Eclipse Plugin.

以下是我们的例子中的完全的构建文件：
Here's the complete build file for our sample:

apply plugin: 'java'
apply plugin: 'eclipse'

sourceCompatibility = 1.5
version = '1.0'
jar {
    manifest {
        attributes 'Implementation-Title': 'Gradle Quickstart', 'Implementation-Version': version
    }
}

repositories {
    mavenCentral()
}

dependencies {
    compile group: 'commons-collections', name: 'commons-collections', version: '3.2'
    testCompile group: 'junit', name: 'junit', version: '4.+'
}

test {
    systemProperties 'property': 'value'
}

uploadArchives {
    repositories {
       flatDir {
           dirs 'repos'
       }
    }
}

定义一个多项目构建，需要在源码树的根目录下创建一个设置文件。这个设置文件的名字必须是settings.gradle，它会指定要包含哪些项目。在这个例子中，我们会使用一个简单的层次布局，以下是对应的设置文件：
To define a multi-project build, you need to create a settings file. The settings file lives in the root directory of the source tree, and specifies which projects to include in the build. It must be called settings.gradle. For this example, we are using a simple hierarchical layout. Here is the corresponding settings file:

include "shared", "api", "services:webservice", "services:shared"

更多的信息可参阅《第五十六章，多项目构建》。
You can find out more about the settings file in Chapter 56, Multi-project Builds.

对于大多数的多项目构建，会有一些共同的配置。在我们的例子中，将会在根项目中使用一种叫做配置注入的技术来定义这些公共配置。在这里，这个根项目就像一个容器，subprojects 的方法会遍历这个容器的一些元素——这个实例中的所有子项目，并且注入指定的配置。这样我们就可以轻松地定义所有存档的清单内容，以及一些公共的依赖：
For most multi-project builds, there is some configuration which is common to all projects. In our sample, we will define this common configuration in the root project, using a technique called configuration injection. Here, the root project is like a container and the subprojects method iterates over the elements of this container - the projects in this instance - and injects the specified configuration. This way we can easily define the manifest content for all archives, and some common dependencies:

subprojects {
    apply plugin: 'java'
    apply plugin: 'eclipse-wtp'

    repositories {
       mavenCentral()
}
    }

    dependencies {
        testCompile 'junit:junit:4.11'
}
    }

    version = '1.0'

    jar {
        manifest.attributes provider: 'gradle'
    }
}

注意，我们的例子对每一个子项目都应用了Java插件。这意味着，在前一节我们所看到的任务和配置，在每一个子项目中都是可用的。因此，你可以通过在根项目目录中运行gradle build，对所有的项目编译，测试并打成JAR包。
Notice that our sample applies the Java plugin to each subproject. This means the tasks and configuration properties we have seen in the previous section are available in each subproject. So, you can compile, test, and JAR all the projects by running gradle build from the root project directory.

你可以向同一个构建的项目之间添加依赖关系，这样，某个项目中的 JAR 文件就能用于编译另一个项目了。在 api项目的构建文件里，我们让它依赖 shared 项目所生成的JAR文件。由于这个依赖关系，Gradle会确保 shared项目总是在 api项目之前构建。
You can add dependencies between projects in the same build, so that, for example, the JAR file of one project is used to compile another project. In the api build file we will add a dependency on the JAR produced by the shared project. Due to this dependency, Gradle will ensure that project shared always gets built before project api.

dependencies {
    compile project(':shared')
}

在下面的例子中，我们创建了一个分发，来发送给客户端：
We also add a distribution, that gets shipped to the client:

task dist(type: Zip) {
    dependsOn spiJar
    from 'src/dist'
    into('libs') {
        from spiJar.archivePath
        from configurations.runtime
    }
}

artifacts {
   archives dist
}