gradle和grails的区别

gradle是一个构建工具。【拓展资料】一、对gradle的了解。简单的说，Gradle是一个构建工具，它是用来帮助我们构建app的，构建包括编译、打包等过程。我们可以为Gradle指定构建规则，然后它就会根据我们的“命令”自动为我们构建app。Android Studio中默认就使用Gradle来完成应用的构建。有些同学可能会有疑问：”我用AS不记得给Gradle指定过什么构建规则呀，然后不还是能搞出来个apk。“ 实际上，app的构建过程是大同小异的，有一些过程是”通用“的，也就是每个app的构建都要经历一些公共步骤。因此，在我们在创建工程时，Android Studio自动帮我们生成了一些通用构建规则，很多时候我们甚至完全不用修改这些规则就能完成我们app的构建。

gradle的意思是用于多语言软件开发的自动化构建工具。一、gradle是以Groovy语言为基础，面向Java应用为主，基于DSL语法的第一个构建集成工具，与ant、maven、ivy有良好的相容相关性。gradle整体设计是以作为一种语言为导向的，而非成为一个严格死板的框架。二、gradle的日常运用1、一种可切换的，像maven一样的基于约定的构建框架，却又从不锁住你的装置。2、强大的支持多工程的构建。强大的依赖管理，提供最大的便利去构建你的工程。全力支持已有的Maven或者Ivy仓库基础建设。3、支持传递性依赖管理，在不需要远程仓库和pom.xml和ivy配置文件的前提下。基于groovy脚本构建，其build脚本使用groovy语言编写。具有广泛的领域模型支持你的构建。三、Groovy语言介绍Groovy是一种基于JVM（Java虚拟机）的敏捷开发语言，是用于Java虚拟机的一种敏捷的动态语言。它是一种成熟的面向对象编程语言，既可以用于面向对象编程，又可以用作纯粹的脚本语言。其是JVM的一个替代语言，使用方式基本与使用Java代码的方式相同。

1.【Gradle深入浅出】——初识Gradle 2.【Gradle深入浅出】——Gradle基础概念 3.【Gradle深入浅出】——Android Gradle Plugin 基础概念 4.【Gradle深入浅出】——Gradle配置（一） 5.【Gradle深入浅出】——Gralde配置（二） 前面三篇博客讲解了Gradle的基础概念，看完前面三篇博客我们应该对于Gradle都有了一个基础的认知，知道了文件的作用，Gradle的基本构成，本篇博客开始就开始进入Gradle的学习，首先讲解的是Gradle的配置，Gradle配置应该是我们日常开发中必不可少的技能，平时的打包，编译等等都需要熟悉Gradle的配置。 我们知道Gradle都关于属性配置有两个文件， local.properties 和 gradle.properties ，这两个文件的实质都是生成Java的 Properties 对象，所以要属性这两个文件的作用，首先要属性下 Properties 类。 我们首先来看下这个类的基本上结构。 看完这个我们应该就有一个大体的认识了， Properties 本质就是一个HashTable，支持设置默认属性，其他的没啥区别，哪我们看下 Properties 如何读取文件呢 可以看到 Properites 给我们提供了三个加载文件的方式，所以这里我们也可以得出一个结论， 使用 Properties 不是必须使用 .properties 格式的文件。 哪可能有人要问了，为啥这里的配置都使用properties格式的文件呢？ 我猜测可能是复用Spring Boot中的支持的配置文件，Spring Boot中支持三种格式的配置文件 YAML,XML,Properties ，具体的差异这里就不展开讲解了。 我们可以理解为 .properties 就是类似于json的一套配置文件格式，IDE对于这类文件有特殊的支持，比如注释等语法，做了统一的规范 Properties文件的格式规范 有了对于Properties类的理解，我们在来看local.properties文件，理解起来就方便类许多，前面几篇博客已经提到了 local.properties 是Studio自动生成的一个本地配置文件，并且不会提交到远端，是我们自己本地的配置文件，常见的配置如下： 既然是配置文件，那么如何在 local.properites 中定义全局变量，然后在build.gradle中读取呢？比如我们的maven上传需要用户的姓名密码，每个人的都不一样，所以可以放到local.propertiest文件中 和前面介绍的一样，我们只需要在local.properties中定义变量，然后在gradle中读取变量只需要生成Properties类来进行读取文件。 同样的这也是一个Properties类型的文件，但这个文件主要是配置和Gradle自身相关的配置内容的，接下来聊聊他的几个作用： 这里主要是配置本项目在使用Gradle进行编译时的配置，比如虚拟机堆栈配置(常见的编译速度优化就在这里配置) 所以看到上面的定义后，我们就可以理解常见的“编译速度优化”的配置的大概意思 除了刚才说的这个文件用于配置gradle属性，这个文件还可以用于配置系统属性和android属性 并且可以区分配置不同的项目的配置 1、单项目gradle使用代理：gradle/wrapper/gradle-wrapper.properties 2、全局gradle使用代理：userdir/.gradle/gradle.properties 其他的系统变量这里就不列举了，具体看我们遇到具体场景来设置 接着来看下在gradle.properties文件中如何定义变量，gradle.properties就是官方定义的用来定义变量的文件的地方，所以定义和获取就不需要像local.properties那么麻烦了。 获取变量，就不需要通过文件流读取文件流，gralde内部自身已经做了这个，我们可以直接引用变量即可。 setting.gradle前面的博客介绍了，是用于配置项目的组成和模块的，所以一半我们的setting.gradle文件都是这样的 前面有讲过setting.gradle的实质是生成一个Setting对象，我们按住ctrl点击include就进入了Setting.gradle类，其实就可以知道我们可以调用的api，这里还是介绍我们常用的几个方法吧。首先来看下最常用的 include 方法。 这里特意把注释也放了进来，不得不说老外对于注释真的写的非常详细，往往我们忽视了这么冗长的注释，但当发现问题，从搜索引擎上搜相关资料都时候就会发现，其实大部分就是对于注释都翻译。 所以这里我下面介绍都内容，就会发现和上面注释都大同小异。 首次看下这里的引入方式，一般都是 include ":app" ，这里的语法是这样的 在这里 : 表示的路径的分隔符，也就是 的意思，所以这里都需要使用 : ，其次这里都路径是相当于根目录的路径。然后我们可以看到其实这个方法是可变参数，所以这里支持多个项目引入。 所以我们如果有一个这样的目录结构的项目 那么这时的setting.gradle就是这样 这时我们可能有个问题：我们如果引入的不是根目录下的项目怎么办？也就是引入其他路径下的项目作为我们的子module，因为这里一直是相对与根目录的路径 这样我们就可以引入不在这个项目中的Lib作为我们这个项目的Lib，组件化的工程经常就会这样使用。 最后我们看下还有一个小知识点，我们如果想改变这个Lib在Studio的显示的名称，该如何操作？ 这个方法的作用就是我们这样的，可以改变Lib在IDE中的名称。 接着来看下在setting.gradle怎么定义全局变量呢？这时候就是利用gradle的拓展属性的特性了。 然后在build.gradle中使用变量的时候，就还是使用gradle.ext使用即可。 关于ext属性我们后面专门再讲下，我们前面也讲到了我们全局就只会有一个gradle对象，所以这里可以理解是一个全局的map对象，这样就好理解了很多。 至此，本篇博客对于 gradle.properties 、 local.properties 、 setting.gradle 都配置都有了一个较为详细都讲解，我们后面在使用过程中，对于这三个文件的配置都不会那么陌生，并且对于三个文件的差异都有了一个基本都认知，知道我们在定义本地变量，不同人都环境有差异都地方都应该在local.properties配置，大家共同的配置和变量定义可以放到gradle.properties这个专职用于存放配置的文件，最后就是专门用于配置我们项目的目录结构的setting.gradle，当然这个文件也可以用于配置一些变量，这时候我们就要把我单一职责的原则，也就是高内聚，低耦合那一套，按照文件职责进行划分，下一篇博客准备对build.gradle的配置进行讲解。

Gradle是一个构建工具。它是用来帮助我们构建app的，构建包括编译、打包等过程。我们可以为Gradle指定构建规则，然后它就会根据我们的命令自动为我们构建app。AndroidStudio中默认就使用Gradle来完成应用的构建。有些同学可能会有疑问：”我用AS不记得给Gradle指定过什么构建规则呀，最后不还是能搞出来个apk。gradle构建工具多项目管理实际使用中，往往需要管理的都不是单单一个项目，maven使用依赖，继承，组成的概念，在父模块指定自己的子模块，并且准备一些各个子模块公用的资源，配置信息等等。将打包的模块与实现具体功能的模块分开的做法来管理多个项目。Gradle在这一方面做得更加清楚。

title: gradle基础 date: 2018-01-12 14:50:13 categories: android tags: android基础学习 Gradle 是一个能通过插件形式自定义构建逻辑的优秀构建工具。 以下的一些特性让我们选择了 Gradle： 这里主要记录几个比较常用，重要的点。 gradle的依赖主要分成本地包依赖和远程包依赖。 依赖的关键字主要包括： 依赖格式: 其中的group表示组织，name表示要依赖的库，vesion表示版本。 我们可以简写成 当然，不单只有对jar包的依赖，还可以有对文件的依赖，对项目的依赖，他们的写法依次如下： 上面讲到的就是本地依赖的方式： 首先需要添加远程仓库，android中至少添加一个远程仓库，例如使用开放的maven仓库。 然后，就对添加具体依赖。 启动混淆非常简单，只需要在 build.gradle 中启动即可。 其中的 minfyEnabled 默认是false，即不混淆，因为启动混淆编译速度会比较慢。 与混淆相关的还有一个 shrinkResources 属性，可以通过将其设置为 true ，设置资源文件压缩。

英文原文：gradle英式音标：[ɡreɪdl] 美式音标：[ɡredl]

　　鉴于Android Studio使用Gradle构建项目，在IDE的使用过程中可能会遇到很多令人头疼的问题。大锤也是第一次接触，为有个基本的认识，特找来Android官方手册，和大家一起学习学习。翻译不当之处，望指出。　　为什么要用Gradle？　　Gradle是比较先进的构建系统，也是一个很好的构建工具，允许通过插件自定义构建逻辑　　以下是为什么Android Studio选择Gradle的主要原因：　　使用领域专用语言（Domain Specific Language）来描述和处理构建逻辑。（以下简称DSL）　　基于Groovy。DSL可以混合各种声明元素，用代码操控这些DSL元素达到逻辑自定义。　　支持已有的Maven或者Ivy仓库基础建设　　非常灵活，允许使用best practices，并不强制让你遵照它的原则来。　　其它插件时可以暴露自己的DSL和API来让Gradle构建文件使用。　　允许IDE集成，是很好的API工具　　需要准备：　　Gradle 1.6 or 1.7　　SDK with Build Tools 17.0.0 (released 5/16/2013)　　Basic Project　　在Gradle项目的根目录下，有个叫build.gradle的文件，它描述了这个项目的整体构建基础。　　build文件　　最基本的java程序，它的build.gradle文件就一句话：　　apply plugin: "java"　　最基本的Android项目，它的build.gradle如下：　　buildscript { repositories { mavenCentral() } dependencies { classpath "com.android.tools.build:gradle:0.5.6" }}apply plugin: "android"android { compileSdkVersion 17}　　我们一步步来分析一下上面三部分的内容。　　buildscript{...} 配置了驱动build的代码，它声明将在Maven中央仓库，取一个classpath dependency，也就是Android plugin for Gradle v0.5.6　　apply plugin 指明了用到的plugin是android，就像前面java程序中，用的plugin是java一样　　android{...} 中配置了所有android构建的参数，这里也就是Android DSL的入口点。　　默认的，只有目标编译环境是必要的，也就是compileSdkVersion这个属性。这和以前在project.properties中的target属性类似。　　值得注意的是，如果你在Android项目中写 apply plugin:java 而不是apply plugin:android的话，将会build失败。

gradle和maven的区别为：依赖项不同、版本依赖不同、定义工具不同。一、依赖项不同1、gradle：gradle一个依赖项有4种scope，分别是compile、runtime、testCompile、testRuntime。2、maven：maven一个依赖项有6种scope，分别是complie(默认)、provided、runtime、test、system、import。二、版本依赖不同1、gradle：gradle支持动态的版本依赖。在版本号后面使用+号的方式可以实现动态的版本管理。2、maven：maven只支持静态的版本依赖。升级版本需要手动修改版本依赖的版本号。三、定义工具不同1、gradle：gradle使用allprojects和subprojects代码块来分别定义子模块里面的配置。2、maven：maven需要定义个parent POM作为一组module的聚合POM。在该POM中可以使用<modules>标签来定义一组子模块。

上一篇文章 Just Enough Gradle for Android 介绍了Gradle的一些基本知识，基本概念，理解这些有助于我们更加合理地使用Gradle。这篇文章聚焦于Gradle在Android项目中的实际使用。之所以叫做多维度实例，是想展示Gradle运用的灵活性，对于同一种需求，尽可能尝试用多种方式去实现。比较各种实现之间的思路、方式及优劣。 Gradle的Android插件默认定义了两种BuildTypes：debug和release。我们往往需要对这两种BuildTypes进行区分。 为了使debug版本和release版本的APP能同时装到手机上，它们需要有不同的applicationId。 BuildType和ProductFlavor都可以设置自己的applicationId、minSdkVersion、targetSdkVersion、versionName等，如果没有设置，则使用defaultConfig中的设置。 如今debug版和release版的APP都装到我们的手机里了，但是它们俩看上去长得一模一样，无论是应用图标还是名称都一样，实在不容易区分。给不同版本的APP起不一样的名字也许是最简单明了的区分方式了。 之所以有不同的BuildType就是为了可以对它们进行差异化设置。Android资源（即res文件下面的内容）的差异化设置非常简单。在与main平级的目录下增加debug文件夹，在相应的资源文件夹下设置app_name即可： 我们甚至可以为不同版本的APP设置不一样的应用图标（以及其它一切资源），步骤跟修改app_name是一样的，把图标放置在相应文件夹里即可。如果仅仅是为了区分debug版和release版的话，确实没必要。不过对于不同的ProductFlavor还是有用的，的确不同的ProductFlavor可能会用不同的应用图标。一般而言，BuildType主要是内部使用，如debug或者测试什么的；而ProductFlavor主要是外部使用，发布不同版本的APP，如免费版和付费版等。 其实，在build.gradle中可以直接定义资源，跟我们在res/values中定义是一样的： debug和release版的APP，一般需要设置不同的接口地址，方便测试使用。我们可以使用如下的方式实现： BuildConfig类是项目构建过程中生成的，默认情况下DEBUG只在BuildType为debug的时候为true，其它情况下都为false。当然也可以设置： 我们通过BuildConfig的DEBUG字段去决定使用哪个URL，能不能在BuildConfig中增加字段呢？例如直接增加一个BASE_URL字段，这样岂不是更加直接。当然可以： 利用buildConfigField方法定义新的字段，注意最后一个参数的写法"" http://example.com/api ""，buildConfigField的三个参数都是String类型，最后一个参数String的值会直接拿来赋值给我们定义的字段： 一顿操作之后，我们便可以直接引用我们定义的字段了： 这种方式比较直接，但是如果要修改BASE_URL的值则需要Sync Gradle。究竟使用哪种方式，看你的喜好了。 对于multiproject多工程（包含有多个module）而言，一个常见的需求就是在不同的Project之间“共享”一些属性。例如，指定统一的compileSdkVersion、buildToolsVersion、appcompat版本等。这可以通过额外属性来实现。 这种方式的确可以，但是并不推荐。因为gradle.properties主要是用来设置Gradle本身的属性的。 这样就可以在所有build.gradle中直接使用额外属性了： 插件对于Gradle而言是极其重要的，除了我们常用的Android Application插件和Android Library插件外，我们也可以自己定义插件。Gradle插件既可以是像Android Application这样的，实现了Plugin接口的插件（主要用来定义了Tasks，在多个Project中复用这些Tasks）；也可以是简单的groovy脚本文件（主要用来在多个Project中共享一些属性、方法等）。根据我们的需求，定义脚本插件即可。 可以在根目录定义versions.gradle文件： 然后在顶层build.gradle中将versions.gradle作为脚本插件，应用到所有Project中： 余下的步骤是一样的，可以在所有build.gradle中直接使用额外属性了。这种方式不同于在RootProject中定义额外属性，versions.gradle被应用在了所有的Project中，相当于在每个Project中都定义了额外属性，只是这些属性都是相同的。并且，这种方式也更加符合Gradle模块化的思想，是比较推荐的方式。 进一步的，我们可以在versions.gralde中定义更多东西： 在module中的build.gradle中： 我自己对Gradle的使用也比较有限，遇到更多Gradle的使用实例我再补充。

gradle -v //版本号 gradle clean //清除build文件夹 gradle build //检查依赖并打包 gradle assembleDebug //编译打包Debug包 gradle assembleRelease //编译打包Release包 gradle installRelease //打包并安装Release包 gradle unstallRelease //卸载Release包 gradle dependencies //查看依赖图表 gradle clean build -x test //跳过测试编译 gradle --profile build //分析构建任务 gradle build --dry-run //编译并不执行任务 gradle install //安置项目jar包到本地Maven仓库 gradle tasks //查看Gradle任务 gradle tasks --all //查看所有Gradle任务 gradle build --daemon //使用Gradle守护程序(Daemon) gradle build --offline //用离线模式运行 gradle clean build --refresh-dependencies //刷新Gradle依赖缓存

Gradle是可以用于Android开发的新一代的 Build System， 也是 Android Studio默认的build工具。Gradle脚本是基于一种JVM语言 -- Groovy，再加上DSL（领域特定语言）组成的。因为Groovy是JVM语言，所以可以使用大部分的Java语言库。所谓DSL就是专门针对Android开发的插件，比如标准Gradle之外的一些新的方法（Method）、闭包（Closure）等。由于Gradle的语法足够简洁，而且可以使用大部分的java包，当之无愧地成为新一代 Build System。使用Android Studio新建一个工程后，默认会生成两个build.gralde文件，一个位于工程根目录，一个位于app目录下。还有另外一个文件 --settings.gradle。根目录下的脚本文件是针对module的全局配置，它的作用阈所包含的所有 module 是通过settings.gradle来配置。app文件夹就是一个module，如果在当前工程中添加了一个新的module -- lib，就需要在settings.gralde文件中包含这个新的module。gradle脚本的基本结构用我现在的工程举例来说，根目录的build.gradle的内容如下所示：// Top-level build file where you can add configuration options common to all sub-projects/modules.buildscript { repositories { jcenter() } dependencies { classpath "com.android.tools.build:gradle:1.0.0-rc4" // NOTE: Do not place your application dependencies here; they belong // in the individual module build.gradle files }}allprojects { repositories { jcenter() maven { url "http://mvnrepo.xxx.com/mvn/repository" } }}classpath "com.android.tools.build:gradle:1.0.0-rc4"就是Android特有的插件，maven仓库位于通过方法jCenter() 获取，这也是默认的maven仓库。当然也可以添加额外的maven仓库地址，例如以上文件中的maven { url "http://mvnrepo.xxx.com/mvn/repository"}然后是 settings.gradle 文件：include ":app"app就是项目包含的一个module，如果有多个module，可以在为 include 方法添加多个参数。最后是app/build.gradleapply plugin: "com.android.application"android { compileSdkVersion 21 buildToolsVersion "21.1.1" compileOptions { sourceCompatibility JavaVersion.VERSION_1_7 targetCompatibility JavaVersion.VERSION_1_7 }defaultConfig { applicationId "your.application.id" minSdkVersion 14 targetSdkVersion 21 versionCode 2 versionName "2.0.0" } signingConfigs { release { storeFile file("release.keystore") storePassword "yourstorepassword" keyAlias "yourkeyalias" keyPassword "yourkeypassword" } debug { storeFile file("debug.keystore") } } buildTypes { release { minifyEnabled true proguardFiles getDefaultProguardFile("proguard-android.txt"), "proguard-rules.pro" signingConfig signingConfigs.release } debug { signingConfig signingConfigs.debug } } productFlavors { inner { applicationId "your.application.inner.id" versionName "2.0.0" } market { } }}repositories { flatDir { dirs "libs" }}dependencies { // 通用 compile name: "volley", ext: "aar" compile "com.nostra13.universalimageloader:universal-image-loader:1.9.3" compile "com.alibaba:fastjson:latest.integration" // 项目相关（已删除）}Groovy 的基本语法方法调用apply plugin: "com.android.application"以上语句中的apply是一个方法，给它传递了一个参数plugin，plugin 的值是"com.android.application"。如果有多个参数，则以逗号隔开，例如compile name: "volley", ext: "aar"闭包Groovy中花括号包含的部分成为一个闭包（Closure）。例如下面的代码compileOptions { sourceCompatibility JavaVersion.VERSION_1_7 targetCompatibility JavaVersion.VERSION_1_7}compileOptions 是一个 Method， 它的参数是一个闭包，这个闭包内依次执行了两个方法 -- sourceCompatibility 和targetCompatibility， 参数都是JavaVersion.VERSION17。闭包也可以嵌套包含repositories { flatDir { dirs "libs" }}常见使用方法包依赖（aar）使用aar时可以分为两种情况① aar位于本地目录首先在 android 的参数闭包中添加调用方法 repositoriesrepositories { flatDir { dirs "libs" }}然后在 dependencies 的参数闭包中添加compile name: "volley", ext: "aar"② aar位于远程仓库这里以maven为例，当然也可以使用其他类型的仓库，例如 Ivy。只需要在jar包引用方式后面添加一个@aar就可以了compile "com.alibaba:fastjson:latest.integration@aar"包依赖（jar）compile group: "com.alibaba", module: "fastjson", version: "latest.integration"可以简写成compile "com.alibaba:fastjson:latest.integration"latest.integration可以替换成具体的版本号，这里是获取服务器上的最新版本。去掉重复依赖compile "com.alibaba.fastjson.latest.integration" { exclude module: "annotations", group: "com.google.android"}使用 Java7compileOptions { sourceCompatibility JavaVersion.VERSION_1_7 targetCompatibility JavaVersion.VERSION_1_7}productFlavors针对不同的APP分发渠道，我们可以定义不同的 product flavor。也可以定义内部版本和外部版本，内部版本中包含了一些调试代码，这些代码在发布时并不会被编译进最后的APP中。而且可以分别为内部版本和外部版本指定不同的ApplicationId，这样在同一个设备上可以同时安装两个版本以方便调试。命令行执行Gradle脚本在Android工程根目录下会自动生成一个shell脚本 - gradlew，执行之前记得加上x属性 - chomod +x gradlewgradle脚本中包含了很多 task，可以通过task名来指定需要执行的task。./gradlew build./gradlew assemble./gradlew assembleInnderDebug总结不得不说，Gradle实在太好用了！虽然 Gradle 可以与 Ant 或 maven 配合使用，但是其简洁和功能性远远超过其他两个。我现在开发的项目普遍使用的是 maven，不知道什么原因，使用Gradle时经常会遇到一些无法获取远程依赖包的问题，最简单的解决办法就是把依赖包下载的本地。

使用Gradle开发中，或多或少都会引入三方库，但是三方库又会有自己的子依赖，那么真正依赖到版本中的版本是多少呢？其实官方也有给出查看方法， 官方说明点这里 ，采用以下方式可查看： 这样子可以看到各个状态下依赖的版本，比如这里截出来的是releaseCompileClasspath的 (1) 利用dependencies查看依赖树 PS：方式一和二还是有区别的，比如看在window中点击androidDepencies，能看到依赖的本地jar包，但是通过命令查看依赖，则查看的没有本地jar文件依赖。 通过--configuration可以配置要查看哪个variant下的版本，比如这里是releaseCompileClasspath看的就是release的依赖。 看打印就能更清晰的看到依赖的版本，是为什么依赖到了，比如okhttp依赖到的是3.9.0版本，是因为com.squareup.okhttp3:logging-interceptor:3.9.0中的依赖是3.9.0 (*)，这样子就替换掉了retrofit中的3.8.0的依赖 (2) 利用dependencyInsight 详细查看某个库(采用模糊过滤的方式，比如下面查看的是com.squareup.okhttp)的版本依赖。 这里就能很明显的看到，依赖的okhttp的版本是3.9.0了，interceptor中的3.9.0解决了retrofit中的3.8.0 自己上传maven库之后，可能是覆盖的形式更新的maven库，如果不刷新，则一直都会使用本地缓存的依赖，我试过从文件中找到依赖删除掉他，但是一sync，就自己又生成出来了，很奇怪。 在android右侧gradle选项，随便找一个tasks下的build里面，执行cleanBuildCache gradle是比较智能的了，也能智能的处理相同包不同版本的冲突，会默认依赖较新的一个版本。但是如果是不同包之间的冲突，那么就会报错，得需要人为来解决了，比如： 依赖： 这两个依赖在一起会报错: 那么我们通过前面的命令可以查 com.github.bumptech.glide:glide下面的依赖树，但是解决这种冲突光看依赖树还不行，得结合报错，CoordinatorLayout$Behavior，我们在出问题的情况下全局搜索(双击shift,记得够上从选择框)一下CoordinatorLayout，就能看到是在哪两个库中存在了，再结合依赖树就能看出来com.github.bumptech.glide:glide依赖了： 而support-fragment:27.1.1下面依赖了 在这个库里也有android.support.design.widget.CoordinatorLayout，就与默认的com.android.support:design的冲突了。 所以处理下即可: 吐槽：google大法更新库是有可能不考虑兼容性的，所以建议都使用同一个版本。出现这个根本原因就是因为两个支持库的版本不一致，一个是26.1.0一个是27.1.1，如果两个都是同一个版本则不会存在这个问题

https://services.gradle.org/distributions/ GRADLE_HOME：gradle压缩包解压后的目录 GRADLE_USER_HOME：gradle默认的仓库地址 Path：增加一段 %GRADLE_HOME%/bin 安装软件、配置环境变量，可参考 https://blog.csdn.net/qq_22172133/article/details/81513955 new -> project -> gradle -> java -> next -> 输入groupId、ArtifactId -> next -> next -> finish 打开idea右侧的gradle菜单，Tasks/build子菜单下有一组gradle指令，可以使用jar指令打包项目。打包结果输出在build目录。 如上图。 idea会不支持高版本的gradle。比如我的idea是2018.3的版本，可以使用5.6.2版本的gradle，但是使用6.x.x版本的grade就不行。 我在网上也没有找到一份具体的idea支持的gradle版本对应表。大家如果发现自己的idea使用gradle报错，可以试试降一下gradle的版本，修改gradle/wrapper/gradle-wrapper.properties。 5.6.2版本的gradle，可以build成功 6.6.1版本build失败

build.gradle//设置脚本的运行环境buildscript {//支持java 依赖库管理（maven/ivy）,用于项目的依赖。repositories {mavenCentral()}//依赖包的定义。支持maven/ivy，远程，本地库，也支持单文件dependencies {classpath "com.android.tools.build:gradle:0.4"}}//声明构建的项目类型，这里当然是android了apply plugin: "android"//设置编译android项目的参数android {compileSdkVersion 17buildToolsVersion "17"defaultConfig {minSdkVersion 8targetSdkVersion 17}//Android默认配置sourceSets {main {manifest.srcFile "AndroidManifest.xml"java.srcDirs = ["src"]resources.srcDirs = ["src"]aidl.srcDirs = ["src"]renderscript.srcDirs = ["src"]res.srcDirs = ["res"]assets.srcDirs = ["assets"]}//测试所在的路径，这里假设是tests文件夹，没有可以不写这一行instrumentTest.setRoot("tests")}//这个是解决lint报错的代码lintOptions {abortOnError false}/*** 签名设置*/signingConfigs {myConfigs {storeFile file("签名文件地址")keyAlias "..."keyPassword "..."storePassword "..."}}/*** 混淆设置*/buildTypes {release {signingConfig signingConfigs.myConfigsrunProguard trueproguardFiles getDefaultProguardFile("proguard-android.txt"), "proguard-rules.pro"}}/*** 渠道打包（不同包名）*/productFlavors {qqqq {applicationId = "包名"}hhhhh {applicationId="包名"}}}/*** .so文件的导入*/task copyNativeLibs(type: Copy) {from fileTree(dir: "libs", include: "armeabi/*.so") into "build/lib"}tasks.withType(Compile) {options.encoding = "UTF-8"}tasks.withType(Compile) {compileTask -> compileTask.dependsOn copyNativeLibs}clean.dependsOn "cleanCopyNativeLibs"tasks.withType(com.android.build.gradle.tasks.PackageApplication) { pkgTask ->pkgTask.jniFolders = [new File(buildDir, "lib")]}//依赖库dependencies {compile fileTree(dir: "libs", include: ["*.jar"])}gradle 作为构建工具，能够很方便的使用本地jar包，以下为使用的代码块。ependencies {//单文件依赖compile files("libs/android-support-v4.jar") //某个文件夹下面全部依赖compile fileTree(dir: "libs", include: "*.jar")}android {}gradle 同时支持maven，ivy，由于ivy我没用过，所以用maven 作为例子，以下为代码块：repositories {//从中央库里面获取依赖mavenCentral() //或者使用指定的本地maven 库maven{url "file://F:/githubrepo/releases"} //或者使用指定的远程maven库maven{url "远程库地址"}}dependencies {//应用格式: packageName:artifactId:versioncompile "com.google.android:support-v4:r13"}android {}对于项目依赖 android library的话，就不是依赖一个jar，那么简单了，在这里需要使用gradle mulit project 机制。在过去，android library并没有一个很好的包管理方式，简单来说，在gradle出现以前，官方并没有一种用于管理android library 依赖包的方式，一般我们都是直接下载别人的android library project 源码进行集成，而对于第三方的android-maven-plugin 用的是apklib 格式。而现在，官方终于推出一种android library的打包格式，扩展名为*.aar。前面提到，目前android gradle插件并不支持本地直接使用*.aar文件，不过，支持包管理库的引用方式，下面，我为大家说一下，怎么对android library 发布使用。打包android library对android library 进行打包直接在library项目下面使用gradle build 即可，然后，你就会在 build/libs 目录下看到两个*.aar文件，一个debug包用的，一个是release 下用的，看个人需求使用，这里我们用的是release 版本的 .aar 文件。

Gradle 默认直连网络，即使 Mac 设置了全局代理也是一样。就算你给 Android Studio 设置了代理，它依旧会风轻云淡地直连那个你在中国一辈子也不可能连上的网站…… 根据需要在下列所述文件中添加相应配置语句 1、单项目gradle使用代理：gradle/wrapper/gradle-wrapper.properties 2、全局gradle使用代理：userdir/.gradle/gradle.properties #代理服务器IP/域名 systemProp.http.proxyHost=127.0.0.1 #代理服务器端口 systemProp.http.proxyPort=8080 #代理服务器需要验证时，填写用户名 systemProp.http.proxyUser=userid #代理服务器需要验证时，填写密码 systemProp.http.proxyPassword=password #不需要代理的域名/IP systemProp.http.nonProxyHosts=*.nonproxyrepos.com|localhost systemProp.https.proxyHost=127.0.0.1 systemProp.https.proxyPort=8080 systemProp.https.proxyUser=userid systemProp.https.proxyPassword=password systemProp.https.nonProxyHosts=*.nonproxyrepos.com|localhost 然后重启部署，Gradle 就会老老实实地走代理部署了。

在写gradle插件时可能会使用到源码文件，如作源码文件的版本对比，源码分析等，但源码如何来获取呢？一般gradle项目的源码默认都是在固定的位置，如project/app/src/main/java 。但源码的位置并非一定要在此，这只是一个 默认位置 ，在Gradle的配置文件build.gradle里是可以配置源码的位置的，下面可以看下在Android和Java项目中是如何配置的。 Android源码配置是在android下面的sourceSets参数里进行配置。 Java项目sourceSets与Android项目的不同，它在最外层直接配置。 我们知道在gradle的配置文件中，每个名称都是一个Extension，每个Extension可以配置指定的参数列表。如android{}，是由AppPlugin通过project.getExtensions().create("android",AppExtension)来创建的，而AppExtension类的成员变量定义了gradle参数，如defaultConfig，productFlavors，buildTypes，signingConfigs等。然而事实并非如何，gradle里还有一种配置自定义参数的方式，即Convention。Convention方式中每个成员变量对应的是一个extension。其中Java项目中的sourceSets即是使用如何方式进行配置的。 下面看一下如何获取获取项目的源码。既然源码是通过自定义参数配置的，那么获取的时候通过拿到自定义的参数对象，获取其sourceSets字段即可。 android使用的是BaseExension对象配置的参数，所有通过Plugin获取到extension对象，取其中的sourceSets字段。 Java项目是通过Convention配置的，所以需要找到Convention对象，即JavaPluginConvention。通过此对象来获取Java项目的源码文件 注意Java项目创建了Jar任务用来打包，而Jar也有一个getSource方法，此方法获取的并不是源码文件，而是编译过的class文件。

使用Android Studio开发Gradle插件的步骤：1 创建Gradle ModuleAndroidStudio中是没有新建类似Gradle Plugin这样的选项的，那我们如何在AndroidStudio中编写Gradle插件，并打包出来呢？(1) 首先，你得新建一个Android Project(2) 然后再新建一个Module，这个Module用于开发Gradle插件，同样，Module里面没有gradle plugin给你选，但是我们只是需要一个“容器”来容纳我们写的插件，因此，你可以随便选择一个Module类型（如Phone&Tablet Module或Android Librarty）,因为接下来一步我们是将里面的大部分内容删除，所以选择哪个类型的Module不重要。(3) 将Module里面的内容删除，只保留build.gradle文件和src/main目录。由于gradle是基于groovy，因此，我们开发的gradle插件相当于一个groovy项目。所以需要在main目录下新建groovy目录(4) groovy又是基于Java，因此，接下来创建groovy的过程跟创建java很类似。在groovy新建包名，如：com.hc.plugin，然后在该包下新建groovy文件，通过new->file->MyPlugin.groovy来新建名为MyPlugin的groovy文件。(5) 为了让我们的groovy类申明为gradle的插件，新建的groovy需要实现org.gradle.api.Plugin接口。如下所示：package com.hc.pluginimport org.gradle.api.Pluginimport org.gradle.api.Projectpublic class MyPlugin implements Plugin<project> {</project>void apply(Project project) {System.out.println("========================");System.out.println("hello gradle plugin!");System.out.println("========================");}}因为我本人对groovy也不是特别熟悉，所以我尽可能的用Java语言，使用System.out.println而不是用groovy的pintln ""，我们的代码里面啥也没做，就打印信息。(6) 现在，我们已经定义好了自己的gradle插件类，接下来就是告诉gradle，哪一个是我们自定义的插件类，因此，需要在main目录下新建resources目录，然后在resources目录里面再新建META-INF目录，再在META-INF里面新建gradle-plugins目录。最后在gradle-plugins目录里面新建properties文件，注意这个文件的命名，你可以随意取名，但是后面使用这个插件的时候，会用到这个名字。比如，你取名为com.hc.gradle.properties，而在其他build.gradle文件中使用自定义的插件时候则需写成：apply plugin: "com.hc.gradle"然后在com.hc.gradle.properties文件里面指明你自定义的类implementation-class=com.hc.plugin.MyPlugin现在，你的目录应该如下：(7) 因为我们要用到groovy以及后面打包要用到maven,所以在我们自定义的Module下的build.gradle需要添加如下代码：apply plugin: "groovy"apply plugin: "maven"dependencies {compile gradleApi()compile localGroovy()}repositories {mavenCentral()}2 打包到本地Maven前面我们已经自定义好了插件，接下来就是要打包到Maven库里面去了，你可以选择打包到本地，或者是远程服务器中。在我们自定义Module目录下的build.gradle添加如下代码：group="com.hc.plugin"version="1.0.0"uploadArchives {repositories {mavenDeployer {repository(url: uri("D:/repos"))}}}其中，group和version后面会用到，我们后面再讲。虽然我们已经定义好了打包地址以及打包相关配置，但是还需要我们让这个打包task执行。点击AndroidStudio右侧的gradle工具，如下图所示：可以看到有uploadArchives这个Task,双击uploadArchives就会执行打包上传啦！执行完成后，去我们的Maven本地仓库查看一下：其中，com/hc/plugin这几层目录是由我们的group指定，myplugin是模块的名称，1.0.0是版本号（version指定）。

eclipse安装 gradle：首先当然是到官网gradle.org下载最新的gradle版本了，这里我下的是1.1版本，最新是2.0，不过没影响我们使用下载完成后，放到任意的位置，我的是在D:/gradle-1.1，然后需要放到换进配置，步骤是右键“计算机”-“属性”，进入“高级配置”，选择“环境变量”，点击”新建“，配置”GRADLE_HOME“继续在此处选择“path”，进行修改，加入“；%GRADLE_HOME%in”，注意此处没有引号，记得前面要加分号，这样就配置好gradle的环境变量了在命令窗口输入”gradle -version“，进行验证，出现以下提示则表示成功接下来是构建一个java项目，可以随便建一个文件夹，如：D:javapro1，按照gradle的规约新建相应的文件目录，类似于maven的一样，如下最主要的是在该目录下新建一个gradle文件，build.gradle，文件内容只要一句话即可：apply plugin:"java"在命令窗口中，进入项目对应文件夹，输入gradle build，即可完成构建，然后可以在项目文件夹中发现多了一些构建完的文件，这时就完成了一个最简单的项目构建后面的一些基本命令就是clean、check、assemble等待，具体也可以直接查看官网文档

本文介绍通过gradle打包相比gradlew的优势，主要实现方式是配置gradle的环境变量。 1、 gradlew build 和 gradle build 有区别吗?使用gradle wrapper是gradle官方推荐的build方式，而gradlew正是运行了wrapper task之后生成的（运行wrapper task是Android Studio自动做的）。使用gralde wrapper的一个好处就是每个项目可以依赖不同版本的gradle，构建的时候gradle wrapper会帮你自动下载所依赖的版本的gradle。而如果你使用gradle build的话，同时你又有多个项目使用不同版本的gradle，那就需要你手动在自己的机器上配置多个版本的gradle，稍微麻烦一些2、避免每次工程都下载gradle可以使用gradle命令打包而不是gradlew 方法：配置gradle到环境变量；工程中使用自己配置变量的gradle即可。 先找到gralde的根目录，在系统变量里添加两个环境变量：变量名为：GRADLE_HOME，变量值就为gradle的根目录；比如变量值为： D:androidandroid-studio-ide-143.2739321-windowsandroid-studiogradlegradle-2.10还有一个在系统变量里PATH里面添加gradle的bin目录比如： D:androidandroid-studio-ide-143.2739321-windowsandroid-studiogradlegradle-2.10bin这样就配置完了，执行以下这个命令：gradle assembleRelease，看看是不是可以了

在build.gradle配置文件最后加上tasks.withType(JavaCompile) {options.encoding = "UTF-8" }或者直接修改gradle/bin目录下的gradle.bat文件和gradle文件在gradle.bat第12行左右的位置写成set DEFAULT_JVM_OPTS="Dfile.encoding=UTF-8"用notepad++打开gradle文件，第10行左右写成set DEFAULT_JVM_OPTS="Dfile.encoding=UTF-8"

首先，新建一个Android项目。之后，新建一个AndroidModule项目，类型选择AndroidLibrary。将新建的Module中除了build.gradle文件外的其余文件全都删除，然后删除build.gradle文件中的所有内容。在新建的module中新建文件夹src，接着在src文件目录下新建main文件夹，在main目录下新建groovy目录，这时候groovy文件夹会被Android识别为groovy源码目录。除了在main目录下新建groovy目录外，还要在main目录下新建resources目录，同理resources目录会被自动识别为资源文件夹。在groovy目录下新建项目包名，就像Java包名那样。resources目录下新建文件夹META-INF，META-INF文件夹下新建gradle-plugins文件夹。这样，就完成了gradle插件的项目的整体搭建，

----《Android Gradle 权威指南》学习笔记 总目录： Gradle 学习系列 -- 目录 上一篇： Gradle 任务 -- 任务的执行分析 下一篇： Gradle 任务 -- 任务的弃用和禁用 (1) 在命令行中执行命令： gradle taskOrder1 taskOrder2 打印结果： (2) 在命令行中执行命令： gradle taskOrder2 taskOrder1 打印结果： (3) 关闭注释1，打开注释2，测试 shouldRunAfter 语法 在命令行中执行命令： gradle taskOrder1 taskOrder2 或，在命令行中执行命令： gradle taskOrder2 taskOrder1 打印结果： 未出现任务乱序的情况 (4) 打开注释1，关闭注释2，测试 mustRunAfter 语法， 在命令行中执行命令： gradle taskOrder1 taskOrder2 或，在命令行中执行命令： gradle taskOrder2 taskOrder1 打印结果： 未出现任务乱序的情况

在Android studio安装目录下进行查看，比如我的D:MyAppsSoftwareAndroidandroid-studiogradlem2repositorycomandroid oolsuildgradle这个下面查看

Eclipse迁移到Android studio步骤如下： 一、从Eclipse中导出： 1、将ADT插件版本升级到22.0以上。 2、在Eclipse中，选择File-->Export。 3、在弹出的导出窗口中，打开Android的文件夹，选择“Generate Gradle Build Files”。 4、选中想要导入到Android Studio中的项目，Finish。 注意：导出的项目将会和原来的项目在同一目录，覆盖原来的同时，会新增一个叫build.gradle的文件，导入Android Studio时将首先读取这个文件。 二、导入到Android Studio： 1、在Android Studio 中，首先关掉当前的打开的项目。 2、在欢迎界面，点击Import Project（注：也是可以直接在菜单选择Import project的）。 3、选中Eclipse中导出的项目，目录，点击build.gradle文件，然后OK。 4、在之后的弹出对话框中，会要求选择Gradle的配置，选中Use gradle wrapper.(注：也可以自定义本机装的Gradle)。 注意：如果没有Grade build文件，也是可以将普通的安卓项目导入到Android Studio中，它会用现有的Ant build.但为了更好地使用之后的功能和充分使用构建变量，还是强烈地建议先从ADT插件中生成Gradle文件再导入Android Studio。

方法步骤如下:前提：系统已经安装gradle1. 下载MaterialDrawer-develop.zip，并进行解压。2. 新建文件夹MaterialDrawerProjectslibrary3. 将目录MaterialDrawer-developlibrarysrcmain下的文件拷贝到新建的文件夹下，并将java文件夹重命名为src4. 文件MaterialDrawer-developlibraryuild.gradle开头处，添加“apply plugin: "eclipse"”5. 启动cmd，进入目录MaterialDrawer-develop,执行命令：gradle eclipse6. 目录MaterialDrawer-developlibrary会生成两个文件.classpath和.project7. 将生成的文件.classpath和.project拷贝到MaterialDrawerProjectslibrary下8. 将.project下的<name>library</name>修改为<name>MaterialDrawerlibrary</name>9. 通过eclipse软件将MaterialDrawerProjectslibrary导入到工程10. MaterialDrawerProjectslibrary依赖的库，需要仿造上面的步骤导入到eclipse中recycleriview:android SDK自带的库(路径：extrasandroidsupportv7)MaterializeLibary（github.com/mikepenz/Materialize），前面加上https://AndroidIconicsLibrary-core(github.com/mikepenz/Android-Iconics 下的library-core) 前面加上https://11. 注意以上的库都涉及到android-support-v7-appcompat，也需要导入到eclipse。

gradle 目录是什么时候生成的1.首先当然是到官网gradle.org下载最新的gradle版本了，比如是1.1版本，最新是2.0，不过没影响我们使用2.下载完成后，放到任意的位置，我的是在D:/gradle-1.1，然后需要放到换进配置，步骤是右键“计算机”-“属性”，进入“高级配置”，选择“环境变量”，点击”新建“，配置”GRADLE_HOME“3.继续在此处选择“path”，进行修改，加入“；%GRADLE_HOME%in”，注意此处没有引号，记得前面要加分号，这样就配置好gradle的环境变量了4.在命令窗口输入”gradle -version“，进行验证，出现以下提示则表示成功接下来是构建一个java项目，可以随便建一个文件夹，如：D:javapro1，按照gradle的规约新建相应的文件目录，类似于maven的一样，如下5.最主要的是在该目录下新建一个gradle文件，build.gradle，文件内容只要一句话即可：apply plugin:"java"6.在命令窗口中，进入项目对应文件夹，输入gradle build，即可完成构建，然后可以在项目文件夹中发现多了一些构建完的文件，这时就完成了一个最简单的项目构建7。后面的一些基本命令就是clean、check、assemble等待，具体也可以直接查看官网文档

下载Gradle到对应目录，修改配置文件就可以了

在Mac上配置Gradle环境 本人Gradle文件的路径为（要选择有/bin文件夹的gradle版本） 1.打开.zsh_profile文件，如下： 2.在.zsh_profile文件中添加一下信息，并保存 这样子就能全局指定gradle版本。

在编写程序的时候，有时候我们需要兼容不同系统版本的手机来进行真机测试，所以有时候我们需要修改sdk或者其他的东西的版本号，这时候我们就需要了解build.gradle文件了。首先，在Android studio的一个工程里，在Gradle Scripts目录下，有一个文件build.gradle（Module：app），打开。这里我随便选了一个工程的build.gradle文件做例子：apply plugin: "com.android.application"android { compileSdkVersion 21 buildToolsVersion "21.1.2" defaultConfig { minSdkVersion 14 targetSdkVersion 21 versionCode 1 versionName "1.0" } buildTypes { release { minifyEnabled false proguardFiles getDefaultProguardFile("proguard-android.txt"), "proguard-rules.pro" } }}dependencies { compile fileTree(dir: "libs", include: ["*.jar"]) compile project(":xDroid") compile project(":UniversalImageLoader") compile project(":xdroidrequest") compile project ( ":library")}compileSdkVersion 21，说明要运行该源码，你必选已经安装了android API 21。buildToolsVersion 21.1.2 说明要运行该源码，你必须已经安装了 android sdk build-tools 21.1.2。minSdkVerison 表示向下低至android API 14，即androd 4.0和4.0以上的版本都可以运行该工程。targetSdkVerision 表示采用的目标android API是 API 21即 android 5.0。 3.下面的dependencies里指明的就是一些需要用到的第三方库。 gradle文件可以有更多的内容，更多详情可以查看百度文库 http://wenku.baidu.com/link?url=dU5_gdgmk-NKE9U4Z1fTarFWFXf6jsHHMoxxVwRc0P4ZRr__OiZHhIhiSQMOla6wqa9FxKdQCfGv3gOZz1e7pemG9g58loNdFObm9g9A8DK

方法/步骤1、根据需要，从官网下载最新jenkins软件包，同时下载最新的gradle软件包，jenkins插件，设置好环境变量，配置好端口，启动。2、点击新建任务输入项目名称和使用的jdk，同时还输入节点，不输入默认为master节点3、选择源码管理工具为CVS，Git或subversion，根据自身情况而定，然后填写URL路径@HEAD4、在构建一栏里增加构建步骤选择Invoke Gradle script,同时选择你的Gradle Version，Switches，Root Build script，对于多工程，需要添加多个Invoke Gradle script5、上传脚本：在每个子工程的根目录下放置名为gradle.build的脚本，内容如下:6、点击步骤1里面截图的立即构建，通过Console Output 查看结果。

首先当然是到官网gradle.org下载最新的gradle版本了，这里我下的是1.1版本，最新是2.0，不过没影响我们使用下载完成后，放到任意的位置，我的是在D:/gradle-1.1，然后需要放到换进配置，步骤是右键“计算机”-“属性”，进入“高级配置”，选择“环境变量”，点击”新建“，配置”GRADLE_HOME“继续在此处选择“path”，进行修改，加入“；%GRADLE_HOME%in”，注意此处没有引号，记得前面要加分号，这样就配置好gradle的环境变量了在命令窗口输入”gradle -version“，进行验证，出现以下提示则表示成功接下来是构建一个java项目，可以随便建一个文件夹，如：D:javapro1，按照gradle的规约新建相应的文件目录，类似于maven的一样，如下最主要的是在该目录下新建一个gradle文件，build.gradle，文件内容只要一句话即可：apply plugin:"java"在命令窗口中，进入项目对应文件夹，输入gradle build，即可完成构建，然后可以在项目文件夹中发现多了一些构建完的文件，这时就完成了一个最简单的项目构建后面的一些基本命令就是clean、check、assemble等待，具体也可以直接查看官网文档

一、路径不同1.local.properties文件里的SDK路径a) Windows上sdk.dir=D: \Android\sdk，注意这里的转义字符，下同b) Linux上 sdk.dir=/home/adt-bundle-linux-x86/sdk2.在gradle-wrapper.properties文件里的Gradle路径与版本a) Windows 上distributionUrl=https://services.gradle.org/distributions/gradle-2.8-all.zipb) Linux上distributionUrl=https://services.gradle.org/distributions/gradle-2.10-bin.zip3.在keystore.properties文件里的签名文件路径不同a) Windows上storeFile=\keys\JenkinsGradleTest.jksb) Linux上storeFile=/keys/JenkinsGradleTest.jks二、编译版本和编译工具版本不同app/build.gradle文件里minSdkVersion、targetSdkVersion和 buildTools 版本号，需要调整a) Windows 上minSdkVersion 14，targetSdkVersion 18，buildToolsVersion "23.0.2"b) Linux 上minSdkVersion 14， targetSdkVersion 19， buildToolsVersion "21.0.2"三、Gradle参数不同当用户下.gradle/ gradle.properties文件内容不同，如果没有该就手动创建一个。a) Windows上C:/Users/Kenny/.gradle/gradle.properties，设置如下：org.gradle.daemon=trueb) Linux上/home/tester/.gradle/gradle.properties，设置如下：org.gradle.daemon=false

首先当然是到官网gradle.org下载最新的gradle版本了，这里我下的是1.1版本，最新是2.0，不过没影响我们使用下载完成后，放到任意的位置，我的是在D:/gradle-1.1，然后需要放到换进配置，步骤是右键“计算机”-“属性”，进入“高级配置”，选择“环境变量”，点击”新建“，配置”GRADLE_HOME“继续在此处选择“path”，进行修改，加入“；%GRADLE_HOME%in”，注意此处没有引号，记得前面要加分号，这样就配置好gradle的环境变量了在命令窗口输入”gradle -version“，进行验证，出现以下提示则表示成功接下来是构建一个java项目，可以随便建一个文件夹，如：D:javapro1，按照gradle的规约新建相应的文件目录，类似于maven的一样，如下最主要的是在该目录下新建一个gradle文件，build.gradle，文件内容只要一句话即可：apply plugin:"java"在命令窗口中，进入项目对应文件夹，输入gradle build，即可完成构建，然后可以在项目文件夹中发现多了一些构建完的文件，这时就完成了一个最简单的项目构建后面的一些基本命令就是clean、check、assemble等待，具体也可以直接查看官网文档

ndroidStudio 里进入Project Structure选项，里边可以设置JDK，在那里可以选择JDK1.7的路径，前提是你得有JDK1.7

myeclipse配置gradle过程如下：1、在线安装地址：百度搜gradle官网地址2、选择Core / Eclipse Integration for Gradle -> Gradle IDE这个是gradle 的核心了下面直接点击下一步，即可完成安装。3、使用myeclipse 创建一个gradle项目File -> New -> Project -> Gradle -> Gradle Project -> Next输入项目的名称，选择Sample project Java Quickstart,点击完成即可4、添加一个jar包依赖编辑文件build.gradle,找到dependencies,在里面添加一条jar的信息,例如：dependencies {compile group: "commons-collections", name: "commons-collections", version: "3.2"//添加一个spring 依赖compile "org.springframework:spring-core:4.1.2.RELEASE"testCompile group: "junit", name: "junit", version: "4.+"}5、刷新项目，使得myeclipse自动下载jar包.右击项目->Gradle->Refresh Dependencies6、打包项目右击项目->Run As -> Gradle Build... -> 在命令行里面输入build,点击运行即可

英文原文：gradle英式音标：[ɡreu026adl] 美式音标：[ɡredl]

一般默认安装的话，这个文件的文职是在：C:UsersAdministrator.gradlewrapperdists你放在dists资料夹下面就可以。C:UsersAdministrator.gradlewrapperdistsgradle-6.1.1-allwrapperdistsgradle-6.1.1-allcfmwm155h49vnt3hynmlrsdst

Android Studio使用Gradle的目的在于帮助开发者管理项目依赖，开发部署，代码复用。Gradle是一种构建工具，可以帮助开发者管理项目中的差异，依赖，编译，打包，部署等，可以定义满足自己需要的构建逻辑，写入到build.gradle中供日后复用。Gradle是一个基于Apache Ant和Apache Maven概念的项目自动化构建开源工具。它使用一种基于Groovy的特定领域语言(DSL)来声明项目设置，目前也增加了基于Kotlin语言的kotlin-based DSL，抛弃了基于XML的各种繁琐配置。Gradle是一个基于JVM的构建工具，是一款通用灵活的构建工具，支持maven， Ivy仓库，支持传递性依赖管理，而不需要远程仓库或者是pom.xml和ivy.xml配置文件，基于Groovy，build脚本使用Groovy编写。扩展资料：gradle提供的功能：1、一种可切换的，像maven一样的基于约定的构建框架，却又从不锁住你（约定优于配置）2、强大的支持多工程的构建3、强大的依赖管理（基于Apache Ivy），提供最大的便利去构建你的工程4、全力支持已有的Maven或者Ivy仓库基础建设5、支持传递性依赖管理，在不需要远程仓库和pom.xml和ivy配置文件的前提下6、基于groovy脚本构建，其build脚本使用groovy语言编写7、具有广泛的领域模型支持你的构建参考资料：百度百科-gradle

Gradle全局配置流程 3.在主项目根目录的build.gradle中申明一下(声明在 project/buile.gradle 下)： 4在项目中( app/build.gradle )引用我们的路径配置(如图：)

我只能说给你这份资料看看了：http://www.linuxidc.com/Linux/2015-02/113890p4.htm

1，首先当然是到官网gradle.org下载最新的gradle版本了2，下载完成后，放到任意的位置，我的是在D:/gradle-1.1，然后需要放到换进配置，步骤是右键“计算机”-“属性”，进入“高级配置”，选择“环境变量”，点击”新建“，配置”GRADLE_HOME“3，选择“path”，进行修改，加入“；%GRADLE_HOME%in”，注意此处没有引号，记得前面要加分号，这样就配置好gradle的环境变量了4，在命令窗口输入”gradle -version“，进行验证，出现以下提示则表示成功5，接下来是构建一个java项目，可以随便建一个文件夹，如：D:javapro1，按照gradle的规约新建相应的文件目录，类似于maven的一样6，最主要的是在该目录下新建一个gradle文件，build.gradle，文件内容只要一句话即可：apply plugin:"java"7，在命令窗口中，进入项目对应文件夹，输入gradle build，即可完成构建，然后可以在项目文件夹中发现多了一些构建完的文件，这时就完成了一个最简单的项目构建

Android Studio使用Gradle的目的在于帮助开发者管理项目依赖，开发部署，代码复用。Gradle是一种构建工具，可以帮助开发者管理项目中的差异，依赖，编译，打包，部署等，可以定义满足自己需要的构建逻辑，写入到build.gradle中供日后复用。Gradle是一个基于Apache Ant和Apache Maven概念的项目自动化构建开源工具。它使用一种基于Groovy的特定领域语言(DSL)来声明项目设置，目前也增加了基于Kotlin语言的kotlin-based DSL，抛弃了基于XML的各种繁琐配置。Gradle是一个基于JVM的构建工具，是一款通用灵活的构建工具，支持maven， Ivy仓库，支持传递性依赖管理，而不需要远程仓库或者是pom.xml和ivy.xml配置文件，基于Groovy，build脚本使用Groovy编写。扩展资料：gradle提供的功能：1、一种可切换的，像maven一样的基于约定的构建框架，却又从不锁住你（约定优于配置）2、强大的支持多工程的构建3、强大的依赖管理（基于Apache Ivy），提供最大的便利去构建你的工程4、全力支持已有的Maven或者Ivy仓库基础建设5、支持传递性依赖管理，在不需要远程仓库和pom.xml和ivy配置文件的前提下6、基于groovy脚本构建，其build脚本使用groovy语言编写7、具有广泛的领域模型支持你的构建参考资料：百度百科-gradle

1.面向未来，就目前的趋势而言，gradle或者maven正逐渐演化为一种标准。尤其是国际上。比如你去spring官网看demo，它们一般提供基于这两种的源码，还有android开发，很多流行的库，demo演示都是通过gradle搭建的，你不懂gradle就很难跟它们接轨。这显然是固步自封的表现。2.极细的粒度，给你更大的发挥空间。你用eclipse的run的时候，你并不知道eclipse是怎么执行的，即便你知道，但是不可能轻易结合自己的代码逻辑。举个例子：我需要在run java项目的时候，把flex项目先编译好，放到web目录下。类似于这样，大部分情况下，光靠IDE自己的功能就力不从心了。 但是gradle给了你两个维度的机会，让你能干的更多。 第一 task的dependsOn、finalizedBy 让你可以把各种工作串行连接；第二 绝大多数插件是开源的，也就是用的不爽，你自己可以改，那样就更灵活了。当然这只是冰山一角。3.协作，一个个build文件，描述项目依赖，插件，显然更具有一致性。再也不需要把那些讨厌的jar包提交到git了，要知道git里面存放二进制简直就是灾难。还有，甚至可以通过gradle跟，非程序员交流，比如你想让美工可以自己测试修改并在项目里面看最终效果。这时候你让她装个idea，估计她会很不情愿。但是，你可以通过gradle，告诉她，把素材覆盖到某某文件之后，只要在控制台来个gradle run，刷新页面就能看到效果了。（仅是个例子，可能不严谨）4.布道groovy，gradle所使用的语言，也许groovy并不能算是jvm里的屠龙刀，但是也绝对可以算是一把锋利的匕首。相信我，作为一个java程序员，试着在代码中融入groovy，一定乐趣无限。尤其是还能用在android项目。

使用Android Studio开发Gradle插件的步骤：1 创建Gradle ModuleAndroidStudio中是没有新建类似Gradle Plugin这样的选项的，那我们如何在AndroidStudio中编写Gradle插件，并打包出来呢？(1) 首先，你得新建一个Android Project(2) 然后再新建一个Module，这个Module用于开发Gradle插件，同样，Module里面没有gradle plugin给你选，但是我们只是需要一个“容器”来容纳我们写的插件，因此，你可以随便选择一个Module类型（如Phone&Tablet Module或Android Librarty）,因为接下来一步我们是将里面的大部分内容删除，所以选择哪个类型的Module不重要。(3) 将Module里面的内容删除，只保留build.gradle文件和src/main目录。由于gradle是基于groovy，因此，我们开发的gradle插件相当于一个groovy项目。所以需要在main目录下新建groovy目录(4) groovy又是基于Java，因此，接下来创建groovy的过程跟创建java很类似。在groovy新建包名，如：com.hc.plugin，然后在该包下新建groovy文件，通过new->file->MyPlugin.groovy来新建名为MyPlugin的groovy文件。(5) 为了让我们的groovy类申明为gradle的插件，新建的groovy需要实现org.gradle.api.Plugin接口。如下所示：package com.hc.pluginimport org.gradle.api.Pluginimport org.gradle.api.Projectpublic class MyPlugin implements Plugin<project> {</project>void apply(Project project) {System.out.println("========================");System.out.println("hello gradle plugin!");System.out.println("========================");}}因为我本人对groovy也不是特别熟悉，所以我尽可能的用Java语言，使用System.out.println而不是用groovy的pintln ""，我们的代码里面啥也没做，就打印信息。(6) 现在，我们已经定义好了自己的gradle插件类，接下来就是告诉gradle，哪一个是我们自定义的插件类，因此，需要在main目录下新建resources目录，然后在resources目录里面再新建META-INF目录，再在META-INF里面新建gradle-plugins目录。最后在gradle-plugins目录里面新建properties文件，注意这个文件的命名，你可以随意取名，但是后面使用这个插件的时候，会用到这个名字。比如，你取名为com.hc.gradle.properties，而在其他build.gradle文件中使用自定义的插件时候则需写成：apply plugin: "com.hc.gradle"然后在com.hc.gradle.properties文件里面指明你自定义的类implementation-class=com.hc.plugin.MyPlugin现在，你的目录应该如下：(7) 因为我们要用到groovy以及后面打包要用到maven,所以在我们自定义的Module下的build.gradle需要添加如下代码：apply plugin: "groovy"apply plugin: "maven"dependencies {compile gradleApi()compile localGroovy()}repositories {mavenCentral()}2 打包到本地Maven前面我们已经自定义好了插件，接下来就是要打包到Maven库里面去了，你可以选择打包到本地，或者是远程服务器中。在我们自定义Module目录下的build.gradle添加如下代码：group="com.hc.plugin"version="1.0.0"uploadArchives {repositories {mavenDeployer {repository(url: uri("D:/repos"))}}}其中，group和version后面会用到，我们后面再讲。虽然我们已经定义好了打包地址以及打包相关配置，但是还需要我们让这个打包task执行。点击AndroidStudio右侧的gradle工具，如下图所示：可以看到有uploadArchives这个Task,双击uploadArchives就会执行打包上传啦！执行完成后，去我们的Maven本地仓库查看一下：其中，com/hc/plugin这几层目录是由我们的group指定，myplugin是模块的名称，1.0.0是版本号（version指定）。

build.gradle//设置脚本的运行环境buildscript {//支持java 依赖库管理（maven/ivy）,用于项目的依赖。repositories {mavenCentral()}//依赖包的定义。支持maven/ivy，远程，本地库，也支持单文件dependencies {classpath "com.android.tools.build:gradle:0.4"}}//声明构建的项目类型，这里当然是android了apply plugin: "android"//设置编译android项目的参数android {compileSdkVersion 17buildToolsVersion "17"defaultConfig {minSdkVersion 8targetSdkVersion 17}//Android默认配置sourceSets {main {manifest.srcFile "AndroidManifest.xml"java.srcDirs = ["src"]resources.srcDirs = ["src"]aidl.srcDirs = ["src"]renderscript.srcDirs = ["src"]res.srcDirs = ["res"]assets.srcDirs = ["assets"]}//测试所在的路径，这里假设是tests文件夹，没有可以不写这一行instrumentTest.setRoot("tests")}//这个是解决lint报错的代码lintOptions {abortOnError false}/*** 签名设置*/signingConfigs {myConfigs {storeFile file("签名文件地址")keyAlias "..."keyPassword "..."storePassword "..."}}/*** 混淆设置*/buildTypes {release {signingConfig signingConfigs.myConfigsrunProguard trueproguardFiles getDefaultProguardFile("proguard-android.txt"), "proguard-rules.pro"}}/*** 渠道打包（不同包名）*/productFlavors {qqqq {applicationId = "包名"}hhhhh {applicationId="包名"}}}/*** .so文件的导入*/task copyNativeLibs(type: Copy) {from fileTree(dir: "libs", include: "armeabi/*.so") into "build/lib"}tasks.withType(Compile) {options.encoding = "UTF-8"}tasks.withType(Compile) {compileTask -> compileTask.dependsOn copyNativeLibs}clean.dependsOn "cleanCopyNativeLibs"tasks.withType(com.android.build.gradle.tasks.PackageApplication) { pkgTask ->pkgTask.jniFolders = [new File(buildDir, "lib")]}//依赖库dependencies {compile fileTree(dir: "libs", include: ["*.jar"])}gradle 作为构建工具，能够很方便的使用本地jar包，以下为使用的代码块。ependencies {//单文件依赖compile files("libs/android-support-v4.jar") //某个文件夹下面全部依赖compile fileTree(dir: "libs", include: "*.jar")}android {}gradle 同时支持maven，ivy，由于ivy我没用过，所以用maven 作为例子，以下为代码块：repositories {//从中央库里面获取依赖mavenCentral() //或者使用指定的本地maven 库maven{url "file://F:/githubrepo/releases"} //或者使用指定的远程maven库maven{url "远程库地址"}}dependencies {//应用格式: packageName:artifactId:versioncompile "com.google.android:support-v4:r13"}android {}对于项目依赖 android library的话，就不是依赖一个jar，那么简单了，在这里需要使用gradle mulit project 机制。在过去，android library并没有一个很好的包管理方式，简单来说，在gradle出现以前，官方并没有一种用于管理android library 依赖包的方式，一般我们都是直接下载别人的android library project 源码进行集成，而对于第三方的android-maven-plugin 用的是apklib 格式。而现在，官方终于推出一种android library的打包格式，扩展名为*.aar。前面提到，目前android gradle插件并不支持本地直接使用*.aar文件，不过，支持包管理库的引用方式，下面，我为大家说一下，怎么对android library 发布使用。打包android library对android library 进行打包直接在library项目下面使用gradle build 即可，然后，你就会在 build/libs 目录下看到两个*.aar文件，一个debug包用的，一个是release 下用的，看个人需求使用，这里我们用的是release 版本的 .aar 文件。

Gradle和Maven都是项目自动构建工具，编译源代码只是整个过程的一个方面，更重要的是，你要把你的软件发布到生产环境中来产生商业价值，所以，你要运行测试，构建分布、分析代码质量、甚至为不同目标环境提供不同版本，然后部署。整个过程进行自动化操作是很有必要的。整个过程可以分成以下几个步骤：编译源代码运行单元测试和集成测试执行静态代码分析、生成分析报告创建发布版本部署到目标环境部署传递过程执行冒烟测试和自动功能测试如果你手工去执行每一个步骤无疑效率比较低而且容易出错，有了自动化构建你只需要自定义你的构建逻辑，剩下的事情交给工具去完成。虽然两者都是项目工具，但是maven现在已经是行业标准，Gradle是后起之秀，很多人对他的了解都是从android studio中得到的，Gradle抛弃了Maven的基于XML的繁琐配置，众所周知XML的阅读体验比较差，对于机器来说虽然容易识别，但毕竟是由人去维护的。取而代之的是Gradle采用了领域特定语言Groovy的配置，大大简化了构建代码的行数，比如在Maven中你要引入一个依赖：<properties> <kaptcha.version>2.3</kaptcha.version> </properties><dependencies> <dependency> <groupId>com.google.code.kaptcha</groupId> <artifactId>kaptcha</artifactId> <version>${kaptcha.version}</version> <classifier>jdk15</classifier> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-core</artifactId> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-beans</artifactId> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> </dependency> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> </dependency> </dependencies>然后我将其转换成Gradle脚本，结果是惊人的：dependencies { compile("org.springframework:spring-core:2.5.6") compile("org.springframework:spring-beans:2.5.6") compile("org.springframework:spring-context:2.5.6") compile("com.google.code.kaptcha:kaptcha:2.3:jdk15") testCompile("junit:junit:4.7")}注意配置从原来的28行缩减至7行！这还不算我省略的一些父POM配置。依赖的groupId、artifactId、 version，scope甚至是classfier，一点都不少。较之于Maven或者Ant的XML配置脚本，Gradle使用的Grovvy脚本杀伤力太大了，爱美之心，人皆有之，相比于七旬老妇松松垮垮的皱纹，大家肯定都喜欢少女紧致的脸蛋，XML就是那老妇的皱纹。Gradle给我最大的有点是两点。其一是简洁，基于Groovy的紧凑脚本实在让人爱不释手，在表述意图方面也没有什么不清晰的地方。其二是灵活，各种在Maven中难以下手的事情，在Gradle就是小菜一碟，比如修改现有的构建生命周期，几行配置就完成了，同样的事情，在Maven中你必须编写一个插件，那对于一个刚入门的用户来说，没个一两天几乎是不可能完成的任务。

使用Android Studio开发Gradle插件的步骤：1 创建Gradle ModuleAndroidStudio中是没有新建类似Gradle Plugin这样的选项的，那我们如何在AndroidStudio中编写Gradle插件，并打包出来呢？(1) 首先，你得新建一个Android Project(2) 然后再新建一个Module，这个Module用于开发Gradle插件，同样，Module里面没有gradle plugin给你选，但是我们只是需要一个“容器”来容纳我们写的插件，因此，你可以随便选择一个Module类型（如Phone&Tablet Module或Android Librarty）,因为接下来一步我们是将里面的大部分内容删除，所以选择哪个类型的Module不重要。(3) 将Module里面的内容删除，只保留build.gradle文件和src/main目录。由于gradle是基于groovy，因此，我们开发的gradle插件相当于一个groovy项目。所以需要在main目录下新建groovy目录(4) groovy又是基于Java，因此，接下来创建groovy的过程跟创建java很类似。在groovy新建包名，如：com.hc.plugin，然后在该包下新建groovy文件，通过new->file->MyPlugin.groovy来新建名为MyPlugin的groovy文件。(5) 为了让我们的groovy类申明为gradle的插件，新建的groovy需要实现org.gradle.api.Plugin接口。如下所示：package com.hc.pluginimport org.gradle.api.Pluginimport org.gradle.api.Projectpublic class MyPlugin implements Plugin<project> {</project>void apply(Project project) {System.out.println("========================");System.out.println("hello gradle plugin!");System.out.println("========================");}}因为我本人对groovy也不是特别熟悉，所以我尽可能的用Java语言，使用System.out.println而不是用groovy的pintln ""，我们的代码里面啥也没做，就打印信息。(6) 现在，我们已经定义好了自己的gradle插件类，接下来就是告诉gradle，哪一个是我们自定义的插件类，因此，需要在main目录下新建resources目录，然后在resources目录里面再新建META-INF目录，再在META-INF里面新建gradle-plugins目录。最后在gradle-plugins目录里面新建properties文件，注意这个文件的命名，你可以随意取名，但是后面使用这个插件的时候，会用到这个名字。比如，你取名为com.hc.gradle.properties，而在其他build.gradle文件中使用自定义的插件时候则需写成：apply plugin: "com.hc.gradle"然后在com.hc.gradle.properties文件里面指明你自定义的类implementation-class=com.hc.plugin.MyPlugin现在，你的目录应该如下：(7) 因为我们要用到groovy以及后面打包要用到maven,所以在我们自定义的Module下的build.gradle需要添加如下代码：apply plugin: "groovy"apply plugin: "maven"dependencies {compile gradleApi()compile localGroovy()}repositories {mavenCentral()}2 打包到本地Maven前面我们已经自定义好了插件，接下来就是要打包到Maven库里面去了，你可以选择打包到本地，或者是远程服务器中。在我们自定义Module目录下的build.gradle添加如下代码：group="com.hc.plugin"version="1.0.0"uploadArchives {repositories {mavenDeployer {repository(url: uri("D:/repos"))}}}其中，group和version后面会用到，我们后面再讲。虽然我们已经定义好了打包地址以及打包相关配置，但是还需要我们让这个打包task执行。点击AndroidStudio右侧的gradle工具，如下图所示：可以看到有uploadArchives这个Task,双击uploadArchives就会执行打包上传啦！执行完成后，去我们的Maven本地仓库查看一下：其中，com/hc/plugin这几层目录是由我们的group指定，myplugin是模块的名称，1.0.0是版本号（version指定）。

我也不知道

首先说明一下为什么会有这篇文章。前段时间，插件化以及热修复的技术很热，Nuwa热修复的工具NuwaGradle，携程动态加载技术DynamicAPK，还有希望做最轻巧的插件化框架的Small。这三个App有一个共同的地方就是大量的使用了Gradle这个强大的构建工具，除了携程的框架外，另外两个都发布了独立的Gradle插件提供自动化构建插件，或者生成热修复的补丁。所以学习一下Gradle插件的编写还是一件十分有意义的事。http://blog.csdn.net/sbsujjbcy/article/details/50782830

①、根目录的build.gradle的内容所示如下：buildscript {repositories {jcenter()}dependencies {classpath "com.android.tools.build:gradle:1.0.0-rc4"}}allprojects {repositories {jcenter()maven {url "http://mvnrepo.xxx.com/mvn/repository"}}}解释：classpath "com.android.tools.build:gradle:1.0.0-rc4"就是Android特有的插件，maven仓库地址通过方法jCenter() 获取，这也是默认的maven仓库。当然也可以添加额外的maven仓库地址，例如以上文件中的maven {url "http://mvnrepo.xxx.com/mvn/repository"}②、app目录下的build.gradle的内容展示如下：//设置脚本的运行环境buildscript {//支持java 依赖库管理（maven/ivy）,用于项目的依赖。repositories {mavenCentral()}//依赖包的定义。支持maven/ivy，远程，本地库，也支持单文件dependencies {classpath "com.android.tools.build:gradle:0.4"}}//声明构建的项目类型，这里当然是android了apply plugin: "android"//设置编译android项目的参数android {compileSdkVersion 17buildToolsVersion "17"defaultConfig {minSdkVersion 8targetSdkVersion 17}//Android默认配置sourceSets {main {manifest.srcFile "AndroidManifest.xml"java.srcDirs = ["src"]resources.srcDirs = ["src"]aidl.srcDirs = ["src"]renderscript.srcDirs = ["src"]res.srcDirs = ["res"]assets.srcDirs = ["assets"]}//测试所在的路径，这里假设是tests文件夹，没有可以不写这一行instrumentTest.setRoot("tests")}//这个是解决lint报错的代码lintOptions {abortOnError false}/*** 签名设置*/signingConfigs {myConfigs {storeFile file("签名文件地址")keyAlias "..."keyPassword "..."storePassword "..."}}/*** 混淆设置*/buildTypes {release {signingConfig signingConfigs.myConfigsrunProguard trueproguardFiles getDefaultProguardFile("proguard-android.txt"), "proguard-rules.pro"}}/*** 渠道打包（不同包名）*/productFlavors {qqqq {applicationId = "包名"}hhhhh {applicationId="包名"}}}/*** .so文件的导入*/task copyNativeLibs(type: Copy) {from fileTree(dir: "libs", include: "armeabi/*.so") into "build/lib"}tasks.withType(Compile) {options.encoding = "UTF-8"}tasks.withType(Compile) {compileTask -> compileTask.dependsOn copyNativeLibs}clean.dependsOn "cleanCopyNativeLibs"tasks.withType(com.android.build.gradle.tasks.PackageApplication) { pkgTask ->pkgTask.jniFolders = [new File(buildDir, "lib")]}//依赖库dependencies {compile fileTree(dir: "libs", include: ["*.jar"])}包依赖使用aar时分为本地依赖和远程依赖，分别如下：本地依赖：gradle 作为构建工具，能够很方便的使用本地jar包，以下为使用的代码块：dependencies {//单文件依赖compile files("libs/android-support-v4.jar")//某个文件夹下面全部依赖compile fileTree(dir: "libs", include: "*.jar")}android {}远程依赖：gradle 同时支持maven，ivy，我们用maven 作为例子，以下为代码块：repositories {//从中央库里面获取依赖mavenCentral()//或者使用指定的本地maven 库maven{url "file://F:/githubrepo/releases"}//或者使用指定的远程maven库maven{url "远程库地址"}}dependencies {//应用格式: packageName:artifactId:versioncompile "com.google.android:support-v4:r13"}android {}