1、用Gradle构建
1.1 工程结构
如图所示，这是一个不能更普通的Android的Gradle工程了。
- 根目录下面的settings.gradle当中主要是用来include子模块的，比如我们这个工程有一个叫作app的子模块，那么settings.gradle的内容如下：
include ':app'
根目录下面的build.gradle包含一些通用的配置，这些配置可以在各个子模块当中使用。
gradle.properties文件包含的属性，会成为project的properties的成员,例如我们添加了属性hello，
hello=Hello Tas!
- 然后我们在build.gradle当中创建task：
task hello << { println hello println project.getProperties().get("hello") }输出的结果是一样地：
14:28:11: Executing external task 'hello'...
Configuration on demand is an incubating feature.
:app:hello
Hello Tas!
Hello Tas!
BUILD SUCCESSFUL
Total time: 0.54 secs
14:28:12: External task execution finished 'hello'.
- local.properties这个文件在Android工程当中会遇到，我们通常在其中设置Android的SDK和NDK路径。当然，这个Android Studio会帮我们设置好的。为了更清楚地了解这一点，我把Android的Gradle插件的部分源码摘录出来：
SDK.groovy，下面的代码主要包含了加载SDK、NDK路径的操作。
private void findLocation() { if (TEST_SDK_DIR != null) { androidSdkDir = TEST_SDK_DIR return} def rootDir = project.rootDir def localProperties = new File(rootDir, FN_LOCAL_PROPERTIES) if (localProperties.exists()) { Properties properties = new Properties() localProperties.withInputStream { instr -> properties.load(instr) } def sdkDirProp = properties.getProperty('sdk.dir') if (sdkDirProp != null) { androidSdkDir = new File(sdkDirProp)} else { sdkDirProp = properties.getProperty('android.dir') if (sdkDirProp != null) { androidSdkDir = new File(rootDir, sdkDirProp) isPlatformSdk = true } else { throw new RuntimeException("No sdk.dir property defined in local.properties file.") } } def ndkDirProp = properties.getProperty('ndk.dir') if (ndkDirProp != null) { androidNdkDir = new File(ndkDirProp) }} else { String envVar = System.getenv("ANDROID_HOME") if (envVar != null) { androidSdkDir = new File(envVar) } else { String property = System.getProperty("android.home") if (property != null) { androidSdkDir = new File(property) } } envVar = System.getenv("ANDROID_NDK_HOME") if (envVar != null) { androidNdkDir = new File(envVar) } }} BasePlugin.groovy，通过这两个方法，我们可以在Gradle脚本当中获取SDK和NDK的路径：
File getSdkDirectory() { return sdk.sdkDirectory}File getNdkDirectory() { return sdk.ndkDirectory}例如：
task hello << { println android.getSdkDirectory() }14:37:33: Executing external task 'hello'...
Configuration on demand is an incubating feature.
:app:hello
/Users/benny/Library/Android/sdk
BUILD SUCCESSFUL
Total time: 0.782 secs
14:37:35: External task execution finished 'hello'.
上面给出的只是最常见的hierarchy结构，还有 flat 结构，如下图1为flat结构，2为hierarchy结构。有兴趣的话可以Google一下。
1.2 几个重要的概念
这一小节的出场顺序基本上跟build.gradle的顺序一致。
1.2.1 Repository和Dependency
如果你只是写Android程序，那么依赖问题可能还不是那么的烦人——如果你用Java写服务端程序，那可就是一把辛酸一把泪了。
仓库的出现，完美的解决了这个问题，我们在开发时只需要知道依赖的id和版本，至于它存放在哪里，我不关心；它又依赖了哪些，构建工具都可以在仓库中帮我们找到并搞定。这一切都是那么自然，要不要来一杯拿铁，让代码构建一会儿？
据说在Java发展史上，涌现出非常多的仓库，不过最著名的当然是Maven了。Maven通过groupId和artifactId来锁定构件，再配置好版本，那么Maven仓库就可以最终锁定一个确定版本的构件供你使用了。比如我们开头那个例子：
<dependency> <groupId>com.google.code.gson</groupId> <artifactId>gson</artifactId> <version>2.4</version></dependency>
Maven就凭这么几句配置就可以帮你搞定gson-2.4.jar，不仅如此，它还会按照你的设置帮你把javadoc和source搞定。妈妈再也不用担心我看不到构件的源码了。
那么这个神奇的Maven仓库在哪儿呢？Maven Central，中央仓库，是Maven仓库的鼻祖，其他的大多数仓库都会对它进行代理，同时根据需求添加自己的特色库房。简单说几个概念：
代理仓库：要租房，去搜房网啊。你要去驾校报名，我是驾校代理，你找我，我去找驾校。具体到这里，还有点儿不一样，一旦有人从代理仓库下载过一次特定得构件，那么这个构件会被代理仓库缓存起来，以后就不需要找被代理的仓库下载了。
私有仓库：中国特色社会主义。走自己的路，你管我啊？公司内部的仓库里面有几个hosted的仓库，这些仓库就是我们公司内部特有的，里面的构件也是我们自己内部的同事上传以后供团队开发使用的。
本地仓库：大隐隐于市。跟代理仓库的道理很像，只不过，这个仓库是存放在你自己的硬盘上的。
说起来，Android SDK下面有个extra目录，里面的很多依赖也是以Maven仓库的形式组织的。不过这是Google特色嘛，人家牛到不往Maven的中央仓库上传，真是没辙。
1.2.2 SourceSets
源码集，这里面主要包含你的各种类型的代码的路径，比如'src/main/java'等等。
1.2.3 Properties
前面我们其实也稍稍有提到，这个properties其实是gradle的属性，在gradle源码当中，我们找到Project.java这个接口，可以看到：
/** * <p>Determines if this project has the given property. See <a href="#properties">here</a> for details of the * properties which are available for a project.</p> * * @param propertyName The name of the property to locate. * @return True if this project has the given property, false otherwise. */ boolean hasProperty(String propertyName); /** * <p>Returns the properties of this project. See <a href="#properties">here</a> for details of the properties which * are available for a project.</p> * * @return A map from property name to value. */ Map<String, ?> getProperties(); /** * <p>Returns the value of the given property. This method locates a property as follows:</p> * * <ol> * * <li>If this project object has a property with the given name, return the value of the property.</li> * * <li>If this project has an extension with the given name, return the extension.</li> * * <li>If this project's convention object has a property with the given name, return the value of the * property.</li> * * <li>If this project has an extra property with the given name, return the value of the property.</li> * * <li>If this project has a task with the given name, return the task.</li> * * <li>Search up through this project's ancestor projects for a convention property or extra property with the * given name.</li> * * <li>If not found, a {@link MissingPropertyException} is thrown.</li> * * </ol> * * @param propertyName The name of the property. * @return The value of the property, possibly null. * @throws MissingPropertyException When the given property is unknown. */ Object property(String propertyName) throws MissingPropertyException; /** * <p>Sets a property of this project. This method searches for a property with the given name in the following * locations, and sets the property on the first location where it finds the property.</p> * * <ol> * * <li>The project object itself. For example, the <code>rootDir</code> project property.</li> * * <li>The project's {@link Convention} object. For example, the <code>srcRootName</code> java plugin * property.</li> * * <li>The project's extra properties.</li> * * </ol> * * If the property is not found, a {@link groovy.lang.MissingPropertyException} is thrown. * * @param name The name of the property * @param value The value of the property */ void setProperty(String name, Object value) throws MissingPropertyException;不难知道，properties其实就是一个map，我们可以在gradle.properties当中定义属性，也可以通过 gradle 脚本来定义：
setProperty('hello', 'Hello Tas again!')使用方法我们前面已经提到，这里就不多说了。
1.2.4 Project和Task
如果你用过ant，那么project基本上类似于ant的project标签，task则类似于ant的target标签。我们在 build.gradle当中编写的：
task hello << { ...... }实际上，是调用：
Task Project.task(String name) throws InvalidUserDataException;
创建了一个task，并通过 << 来定义这个task的行为。我们看到task还有如下的重载：
Task task(String name, Closure configureClosure);
所以下面的定义也是合法的：
task('hello2',{ println hello })简单说，project就是整个构建项目的一个逻辑实体，而task就是这个项目的具体任务点。更多的介绍可以参见官网的文档，和gradle的源码。
2、发布构件
发布构件，还是依赖仓库，我们仍然以Maven仓库为例，私有仓库多数采用sonatype。
2.1 UI 发布
如果管理员给你开了这个权限，你会在UI上面看到upload artifact的tab，选择你要上传的构件，配置好对应的参数，点击上传即可。
2.2 使用 Maven 插件
这里的意思是使用Maven的gradle插件，在构建的过程中直接上传。构建好的构件需要签名，请下载GPG4WIN(windows)，或者GPGTOOLS(mac)，生成自己的key。
直接上代码：
gradle.properties
sonatypeUsername=你的用户名
sonatypePassword=你的密码
signing.keyId=你的keyid
signing.password=你的keypass
#注意，通常来讲是这个路径。
# mac/linux
signing.secretKeyRingFile=/Users/你的用户名/.gnupg/secring.gpg
# Window XP and earlier (XP/2000/NT)
# signing.secretKeyRingFile=C:\\Documents and Settings\\<username>\\Application Data\\GnuPG\\secring.gpg
# Windows Vista and Windows 7
# signing.secretKeyRingFile=C:\\Users\\<username>\\AppData\\Roaming\\gnupg\\secring.gpg
projectName=你的构件名称
group=你的构件groupid
artifactId=你的构件artifactid
# 版本号，采用三位数字的形式，如果是非稳定版本，请务必添加SNAPSHOT
version=0.0.1-SNAPSHOT
build.gradle
apply plugin: 'com.android.library' apply plugin: 'maven' apply plugin: 'signing' android { compileSdkVersion 21 buildToolsVersion "21.1.2" defaultConfig { minSdkVersion 17 targetSdkVersion 21 versionCode 1 versionName "0.2" } buildTypes { release { minifyEnabled false proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro' } } } dependencies { compile fileTree(include: ['*.jar'], dir: 'libs') ...... } def isSnapshot = version.endsWith('-SNAPSHOT') def sonatypeRepositoryUrl if(isSnapshot) { sonatypeRepositoryUrl = "http://maven.oa.com/nexus/content/repositories/thirdparty-snapshots/" } else { sonatypeRepositoryUrl = "http://maven.oa.com/nexus/content/repositories/thirdparty/" } sourceSets { main { java { srcDir 'src/main/java' } } } task sourcesJar(type: Jar) { from sourceSets.main.allSource classifier = 'sources' } artifacts { //archives javadocJar archives sourcesJar } signing { if(project.hasProperty('signing.keyId') && project.hasProperty('signing.password') && project.hasProperty('signing.secretKeyRingFile')) { sign configurations.archives } else { println "Signing information missing/incomplete for ${project.name}" } } uploadArchives { repositories { mavenDeployer { if(project.hasProperty('preferedRepo') && project.hasProperty('preferedUsername') && project.hasProperty('preferedPassword')) { configuration = configurations.archives repository(url: preferedRepo) { authentication(userName: preferedUsername, password: preferedPassword) } } else if(project.hasProperty('sonatypeUsername') && project.hasProperty('sonatypePassword')) { beforeDeployment { MavenDeployment deployment -> signing.signPom(deployment) } repository(url: sonatypeRepositoryUrl) { authentication(userName: sonatypeUsername, password: sonatypePassword) } } else { println "Settings sonatypeUsername/sonatypePassword missing/incomplete for ${project.name}" } pom.artifactId = artifactId pom.project { name projectName packaging 'aar' developers { developer { id 'wecar' name 'wecar' } } } } } }然后运行gradle uploadArchives就可以将打包的aar发布到公司的Maven仓库当中了。jar包的方式类似，这里就不在列出了。
2.3 使用Maven命令
这个可以通过mvn在cmdline直接发布构件，命令使用说明：
mvn deploy:deploy-file -Durl=file://C:\m2-repo \
-DrepositoryId=some.id \
-Dfile=your-artifact-1.0.jar \
[-DpomFile=your-pom.xml] \
[-DgroupId=org.some.group] \
[-DartifactId=your-artifact] \
[-Dversion=1.0] \
[-Dpackaging=jar] \
[-Dclassifier=test] \
[-DgeneratePom=true] \
[-DgeneratePom.description="My Project Description"] \
[-DrepositoryLayout=legacy] \
[-DuniqueVersion=false]
当然这里仍然有个认证的问题，我们需要首先在maven的settings配置当中加入：
<servers> <server> <id>Maven.oa.com</id> <username>rdm</username> <password>rdm</password> </server></servers>
然后我们就可以使用命令上传了：
mvn deploy:deploy-file -DgroupId=com.tencent.test -DartifactId=test -Dversion=1.0.0 -Dpackaging=aar -Dfile=test.aar -Durl=http://maven.oa.com/nexus/content/repositories/thirdparty -DrepositoryId=Maven.oa.com
3、插件
3.1 什么是插件
插件其实就是用来让我们偷懒的。如果没有插件，我们想要构建一个 Java 工程，就要自己定义 sourceSets，自己定义 classpath，自己定义构建步骤等等。
简单地说，插件其实就是一组配置和任务的合集。
gradle 插件的存在形式主要由三种，
- gradle文件中直接编写，你可以在你的build.gradle当中写一个插件来直接引入：
apply plugin: GreetingPlugin class GreetingPlugin implements Plugin<Project{ void apply(Project project) { project.task('hello') << { println "Hello from the GreetingPlugin" } } }3.2 常见的插件
目前接触到的插件，有下面这么几种：
- java，构建 java 工程
- war，发布 war 包用，构建 web 工程会用到
- groovy，构建 groovy 工程
- com.android.application，构建 Android app 工程
- com.android.library，构建 Android library，通常输出 aar
- sign，签名
- maven，发布到 maven 仓库
- org.jetbrains.intellij，构建 intellij 插件工程
3.3 自己动手写一个插件
创建一个普通的 groovy 工程（java 工程也没有关系），创建 src/main/groovy 目录，编写下面的代码：
package com.tencent.wecar.pluginimport org.gradle.api.Pluginimport org.gradle.api.internal.project.ProjectInternalclass GreetingPlugin implements Plugin<ProjectInternal> { void apply(ProjectInternal project) { project.task('hello') << { println 'hello' } }}在 src/main/resources创建META-INF/gradle-plugins目录，创建greetings.properties文件：
implementation-class=com.tencent.wecar.plugin.GreetingPlugin
其中greettings就是你的插件id。
build.gradle
group 'com.tencent.wecar.plugin'version '1.1-SNAPSHOT'buildscript { repositories { mavenLocal() }}apply plugin: 'groovy'apply plugin: 'java'repositories { mavenCentral()}sourceSets { main { groovy { srcDirs = [ 'src/main/groovy', 'src/main/java' ] } // compile everything in src/ with groovy java { srcDirs = []}// no source dirs for the java compiler }}dependencies { //tasks.withType(Compile) { options.encoding = "UTF-8" } compile gradleApi()}// custom tasks for creating source jarstask sourcesJar(type: Jar, dependsOn:classes) { classifier = 'sources' from sourceSets.main.allSource}// add source jar tasks as artifactsartifacts { archives sourcesJar }// upload to localuploadArchives { repositories{ mavenLocal() }}运行uploadArchives发布到本地仓库，那么就可以找到我们自己的插件了，由于当中没有指定artifactId，那么我们的插件的artifactId就是我们的工程名称，比如这里是deployplugin。
那么我们要怎么引入这个插件呢？
首先要再buildScript增加依赖：
buildscript { repositories { mavenLocal() } dependencies { classpath 'com.tencent.wecar.plugin:deployplugin:1.1-SNAPSHOT' }}然后：
apply plugin: 'greetings'
这样我们的task “hello”就被引入了。
4、Gradle运行慢？
用过Gradle的朋友多少会感觉到这货有时候会比较慢。我们可以通过下面的三个手段加速你的Gradle。
- 不用中央仓库。如果你的repository 配置的是mavenCentral，放开它吧，全世界的人都在琢磨着怎么虐它，你就不要瞎掺和了。试试jCenter。
- 升级最新的Gradle版本。目前最新的版本是2.4，Android Studio从1.3开始默认使用Gradle2.4。
- 开启Gradle的电动小马达。在gradle.properties（眼熟？没错，就是它！！）
里面添加下面的配置：
如果你的任务没有时序要求，那么打开这个选项可以并发处理多个任务，充分利用硬件资源。。嗯，如果你的是单核CPU。。当我没说。。 org.gradle.parallel=true 这个也可以在命令行通过参数的形式启动，3个小时有效。守护进程可以使编译时间大大缩短 org.gradle.daemon=true 这个看需求吧，Gradle 是运行在 Java 虚拟机上的，这个指定了这个虚拟机的堆内存初始化为256M，最大为1G。如果你内存只有2G，那当我没说。。 org.gradle.jvmargs=-Xms256m -Xmx1024m
当然，建议的方式是在你的用户目录下面的.gradle/下面创建一个gradle.properties，免得坑你的队友。。。
本文为腾讯Bugly投稿，Bugly是腾讯内部产品质量监控平台的外发版本，经团队四年打磨，支持iOS和Android两大主流平台，其主要功能是App发布以后，对用户端发生的Crash以及卡顿现象进行监控并上报，让开发同学可以第一时间了解到App的质量情况，及时修改。目前腾讯内部所有的产品，均在使用其进行线上产品的崩溃监控。
1 1
