gradlebuild编译过程

❶ android Studio开发解读 - gradle编译项目的build目录结构

转自：http://www.cnblogs.com/bbqzsl/p/5926591.html

本文针对android studio工具下的ndk开发。

build目录就是项目模块构建过程和结果使用到的位置。

项目根目录下有一个build目录。

项目根目录下各模块子目录下各自有一个build目录。

build目录下一般由4个子目录组成：

generated由aapt工具根据资源数据自动生成的java类

intermediates中间过程

outputs输出结果

tmp编译日志

根目录下的build目录，这个build服务于整个项目，在本文中称其做项目build，以区分模块build。

项目build一般只有generated和intermediates两个子目录，用于生成这个项目的buildTools。

generated目录会生成一个mockable-android-${buildToolsVersion}.jar。

intermediates目录根据需要生成dex-cache，这个目录纤谨下的xml文件配置jar包在编译过程中如何缓冲使用。

模块build目录在make mole ${MOD_NAME}后就会生成4个子目录。

我们来看intermediates目录，中间生成和编译过程使用到的目录。

这个目录下有这么几个比较关心的子目录：

binaries                  NDK，生成c++连接库

bundles                  模块链接到的自定义毁樱基jar包和各abi版本的c++链接库都捆绑在这里

classes模块中生成的自定义java类

exploded-aar          由aar包解压出来的资源，jar包和so链接文件等。用于本模块的链接和集成。

jniLibs                   在build.grade中你指定的jniLibs目录整个拷贝。模块链接到的库文件会被捆到bundles目录。

objectFiles              NDK，生成c++中间对象（.o）文件。

transforms              根据你当前选择的proctFlavor和其包含的abiFilter，从bundles和binaries取出链接库。

接着就是output目录：

aar如果模块是android library

jar                         如果模块是java library

apk                        如果是Activity应用程序

最后就是tmp目录：

compile$(NDK_Mole)$(ABI)$(BUILD_TYPE)$(PRODUCT_FLAVOR)MainCpp               ndk编译日志

link$(NDK_Mole)$(ABI)$(BUILD_TYPE)$(PRODUCT_FLAVOR)$(LIB_TYPE)                ndk链接日志

编译的子目录由三要素组合颂磨而成，分别是

BUILD_TYPE := debug|release

ProctFlavor := 你在gradle文件中创建的flavor

abiFilter :=

逆向深入objc,c++ windows下仿objc动画层UI引擎

❷ 如何 gradle build

1. 为什么选择Gradle？

2. 简单入门
2.1 使用Intellij Idea创建gradle项目
首先在Idea中启用Gradle支持：Settings->Plugins: Gradle
然后创建一个gradle项目或模块，会发现目录结构和maven的很像，其中build.gradle是gradle的配置文件，类似于maven中pom.xml文件，以下是build.gradle的简单示例：
apply plugin: 'java'

group = 'org.yousharp'
version = '1.0-SNAPSHOT'

sourceCompatibility = 1.7
targetCompatibility = 1.7

repositories {
mavenCentral()
maven { url "repo.maven.apache.org/maven2" }
}
dependencies {
compile group: 'com.google.guava', name: 'guava', version:'17.0'
compile group: 'redis.clients', name: 'jedis', version:'2.6.0'
testCompile group: 'junit', name: 'junit', version:'4.11'
}

插件(plugin)：是gradle的一种扩展，gradle预定义了很多插件，常见的如java插件、war插件等；java插件中定义了一些有用的task，如编译源码、执行单元测试、生成jar包、约定默认的目录结构等； repositories定义仓库，dependencies定义项目的依赖，比maven的XML定义更简洁；
那么，如何编译、测试，以及运行gradle的项目呢？
刚才说到java插件预定义了很多task，其中就包括编译、测试、生成jar包等task，可以在命令行通过 $ gradle tasks 查看项目已定义的所有task以及含义，如java插件中常用的task有：
+ assemble: 编译
+ build：编译并执行测试
+ clean：删除build目录
+ jar： 生成jar包
+ test：执行单元测试

2.2 将Java项目从maven迁移到gradle
如何将一个java项目从maven迁移到gradle呢？gradle集成了一个很方便的插件：Build Init Plugin，使用这个插件可以很方便地创建一个新的gradle项目，或者将其它类型的项目转换为gradle项目。
要将maven项目转换为gradle项目，只需要在项目的pom文件所在的目录下执行以下命令：
$ gradle init --type pom

上面的命令会根据pom文件自动生成gradle项目所需的文件和配置，然后以gradle项目重新导入即可。

❸ minecraft我的世界gradle构建，总是失败，求告诉详细教程。不要发网址，要会的人。不会的

最近在项目中遇到一个不大，但是还蛮烦人的问题，在Maven的约定中，一个标准Java项目的代码结构如下：
project
--src
--main
--java
--resources
--test
--java
--resources

当‘gradle idea’构建intelliJ项目文件时，会自动帮忙设置好所有的Source Root，Test Source Root。但是，在我工作的部门中，我们希望可以把测试分为unit，intg2个类别，这样可以更加容易区分测试的目的，同时提供了Build Pipeline分别运行不同类别测试的能力。因此，我们部门内的标准Java项目结构如下：
project
--src
--main
--java
--resources
--test
--common
--java
--unit
--java
--resources
--intg
--java
--resources

有了这个目录结构之后我们剩下2个问题要解决：
1. 如何区分运行IntegrationTest和Unit Test
2. 如何保证‘gradle idea’以后，无需重新设置Test Source Root。因为gradle不具备识别新的代码结构的能力。

如何写一个Gradle Plugin

语言：
Java，Groovy，Scala都可，推荐用Groovy,毕竟Gradle本质上来说就是一个用Groovy写的DSL，使用Groovy可以更一致一点。

注入方式：
Gradle支持3种形式的定制Plugin注入：

1. 直接把Plugin源代码直接写在Build Script里面。
2. 把Pluigin源代码写到rootProjectDir/buildSrc/src/main/groovy目录下
3. 用一个单独的project来写Plugin源代码，然后以jar依赖的形式注入项目。

个人觉得，都想到要自己写一个Plugin了，那么一定是有多个项目公用这个Plugin了，否则的话，直接把Plugin的代码直接写到脚本里就好了。因此，要定制Plugin，在我看来，一定是需要以一个单独的jar形式注入的。

写project-structure Plugin:
在Gradle中，写一个Plugin非常简单，首先，添加项目依赖，我使用Groovy来写插件，所以添加了localGroovy依赖。

Gradle代码
apply plugin: 'groovy'

dependencies {
compile gradleApi()
compile localGroovy()
}

然后写Plugin的实现代码，实现代码只需要实现Plugin<Project>接口即可，在我的实现代码中，做了两件事，一是定制了项目的代码结构，二是添加了integrationTest Task，该Task只运行*IntegrationTest.class, 这样可以在Build Pipeline分阶段运行Unit Test和IntegrationTest。

Groovy代码
import org.gradle.api.Plugin
import org.gradle.api.Project
import org.gradle.api.tasks.testing.Test

class ProjectStructurePlugin implements Plugin<Project> {
@Override
void apply(Project project) {
project.logger.info "Configuring Project Structure for $project.name"

project.configurations {
integrationTestCompile { extendsFrom testCompile }
integrationTestRuntime { extendsFrom integrationTestCompile, testRuntime }
}
configureSourceSets(project)
addIntegrationTestTask(project)
}

private void addIntegrationTestTask(Project project) {
Test intgTest = project.getTasks().create("integrationTest", Test.class);
intgTest.testClassesDir = project.sourceSets.integrationTest.output.classesDir
intgTest.includes = ["**/*IntegrationTest.class"]
intgTest.inputs.dir 'src'
intgTest.outputs.dir project.sourceSets.integrationTest.output.classesDir
project.check.dependsOn project.integrationTest
intgTest.dependsOn project.test
}

private void configureSourceSets(Project project) {
project.sourceSets {
test {
java {
srcDir 'src/test/unit/java'
srcDir 'src/test/common/java'
}
resources {
srcDir 'src/test/unit/resources'
}
}

integrationTest {
java {
srcDir 'src/test/intg/java'
srcDir 'src/test/common/java'
}
resources {
srcDir 'src/test/intg/resources'
}
compileClasspath = project.sourceSets.main.output + project.sourceSets.test.output + project.configurations.integrationTestCompile
runtimeClasspath = output + compileClasspath + project.configurations.integrationTestRuntime
}
}
}
}

接着，在项目的src/main/resources/META-INF/gradle-plugins目录下，创建一个文件：<plugin-name>.properties,在该文件中指定Plugin的实现类：

Java代码
implementation-class=com.xianlinbox.plugins.ProjectStructurePlugin

在项目中使用该Plugin
首先，需要在build.gradle脚本中引入该Plugin的jar包依赖，可以是以文件的形式，当然个人更推荐的是把jar包发布到Maven库中，以Maven依赖的形式的注入，本例中使用的是本地文件依赖：

Groovy代码
buildscript {
dependencies {
classpath fileTree(dir: 'libs', include: '*.jar')
}
}
然后，注入编写的插件，注意，该插件必须和java plugin一起使用，因为其中使用到SourceSets属性是从该插件中引入进来的：

Groovy代码
apply plugin: 'java'
apply plugin: 'project-structure'

有了这个插件之后，就可以通过‘gradle test’和‘gradle integrationtTest’区别运行UnitTest和IntrgrationTest了。

最后，解决自动设置Test Source Root的问题，只需要在build.gradle为ideaMole Task增加识别Test Source Root的能力即可：

Groovy代码
apply plugin: 'idea'
...
idea {
mole {
testSourceDirs += file('src/test/intg/java')
testSourceDirs += file('src/test/intg/resources')
}
}

当然，我们也可以把它写到Plugin中去，在设置为Project-Structrue之后：

Groovy代码
......
compileClasspath = project.sourceSets.main.output + project.sourceSets.test.output + project.configurations.integrationTestCompile
runtimeClasspath = output + compileClasspath + project.configurations.integrationTestRuntime
project.idea {
mole {
testSourceDirs = testSourceDirs + new File('src/test/intg/java') + new File('src/test/intg/resources')
}
}
1、安装
Gradle安装和Maven一样方便，只需要，下载(http://www.gradle.org/downloads )==》解压==》配置环境变量(GRADLE_HOME & PATH)，配置好环境变量之后记得使用 source命令使新的环境变量生效。配置成功之后，可以在命令行通过 “gradle -v"验证是否安装成功。

2、Gradle编译Maven风格的java项目
首先，在项目根目录创建"build.gradle"文件，编译java项目需要使用gradle的java插件
Groovy代码
apply plugin: 'java'
,因为要集成maven的功能，需要添加maven插件
Groovy代码
apply plugin: 'maven'[
。
接着，配置项目的Repository，风格如下
Groovy代码
repositories{
mavenCentral();
}
，上面例子使用的是默认的maven的中央库，如果想用自己的本地库，可通过如下方式配置
Groovy代码
def localMavenRepo = 'file://' + new File(System.getProperty('user.home'), '.m2/repository').absolutePath
repositories {
// Use local Maven repo location. We don't need this if we only want to install
// an artifact, but we do need it if we want to use dependencies from the local
// repository.
mavenRepo urls: localMavenRepo
mavenCentral()
}

再然后，配置项目依赖的第三方库，配置模板如下:
Groovy代码
dependencies{
compile group: '<group-id>',name:'<artifact-id>',version:'<version>'
}
，举个例子，假设项目依赖了4.10版本的junit，那么配置就是
Groovy代码
compile group: 'junit',name:'junit',version:'4.10'
另外Depencies还可以按如下方式简写
Groovy代码
compile '<group-id>:<artifact-id>:<version>'
例子
Groovy代码
compile 'junit:junit:4.10'

最后，如何把自己的项目发布到Repository中，
Groovy代码
uploadArchives {
repositories {
mavenDeployer {
repository(url: "file://localhost/tmp/myRepo/")
}
}