您的位置 首页 杂谈

Gradle 快速入门

虐杀原形2寻找博士,388.31,金苹果手机

1.1 什么是构建工具 项目编译 如果你有一个项目,项目中有很多的包和Java文件,如果你想把这个项目打包成一个jar,你该怎么做?最坑爹的方式恐怕就是通过Java命令行把文件一个…

1.1 什么是构建工具

  • 项目编译

    如果你有一个项目,项目中有很多的包和Java文件,如果你想把这个项目打包成一个jar,你该怎么做?最坑爹的方式恐怕就是通过Java命令行把文件一个个编译成class文件,然后打包成jar了,这样的做法估计编译10个class文件,打包一次jar就可以让你抓狂了。于是构建工具就出现了,你所要做的就是写好配置文件,然后运行构建工具,接下来构建工具就会自动帮你编译所有的文件,并打包成jar文件。


  • 依赖管理

    你还在使用Ctrl+CCtrl+V的方式把你项目所需的jar包一个个拷贝到libs目录下吗?每次项目依赖的jar包有更新的时候,你又要去手动替换?当你拷贝了一个依赖库到项目里,赫然发现这个库又依赖了其他库,这时候你又要去拷贝其他库,是不是觉得很坑爹?使用构建工具吧,简单地几句配置信息就搞定了,从此你就不在需要去做那些无聊的体力活了。


  • 项目模块化

    构建工具的另一个功能就是能够帮助你将项目模块化,也许你会问一个包不就是一个模块了吗?在我看来,真正的模块化应该是一个完全独立的、可以快速移植的小程序,对于Android项目来说其中会包含各种布局文件和素材等,如果你以包作为模块,结果就是在移植的时候你还要去手动拷贝资源文件(这很容易丢三落四),通过构建工具,你可以将一个功能模块完全独立出来,各个模块之间是一种依赖关系。项目的模块化同时也在逼迫着你设计出高内聚低耦合的程序。

1.2 Gradle的特性

  1. Gradle使用Groovy作为脚本语言的构建工具,而Groovy是基于JVM的动态语言,它对Java有着先天的兼容性,你甚至可以在构建脚本中编写Java程序。

  2. Gradle不像Ant和Maven那样使用xml编写脚本,它使用的是Groovy,这意味着你在编写脚本的时候更像是在写程序,而不是编写充满尖括号又不好阅读xml文件。

  3. Gradle像Maven一样遵循约定优于配置的原则,也就是说你的项目只要按照标准约定搭建起来,你只需要做简单的配置就可以构建你的项目了。

  4. Gradle支持现有的Maven仓库,所以你可以很方面地利用Maven上的所有库。

  5. Gradle支持依赖传递,也就是说当A库依赖B库的时候,你只需要引用A库就可以了,Gradle会自动帮你依赖B库。

2 安装Gradle

Gradle的安装很简单,首先你要到Gradle的官网下载Gradle压缩包,这里我们以最新版的Gradle2.5为例,说明如何安装Gradle。

2.1 解压

首先你需要把下载下来的Gradle压缩包解压到任意位置,把Gradle安装在哪里完全取决于你,例如:

  • Linux系统可以解压到/home/xxx/gradle-2.5目录下。

  • Windows系统可以解压到C://gradle-2.5目录下。

2.2 配置环境变量

接下来我们需要在环境变了中配置Gradle,熟悉Java的人对于环境变量的配置应该得心应手了,因为这跟配置Java环境变量如出一辙。

  • Linux系统可以在/home/xxx/.profile中配置环境变量,把/home/xxx/gradle-2.5赋值给GRADLE_HOME,把/home/xxx/gradle-2.5/bin目录加入到PATH中。

    export GRADLE_HOME=/home/xxx/gradle-2.5
    export PATH=${GRADLE_HOME}/bin:$PATH

    • 1
    • 2
  • Windows系统可以右键我的电脑,选择属性进行环境变量配置,把C://gradle-2.5赋值给GRADLE_HOME,把%GRADLE_HOME%/bin目录加入到path中。

2.3 验证安装是否成功

完成前面两个步骤之后,你可以打开命令行窗口输入gradle -v命令,如果安装成功你会看到类似如下的信息:

------------------------------------------------------------
Gradle 2.5
------------------------------------------------------------

Build time: 2015-07-08 07:38:37 UTC
Build number: none
Revision: 093765bccd3ee722ed5310583e5ed140688a8c2b

Groovy: 2.3.10
Ant: Apache Ant(TM) version 1.9.3 compiled on December 23 2013
JVM: 1.7.0_79 (Oracle Corporation 24.79-b02)
OS: Linux 3.19.0-23-generic amd64

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13

3 牛刀小试

接下来我们就用一个很简单的Demo来小试一下Gradle,我们会创建一个Java项目并取名为HelloGradle,该项目会在main函数中打印一句话Hello Gradle,我所使用的是Linux操作系统。

3.1 项目结构

我们先创建整个项目的目录结构,由于Gradle遵循约定优于配置的原则,所以我们会创建一个标准的Gradle项目结构,这样Gradle就能过几乎不做任何配置就可以识别我们的项目,整个项目的结构如下所示:

HelloGradle
src/main/java
src/main/resources

  • 1
  • 2
  • 3
  • 4
  • src/main/java目录是我们存放源码的地方。

  • src/main/resources目录是我们存放资源文件的地方。

3.2 编写代码

接着我们在src/main/java目录下创建一个类并取名为Main.java,然后编写如下所示的代码:

public class Main {

public static void main(String args) {
System.out.println("Hello Gradle");
}

}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

3.3 编写构建脚本

我们需要在项目的根目录,也就是HelloGradle目录下创建一个名为build.gradle的脚本文件,并且在文件中配置我们的项目,Gradle就会根据配置信息帮我们构建整个项目,配置信息如下所示:

build.gradle:

apply plugin: 'java'

  • 1

没错,就这么一句话就可以了,这就是约定优于配置的威力所在,因为我们整个项目都是按照标准约定搭建的,所以Gradle能够根据约定识别出我们的项目,进而执行构建任务。

3.4 构建项目

最后,我们打开命令号窗口,定位到项目的跟目录下,然后输入gradle build命令,然后我们就会看到Gradle打印出如下信息:

:compileJava
:processResources UP-TO-DATE
:classes
:jar
:assemble
:compileTestJava UP-TO-DATE
:processTestResources UP-TO-DATE
:testClasses UP-TO-DATE
:test UP-TO-DATE
:check UP-TO-DATE
:build

BUILD SUCCESSFUL

Total time: 3.7 secs

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16

然后我们会在HelloGradle目录下看到几个新的目录,分别是.gradlebuild目录,我们可以在build/classes/main目录下找到Gradle编译好的class文件,在build/libs目录下找打Gradle打包好的jar文件。我们可以进入build/classes/main目录执行java Main命令,就会看到打印出Hello Gradle。怎么样,使用Gradle构建一个Java项目是不是很简单,可能有人会说用IDE比这个还简单,我会告诉你当Gradle和IDE结合在一起的时候,会让项目构建更加简单和高效。

4 Gradle基础

想要使用Gradle作为你的项目构建利器,你必须先学会Gradle的脚本知识,这一章我们会讲解Gradle的一些脚本基础,旨在让你能够快速的入门

4.1 脚本文件(build.gradle)

项目与脚本文件

当我们执行gradle命令的时候,Gradle会在你执行命令的目录下寻找一个名为build.gradle的文件,这个文件就是Gradle的脚本文件,我们所有的脚本、配置信息都写在这里面,并且一个目录下只能有一个脚本文件。下面是一个简单的例子,我们创建一个项目取名为HelloGradle

HelloGradle
build.gradle
src/main/java/Main.java

  • 1
  • 2
  • 3
  • 4

实际上,一个脚本文件就代表着一个项目,所以如果你在某个目录下创建一个脚本文件,Gradle就会把该目录作为一个项目的根目录。对于多项目构建的情况下,你可能会在主项目下创建多个子项目,这时候你应该在一个项目(主项目和子项目)的跟目录下创建一个脚本文件,并且通过settings.gradle文件配置主项目与子项目之间的关系,在后面的内容中我们会对多项目构建进行更多的说明,所以这里大家可以先无视settings.gradle的存在。下面是一个简单的例子,我们创建一个主项目名为Project1,在主项目下面有两个子项目分别命名为Project2Project3,我们通过build.gradle让Gradle识别出每一个项目,并且在settings.gradle文件中将Project2Project3声明为Project1的子项目:

Project1
build.gradle
settings.gradle
Project2
build.gradle
src/main/java
src/main/resources
Project3
build.gradle
src/main/java
src/main/resources

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12

脚本块

一个build.gradle文件由若干个指定的脚本块组成,每一个脚本块都代表着不同的功能,Gradle内置了好几种脚本块供我们使用,并且脚本块可以嵌套使用,详情可以查看官方文档,我们来看一段脚本:

buildscript {
repositories {
jcenter()
}
dependencies {
classpath 'com.android.tools.build:gradle:1.2.3'
}
}

allprojects {
repositories {
jcenter()
}
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14

这是一段配置Android项目的脚本,在build.gradle中通过buildscripte脚本块指定脚本文件所使用的插件来源和远程仓库,通过repositories脚本块指定了所使用的远程仓库,通过dependencies指定了相关的依赖关系,通过allprojects脚本块为所有子项目指定配置信息。

4.2 项目(project)

在Gradle中,每一个项目都会有个名为project的实例与之对应,而之前我们说过一个脚本文件就代表着一个项目,所以实际上我们在脚本文件中编写的脚本最后都是委托给project对象处理的,即projectbuild.gradle是一对一的关系。我们可以在脚本文件中通过该实例访问项目脚本的属性、方法和任务,例如project.name可以访问项目的名称、project.version可以访问项目的版本名称、project.rootProject可以访问该项目的父项目等,总之project几乎包含了所有脚本的内容。

在编写脚本的时候,虽然在脚本中直接写属性名称是可以的,但是通过project引用属性名称能够让你的脚本更加清晰易懂,例如project.name会比name更容易让人知道这是一个项目的名称。

4.3 属性(property)

在Gradle中,属性分为两种,一种是系统属性,它可以被JVM使用,而另一种我们姑且称之为项目属性,它用于项目的配置。


4.3.1 系统属性

系统属性是可以直接被JVM所使用的,我们可以用它来设置JVM的相关参数,下面按照读取属性的优先级由高到低的方式列出来所有定义方式:

  1. 通过命令行执行gradle -D name=value方式定义系统属性,例如gradle -D org.gradle.java.home=/jdk定义了Gradle运行时所依赖的Java路径。

  2. 用户目录下创建gradle.properties文件,然后以systemProp.name=value方式定义系统属性,例如用户目录为/home/jerry,那么我们就在该目录下创建gradle.properties文件,并且在文件内定义org.gradle.java.home=/jdk,这样Gradle所以需的Java路径就被定义了。

  3. 项目目录下创建gradle.properties文件,然后以systemProp.name=value方式定义系统属性,例如项目目录为/HelloGradle,那么我们就在该目录下创建gradle.properties文件,并且在文件内定义org.gradle.java.home=/jdk,这样Gradle所以需的Java路径就被定义了。


4.3.2 项目属性

在开发项目的时候我们经常会遇到各种项目属性的配置,例如项目名称、项目版本、打包路径、渠道名称等等,对于这些属性,Gradle为我们提供了多种方式来定义,下面按照读取属性的优先级由高到低列出来所有定义方式:

  1. 通过project.ext.name=value方式定义属性,例如project.ext.channel='360'定义渠道名称为360。

  2. 通过命令行执行gradle -P name=value方式定义属性,例如gradle -P channel=360定义渠道名称为360。

  3. 用户目录下创建gradle.properties文件,然后以name=value方式定义系统属性,例如用户目录为/home/jerry,那么我们就在该目录下创建gradle.properties文件,并且在文件内定义channel=360,这样就定义了渠道名为360。

  4. 项目目录下创建gradle.properties文件,然后以name=value方式定义系统属性,例如项目目录为/HelloGradle,那么我们就在该目录下创建gradle.properties文件,并且在文件内定义channel=360,这样就定义了渠道名为360。


4.3.3 读取属性

在脚本中读取属性十分容易,对于系统属性,我们可以通过System.properties方式读取,对于项目属性则通过project.name方式读取:

build.gradle:

println System.properties
println project.channel

  • 1
  • 2

4.4 任务(task)

在构建项目的时候,我们如果对整个构建过程进行分解的话,大概可以分解成编译代码、打包、生成文档等过程,Gradle用task来代表这些构建过程,每个步骤对应一个task。如果把项目比喻成一个类,那么task就是类中的方法,我们也可以认为task就是构建项目的原子操作,再细分下去就没有意义了。

4.4.1 定义task

Hello world

首先我们来定义一个打印Hello world的task,在build.gradle中编写如下脚本:

build.gradle:

task Hello {
doFirst {
println 'Hello world'
}
}

  • 1
  • 2
  • 3
  • 4
  • 5

然后我们执行gradle -q Hello命令,-q参数用于过滤多余信息而已,并不是必须的,执行命令后我们会看到如下输出:

gradle -q Hello
Hello world

  • 1
  • 2
  • 3

执行顺序

在上面的脚本中,我们看到了doFirst关键字,我想大家也理所当然会想是不是有doLast之类的关键字,答案是肯定的。在task中,我们通过doFirstdoLast来控制task内部脚本的执行顺序,我们来看下面的脚本:

build.gradle:

task MyTask {
doLast {
println 'Execute doLast'
}

doFirst {
println 'Execute doFirst'
}
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

执行gradle -q MyTask命令,我们会看到如下输出:

gradle -q MyTask
Execute doFirst
Execute doLast

  • 1
  • 2
  • 3
  • 4

也许有人会说这有什么特别的,不就相当于把脚本的编写顺序改一下而已,那么我们来看下面一段脚本:

task MyTask {
doLast {
println 'Execute doLast A'
}

doFirst {
println 'Execute doFirst A'
}
}

MyTask.doFirst {
println 'Execute doFrist B'
}

MyTask.doLast {
println 'Execute doLast B'
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17

执行gradle -q MyTask命令,我们会看到如下输出:

gradle -q MyTask
Execute doFrist B
Execute doFirst A
Execute doLast A
Execute doLast B

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

从执行结果,我们可以看出MyTask的行为被我们修改了,也就是说Gradle允许你在定义完task之后动态添加更多的行为,其中MyTask.doFirst {...}新增的doFrist会被添加到执行队列的头部,而MyTask.doLast {...}新增的doLast会被添加到执行队列的尾部,所以我们会看到先打印Execute doFirst again,最后打印Execute doLast again


如果我们不关心脚本的执行顺序,我们可以用来快速定义task,等价于doLast,也就是说下面的两种定义方式是等价的:

task Task1 {
println 'Hello'
}

task Task2 {
doLast {
println 'Hello'
}
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

动态定义

Gradle允许我们动态定义task,看如下代码:

3.times { i -
task "MyTask$i" {
println "My task $i"
}
}

  • 1
  • 2
  • 3
  • 4
  • 5

提示:这段代码是Groovy的语法,它的作用相当于Java的`for(int i = 0; i 3; i++)`。

执行`gradle -q MyTask0 MyTask1 MyTask2`命令,我们会看到如下输出:

~~~
gradle -q MyTask0 MyTask1 MyTask2
My task 0
My task 1
My task 2
~~~

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

4.4.2 依赖关系

task之间可以通过关键字dependsOn指定依赖关系,比如负责打包的task A依赖于编译class文件的task B,这时候当我们允许task A的时候,task B会被先执行,然后才执行task A。

单个依赖

首先我们来看一个最简单的依赖关系,我们称他为单个依赖,因为一个task的运行只依赖于另一个依赖:

task task2 {
println 'Execute task2'
}

task task1(dependsOn: task2) {
println 'Execute task1'
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

执行gradle -q task1命令,我们会看到如下输出:

gradle -q task1
Execute task2
Execute task1

  • 1
  • 2
  • 3
  • 4

多个依赖

如果我们想指定更多的依赖关系的话,可以用” “定义多个task,看如下脚本:

task task2 {
println 'Execute task2'
}

task task3 {
println 'Execute task3'
}

task task4 {
println 'Execute task4'
}

task task1(dependsOn: ) {
println 'Execute task1'
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15

执行gradle -q task1命令,我们会看到如下输出:

gradle -q task1
Execute task2
Execute task3
Execute task4
Execute task1

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

4.4.3 指定类型

在定义task的时候,我们可以通过关键字type为task指定一种类型,task会根据不同类型具有不同的功能,并且Gradle内置了很多实用的task类型,比如Copy类型让task具有拷贝文件的功能,task的类型指定有点像继承的关系:

task copyFile(type: Copy) {
from '/home/xxx/'
into '/home/yyy/'
include 'file1.txt'
rename 'file1.txt', 'file2.txt'
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

执行gradle copyFile命令,然后该task就会从/home/xxx/目录下将file1.txt文件复制到/home/yyy/目录下,并且重命名为file2.txt。更多的task类型可以查看Gradle的官方文档。

4.4.4 查看task

最后你可以通过gradle tasks命令查看有多少的task可用,并且父项目可以直接操作子项目的task,反过来却不行:

gradle tasks
------------------------------------------------------------
All tasks runnable from root project
------------------------------------------------------------

Build tasks
-----------
assemble - Assembles the outputs of this project.
build - Assembles and tests this project.
buildDependents - Assembles and tests this project and all projects that depend on it.
buildNeeded - Assembles and tests this project and all projects it depends on.
classes - Assembles classes 'main'.
clean - Deletes the build directory.
jar - Assembles a jar archive containing the main classes.
testClasses - Assembles classes 'test'.

Build Setup tasks
-----------------
init - Initializes a new Gradle build.
wrapper - Generates Gradle wrapper files.

Documentation tasks
-------------------
javadoc - Generates Javadoc API documentation for the main source code.

Help tasks
----------
components - Displays the components produced by root project 'Project1'.
dependencies - Displays all dependencies declared in root project 'Project1'.
dependencyInsight - Displays the insight into a specific dependency in root project 'Project1'.
help - Displays a help message.
model - Displays the configuration model of root project 'Project1'.
projects - Displays the sub-projects of root project 'Project1'.
properties - Displays the properties of root project 'Project1'.
tasks - Displays the tasks runnable from root project 'Project1' (some of the displayed tasks may belong to subprojects).

Verification tasks
------------------
check - Runs all checks.
test - Runs the unit tests.

Other tasks
-----------
copyFile

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45

4.4 依赖(dependency)

很多时候我们的项目会依赖到一些第三方库,Gradle为我们提供了3中方式配置依赖项。

4.4.1 依赖本地文件

假设我们在项目的libs目录下有个库叫做mylib.jar,我们可以通过以下方式让项目依赖这个库:

dependencies {
compile files('libs/mylib.jar')
}

  • 1
  • 2
  • 3

通过上面的脚本,我们的项目在编译的时候会自动依赖mylib.jar库。


如果你的libs下面有好几个文件需要依赖,可以通过以下方式让项目一次性依赖所有库文件:

dependencies {
compile fileTree(dir: 'libs', include: )
}

  • 1
  • 2
  • 3

通过该方式,我们的项目会把libs目录下的所有jar文件都当做依赖库。

4.4.2 依赖网络库

我们可以通过Gradle依赖网络上的第三方库,这些库一般都会保存在一个网络仓库中,例如mavenjcenter,使用网络上的库带来的好处就是我们可以简单修改版本号就可以更新到最新版的库,并且也省去了我们手动去复制文件。

想要依赖网络仓库里面的第三方库,我们需要知道3个信息:group、name和version。

  • group:第三方库的组织名称。

  • name:第三方库的名称。

  • version:第三方库的版本。

现在假设我们有一个第三方库在maven仓库下,它的信息如下:

group: com.hjdzone.lib
name: mylib
version: 1.0.0

  • 1
  • 2
  • 3
  • 4

想要使用这个第三方库,我们可以编写如下脚本:

repositories {
mavenCentral()
}

dependencies {
compile group: 'com.hjdzone.lib', name: 'mylib', version: '1.0.0'
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

该脚本告诉Gradle应该到maven仓库去查找库文件,并且Gradle会把该文件自动加载到本地。


你还可以用以简写方式式来声明依赖,简写方式要求group、name和version之间用:隔开:

repositories {
mavenCentral()
}

dependencies {
compile 'com.hjdzone.lib:mylib:1.0.0'
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

4.6 插件(plugin)

严格上来说Gradle只是一个构建框架,并没有提供任何真正的构建功能,构建任务其实是通过插件实现的,不同的插件会根据不同构建需求定义各种task供我们使用,并且Gradle已经提供了大量的插件,大多数情况下我们无需自己重写plugin,只需要简单地指定plugin就可以使用了。其实在前面的例子中我们就用到了名为java的插件,接下来我们就继续以之前的HelloGradle项目为例,介绍插件的用法。


首先你必须在build.gradle中声明使用java插件:

apply plugin: 'java'

  • 1

Gradle遵循约定优于配置的原则,所以你的项目结构必须符合插件的要求才能够被插件所识别,例如java插件要求我们的代码必须放在src/main/java 目录下,资源文件必须放在src/main/resources目录下,测试代码必须放在src/test/java目录下,测试资源必须放在src/test/resources目录下:

HelloGradle
build.gradle
src/main/java/Main.java
src/main/resources/logo.png
src/test/java/TestMain.java
src/test/resources/logo.png

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

java插件提供了各种脚本块用于配置项目,例如你可以通过插件提供的脚本块sourceSets修改项目的结构:

sourceSets {
main {
java './java'
resources './resources'
}
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

该脚本把代码目录指定到了./java目录下,把资源文件目录指定到了./resources目录下。


java插件为我们提供了一套完整的构建任务,我们可以通过执行gradle tasks命令查看可用的task:

assemble - Assembles the outputs of this project.
build - Assembles and tests this project.
buildDependents - Assembles and tests this project and all projects that depend on it.
buildNeeded - Assembles and tests this project and all projects it depends on.
classes - Assembles classes 'main'.
clean - Deletes the build directory.
jar - Assembles a jar archive containing the main classes.
testClasses - Assembles classes 'test'.

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

更多关于java插件的用法可以参照官方文档,本文只是起到一个引导作用而已。


简单来说插件就是事先定义好的脚本块和task的集合,我们只需要参照文档使用就可以了。

版权声明:本文为博主原创文章,转载请注明出处。 https://blog.csdn.net/hjpdyxhjd/article/details/50364719

文章标签:
gradle android studio

个人分类:
AS-Gradle

▼查看关于本篇文章更多信息

JavaScript大神之路第一季

从0开始学习JavaScript,从入门到进阶高级编程

想对作者说点什么?

我来说一句

Gradle 15分钟入门教程”>

Gradle 15分钟入门教程

qitongce

05-18

1.4万

1-Gradle入门介绍

在阅读或实践本文中的实例前,必须首先确保已将Gradle插件安装到Eclipse中。如果没有,可以点击下面的链接查看Gradle安装说明:
-http://www…

gradle 5分钟快速入门“>

gradle 5分钟快速入门

seehunter

03-27

50

1,将项目初始化为gradle项目; 进入项目根目录,运行gradle init 熟悉gradle项目的构建目录:(1),build.gradle 用于项目构建以及自动化管理的任务配…

Gradle 实战教程 – CSDN博客

7-16

jiapeng2b 2015-07-13 16:13:44 阅读数:894 Gradle 实战(1)—— 配置…1-Gradle入门介绍 在阅读或实践本文中的实例前,必须首先确保已将Gradle插件安装到…

【安卓笔记】gradle入门 – CSDN博客

6-6

jiapeng2b 2015-07-13 16:13:44 阅读数:839 Android Gradle,Groovy自动化构建入门篇 Gradle是一个基于Apache Ant和Apache Maven概念的项目自动化构建工具。…

Gradle学习系列之一——Gradle快速入门“>

Gradle学习系列之一——Gradle快速入门

caomiao2006

04-24

562

这是一个关于Gradle的学习系列,其中包含以下文章:

Gradle快速入门创建Task的多种方法读懂Gradle语法增量式构建自定义Property使用java
Plugin依赖管…

gradle基础 – CSDN博客

8-1

 原文链接:http://stormzhang.com/devtools/2014/12/18/android-studio-tutorial4/ 其实很早之前也写了一篇Gradle的基础博客,但是时间很久了,现在Gradle…

gradle基础使用教程

8-12

翻译自gradle官网的针对APP DEVELOPER的教程,希望对你能有帮助。综合评分:4 收藏…inc1ud3 2018-01-02 16:03:46 写的比较简单。入门不错。感谢分享 gradle…

Gradle“>

在Windows上安装Gradle

wellplaying

11-23

1万

1.开发环境
(1)Java:JDK8(必须是JDK或JRE7以上,使用java -version查看当前电脑java版本)
(2)操作系统:Windows 7
2.安装步骤
(1)下载最新的…

Gradle 实战(1)—— 配置环境变量”>

Gradle 实战(1)—— 配置环境变量

lw_power

04-25

3.7万

背景:Gradle 是一款构建工具,继 Ant 、Maven 之后的现代构建工具,我会在接下来的博文中陆续介绍,我在工作中是如何使用 Gradle 的。下载 Gradle下面是 Gradle 的官方网…

gradle 实战 中文高清完整版PDF

8-10

Gradle从入门到实战 – Groovy基础 上传资源 yuqingshui1988 关注 查看TA的资源…欧洲能源一哥照样用区块链玩转2B的生意 | 人物志 未来3 年,什么样的技术人…

gradle基础

8-5

gradle的基础知识 综合评分:0 收藏评论举报 所需: 3积分/C币 开通VIP 立即…欧洲能源一哥照样用区块链玩转2B的生意 | 人物志 未来3 年,什么样的技术人…

Gradle学习系列之(一)——Gradle快速入门“>

Gradle学习系列之(一)——Gradle快速入门

u012306714

06-02

170

和Maven一样,Gradle只是提供了构建项目的一个框架,真正起作用的是Plugin。Gradle在默认情况下为我们提供了许多常用的Plugin,其中包括有构建Java项目的Plugin,还有War…

痛风患者如何快速降尿酸?这个方法后悔没有早知道
华蓥华兴 · 顶新

gradle教程 – CSDN博客

8-3

史上最详细的Android Studio Gradle基础教程 jiapeng2b 07-13 915 原文链接:…Gradle从入门到实战 – Groovy基础 singwhatiwanna 07-25 2.3万 Groovy是一…

Gradle基础 – CSDN博客

6-7

jiapeng2b 2015-07-13 16:13:44 阅读数:841 gradle使用基础 说明介绍gradle…Gradle 入门到精通 前言Gradle详解内容将分篇介绍,这里首先介绍Gradle的基础知…

Gradle For Android系列1:Gradle快速入门及AndroidStudio介绍”>

Gradle For Android系列1:Gradle快速入门及AndroidStudio介绍

likuangren

12-29

64

在2013年的Google Io,出于更好的重用代码和自定义编译流程,Google推出了AndroidStudio和新的编译系统Gradle,AndroidStudio能使用Gradle编译,但是Gr…

Gradle快速入门“>

Gradle快速入门

u014430366

01-23

83

Gradle快速入门

Android Studio和gradle 开发入门 – CSDN博客

7-1

gradle配置: file-settings-gradle-Use local gradle distribution 选择gradle目录 android sdk配置: file-project structure-sdk location 配置jdk和sdk目录

Gradle基础 – CSDN博客

7-14

根目录的build.gradle 该gradle文件是定义在这个工程下的所有模块的公变成蚯蚓腿怎么办?用这方法坚持3个月全恢复!
水英电器 · 顶新

gradle 打印日志”>

android gradle 打印日志

mengyueyao

04-27

479

println “打印的日志” 然后在Gradle Console 中可以查看打印的内容

简单、完整的spring cloud入门

u013218587

05-05

465

https://blog.csdn.net/forezp/article/details/70148833https://blog.csdn.net/u012702547/article/detail…

gradle构建spring-cloud工程用docker运行”>

gradle构建spring-cloud工程用docker运行

happyyangyuan

12-29

1151

基于gradle构建工具的spring cloud微服务框架超级简单入门教程。

Android Gradle 权威指南

2018年06月13日
27.71MB
下载

《qt creator 快速入门.PDF》第三版 高清完整版+书签

2017年12月23日
78.96MB
下载

Gradle笔记——构建基础”>

Gradle笔记——构建基础

maosidiaoxian

10-21

4.8万

本篇文章主要介绍一下Gradle的构建基础。它看起来似乎和android项目没多大关系,不能让人一下子理解android项目中的Gradle配置文件,但是这篇基础真的很重要。
学习Gradle前,需…

gradle 打印依赖树”>

gradle 打印依赖树

yuanxw44

04-19

8529

./gradlew app:dependencies

通过依赖树具体排查, 找到问题根源,排除掉

./gradlew dependencies -q –configuration compile…

Gradle入门教程”>

Gradle入门教程

u014077888

02-26

834

一、简介Gradle是一种构建工具,它抛弃了基于XML的构建脚本,取而代之的是采用一种基于Groovy的内部领域特定语言。Gradle 通过提供可以随意集成的声明式语言元素将声明性构建推到了一个新的高…

Gradle 入门到精通(三)”>

Gradle 入门到精通(三)

seemygoandroid

07-26

1359

前言根据我们上一篇的介绍,我们知道了项目的结构以及构建的流程,根据上面的知识,我们知道了构建的规则实际就是我们写在build.gradle的内容。gradle android插件读取这个文件的内容后,…

Gradle学习笔记(四)”>

Gradle学习笔记(四)

hqocshheqing

12-28

654

上一篇日志,我们搞清楚了基础的概念以及Hello World,接下来我们继续学习Gradle。
构建脚本代码:
Gradle构建脚本将向你展示Groovy的所有出色的功能,接下来看看它强大的功能:
E…

耳聋、耳鸣、耳朵嗡嗡响,试试这个小妙招,一招解决
广福门诊部 · 顶新

ThinkPHP5-快速入门pdf

2017年11月04日
5.82MB
下载

《QtCreator快速入门第三版》完整高清带书签源码

2018年01月27日
98.1MB
下载

ThinkPHP5.0-快速入门手册(新手教程版).pdf

2017年08月13日
1.07MB
下载

gradleCHANGES

2017年11月26日
51KB
下载

最新版gradle 4.4.1

2017年12月27日
72.02MB
下载

Gradle从入门到实战 – Groovy基础”>

Gradle从入门到实战 – Groovy基础

singwhatiwanna

07-25

2.4万

Groovy是一门jvm语言,它最终是要编译成class文件然后在jvm上执行,所以Java语言的特性Groovy都支持,我们完全可以混写Java和Groovy。

既然如此,那Groovy的优势是什…

gradle入门”>

gradle入门

pengpenggxp

03-10

184

随着Android Studio越来越完善,更多的开发者舍弃掉Eclipse。但是新的IDE与以往的Eclipse有很大区别,这导

本文来自网络,不代表加推新闻网立场,转载请注明出处:http://www.bafangmiaomu.com/shehui/97846/

作者: 头条新闻

为您推荐