第七章.Java构建入门

Java插件为你添加了众多任务.但是它们只是在你需要构建项目的时候才能发挥作用. 最常用的就是build任务,这会构建整个项目.当你执行 gradle build时,Gralde会编译并执行单元测试,并且将src/main/*下面class和资源文件打包
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项目拥有许多外部依赖.你需要告诉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-collections和测试期所需依赖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.+'
}

了解更多可参阅第 8&nsbp;章, 依赖管理基础.
You can find out more in Chapter 8, Dependency Management Basics.

Java插件为你的项目添加了众多默认配置.这些默认值通常对于一个普通项目来说已经足够了.但如果你觉得不适用修改起来也很简单. 看下面的例子,我们为Java项目指定了版本号以及所用的Jdk版本,并且添加一些属性到mainfest中.
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插件添加的都是一些普通任务,如同他们写在Build文件中一样.这意味着前面章节展示的机制都可以用来修改这些任务的行为. 例如,可以设置任务的属性,添加任务行为,更改任务依赖,甚至是重写覆盖整个任务.在下面的例子中,我们将修改 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发布到到哪.在Gradle中Jar包通常被发布到某个仓库中. 在下面的例子中,我们会将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项目文件.了解更多内容请参阅 第 38 章, The 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'
       }
    }
}

定义一个多项目构建工程需要在根目录(本例中与multiproject同级)创建一个setting 配置文件来指明构建包含哪些项目.并且这个文件必需叫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"
						

了解更多可参阅第 56 章, 多项目构建.
You can find out more about the settings file in Chapter 56, Multi-project Builds.

对多项目构建而言,总有一些共同的配置.在本例中,我们会在根项目上采用配置注入的方式定义一些公共配置.根项目就像一个容器,子项目会迭代访问它的配置并注入到自己的配置中. 这样我们就可以简单的为所有工程定义主配置单了:
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插件.这意味着我们在前面章节学习的内容在子项目中也都是可用的. 所以你可以在根项目目录进行编译,测试,打包等所有操作.
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在构建api之前总是会先构建shared工程.
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
}