澳门新葡萄京娱乐场 1

澳门新葡萄京娱乐场通过Maven构建Java项目

使用Gradle构建Java项目

这个手册将通过一个简单的Java项目向大家介绍如何使用Gradle构建Java项目。

本指南将指导你利用Maven构建一个简单的Java项目。

Gradle

首先介绍一下 Gradle
Gradle 是一个基于JVM的构建工具,这种工具使用的语言是 Groovy,即
build.gradle 里使用的语言。Gradle
能够配置一些编译的选项,也能添加一些开源库的引用。

扔一段维基的介绍:

Gradle 是一个基于 Apache
Ant
和 Apache
Maven
概念的项目自动化建构工具。它使用一种基于
Groovy
的特定领域语言来声明项目设置,而不是传统的XML。
当前其支持的语言限于Java澳门新葡萄京娱乐场,、Groovy

Scala,计划未来将支持更多的语言。

我们将要做什么?

我们将在这篇文档航中创建一个简单的Java项目,然后使用Gradle构建它。

你所构建

你将使用Maven来构建一个应用程序,它将提供一天中的时间。

Gradle Files 分析

当我们要创建一个android项目时,我们会打开Android Studio,新建一个
Project,然后会看到如下的目录结构:

澳门新葡萄京娱乐场 1

项目结构图

黄色框住的区域是gradle相关的配置文件,本文就简单介绍一下剩下的 Gradle
相关的内容。

Gradle
有几个重要的文件,顶层的setting.gradlebuild.gradle文件、每个
Module
自己的build.gradle文件,gradle.properties文件,local.properties文件,gradle目录。

为了以后的和谐相处,下面依次认识一下这几位 Gradle 家族成员:

需要准备什么?

  • 预留15分钟空闲时间
  • 一件称手的兵器(你最喜欢的IDE或者文本编辑器)
  • Java环境([JDK6](

你所需要

  • 大约15min
  • 一个你喜欢的代码编译器
  • JDK6或者更高版本

1. setting.gradle:

include ':app'

这个 setting 文件定义了哪些 module 应该被加入到编译过程,对于 multi
module 的项目我们需要这个文件,它告诉 gradle 要加载哪些 module。
对于一个新建的纯净项目,里面只定义了默认的 appmodule,后续有新的
module 的话都会自动在此处添加,当然也可以手动删掉。

* setting.gradle里也可以用 Groovy
语言写一些方法,这些方法在初始化项目时就被执行,做一些编译前的处理。

如何完成这个手册的内容?

与大多数Spring的入门手册一样,你可以从头开始一步步完成教程中的每一步工作,也可以跳过你已经烂熟的基础步骤。不管采用那种方式,你最后都会得到可工作的代码。

  1. 如果要重头开始,猛戳这里
  2. 如果要跳过基础部分,需执行以下操作:
    • 下载并解压本文档相关源代码,或者使用Git克隆一个:git clone https://github.com/spring-guides/gs-gradle.git
    • cd 进入 gs-gradle/initial
    • 参考到安装Gradle部分

当你完成后,你可以使用gs-gradle/complete来检查你的结果。

如何完成本指南

想大多数的Spring入门指南一样,你可以从头开始然后完成每一步,或者你可以绕过已经熟悉的基本设置步骤。无论哪种方法,你都会得到工作代码。

想从头开始?请移步设置项目

跳过了基础设置?继续看以下内容:

  • 下载并解压本指南的源储存库,或者通过Git
    clone本指南:git clone https://github.com/spring-guides/gs-maven.git
  • cd 进入gs-maven/initial
  • 跳转到初始化

当你完成之后,你可以根据gs-maven/complete中的代码检验结果。

2. 顶层的build.gradle:

buildscript {
    repositories {
        jcenter()
        maven { url 'https://dl.google.com/dl/android/maven2/' }
    }
    dependencies {
        classpath 'com.android.tools.build:gradle:2.3.3'
    }
}

allprojects {
    repositories {
        jcenter()
    }
}
  • buildscript:repositories
    引用了一些代码仓库,比如jcenter()就是一个著名的 Maven
    仓库,也可以用自定义的 url
    来引用一些其他的仓库。dependencies引用了一些 Android 插件,此处是
    gradle 插件。
  • allprojects:其中定义的属性会被应用到所有的 module 中。

配置项目

首先需要配置一个项目给Gradle进行构建。为了保证我们能专注于Gradle,目前最好创建最简单的Java项目。

设置项目

首先你需要通过Maven来构建一个Java项目,只需要注意Maven,至于这个项目可以尽量的简单

创建目录结构
在你选中的项目目录中,创建以下子目录结构;例如,在Unix/Linux系统中使用命令
mkdir -p src/main/java/hello

└── src
    └── main
        └── java
            └── hello

src/main/java/hello这个目录中,你可以创建任何你想要的Java
class文件。为了保持与本指南其余部分的一致,创建以下两个class文件:HelloWorld.javaGreeter.java

src/main/java/hello/HelloWorld.java

package hello;

public class HelloWorld {
    public static void main(String[] args) {
        Greeter greeter = new Greeter();
        System.out.println(greeter.sayHello());
    }
}

src/main/java/hello/Greeter.java

package hello;

public class Greeter {
    public String sayHello() {
        return "Hello world!";
    }
}

至此你已经有了一个可以用Maven来构造的项目,接下来就是安装Maven。

你可以通过http://maven.apache.org/download.cgi下载作为压缩文件的Maven。只需要二进制文件,所以只需要找到apache-maven-{version}-bin.zipapache-maven-{version}-bin.tar.gz的连接即可。

下载压缩文件并解压它,之后将它bin文件夹的路径添加到环境变量path中。

若想测试Maven的安装情况,在命令行执行以下命令:
mvn - v

如果一切正常,你可以看到一些关于Maven的安装信息,例如下面所展示的内容(可能有些轻微的区别):

Apache Maven 3.0.5 (r01de14724cdef164cd33c7c8c2fe155faf9602da; 2013-02-19 07:51:28-0600)
Maven home: /usr/share/maven
Java version: 1.7.0_09, vendor: Oracle Corporation
Java home: /Library/Java/JavaVirtualMachines/jdk1.7.0_09.jdk/Contents/Home/jre
Default locale: en_US, platform encoding: UTF-8
OS name: "mac os x", version: "10.8.3", arch: "x86_64", family: "mac"

恭喜你!Maven已经成功安装啦!

3. module里的的build.gradle:

apply plugin: 'com.android.application'
#apply plugin: 'com.android.library'
android {
    compileSdkVersion 26
    buildToolsVersion "26.0.1"
    defaultConfig {
        applicationId "com.morning.android.glory"
        minSdkVersion 21
        targetSdkVersion 26
        versionCode 1
        versionName "1.0"
        testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
    }
    buildTypes {
        release {
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
        }
    }
}

dependencies {
    compile fileTree(dir: 'libs', include: ['*.jar'])
    androidTestCompile('com.android.support.test.espresso:espresso-core:2.2.2', {
        exclude group: 'com.android.support', module: 'support-annotations'
    })
    compile 'com.android.support:appcompat-v7:26.+'
    compile 'com.android.support.constraint:constraint-layout:1.0.2'
    testCompile 'junit:junit:4.12'
}
  • apply plugin: 这一行代码应用了一些 android
    应用的插件,此处的'com.android.application'表示这个 module
    是主工程,对于子工程,对应要用'com.android.library'
  • android 代码块:这里有对此 module
    的所有配置,例如版本号,应用id,编译配置等。

    • defaultConfig:就是程序的默认配置,注意,如果在AndroidMainfest.xml里面定义了与这里相同的属性,会以这里的为主。
      特别说明一下,applicationId定义了包名,这里的定义只作为程序的唯一识别
      ID。而
      AndroidManifest.xml中定义的package="com.morning.android.glory"才会影响
      R文件的路径名。
    • buildTypes:定义了编译类型,针对每个类型我们可以有不同的编译配置。默认的有debug、release
      的类型。
  • dependencies:属于gradle
    的依赖配置。它定义了当前项目需要依赖的其他库。一般我们在 github
    上遇到喜欢的库想用到项目中,就可以在这里添加引用了。
    这里特别说一下引用库的版本号,一般不要用26.+这种版本号的写法,因为‘+‘号会导致每次编译时都会查询有没有更新版本,导致编译速度变慢,而且会用到一些不稳定的
    beta
    版。对于公司的正经项目,就还是不要去冒这个险了,需要升级的话手动升级就可以。

创建目录结构

在项目主目录下,创建以下子目录;在*nix系统下可以使用命令:mkdir -p src/main/java/hello

└── src
    └── main
        └── java
            └── hello

src/main/java/hello目录中,你可以创建任何Java类。为简单起见并且为了与指南的其余部分保持一致,我们建议创建两个雷HelloWorld.javaGreeter.java

src/main/java/hello/HelloWorld.java的源代码:

package hello;

public class HelloWorld {
  public static void main(String[] args) {
    Greeter greeter = new Greeter();
    System.out.println(greeter.sayHello());
  }
}

src/main/java/hello/Greeter.java的源代码:

package hello;

public class Greeter {
  public String sayHello() {
    return "Hello world!";
  }
}

定义一个简单的Maven构造

Maven已经安装,现在你需要做的就是创建一个Maven项目定义。Maven项目有一个名叫pom.xml的XML文件,它将定义整个项目。除此之外,它还定义了项目的名称、版本和对于外部库的依赖关系。

在项目的根目录中创建一个pom.xml,并给出一下内容:

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>org.springframework</groupId>
    <artifactId>gs-maven</artifactId>
    <packaging>jar</packaging>
    <version>0.1.0</version>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-shade-plugin</artifactId>
                <version>2.1</version>
                <executions>
                    <execution>
                        <phase>package</phase>
                        <goals>
                            <goal>shade</goal>
                        </goals>
                        <configuration>
                            <transformers>
                                <transformer
                                    implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
                                    <mainClass>hello.HelloWorld</mainClass>
                                </transformer>
                            </transformers>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>

除了可选元素<packaging>,以上就是一个Java项目需要的最简单的pom.xml文件。它包括以下项目配置的细节:

  • <modelVersion>,POM版本(通常是4.0.0);
  • <gropId>,本项目属于哪一个项目组,通常用它的反转域名作为名称;
  • <artifactId>,给与项目artifact的名称(例如,那些名字中包含JAR和WAR的文件)
  • <version>,正在构造的项目的版本
  • <packaging>,项目应该以哪种形式被打包,默认用“jar”打包JAR文件,用“war”打包JAR文件。

当谈到选择一个版本控制方案,Spring推荐使用semantic
versioning。

在这一点上,你已经定义了一个最小但是又有能力的Maven项目!

4. gradle.properties:

org.gradle.parallel=true
org.gradle.daemon=true
org.gradle.configureondemand=true
org.gradle.jvmargs=-Xmx4608m -XX:MaxPermSize=1g -XX:+HeapDumpOnOutOfMemoryError -Dfile.encoding=UTF-8 -XX:-UseParNewGC -XX:-UseConcMarkSweepGC -XX:+UnlockExperimentalVMOptions -XX:+UseG1GC

COMPILE_SDK_VERSION=26
BUILD_TOOLS_VERSION=26.0.1
SUPPORT_LIBS_VERSION=26.0.1

这个里面可以配置参数,然后在其他build.gradle中引用

安装Gradle

到目前为止,我们已经搭建了一个可以用来使用Gradle构建的项目,现在到了安装Gradle的时候了。

Gradle可以从下载。我们仅需要下载Gradle的二进制发布包,所以在刚才提供的连接上寻找gradle-version-bin.zip文件(当然,也可以下载gradle-version-all.zip,它包含源代码、文档以已编译代码)

解压缩下载的文件,并将解压后目录中的bin目录加到环境变量中。

可以在命令行中执行以下代码来测试Gradle是否安装成功

gradle

如果你很幸运,嘛事都OK,你会看到下面的welcome信息:

:help

Welcome to Gradle 1.8.

To run a build, run gradle <task> ...

To see a list of available tasks, run gradle tasks

To see a list of command-line options, run gradle --help

BUILD SUCCESSFUL

Total time: 2.675 secs

看到这个了,说明Gradle已经成功安装到系统中了。如果没看到……再去看看Gradle的手册先。

构建Java代码

Maven现在已经准备好构建你的项目了!你可以使用Maven执行几个构建生命周期目标,其中包括编译你的项目代码,创建库包(如JAR文件
),并将库安装到本地Maven依赖关系库中。
若想尝试构建,请在命令行输入以下命令:
mav compile
它会运行Maven,通知Maven运行编译这个功能。当编译完成,你可以在target/classes目录中找到那个被编译的.class文件
由于你不可能直接分发或使用.class文件,你可能跟你想运行包命令:
mvn package
打包命令将编译你的Java代码,运行所有的测试用例,然后把代码导报成一个JAR文件,放在target文件夹中。JAR文件的命名基于项目的<artifactId><version>。举个栗子,在前面提到的最基本的pom.xml,它的JAR文件将被命名为gs-maven-0.1.0.jar

如果你改变了<packaging>中的值,从“jar”变成“war”,那么结果将是target中的文件是WAR,而不是JAR文件。

为了快速访问项目的依赖,Maven在本机维护了一个依赖关系库(通常是在.m2/repository这个目录下)。如果你想安装项目的JAR文件到本地库,只需要执行install命令
mvn install
这个命令将编译、测试和打包你项目的代码,然后把它拷贝到依赖关系库中,为其他项目
同一个依赖参考。
说了这么久的依赖,是时候在Maven构建中声明依赖关系了。

5. local.properties:

sdk.dir=/Users/zhouying/Library/Android/sdk

这里主要定义了sdk和ndk的路径,这个文件一般不会提交到公共仓库中,可以保留一些本地的配置。

Gradle可以做些什么呢?

Gradle已经安装到系统上了,那么它可以做什么呢?在我们为项目创建build.gradle文件之前,我们可以先问一下Gradle目前有哪些可用的任务(Tasks):

gradle tasks

我们可以看到可用任务(Tasks)的列表。假设你执行Gradle的目录不存在build.gradle文件,你可以看到一些非常基础的任务,类似于:

:tasks

== All tasks runnable from root project

== Build Setup tasks
setupBuild - Initializes a new Gradle build. [incubating]
wrapper - Generates Gradle wrapper files. [incubating]

== Help tasks
dependencies - Displays all dependencies declared in root project 'gs-gradle'.
dependencyInsight - Displays the insight into a specific dependency in root project 'gs-gradle'.
help - Displays a help message
projects - Displays the sub-projects of root project 'gs-gradle'.
properties - Displays the properties of root project 'gs-gradle'.
tasks - Displays the tasks runnable from root project 'gs-gradle'.

To see all tasks and more detail, run with --all.

BUILD SUCCESSFUL

Total time: 3.077 secs

尽管上面的列出的任务是可用的,但是如果没有项目的构建配置他们无法提供太多的价值。当配置了项目的build.gradle后,一些任务将变得非常有用。

如果在build.gradle中配置了插件(plugins)上面的任务列表会变得更长,最好在配置插件后使用gradle task看看那些任务是可用的。

刚说到配置插件,马上我们就会配置一个插件来启用基础的Java构建功能。

声明依赖

Hello
World这个简单的实示例完全的独立的,并不需要依赖其他的外部库。但是对于大多数应用来说,都需要依赖外部库来处理一些常见且复杂的功能。
举个栗子,假设除了say“Hello
World!”,你还想让这个应用打印出当前的日期和时间,虽然你可以使用Java库中的日期和时间工具,但如果使用Joda
Time库来操作,会变得非常有趣。
首先,修改你的Hello World.java文件,就像以下这样:
src/main/java/hello/HelloWorld.java

package hello;

import org.joda.time.LocalTime;

public class HelloWorld {
    public static void main(String[] args) {
        LocalTime currentTime = new LocalTime();
        System.out.println("The current local time is: " + currentTime);
        Greeter greeter = new Greeter();
        System.out.println(greeter.sayHello());
    }
}

这里的HelloWorld用了Joda Time的LocalTime类来获取当前的打印的时间。
如果你现在运行mvn compile来构建项目,这个构建必将失败,其原因是你还没有将Joda
Time声明成一个编译依赖。你可以通过增加以下的代码到pom.xml文件(增加到<project>这个元素里)来修复这个问题:

<dependencies>
        <dependency>
            <groupId>joda-time</groupId>
            <artifactId>joda-time</artifactId>
            <version>2.9.2</version>
        </dependency>
</dependencies>

这个XMl快声明了项目的依赖关系列表,具体来说,它为Joda
Time库声明了一个依赖关系。在<dependency>元素中,依赖坐标由三个子元素定义:

  • <groupId> – 这个依赖关系属于什么组织
  • <artifactId> – 被要求的库
  • <version> – 这个库被要求的具体版本

默认的,所有的依赖关系都作为编译依赖关系,意思是,他们将在编译时候被利用到(如果你正在构造一个WAR文件,包括在WAR的/WEB-INF/libs文件夹中)。另外,你可以指定<scope>元素来指定以下范围之一:

  • <provided>
    编译项目代码所需要的依赖关系,但运行时将由运行代码容器提供(例如Java
    Servlet API)
  • <test>
    依赖关系在编译和运行测试的时候将被用到,但是在构建或运行项目的运行代码不是必需的

那么现在,如果你再次运行mvn compile或者mvn package,Maven将从Maven中心库中解析Joda
Time依赖,然后就构建成功了。

6. gradle 目录

在讲 gradle 目录之前,我们需要先了解一下 Gradle Wrapper
的概念。如下。

构建Java代码

先从简单的开始,创建一个最简单的只有一行的build.gradle文件:

apply plugin: 'java'

别看只有一行配置,提供的能力可不是一点点哦。再执行一下gradle task,我们可以看到任务列表中增加了一些内容,比如:用来编译java项目的任务、用来创建JavaDoc的任务、用来执行单元测试的任务。

我们经常使用的任务是gradle build,这个任务执行以下操作:编译、执行单元测试、组装Jar文件:

gradle build

几秒钟以后,会看到”BUILD SUCCESSFUL”输出,说明构建已经完成了。

可以到”build”目录中查看构建结构,在这个目录中我们可以看到很多子目录,其中有三个我们需要特别注意:

  • classes: 保存被编译后的.class文件
  • reports: 构建报告(如:测试报告)
  • lib: 组装好的项目包(通常为:.jar或者.war文件)

classes目录包含编译生成的所有.class文件。执行完编译后,我们应该可以在这里找到”HelloWorld.class”和”Greeter.class”。

到目前为止,我们项目并没有申明任何依赖,所以”debendency_cache”目录是空的。

“reports”目录会包含项目单元测试的测试报告,当然,当前项目并未编写任何单元测试,所以,也是空目录。

“lib”目录包含打包后的jar或war文件,在后面的内容中我们将学会如何定义JAR的名称和版本号。

写一个测试

首先添加一个JUnit依赖到你的pom.xml文件中,作用域为test

<dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
        <scope>test</scope>
</dependency>

接下来创建一个测试用例像以下所示:
src/test/java/hello/GreeterTest.java

package hello;

import static org.hamcrest.CoreMatchers.containsString;
import static org.junit.Assert.*;

import org.junit.Test;

public class GreeterTest {

    private Greeter greeter = new Greeter();

    @Test
    public void greeterSaysHello() {
        assertThat(greeter.sayHello(), containsString("Hello"));
    }

}

Maven使用一个名叫“surefire”的插件来运行单元测试,此插件默认配置是编译并运行在src/test/java中名称与*Test匹配的类。你可以通过以下的命令行来运行这些测试
mvn test
或者用mvn install,就像我们在上面已经提到过的那样(有一个生命周期定义,“test”被包括在“install”阶段)。
这里有一个完整的pom.xml文件:
pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>org.springframework</groupId>
    <artifactId>gs-maven</artifactId>
    <packaging>jar</packaging>
    <version>0.1.0</version>

    <dependencies>
        <!-- tag::joda[] -->
        <dependency>
            <groupId>joda-time</groupId>
            <artifactId>joda-time</artifactId>
            <version>2.9.2</version>
        </dependency>
        <!-- end::joda[] -->
        <!-- tag::junit[] -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
        <!-- end::junit[] -->
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-shade-plugin</artifactId>
                <version>2.1</version>
                <executions>
                    <execution>
                        <phase>package</phase>
                        <goals>
                            <goal>shade</goal>
                        </goals>
                        <configuration>
                            <transformers>
                                <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
                                    <mainClass>hello.HelloWorld</mainClass>
                                </transformer>
                            </transformers>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

</project>

这个完整的pom.xml文件使用Maven Shade
Plugin来简化JAR文件的可执行性。本指南专注于开始使用Maven,而不是使用这个插件。

Gradle Wrapper

Gradle 可以在没有安装 Gradle 的情况下使用,这时候就需要 Gradle
Wrapper
了。Gradle Wrapper 其实就是一个脚本文件,它会在没有安装
Gradle 的情况下为我们下载Gradle,之后我们就可以使用 gradlew 命令了。

申明依赖

我们的Hello
World例程非常简单且不依赖于任何第三方库,但是大多数应用程序都会依赖第三方库提供的通用或复杂的功能。

例如:假设我们希望更好的说”Hello
World!”,我们希望应用程序能同时输出当前的日期和时间。当然这可以使用Java自身的日期和时间相关库,但是我们可以使用”Joda
Time”库实现更有趣的功能。

首先,把HelloWorld.jara类修改成下面这样:

package hello;

import org.joda.time.LocalTime;

public class HelloWorld {
  public static void main(String[] args) {
    LocalTime currentTime = new LocalTime();
    System.out.println("The current local time is: " + currentTime);

    Greeter greeter = new Greeter();
    System.out.println(greeter.sayHello());
  }
}

这里我们的HelloWorld使用”Joda
Time”的LocalTime类来获取和输出当前时间。

如果我们马上执行gradle build来构建项目,构建过程将会失败,因为我们并未将”Joda
Time”库声明为编译时依赖库。

首先,我们需要添加一些配置来定义第三方库的来源:

repositories {
    mavenLocal()
    mavenCentral()
}

上面的repositories定义,告诉构建系统通过Maven中央库来检索项目依赖的软件包,Gradle在很大程度上依赖Maven构建工具的许多约定和基础功能,包括使用Maven中央的库来处理依赖关系。

现在我们可以使用第三方库了,但现需要定义:

dependencies {
    compile "joda-time:joda-time:2.2"
}

使用dependencies块,我们定义了一条Joda
Time的依赖项。这里,明确指定使用joda-time组内的版本为2.2的joda-time库。

另一个要注意的是,我们在这个依赖定义中指定依赖是compile范围的。意思是,这个库在编译和运行时都需要(如果我们正在构建WAR文件,这个文件会在/WEB-INF/libs目录下)。另外值得注意的依赖类型包括:

  • providedCompile:在编译期间需要这个依赖包,但在运行期间可能由容器提供相关组件(比如:Java
    Servlet API)
  • testCompile:依赖项仅在构建和运行测试代码时需要,在项目运行时不需要这个依赖项。

最后,我们来定义我们将生成的Jar文件的名字:

jar {
    baseName = 'gs-gradle'
    version =  '0.1.0'
}

jar块定义如何命名JAR文件,在上面的例子中,我们的JAR文件的名字为:gs-gradle-0.1.0.jar

注:这个时候如果执行gradle build,Gradle会花一些时间从Maven中央库下载Joda
Time包(具体下载时间依赖于你的网速)

摘要

恭喜你!你已经创造了一个简单的有用的通过Maven定义并构造的Java项目

创建 Gradle Wrapper 文件

使用 gradle wrapper 来创建一组 Wrapper 文件。Gradle 官方建议我们在所有
Gradle 项目中都创建 Wrapper 文件,方便没有安装 Gradle
的用户使用。创建完毕之后,会发现我们的项目中多了如下一些文件:

gradlew (Unix Shell 脚本)
gradlew.bat (Windows批处理文件)
gradle/wrapper/gradle-wrapper.jar (Wrapper JAR文件)
gradle/wrapper/gradle-wrapper.properties (Wrapper属性文件)
然后,我们就可以像使用 gradle 命令一样使用 gradlew 了。Gradle
Wrapper会自动为我们下载合适的 Gradle 版本。

Andorid Studio
创建项目时,已经替我们做了这一步,即生成了最上图黄色框中的 6. gradle
目录
,所以我们不需要自己运行命令来创建 graldle wrapper 文件。

使用Gradle Wrapper来构建项目

Gradle
Wrapper是开始一个Gradle构建的首选方式。它包含了windows批处理以及OS
X和Linux的Shell脚本。这些脚本允许我们在没有安装Gradle的系统上执行Gradle构建。要实现这个功能,我们需要在我们的build.gradle文件中增加以下代码:

task wrapper(type: Wrapper) {
    gradleVersion = '1.11'
}

执行下面代码来下载和初始化wrapper脚本:

gradle wrapper

命令执行完后,我们可以看到增加了一些新文件。有两个文件在根目录下,wapper的jar文件和properties文件在新增的gradle/wrapper目录下。

└── initial
    └── gradlew
    └── gradlew.bat
    └── gradle
        └── wrapper
            └── gradle-wrapper.jar
            └── gradle-wrapper.properties

现在Gradle
Wrapper已经可以用来构建系统了。把这些文件增加到版本控制系统中,然后再任何时候、任何地方只要迁出这些文件就一个按照同样的方式(与当前生成
Wrapper的Gradle版本一致)构建系统。运行wrapper脚本来构建系统,跟我们之前桥的命令很像:

./gradlew build

当第一次通过wrapper使用指定版本的Gradle构建系统时,wrapper首先下载对应版本的Gradle可执行文件。Gradle
Wrapper的所有文件在都可以被提交到版本库中,所以,任何人都可以在没有安装Gradle的环境下使用相同版本的Gradle构建系统。

在这个时候,我们需要重新构建我们的代码,构建的结果目录如下:

build
├── classes
│   └── main
│       └── hello
│           ├── Greeter.class
│           └── HelloWorld.class
├── dependency-cache
├── libs
│   └── gs-gradle-0.1.0.jar
└── tmp
    └── jar
        └── MANIFEST.MF

Jar文件中包含我们希望打包的GretterHelloWorld类。

$ jar tvf build/libs/gs-gradle-0.1.0.jar
  0 Fri May 30 16:02:32 CDT 2014 META-INF/
 25 Fri May 30 16:02:32 CDT 2014 META-INF/MANIFEST.MF
  0 Fri May 30 16:02:32 CDT 2014 hello/
369 Fri May 30 16:02:32 CDT 2014 hello/Greeter.class
988 Fri May 30 16:02:32 CDT 2014 hello/HelloWorld.class

需要注意的,即使我们声明了joda-time依赖,但这里也没有包括对应的库文件,而且生成的JAR文件也不是可运行JAR文件。

要想让代码可以运行,我们可以使用Gradle的application插件。增加以下内容到build.gradle文件中。

apply plugin: 'application'

mainClassName = 'hello.HelloWorld'

现在我们的app可以执行了。

$ ./gradlew run
:compileJava UP-TO-DATE
:processResources UP-TO-DATE
:classes UP-TO-DATE
:run
The current local time is: 16:16:20.544
Hello world!

BUILD SUCCESSFUL

Total time: 3.798 secs

为了能够将依赖包也以一起打包,比如,我们希望构建一个WAR包,可以包含第三方组件的打包格式,我们可以使用Gradle的WAR插件。如果我们使用Spring
Boot并且希望得到一个可执行的JAR文件,我们可以使用spring-boot-gradle-plugin插件。在我们的示例中,gradle没有足够的信息来了解我们的目标系统。但是,目前介绍的内容已经足够我们开始使用Gradle了。

下面是本文需要用的的build.gradle文件:

apply plugin: 'java'
apply plugin: 'Eclipse'
apply plugin: 'application'

mainClassName = 'hello.HelloWorld'

// tag::repositories[]
repositories {
    mavenLocal()
    mavenCentral()
}
// end::repositories[]

// tag::jar[]
jar {
    baseName = 'gs-gradle'
    version =  '0.1.0'
}
// end::jar[]

// tag::dependencies[]
dependencies {
    compile "joda-time:joda-time:2.2"
}
// end::dependencies[]

// tag::wrapper[]
task wrapper(type: Wrapper) {
    gradleVersion = '1.11'
}
// end::wrapper[]

注意:文件中有很多start/end注释,这些注释是为了方便拷贝文件中的内容到文章的各个部分,在实际使用中不需要包含他们。

扩展浏览

下面的这个指南或许能更好的帮助到你

  • Building Java Projects with
    Gradle

想要写一个全新的入门指南或者为现有的入门指南做贡献么?点击贡献指南!

所有的指南都将发布ASLv2许可证的代码、Attribution还有为写作颁发的NoDerivatives
creative commons
license

原文地址:Building Java Projects with
Maven

设置 Wrapper版本

使用 gradle wrapper --gradle-version 3.2.1
来设置Wrapper的版本。或者也可以直接编辑
gradle/wrapper/gradle-wrapper.properties 文件来修改版本。

文件内容如下,可以修改最后面的 “gradle-3.5-bin.zip” 来配置版本。

distributionBase=GRADLE_USER_HOME
distributionPath=wrapper/dists
zipStoreBase=GRADLE_USER_HOME
zipStorePath=wrapper/dists
distributionUrl=https://services.gradle.org/distributions/gradle-3.5-bin.zip

总结

恭喜,你已经创建了一个简单的然而可用的Gradle构建文件来构建Java项目。

小结

Gradle 的存在就是为了构建。我们知道 java 代码需要经过编译生成
·class 文件,然后打包成 dex,最后得到一个可以安装的 apk 包。Gradle
就是执行这一过程的构建工具。
除了构建,Gradle
还有一些其他“副业”,比如对于项目各种打包选项的配置,是生成 debug 包还是
release 包,对于各 Module 的管理,使用一些 jcentermaven
的开源项目等。这些功能都使 Gradle
变得更加丰富,也为开发者提供了更多便利。

发表评论

电子邮件地址不会被公开。 必填项已用*标注