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/")
}
}
‘贰’ 如何使用gradle构建工具打包groovy脚本成jar文件
准备工作安装 gradle， groovy。
要使用gradle的groovy plugin 来打包groovy 脚本，项目结构。
目录 含义
src/main/java Java 代码
src/main/resources Java需要的资源文件
src/main/groovy Groovy代码，也可以包含Java代码
src/test/java Java 测试代码
src/test/resources 测试需要的资源文件
src/test/groovy Groovy测试需要的资源文件
src/sourceSet/java Java代码源
src/sourceSet/resources 资源文件源
src/sourceSet/groovy Groovy代码源
我们只需要编译打包groovy脚本 所以只需要创建 src/main/groovy目录结构。例子：
gradle_groovy_archive项目 结构是：
gradle_groovy_archive
创建helloWorld.groovy脚本，代码如下：
package hello
println 'Gradle compile groovy'
创建Gradle构建文件：
apply plugin: 'groovy'
apply plugin: 'maven'
group = 'com.hello'
archiveBaseName = 'hello'
version = '0.1-SNAPSHOT'
defaultTasks 'clean', 'jar'
configurations {
deployerJars
}
repositories {
mavenCentral()
}
dependencies {
//使用本地groovy环境
groovy localGroovy()
//groovy group: 'org.codehaus.groovy', name: 'groovy', version: '1.8.6'
compile fileTree( dir: 'lib', include: ['*.jar'])
deployerJars 'org.apache.maven.wagon:wagon-webdav-jackrabbit:1.0-beta-7'
}
sourceSets {
main {
groovy {
srcDir 'src/main/groovy'
}
}
}
uploadArchives {
repositories.mavenDeployer {
uniqueVersion = false
configuration = configurations.deployerJars
repository(id : repositoryId, url : repositoryUrl) {
authentication (userName : 'deployment', password : 'deployment')
proxy()
}
}
}
创建构建文件属性文件：
//根据不同情况修改
repositoryId=ND
repositoryUrl=ND
systemProp.http.proxyHost=ND
systemProp.http.proxyPort=8080
systemProp.http.proxyUser=ND
systemProp.http.proxyPassword=ND
在命令行中 敲 gradle 运行，会自动运行 defaultTasks,clean 和 jar，会把 所有groovy下的脚本打成jar包。
‘叁’ gradle.properties文件在哪
通常在项目的根目录，在Android Studio 创建一个项目的时候，根目录下会生成gradle.properties和local.properties文件。
properties的数据格式：
采用键值对的方式，写法：key=value
(3)gradle脚本扩展阅读
项目结构
1、app/build：app模块编译输出的文件。
2、app/libs： 放置引用的类库文件。
3、app/src： 放置应用的主要文件目录。
4、app/src/androidTest：单元测试目录。
5、app/src/main：主要的项目目录和代码。
6、app/src/main/assets：放置原生文件，里面的文件会保留原有格式，文件的读取需要通过流。
7、app/src/main/java：项目的源代码。
8、build：系统生成的文件目录。
9、gradle: wrapper的jar和配置文件所在的位置。
10、.gitattributes：用于设置文件的对比方式。
11、.gitignore： 忽略的文件或者目录。
12、build.gradle：项目的gradle编译文件。
13、gradle.properties： gradle相关的全局属性设置。
14、gradlew： 编译脚本，可以在命令行执行打包。
15、gradlew.bat：windows下的gradle wrapper可执行文件。
16、local.properties：配置SDK/NDK所在的路径。
17、MyApplication.iml：保存该模块的相关信息。
18、README.md：文本编辑器，记录一些相关信息。
19、settings.gradle：设置相关的gradle脚本。
20、External Libraries：项目依赖的库，编译时自动下载。
‘肆’ 如何更改gradle默认执行顺序
1
gradle的解析顺序：rootproject 的setting.gradle,然后是rootproject的build.gradle,然后是各个subproject。所以project下的build.gradle会先于app下的build.gradle。
2
在build.gradle中，我们可以通过apply plugin: 引入插件，也可以通过 apply from .gradle引入其他gradle脚本中的函数定义或task等
3
你说的check，clean实际是task，一般hook我们指的是gradle的生命周期：
‘伍’ 如何在android studio中查看当前使用的gradle版本和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。
根目录下的脚本文件是针对mole的全局配置，它的作用阈所包含的所有 mole 是通过settings.gradle来配置。
app文件夹就是一个mole，如果在当前工程中添加了一个新的mole -- lib，就需要在settings.gralde文件中包含这个新的mole。
gradle脚本的基本结构
用我现在的工程举例来说，根目录的build.gradle的内容如下所示：
[plain] view plainprint?
// Top-level build file where you can add configuration options common to all sub-projects/moles.
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 indivial mole 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'
}
‘陆’ 为什么应该选择gradle
Ø gradle对多工程的构建支持很出色，工程依赖是gradle的第一公民。
Ø gradle支持局部构建。
Ø 支持多方式依赖管理：包括从maven远程仓库、nexus私服、ivy仓库以及本地文件系统的jars或者dirs
Ø gradle是第一个构建集成工具（the first build integration tool），与ant、maven、ivy有良好的相容相关性。
Ø 轻松迁移：gradle适用于任何结构的工程（Gradle can adapt to any structure you have.）。你可以在同一个开发平台平行构建原工程和gradle工程。通常要求写相关测试，以保证开发的插件的相似性，这种迁移可以减少破坏性，尽可能的可靠。这也是重构的最佳实践。
Ø gradle的整体设计是以作为一种语言为导向的，而非成为一个严格死板的框架。
Ø 免费开源
gradle提供了什么
1.一种可切换的，像maven一样的基于约定的构建框架，却又从不锁住你（约定优于配置）
Switchable, build-by-convention frameworks a la Maven. But we never lock you in!
2. 强大的支持多工程的构建
3. 强大的依赖管理（基于Apache Ivy），提供最大的便利去构建你的工程
Language for dependency based programming
4. 全力支持已有的Maven或者Ivy仓库基础建设
5. 支持传递性依赖管理，在不需要远程仓库和pom.xml和ivy配置文件的前提下
6 基于groovy脚本构建，其build脚本使用groovy语言编写
7 具有广泛的领域模型支持你的构建A rich domain model for describing your build.
‘柒’ gradle scripts里面都有什么文件
gradle编译相关的脚本
‘捌’ 如何用gradle执行ionic build android
如何用gradle执行ionic build android –release的时候自动签名
假设android的platform和keystore已经有了，我们可以看到如下目录结构
其中release-signing.properties这个时候应该是没有的，现在我们新建一个release-signing.properties
storeFile=YiShangpu.keystore
key.store.password=your password
key.alias=YiShangpu
key.alias.password=your password
‘玖’ 如何在python脚本中嵌入gradle 命令
首先下载安装python，建议安装2.7版本以上，3.0版本以下，由于3.0版本以上不向下兼容，体验较差。
打开文本编辑器，将文件保存成 .py格式，editplus和notepad支持识别python语法。
脚本第一行一定要写上 #!usr/bin/python
表示该脚本文件是可执行python脚本
如果您的python目录不在usr/bin目录下，则替换成当前python执行程序的目录
编写完脚本之后注意调试、可以直接用editplus调试。调试方法可自行网络。脚本写完之后，打开CMD命令行，前提是python 已经被加入到环境变量中，如果没有加入到环境变量，请网络
在CMD命令行中，输入 “python” + “空格”，即 ”python “；
将已经写好的脚本文件拖拽到当前光标位置，然后敲回车运行即可
‘拾’ 运行与Gradle咕噜问题，怎么解决
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 17
buildToolsVersion "17"
defaultConfig {
minSdkVersion 8
targetSdkVersion 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.myConfigs
runProguard true
proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
}
}
/**
* 渠道打包（不同包名）
*/
proctFlavors {
qqqq {
applicationId = '包名'
}
hhhhh {
applicationId='包名'
}
}
}
/**
* .so文件的导入
*/
task NativeLibs(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 NativeLibs
}
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:version
compile '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 文件。