gradle 订阅
Gradle是一个基于Apache Ant和Apache Maven概念的项目自动化构建开源工具。它使用一种基于Groovy的特定领域语言(DSL)来声明项目设置,目前也增加了基于Kotlin语言的kotlin-based DSL,抛弃了基于XML的各种繁琐配置。面向Java应用为主。当前其支持的语言限于Java、Groovy、Kotlin和Scala,计划未来将支持更多的语言。 展开全文
Gradle是一个基于Apache Ant和Apache Maven概念的项目自动化构建开源工具。它使用一种基于Groovy的特定领域语言(DSL)来声明项目设置,目前也增加了基于Kotlin语言的kotlin-based DSL,抛弃了基于XML的各种繁琐配置。面向Java应用为主。当前其支持的语言限于Java、Groovy、Kotlin和Scala,计划未来将支持更多的语言。
信息
外文名
gradle
整体设计
以作为一种语言为导向
音    标
[g'reɪdl]
中文名
gradle
基    础
Groovy 语言
服务对象
Java应用
gradle简介
Gradle是一个基于JVM的构建工具,是一款通用灵活的构建工具,支持maven, Ivy仓库,支持传递性依赖管理,而不需要远程仓库或者是pom.xml和ivy.xml配置文件,基于Groovy,build脚本使用Groovy编写。 [1] 
收起全文
精华内容
参与话题
问答
  • 本课程首先详细系统的介绍了Gradle,包括Groovy语法、Gradle入门和Gradle自定义插件等等。其中在Gradle介绍中,通过各种示例讲解Project、Task与Action等相关对象,API使用,构建生命周期等等,真正让学生在读懂...
  • Gradle笔记——Gradle的简介与安装

    万次阅读 多人点赞 2014-10-15 13:22:40
    这一篇博客,主要是面向对Gradle有所耳闻,但却没有一个比较清晰的概念的。在这篇博客里,将对Gradle进行一个简单的介绍,以及它的安装。 Gradle介绍 Gradle是一个基于JVM的构建工具,它提供了: 像Ant一样,...

    本博客对Gradle进行一个简单的介绍,以及它的安装。


    Gradle介绍

    Gradle是一个基于JVM的构建工具,它提供了:
    • 像Ant一样,通用灵活的构建工具
    • 可以切换的,基于约定的构建框架
    • 强大的多工程构建支持
    • 基于Apache Ivy的强大的依赖管理
    • 支持maven, Ivy仓库
    • 支持传递性依赖管理,而不需要远程仓库或者是pom.xml和ivy.xml配置文件。
    • 对Ant的任务做了很好的集成
    • 基于Groovy,build脚本使用Groovy编写
    • 有广泛的领域模型支持构建

    Gradle 概述

    1,基于声明和基于约定的构建。
    2,依赖型的编程语言。
    3,可以结构化构建,易于维护和理解。
    4,有高级的API允许你在构建执行的整个过程当中,对它的核心进行监视,或者是配置它的行为。
    5,有良好的扩展性。有增量构建功能来克服性能瓶颈问题。
    6,多项目构建的支持。
    7,多种方式的依赖管理。
    8,是第一个构建集成工具。集成了Ant, maven的功能。
    9,易于移值。
    10,脚本采用Groovy编写,易于维护。
    11,通过Gradle Wrapper允许你在没有安装Gradle的机器上进行Gradle构建。
    12,自由,开源。

    Gradle 安装

    1,安装JDK,并配置JAVA_HOME环境变量。因为Gradle是用Groovy编写的,而Groovy基于JAVA。另外,Java版本要不小于1.5.
    2,下载。地址是:http://www.gradle.org/downloads。在这里下载你要的版本。
    3,解压。如果你下载的是gradle-xx-all.zip的完整包,它会有以下内容:
    • 二进制文件
    • 用户手册(包括PDF和HTML两种版本)
    • DSL参考指南
    • API手册(包括Javadoc和Groovydoc)
    • 样例
    • 源代码,仅供参考使用。
    4,配置环境变量。配置GRADLE_HOME到你的gradle根目录当中,然后把%GRADLE_HOME%/bin(linux或mac的是$GRADLE_HOME/bin)加到PATH的环境变量。
    linux用户可以在~/.bashrc文件中配置。

    配置完成之后,运行gradle -v,检查一下是否安装无误。如果安装正确,它会打印出Gradle的版本信息,包括它的构建信息,Groovy, Ant, Ivy, 当前JVM和当前系统的版本信息。

    另外,可以通过GRADLE_OPTS或JAVA_OPTS来配置Gradle运行时的JVM参数。不过,JAVA_OPTS设置的参数也会影响到其他的JAVA应用程序。


    展开全文
  • Gradle的使用教程

    万次阅读 多人点赞 2018-08-08 19:28:28
    Gradle是一个好用的构建工具 ,使用它的原因是: 配置相关依赖代码量少,不会像maven一样xml过多 打包编译测试发布都有,而且使用起来方便 利用自定义的任务可以完成自己想要的功能 二、安装 下载地址...

    一、相关介绍

            Gradle是一个好用的构建工具 ,使用它的原因是:

    • 配置相关依赖代码量少,不会像maven一样xml过多 
    • 打包编译测试发布都有,而且使用起来方便 
    • 利用自定义的任务可以完成自己想要的功能

    二、安装

            下载地址http://services.gradle.org/distributions/  ,下载你所需要对应的版本,我这里下载的是gradle-4.7-bin.zip。下载后解压到你想要的目录即可,然后设置环境变量:

     

    在cmd模式下查看,出现以下信息证明安装成功:

    然后我们可以在在环境变量里配置gradle默认的仓库地址(和maven不太一样):

    三、IED中的使用

    1、IDEA

            使用idea创建一个web的Gradle项目

     

     

    然后对项目进行打包运行:

     

    双击war

     

    打包完成之后的war文件会在:

     

    然后把war放入对应的tomcat目录即可,这里就不多解释了。

    2、Eclipse

            eclipse中要自己安装插件,插件路径为:http://download.eclipse.org/buildship/updates/e46/releases/2.x/ 。

    四、问题说明

    1、解释build.gradle和settings.gradle

            首先是一个项目包含group、name、version 。settings.gradle是用来管理多项目的,里面包含了项目的name

     

    在build.gradle中,apply是应用的插件,如:

     

    这里我们用了java和war的插件 ,dependencies是用于声明这个项目依赖于哪些jar

     

    这里说明的是,测试编译阶段我们依赖junit的jar。其中包括complile(编译时)runtime(运行时)testCompile(测试编译时)testRuntime(测试运行时)。repositories是一个仓库gradle会根据从上到下的顺序依次去仓库中寻找jar 

     

    这里我们默认的是一个maven的中心仓库 ,从gradle源代码中我们看到地址是这样的

    这里可以进行配置,其中mavenLocal()表示使用本地maven仓库;mavenCentral()使用maven中心仓库 。使用固定的地址,这里可以使用阿里云(maven {url 'http://maven.aliyun.com/nexus/content/groups/public/'})的镜像下载速度会快一些,然后也可以使用公司内部的私服地址 。

    附加,这里加上一个spring boot的gradle配置文件,可以和maven的构建对比一下

    // buildscript 代码块中脚本优先执行
    buildscript {
    
    	// ext 用于定义动态属性
    	ext {
    		springBootVersion = '1.5.2.RELEASE'
    	}
    			
    	// 自定义  Thymeleaf 和 Thymeleaf Layout Dialect 的版本
    	ext['thymeleaf.version'] = '3.0.3.RELEASE'
    	ext['thymeleaf-layout-dialect.version'] = '2.2.0'
    	
    	// 自定义  Hibernate 的版本
    	ext['hibernate.version'] = '5.2.8.Final'
     
    	// 使用了 Maven 的中央仓库(你也可以指定其他仓库)
    	repositories {
    		//mavenCentral()
    		maven {
    			url 'http://maven.aliyun.com/nexus/content/groups/public/'
    		}
    	}
    	
    	// 依赖关系
    	dependencies {
    		// classpath 声明说明了在执行其余的脚本时,ClassLoader 可以使用这些依赖项
    		classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
    	}
    }
    
    // 使用插件
    apply plugin: 'java'
    apply plugin: 'eclipse'
    apply plugin: 'org.springframework.boot'
    
    // 打包的类型为 jar,并指定了生成的打包的文件名称和版本
    jar {
    	baseName = 'springboot-test'
    	version = '1.0.0'
    }
    
    // 指定编译 .java 文件的 JDK 版本
    sourceCompatibility = 1.8
    
    // 默认使用了 Maven 的中央仓库。这里改用自定义的镜像库
    repositories {
    	//mavenCentral()
    	maven {
    		url 'http://maven.aliyun.com/nexus/content/groups/public/'
    	}
    }
    
    // 依赖关系
    dependencies {
     
    	// 该依赖对于编译发行是必须的
    	compile('org.springframework.boot:spring-boot-starter-web')
     
    	// 添加 Thymeleaf 的依赖
    	compile('org.springframework.boot:spring-boot-starter-thymeleaf')
    
    	// 添加  Spring Security 依赖
    	compile('org.springframework.boot:spring-boot-starter-security')
    	
    	// 添加 Spring Boot 开发工具依赖
     	//compile("org.springframework.boot:spring-boot-devtools")
     
    	// 添加 Spring Data JPA 的依赖
    	compile('org.springframework.boot:spring-boot-starter-data-jpa')
    	
    	// 添加 MySQL连接驱动 的依赖
    	compile('mysql:mysql-connector-java:6.0.5')
    	
    	// 添加   Thymeleaf Spring Security 依赖,与 Thymeleaf 版本一致都是 3.x
    	compile('org.thymeleaf.extras:thymeleaf-extras-springsecurity4:3.0.2.RELEASE')
    	
    	// 添加  Apache Commons Lang 依赖
    	compile('org.apache.commons:commons-lang3:3.5')
    	
    	// 该依赖对于编译测试是必须的,默认包含编译产品依赖和编译时依
    	testCompile('org.springframework.boot:spring-boot-starter-test')
    	
    
    }

     

    展开全文
  • Gradle 简易入门教程

    万次阅读 2018-08-22 08:00:00
    作者: Yann 来源:原力注入Gradle 是一种构建工具,它抛弃了基于XML的构建脚本,取而代之的是采用一种基于 Groovy(现在也支持 Kotlin)的内部领域...
        

    作者: Yann  

    来源:原力注入


    Gradle 是一种构建工具,它抛弃了基于XML的构建脚本,取而代之的是采用一种基于 Groovy(现在也支持 Kotlin)的内部领域特定语言。


    Gradle特点


    1. Gradle是很成熟的技术,可以处理大规模构建

    2. Gradle对多语言、多平台支持性更好

    3. Gradle关注在构建效率上

    4. Gradle发布很频繁,重要feature开发计划透明化

    5. Gradle社区很活跃,并且增加迅速


    安装Gradle


    • 从 官网 (https://gradle.org/install/)下载二进制文件。

    • 解压Zip文件,加入环境变量(在PATH中加入GRADLE_HOME/bin目录)


    如果在安装过程中遇到问题,可以进一步查看官方的安装指南(https://gradle.org/install/)。最后验证一下 Gradle 是否工作正常


    1. gradle -v

    2. ------------------------------------------------------------

    3. Gradle 4.2.1

    4. ------------------------------------------------------------

    5. Build time:   2017-10-02 15:36:21 UTC

    6. Revision:     a88ebd6be7840c2e59ae4782eb0f27fbe3405ddf

    7. Groovy:       2.4.12

    8. Ant:          Apache Ant(TM) version 1.9.6 compiled on June 29 2015

    9. JVM:          1.8.0_162-ea (Oracle Corporation 25.162-b01)

    10. OS:           Mac OS X 10.13.5 x86_64


    Gradle快速体验


    初始化一个项目


    • 创建一个 demo 目录

    1. ❯ mkdir gradle-demo


    • 初始化 Gradle 项目

    1. ❯ gradle init

    2. Starting a Gradle Daemon (subsequent builds will be faster)

    3. BUILD SUCCESSFUL in 3s

    4. 2 actionable tasks: 2 executed



    Gradle目录结构


    我们看看上一步我们生成了什么文件


    ├── build.gradle  ❶
    ├── gradle
    │   └── wrapper
    │       ├── gradle-wrapper.jar    ➋
    │       └── gradle-wrapper.properties  ➌
    ├── gradlew    ➍
    ├── gradlew.bat  ➎
    └── settings.gradle  ➏


    ❶ 当前项目的配置脚本

    ➋ Gradle Wrapper 的执行jar包(后续介绍)

    ➌ Gradle Wrapper 的配置文件

    ➍ Gradle Wrapper Unix 系执行脚本

    ➎ Gradle Wrapper Windows 系执行脚本

    ➏ 项目脚本设置


    创建一个Task


    Gradle提供了用于通过基于Groovy或Kotlin的DSL创建和配置。项目包括一组Task,每个Task执行一些基本操作。


    • 创建一个目录叫 src

    • 在src目录创建一个 myfile.txt

    • 在构建文件中定义一个名为Copy的类型 Task ,该任务将src目录复制到名为dest的新目录


    groovy代码:

    1. task copy(type: Copy, group: "Custom", description: "Copies sources to the dest directory") {

    2.    from "src"

    3.    into "dest"

    4. }



    kotlin代码:

    1. tasks.create<Copy>("copy") {

    2.    description = "Copies sources to the dest directory"

    3.    group = "Custom"

    4.    from("src")

    5.    into("dest")

    6. }


    group 和 description 是自定义的任意值。现在让我们执行这个 task

    1. ❯ ./gradlew copy

    2. > Task :copy

    3. BUILD SUCCESSFUL in 0s

    4. 1 actionable task: 1 executed



    再一次 ls 我们就可以看见 gradle 为我们创建了一个新的 dest 目录并且将 文件复制进去。


    Gradle Task


    在Gradle中,有两个基本概念:项目和任务。

    • 项目是指我们的构建产物(比如Jar包)或实施产物(将应用程序部署到生产环境)一个项目包含一个或多个任务。

    • 任务是指不可分的最小工作单元,执行构建工作(比如编译项目或执行测试)。

    640?wx_fmt=png

    在项目目录中的 build.gradle 指定了一个项目和它的任务。


    Task执行顺序


    任务可能依赖于其他任务,或者可能被安排为始终在另一个任务之后运行。

    1. project('projectA') {

    2.    task taskX(dependsOn: ':projectB:taskY') {

    3.        doLast {

    4.            println 'taskX'

    5.        }

    6.    }

    7. }

    8. project('projectB') {

    9.    task taskY {

    10.        doLast {

    11.            println 'taskY'

    12.        }

    13.    }

    14. }



    1. > gradle -q taskX

    2. taskY

    3. taskX  // taskx 在 y 之后



    我们可以用 dependsOn 让我们的 Task 有顺序的运行起来。


    Gradle插件


    看到这里,如果每一件事情我们都需要写 Task 岂不是会累死,而且很多功能是可以被复用的,所以Gradle 提供一个 插件 功能,Gradle 默认就内置了大量的插件,比如在 base 中有一系列的功能。


    groovy代码

    1. plugins {

    2.    id "base"

    3. }



    kotlin代码:

    1. plugins {

    2.    id("base")

    3. }



    这个时候我们就可以利用一些额外的 Task,举个例子,我们要把一个目录中的东西都打成一个 ZIP 压缩包。


    groovy代码:

    1. task zip(type: Zip, group: "Archive", description: "Archives sources in a zip file") {

    2.    from "src"

    3.    setArchiveName "basic-demo-1.0.zip"

    4. }



    kotlin代码:

    1. tasks.create<Zip>("zip") {

    2.    description = "Archives sources in a zip file"

    3.    group = "Archive"

    4.    from("src")

    5.    setArchiveName("basic-demo-1.0.zip")

    6. }


    Gradle 的设计理念是

    • 在项目中添加新任务

    • 为新加入的任务提供默认配置,这个默认配置会在项目中注入新的约定(如源文件位置)。

    • 加入新的属性,可以覆盖插件的默认配置属性。

    • 为项目加入新的依赖。


    Gradle Java


    Gradle 内置了 Java 插件,Java插件将Java编译以及测试和捆绑功能添加到项目中。它是许多其他Gradle插件的基础。如果我们需要使用 Java 插件 修改 build.gradle


    1. plugins {

    2.    id 'java'

    3. }



    一旦导入了 Java 插件,就会有一系列的默认的配置值,并且会导入大量的 Task。

    Task含义
    compileJava(type: JavaCompile)Java 编译
    processResources(type: Copy)拷贝 Resources 资源
    classes(type: Task)组装 Java 类
    compileTestJava(type: JavaCompile)Java Test 编译
    processTestResources(type: Copy)拷贝 Test Resources 资源
    testClasses(type: Task)组装 Test 类
    jar(type: Jar)合成Jar包
    javadoc(type: Javadoc)生成 doc 文档
    test(type: Test)运行测试
    uploadArchives(type: Upload)上传 jar 到仓库
    clean(type: Delete)clean

    我们从这些 Task 名字就可以看出来他们分别作作了, 和其他的设计理念类型,在 Task 也会嵌入一些生命周期,其实原理也就是我们之前看的执行顺序。

    640?wx_fmt=png

    资源:Gradle插件仓库


    Gradle依赖管理


    先盗取一张官方的图。

    640?wx_fmt=png


    和 Maven 类似,Gradle 也会将依赖缓冲在本地中,方便在无网的环境使用,和依赖管理相关的有两个参数,举个例子。


    1. repositories {

    2.    mavenCentral() // 定义仓库

    3. }

    4. dependencies {

    5.    compile 'org.springframework:spring-web:5.0.2.RELEASE' // 定义依赖

    6. }


    Gradle支持以下仓库格式:

    • Ivy仓库

    • Maven仓库

    • Flat directory仓库


    lvy仓库


    我们可以通过URL地址或本地文件系统地址,将Ivy仓库加入到我们的构建中。

    1. repositories {

    2.    ivy {

    3.        url "http://ivy.petrikainulainen.net/repo"

    4.    }

    5. }

    6. //或者是本地

    7. repositories {

    8.    ivy {      

    9.        url "../ivy-repo"

    10.    }

    11. }



    Maven仓库


    1. repositories {

    2.    maven {

    3.        url "http://maven.petrikainulainen.net/repo"

    4.    }

    5. }



    在加入Maven仓库时,Gradle提供了三种“别名”供我们使用,它们分别是

    • mavenCentral()别名,表示依赖是从Central Maven 2 仓库中获取的。

    • jcenter()别名,表示依赖是从Bintary’s JCenter Maven 仓库中获取的。

    • mavenLocal()别名,表示依赖是从本地的Maven仓库中获取的。


    Flat Directory仓库


    1. repositories {

    2.    flatDir {

    3.        dirs 'lib'

    4.    }

    5. }

    6. //多个仓库

    7. repositories {

    8.    flatDir {

    9.        dirs 'libA', 'libB'

    10.    }

    11. }



    依赖管理



    在配置完项目仓库后,我们可以声明其中的依赖,首先 Java 插件指定了若干依赖配置项

    • compile 配置项中的依赖是依赖必须的。

    • runtime 配置项中包含的依赖在运行时是必须的。

    • testCompile 配置项中包含的依赖在编译项目的测试代码时是必须的。

    • testRuntime 配置项中包含的依赖在运行测试代码时是必须的。


    在 Gradle 最新版本中更是增加

    • implementation 配置项中的实现类

    • api 配置项中的暴露API


    1. dependencies {

    2.    api 'commons-httpclient:commons-httpclient:3.1'

    3.    implementation 'org.apache.commons:commons-lang3:3.5'

    4. }



    声明项目依赖


    最普遍的依赖称为外部依赖,这些依赖存放在外部仓库中。一个外部依赖可以由以下属性指定:

    • group属性指定依赖的分组(在Maven中,就是groupId)

    • name属性指定依赖的名称(在Maven中,就是artifactId)

    • version属性指定外部依赖的版本(在Maven中,就是version)


    1. dependencies {

    2.    compile group: 'foo', name: 'foo', version: '0.1'

    3. }

    4. // 我们也可以合并到一起去

    5. dependencies {

    6.    compile 'foo:foo:0.1'

    7. }



    声明项目文件依赖


    我们如何依赖本地的一些 jar 呢,正确的操作是如下

    1. dependencies {

    2.    compile files('libs/commons-lang.jar', 'libs/log4j.jar')

    3. }



    声明依赖排除项目


    我们都知道在 Maven中我们有

    1.    <dependency>

    2.        <groupId>sample.ProjectB</groupId>

    3.        <artifactId>Project-B</artifactId>

    4.        <version>1.0-SNAPSHOT</version>

    5.        <exclusions>

    6.            <exclusion>

    7.                <groupId>log4j</groupId>

    8.                <artifactId>log4j</artifactId>

    9.            </exclusion>

    10.        </exclusions>

    11.    </dependency>


    而在 Gradle 中,我们可以这么做。

    1. compile('com.example.m:m:1.0') {

    2.    exclude group: 'org.unwanted', module: 'x

    3. }



    Gradle与Kotlin


    我们想要在 gradle 中增加 kotlin 非常的简单,仅仅需要在 build.gradle 增加

    1. plugins {

    2.     id "org.jetbrains.kotlin.jvm" version "x.x.xx" // 增加插件

    3. }

    4. dependencies {

    5.  compile "org.jetbrains.kotlin:kotlin-stdlib:x.xx.xx" // 增加依赖

    6. }



    大功告成,对了,默认的 Kotlin 的源码路径是 src/main/kotlin, 测试源码是 src/text/kotlin 如果需要修改可以使用

    1. sourceSets {

    2.    main.kotlin.srcDirs += 'src/main/myKotlin'

    3.    main.java.srcDirs += 'src/main/myJava'

    4. }




    其他


    Gradle Wrapper



    Gradle Wrapper 做了三件事情

    • 解析参数传入 gradlew

    • 安装正确的 Gradle 版本

    • 调用 Gradle 执行命令


    Ops,Gradle Wrapper 为什么还需要安装 Gradle,我们在用 Maven 都知道,我们需要自己先安装好一个 Maven版本,因为 Maven 发展多年,现在已经稳定,已经不存在很多个版本并存的现状了,但是我们依然需要去在每个机器上去安装,那我什么我们不能在自己的 构建脚本 中就指定我们的构建工具呢?所以我们在 wrapper/gradle-wrapper.properties 中就可以发现 distributionUrl=https\://services.gradle.org/distributions/gradle-4.2.1-bin.zip 这里也就是定义了我们的gradle所使用的版本。


    640?wx_fmt=png

    Gradle In Real World

    1. // 定义一堆基础插件

    2. apply plugin: 'java'

    3. apply plugin: 'maven'

    4. apply plugin: "jacoco"

    5. apply plugin: 'checkstyle'

    6. apply plugin: 'pmd'

    7. apply plugin: 'findbugs'

    8. apply plugin: 'eclipse'

    9. apply plugin: 'idea'

    10. // 定义项目属性

    11. group = 'Common'

    12. version = '1.0.0'

    13. description = """Giant common library"""

    14. // 定义依赖仓库

    15. repositories {

    16.    mavenCentral()

    17. }

    18. // 额外增加source path

    19. sourceSets {

    20.    main {

    21.        resources {

    22.            srcDir "src/main/profiles/${profile}"

    23.        }

    24.    }

    25. }

    26. // project依赖

    27. dependencies {

    28.    compile 'ch.qos.logback:logback-core:1.0.13'

    29.    compile 'ch.qos.logback:logback-classic:1.0.13'

    30.    compile 'ch.qos.logback:logback-access:1.0.13'

    31.    compile 'commons-io:commons-io:2.0.1'

    32.    compile 'commons-lang:commons-lang:2.6'

    33.    compile 'joda-time:joda-time:1.6.2'

    34.    compile 'org.testng:testng:6.8.7'

    35.    compile 'com.googlecode.jmockit:jmockit:1.5'

    36.    ...

    37. }

    38. // task配置

    39. checkstyle {

    40.    ignoreFailures = true

    41.    sourceSets = [sourceSets.main]

    42. }

    43. findbugs {

    44.    ignoreFailures = true

    45.    sourceSets = [sourceSets.main]

    46. }

    47. pmd {

    48.    ruleSets = ["basic", "braces", "design"]

    49.    ignoreFailures = true

    50.    sourceSets = [sourceSets.main]

    51. }

    52. jacocoTestReport {

    53.    reports {

    54.        xml.enabled true

    55.        html.enabled true

    56.        csv.enabled false

    57.    }

    58.    sourceSets sourceSets.main

    59. }

    60. tasks.withType(Compile) {

    61.    options.encoding = "UTF-8"

    62. }

    63. test {

    64.    useTestNG()

    65.    jacoco {

    66.        excludes = ["org.*"]

    67.    }

    68. }



    Gradle常用指令


    枚列所有可用任务


    1. ❯ gradle tasks

    2. ------------------------------------------------------------

    3. All tasks runnable from root project

    4. ------------------------------------------------------------

    5. Archive tasks

    6. -------------

    7. zip - Archives sources in a zip file

    8. Build tasks

    9. -----------

    10. assemble - Assembles the outputs of this project.

    11. build - Assembles and tests this project.

    12. clean - Deletes the build directory.



    构建配置属性

    1. ❯ gradle properties



    显示构建详情


    在 build.gradle 设置

    1. logging.level = LogLevel.DEBUG


    或者在运行的

    1. ❯ gradle build --stacktrace


    参考资料&推荐文档


    • Gradle入门教程(http://blog.jobbole.com/71999/)

    • Gradle介绍(https://www.jianshu.com/p/00d5469e25e7)

    • 官方教材(https://guides.gradle.org/creating-new-gradle-builds/)

    -END-


     近期热文:

    关注我

    640?wx_fmt=jpeg

    点击“阅读原文”,看本号其他精彩内容

    展开全文
  • 彻底弄明白Gradle相关配置

    万次阅读 多人点赞 2018-05-28 16:45:03
    初识Gradle Gradle是一个基于Apache Ant和Apache Maven概念的项目自动化建构工具。它使用一种基于Groovy的特定领域语言来声明项目设置,而不是传统的XML。当前其支持的语言限于Java、Groovy和Scala,计划未来将支持...

    初识Gradle

    Gradle是一个基于Apache Ant和Apache Maven概念的项目自动化建构工具。它使用一种基于Groovy的特定领域语言来声明项目设置,而不是传统的XML。当前其支持的语言限于Java、Groovy和Scala,计划未来将支持更多的语言。

    怎么看上面都是一段很官方的解释,对于入门的人来说简直是一个噩梦般的解释(包括以前的我)。那下面我就用通俗一点语言说说我的理解。

    Gradle就是工程的管理,帮我们做了依赖,打包,部署,发布,各种渠道的差异管理等工作。举个例子形容,如果我是一个做大事的少爷平时管不了这么多小事情,那Gradle就是一个贴心的秘书或者管家,把一些杂七杂八的小事情都帮我们做好了,让我们可以安心的打代码,其他事情可以交给管家管。

    那有人会问,既然工作都可以交给他做,为什么还要我们去了解。我想我们要管家做事,也要下达我们的命令,我们必须知道这些命令和管家的喜好才能跟他相处和谐,不然你不知道它的脾性下错命令,那后果可是很严重的。

    在以前实习的时候,我还用eclipse,那是导入一个网上的下载的module还需要一步步的import。但自从用了Android Studio后,Gradle很贴心的帮我完成了这个繁杂的工作,而且往往只需要添加一句话,这太神奇了,当时我是这样想的,下面我们也会说到这个。

    分析

    下面我就用自己项目中用到的Gradle慢慢分析:

    我们看到,每个Module都会对应有一个Gradle文件,另外还有一个主Project的Gradle文件管理全局。下面我们先看看那个叫gradle-wrapper.properties的文件:

    gradle-wrapper

    Wrapper是对Gradle的一层包装,便于在团队开发过程中统一Gradle构建的版本号,这样大家都可以使用统一的Gradle版本进行构建。

    上面我们看到的图就是Gradle提供内置的Wrapper task帮助我们自动生成Wrapper所需的目录文件。再看看我们Android项目里面自动生成的文件


    终于,我们知道这几个自动生成的文件原来是Gradle Wrapper创建出来的。

    那下面我们看看gradle-wrapper.properties这个文件的作用

    看到项目里面的各个属性,下面再看看每个属性的作用

    我们其实最关心的应该是distributionUrl这个属性,他是下载Gradle的路径,它下载的东西会出现在以下的文件夹中

    看到了吧,这个文件夹包含了各个版本你下载的Gradle。

    当我是初学者的时候老是会遇到一个问题,那就是下图:

    导入项目的时候一直会停留在这个界面,这是为什么?其实原因很简单,就是你常用项目的Gradle版本跟你新导入项目的Gradle版本不一致造成的,那怎么解决?我本人自己是这么做的:

    • 网速好或者科学上网的时候,由它自己去下载,不过下载时间有长有短,不能保证。
    • 当你在公司被限网速的时候,当然也是我最常用的,就是把你最近常用项目的gradle-wrapper.properties文件替换掉你要导入项目的该文件,基本上我是这样解决的,当然有时候也会遇到替换掉报错的情况,不过比较少。

    settings.gradle

    下面我们讲讲settings.gradle文件,它其实是用于初始化以及工程树的配置的,放在根工程目录下。

    设置文件大多数的作用都是为了配置自工程。在Gradle众多工程是通过工程树表示的,相当于我们在Android Studio看到的Project和Module概念一样。根工程相当于Android Studio的Project,一个根工程可以有很多自工程,也就是很多Module,这样就和Android Studio定义的Module概念对应上了。

    我们可以看到这个项目我们添加了7个module,一一对应,如果你的项目添加了项目依赖,那就会出现在这个文件当中。

    好了,我们说完settings.gradle文件之后就慢慢进入其他文件了,但是首先我们要解释一下什么是Groovy:

    Groovy

    Groovy是基于JVM虚拟机的一种动态语言,它的语法和Java非常相似,由Java入门学习Groovy基本没有障碍。Groovy完全兼容Java,又在此基础上增加了很多动态类型和灵活的特性,比如支持密保,支持DSL,可以说它就是一门非常灵活的动态脚本语言。

    一开始我总把Gradle和Groovy搞混了,现在我总把他们的关系弄清楚了。Gradle像是一个软件,而Groovy就是写这个软件的语言,这就很简单明了吧。那下面我们说到的内容都是用Groovy语法写的,但是这个知识点我就暂时不科普了,有兴趣的小伙伴可以去了解一下更深入的Groovy语法。

    build.gradle(Project)

    下面我们就来讲讲主的build.gradle文件:

    我们这里,分为四个标签来讲:

    1.buildscript

    buildscript中的声明是gradle脚本自身需要使用的资源。可以声明的资源包括依赖项、第三方插件、maven仓库地址等

    2.ext

    ext是自定义属性,现在很多人都喜欢把所有关于版本的信息都利用ext放在另一个自己新建的gradle文件中集中管理,下面我介绍一下ext是怎么用的:

    - 首先我们新建两个文件,分别叫build.gradle和version.gradle


    - 然后分别在两个文件中打上相应的代码

    - 最后在Android Studio的Terminal移动到相应的文件夹中运行task。
    我们可以很神奇的发现,当我们在build.gradle文件中输入了apply from:’version.gradle’这句话,我们就可以读取到该文件下ext的信息。

    现在在项目中我也是这种方法统一管理所有第三方插件的版本号的,有兴趣的朋友也可以试试。

    3.repositories

    顾名思义就是仓库的意思啦,而jcenter()、maven()和google()就是托管第三方插件的平台

    4.dependencies

    当然配置了仓库还不够,我们还需要在dependencies{}里面的配置里,把需要配置的依赖用classpath配置上,因为这个dependencies在buildscript{}里面,所以代表的是Gradle需要的插件。

    下面我们再看看build.gradle(Project)的另一部分代码

    • allprojects

    allprojects块的repositories用于多项目构建,为所有项目提供共同所需依赖包。而子项目可以配置自己的repositories以获取自己独需的依赖包。

    奇怪,有人会问,为什么同一个build.gradle(Project)文件中buildscript和allprojects里面的内容基本上是一样的呢,他们的区别在哪?

    • buildscript和allprojects的作用和区别

    buildscript中的声明是gradle脚本自身需要使用的资源,就是说他是管家自己需要的资源,跟你这个大少爷其实并没有什么关系。而allprojects声明的却是你所有module所需要使用的资源,就是说如果大少爷你的每个module都需要用同一个第三库的时候,你可以在
    allprojects里面声明。这下解释应该可以明白了吧。

    好了,下面该说说build.gradle(Project)文件的最后一个一段代码了

    运行gradle clean时,执行此处定义的task。该任务继承自Delete,删除根目录中的build目录。相当于执行Delete.delete(rootProject.buildDir)。其实这个任务的执行就是可以删除生成的Build文件的,跟Android Studio的clean是一个道理。

    • build.gradle(Module)

    讲完Project的build文件,就来讲讲最后也是内容最多的文件了。

    • apply plugin

    首先要说下apply plugin:’×××’

    这种叫做引入Gradle插件,而Gradle插件大致分为分为两种:

    • apply plugin:’×××’:叫做二进制插件,二进制插件一般都是被打包在一个jar里独立发布的,比如我们自定义的插件,再发布的时候我们也可以为其指定plugin id,这个plugin id最好是一个全限定名称,就像你的包名一样;
    • apply from:’×××’:叫做应用脚本插件,其实这不能算一个插件,它只是一个脚本。应用脚本插件,其实就是把这个脚本加载进来,和二进制插件不同的是它使用的是from关键字.后面紧跟的坫一个脚本文件,可以是本地的,也可以是网络存在的,如果是网络上的话要使用HTTP URL.
      虽然它不是一个真正的插件,但是不能忽视它的作用.它是脚本文件模块化的基础,我们
      可以把庞大的脚本文件.进行分块、分段整理.拆分成一个个共用、职责分明的文件,然后使
      用apply from来引用它们,比如我们可以把常用的函数放在一个Utils.gradle脚本里,供其他脚本文件引用。示例中我们把 App的版本名称和版本号单独放在一个脚本文件里,清晰、简单、方便、快捷.我们也可以使用自动化对该文件自动处理,生成版本。

    说说Gradle插件的作用

    把插件应用到你的项目中,插件会扩展项目的功能,帮助你在项目的构建过程中做很多事情。1.可以添加任务到你的项目中,帮你完成一些亊情,比如测试、编译、打包。2.可以添加依赖配置到你的项目中,我们可以通过它们配置我们项目在构建过程中需要的依赖.比 如我们编译的时候依赖的第三方库等。3.可以向项目中现有的对象类型添加新的扩展属性、 方法等,让你可以使用它们帮助我们配置、优化构建,比如android{}这个配置块就是Android Gradle插件为Project对象添加的一个扩展。4. 可以对项目进行一些约定,比如应用Java插 件之后,约定src/main/java目录下是我们的源代码存放位置,在编译的时候也是编译这个目录下的Java源代码文件。

    然后我们说说’com.android.application’

    Android Gradle插件的分类其实是根据Android工程的属性分类的。在Andriod中有3类工程,一类是App应用工程,它可以生成一个可运行的apk应用:一类是Library库工程,它可以生成AAR包给其他的App工程公用,就和我们的Jar一样,但是它包含了Android的资源等信息,是一个特殊的Jar包;最后一类是Test测试工程,用于对App工程或者Library库工程进行单元测试。

    • App插件id:com.android.application.
    • Library插件id:com.android.library.
    • Test插件id:com.android.test.
      一般一个项目只会设置一个App插件,而module一般是会设置为Library插件。

    android{}

    是Android插件提供的一个扩展类型,可以让我们自定义Android Gradle工程,是Android Gradle工程配置的唯一入口。

    compileSdkVersion

    是编译所依赖的Android SDK的版本,这里是API Level。

    buildToolsVersion

    是构建该Android工程所用构建工具的版本。

    defaultConfig{}

    defaultConfig是默认的配置,它是一个ProductFlavor。ProductFlavor允许我们根据不同的情况同时生成多个不同的apk包。

    applicationId

    配置我们的包名,包名是app的唯一标识,其实他跟AndroidManifest里面的package是可以不同的,他们之间并没有直接的关系。

    package指的是代码目录下路径;applicationId指的是app对外发布的唯一标识,会在签名、申请第三方库、发布时候用到。

    minSdkVersion

    是支持的Android系统的api level,这里是15,也就是说低于Android 15版本的机型不能使用这个app。

    targetSdkVersion

    表明我们是基于哪个Android版本开发的,这里是22。

    versionCode

    表明我们的app应用内部版本号,一般用于控制app升级,当然我在使用的bugly自动升级能不能接受到升级推送就是基于这个。

    versionName

    表明我们的app应用的版本名称,一般是发布的时候写在app上告诉用户的,这样当你修复了一个bug并更新了版本,别人却发现说怎么你这个bug还在,你这时候就可以自信的告诉他自己看下app的版本号。(亲身经历在撕逼的时候可以从容的应对)

    multiDexEnabled

    用于配置该BuildType是否启用自动拆分多个Dex的功能。一般用程序中代码太多,超过了65535个方法的时候。

    ndk{}

    多平台编译,生成有so包的时候使用,包括四个平台’armeabi’, ‘x86’, ‘armeabi-v7a’, ‘mips’。一般使用第三方提供的SDK的时候,可能会附带so库。

    sourceSets

    源代码集合,是Java插件用来描述和管理源代码及资源的一个抽象概念,是一个Java源代码文件和资源文件的集合,我们可以通过sourceSets更改源集的Java目录或者资源目录等。

    譬如像上图,我通过sourceSets告诉了Gradle我的关于jni so包的存放路径就在app/libs上了,叫他编译的时候自己去找。

    name:build type的名字
    
    applicationIdSuffix:应用id后缀
    
    versionNameSuffix:版本名称后缀
    
    debuggable:是否生成一个debug的apk
    
    minifyEnabled:是否混淆
    
    proguardFiles:混淆文件
    
    signingConfig:签名配置
    
    manifestPlaceholders:清单占位符
    
    shrinkResources:是否去除未利用的资源,默认false,表示不去除。
    
    zipAlignEnable:是否使用zipalign工具压缩。
    
    multiDexEnabled:是否拆成多个Dex
    
    multiDexKeepFile:指定文本文件编译进主Dex文件中
    
    multiDexKeepProguard:指定混淆文件编译进主Dex文件中
    

    buildType

    构建类型,在Android Gradle工程中,它已经帮我们内置了debug和release两个构建类型,两种模式主要车别在于,能否在设备上调试以及签名不一样,其他代码和文件资源都是一样的。一般用在代码混淆,而指定的混淆文件在下图的目录上,minifyEnabled=true就会开启混淆:

    signingConfigs

    签名配置,一个app只有在签名之后才能被发布、安装、使用,签名是保护app的方式,标记该app的唯一性。如果app被恶意删改,签名就不一样了,无法升级安装,一定程度保护了我们的app。而signingConfigs就很方便为我们提供这个签名的配置。storeFile签名文件,storePassword签名证书文件的密码,storeType签名证书类型,keyAlias签名证书中秘钥别名,keyPassword签名证书中改密钥的密码。

    默认情况下,debug模式的签名已经被配置好了,使用的就是Android SDK自动生成的debug证书,它一般位于$HOME/.android/debug.keystore,其key和密码是已经知道的,一般情况下我们不需要单独配置debug模式的签名信息。

    productFlavors

    在我看来他就是Gradle的多渠道打包,你可以在不同的包定义不同的变量,实现自己的定制化版本的需求。

    manifestPlaceholders

    占位符,我们可以通过它动态配置AndroidManifest文件一些内容,譬如app的名字:

    看看上图,我们就能发现我们在productFlavors中定义manifestPlaceholders = [APP_NAME: “(测试)”]之后,在AndroidManifest的label加上”${APP_NAME}”,我们就能控制每个包打出来的名字是我们想要不同的名字,譬如测试服务器和生产服务器的包应该名字不一样。

    buildConfigField

    他是BuildConfig文件的一个函数,而BuildConfig这个类是Android Gradle构建脚本在编译后生成的。而buildConfigField就是其中的自定义函数变量,看下图我们分别定义了三个常量:

    我们可以在BuildConfig文件中看到我们声明的三个变量

    然后我们就可以在代码中用这些变量控制不同版本的代码:

    我们这样加个if,就可以轻轻松松的控制测试和生产版本付费的问题了,再也不用手动的改来改去了,那问题来了,我怎么去选择不同的版本呢,看下图:

    如果你是Android Studio,找到Build Variants就可以选择你当前要编译的版本啦。

    flavorDimensions

    顾名思义就是维度,Gradle3.0以后要用flavorDimensions的变量必须在defaultConfig{}中定义才能使用,不然会报错:

    Error:All flavors must now belong to a named flavor dimension.
    The flavor 'flavor_name' is not assigned to a flavor dimension.

    这样我们就可以在不同的包中形成不同的applicationId和versionName了。

    dexOptions{}

    我们知道,Android中的Java源代码被编译成class字节码后,在打包成apk的时候
    被dx命令优化成Android虚拟机可执行的DEX文件。DEX文件比较紧凑,Android费尽心思
    做了这个DEX格式,就是为了能使我们的程序在Android中平台上运行快一些。对于这些生成
    DEX文件的过程和处理,Android Gradle插件都帮我们处理好了,Android Gradle插件会调用
    SDK中的dx命令进行处理。但是有的时候可能会遇到提示内存不足的错误,大致提示异常是
    java,lang.OutOfMemoryError: GC overhead limit exceeded,为什么会提示内存不足呢? 其实这个
    dx命令只是一个脚本,它调用的还是Java编写的dx.jar库,是Java程序处理的,所以当内存
    不足的时候,我们会看到这个Java异常信息.默认情况下给dx分配的内存是一个G8,也就
    是 1024MB。

    所以我们只需要把内存设置大一点,就可以解决这个问题,上图我的项目就把内存设置为4g。

    dependencies{}

    我们平时用的最多的大概就这个了,

    • 首先第一句compile fileTree(include: [‘.jar’], dir: ‘libs’)*,这样配置之后本地libs文件夹下的扩展名为jar的都会被依赖,非常方便。
    • 如果你要引入某个本地module的话,那么需要用compile project(‘×××’)。
    • 如果要引入网上仓库里面的依赖,我们需要这样写compile group:’com.squareup.okhttp3’,name:’okhttp’,version:’3.0.1’,当然这样是最完整的版本,缩写就把group、name、version去掉,然后以”:”分割即可。
      compile ‘com.squareup.okhttp3:okhttp:3.0.1’

      但是到了gradle3.0以后build.gradle中的依赖默认为implementation,而不是
      之前的compile。另外,还有依赖指令api。
      那么下面我们就来说说:

    gradle 3.0中依赖implementation、api的区别:

    其实api跟以前的compile没什么区别,将compile全部改成api是不会错的;
    而implementation指令依赖是不会传递的,也就是说当前引用的第三方库仅限于本module内使用,其他module需要重新添加依赖才能用,下面用两个图说明:



    相信看过图的人都会一目明了。

    作者:19snow93
    链接:https://www.jianshu.com/p/8b8a550246bd

    展开全文
  • gradle安装与入门

    万次阅读 2018-06-22 12:16:09
    1.Gradle安装(本地也可不安装,不安装...下载你所需要对应的版本,gradle-4.6.1-bin.zip下载后解压到你想要的目录设置环境变量新建系统变量,变量名为GRADLE_HOME,变量值为gradle安装包所在目录添加到PATH环境中在c...
  • Gradle

    2020-11-22 16:53:09
    Gradle build.gradle 可能有多个,一般在app 节点,默认里面不包含buildscript,allprojects 这两项。 把这段代码加入 build.gradle (Moudle:app) 尾部: buildscript { repositories { maven{ url = ...
  • Gradle

    2020-11-13 17:54:49
    文章目录Gradle思想闭包taskgradle 工作流程Gradle WrapperAndroid插件构建文件的目录:Android 块dependency块全局配置Gradle 依赖管理 Gradle思想 在软件开发过程中,编码,编译,打包,测试,这几个过程必不可少...
  • Gradle详解

    千次阅读 2018-08-30 22:49:54
    先看下Gradle的定义: Gradle是一个基于Apache Ant和Apache Maven概念的项目自动化构建开源工具。它使用一种基于Groovy的特定领域语言(DSL)来声明项目设置,抛弃了基于XML的各种繁琐配置。 抽住定义中的核心就是...
  • Gradle系列之初识Gradle

    2019-04-21 23:22:09
    学习 Android 有一段时间了,开发中经常使用到 Gradle ,但是不知道 Gradle 构建项目的原理,计划花一点时间学习一下 Gradle 相关的知识。Gradle 是一个非常优秀的项目构建工具,其 DSL(领域特定语言)基于 Groovy ...
  • Maven与Gradle项目构建工具

    千次阅读 2019-06-11 07:15:17
    项目构建管理工具Maven和Gradle的介绍以及常见问题记录!^_^
  • Linux下安装配置Gradle

    千次阅读 2019-06-11 17:10:05
    环境 阿里云 CentOS 7.5 64位 1.下载压缩包 ...下载完成后,得到一个gradle-4.4.1-all.zip文件 2.解压 来到压缩包所在路径,输入以下命令即可解压 unzip gradle-4.4.1-all.zip 若失败,则可能是因为没有...
  • Windows下gradle的安装与配置

    万次阅读 多人点赞 2018-07-12 00:03:38
    下载gradle 直接百度gradle,然后点击链接进去就可以找到,这里附上下载链接:gradle下载 安装gradle 解压下载下来的zip压缩包,如图(我下载的是gradle-4.8.1-bin.zip) 配置环境变量 右键 “计算机”–”...
  • 在IDEA里gradle配置和使用

    万次阅读 多人点赞 2018-06-13 19:32:23
    在IDEA里gradle配置和使用 在IDEA里gradle配置和使用 前言 Windows环境IDEA配置gradle 配置系统环境变量 下载 配置环境变量 测试 idea配置 gradle仓库设置 构建命令 创建缓存依赖 gradle.build构建脚本 ...
  • gradle各版本下载地址

    万次阅读 2016-08-16 11:17:25
    以前都是手动下载gradle的文件,然后修改的,现在从官网上面来解决更新gradle的问题。 android studio更新与gradle的更新: 1、先下载android studio的最新版本,这一步直接点击AS开发环境的update即可 2、下载
  • gradle配置国内镜像

    万次阅读 多人点赞 2017-11-02 11:19:28
    使用阿里云国内镜像对单个项目生效,在项目中的build.gradle修改内容buildscript { repositories { maven { url 'http://maven.aliyun.com/nexus/content/groups/public/' } maven{ url '...
  • Gradle脚本基础全攻略

    万次阅读 多人点赞 2015-10-25 23:19:40
    点我开始Android技术交流】1 背景在开始Gradle之前请务必保证自己已经初步了解了Groovy脚本,特别是闭包规则,如果还不了解Groovy则可以先看《Groovy脚本基础全攻略》这一篇博客速成一下Groovy基础,然后再看此文...
  • gradle-3.3-all.zip 绿色版本,欢迎下载

    万次下载 热门讨论 2017-01-09 10:47:43
    官网下载不成功的,可以直接在这里下载。 官网原下载地址:https://services.gradle.org/distributions/
  • gradle资源包是通过android studio 远程访问安卓的gradle仓库进行下载的 难免会出现网络不佳,以及被墙的情况(并不是所有人都会遇到) 开始正文: 1.现象说明 gradle失败会显示这个界面 2.首先确认自己的g...
  • gradle升级之后,有了新的依赖方式,下面我来介绍一下他们的使用 先看看之前的 再看看现在的 区别和使用 implementation和api implementation和api是取代之前的compile的,其中api和compile是一样的...

空空如也

1 2 3 4 5 ... 20
收藏数 201,213
精华内容 80,485
关键字:

gradle