Gradle digest

task类型

• copy

  task copyFiles(type: Copy) {
      from 'resources'
      into 'target'
      include '**/*.xml', '**/*.txt', '**/*.properties'
  }
  

• jar

  apply plugin: 'java'
  task customJar(type: Jar) {
      manifest {
          attributes firstKey: 'firstValue', secondKey: 'secondValue'
      }
      archiveName = 'hello.jar'
      destinationDir = file("${buildDir}/jars")
      from sourceSets.main.classes
  }
  

• JavaExec 运行一个java类的main方法

  apply plugin: 'java'
  repositories {
      mavenCentral()
  }
  dependencies {
      runtime 'commons-codec:commons-codec:1.5'
  }
  task encode(type: JavaExec, dependsOn: classes) {
      main = 'org.gradle.example.commandline.MetaphoneEncoder'
      args = "The rain in Spain falls mainly in the plain".split().toList()
      classpath sourceSets.main.classesDir
      classpath configurations.runtime
  }
  

自定义task类型

• 在构建文件中定义

  task createDatabase(type: MySqlTask) {

  sql = 'CREATE DATABASE IF NOT EXISTS example'
  

  } 
  task createUser(type: MySqlTask, dependsOn: createDatabase) {

  sql = "GRANT ALL PRIVILEGES ON example.*
  TO exampleuser@localhost IDENTIFIED BY 'passw0rd'"
  

  } 
  task createTable(type: MySqlTask, dependsOn: createUser) {

  username = 'exampleuser'
  password = 'passw0rd'
  database = 'example'
  sql = 'CREATE TABLE IF NOT EXISTS users
  (id BIGINT PRIMARY KEY, username VARCHAR(100))'
  

  } 
  class MySqlTask extends DefaultTask {

  def hostname = 'localhost'
  def port = 3306
  def sql
  def database
  def username = 'root'
  def password = 'password'
  
  @TaskAction
  def runQuery() {
      def cmd
      if(database) {
          cmd = "mysql -u ${username} -p${password} -h ${hostname} -P ${port} ${database} -e "
      }
      else {
          cmd = "mysql -u ${username} -p${password} -h ${hostname} -P ${port} -e "
      }
  project.exec {
      commandLine = cmd.split().toList() + sql
  }
  

  }

• 在源码树中定义

  在构建文件中：

  task createDatabase(type: MySqlTask) {
      sql = 'CREATE DATABASE IF NOT EXISTS example'
  }
  task createUser(type: MySqlTask, dependsOn: createDatabase) {
      sql = "GRANT ALL PRIVILEGES ON example.* TO exampleuser@localhost IDENTIFIED BY 'passw0rd'"
  }
  task createTable(type: MySqlTask, dependsOn: createUser) {
      username = 'exampleuser'
      password = 'passw0rd'
      database = 'example'
      sql = 'CREATE TABLE IF NOT EXISTS users (id BIGINT PRIMARY KEY, username VARCHAR(100))'
  }
  

  在buildSrc文件夹中新建一个MySqlTask.groovy：

  import org.gradle.api.DefaultTask
  import org.gradle.api.tasks.TaskAction
  
  
  class MySqlTask extends DefaultTask {
      def hostname = 'localhost'
      def port = 3306
      def sql 
      def database
      def username = 'root'
      def password = password
  
      @TastAction
      def runQuery(){
          def cmd
          if(database){
              cmd = "mysql -u ${username} -p${password} -h ${hostname} -P ${port} ${database} -e"
          }else{
              cmd = "mysql -u ${username} -p${password} -h ${hostname} -P ${port} -e"
          }
          project.exec{
              commandLine = cmd.split().toList() + sql
          }
      }
  
  }
  

四个位置可以写你的自定义构建代码

1. 在构建文件中的task代码块中
2. 在buildSr文件夹中，此文件夹在.gradle文件同级
3. 将分散的构建文件写入到主构建文件中
4. 使用java或groovy写插件

http://my.oschina.net/zjzhai/blog/220028

 

Gradle中关于Project和Task的更多细节。

1. Project和Task

对于build.gradle配置文件，当运行Gradle <Task> 时，Gradle会为我们创建一个Project的对象，来映射build.gradle中的内容。其中呢，对于不属于任何Task范畴的代码，Gradle会创建一个Script类的对象，来执行这些代码；对于Task的定义，Gradle会创建Task对象，并将它会作为project的属性存在(实际上是通过getTaskName完成的)。ok，看一个简单的例子：

新建文件basic/build.gradle,然后加入如下部分代码：

println "the project name is $name" task hello << {     println "the current task name is $name"     println "hello world" }

当运行这个例子时，首先Gradle会创建一个Porject的对象，然后将它和build.gradle的内容映射起来。在这个例子中，project包括两部分： 1)可执行脚本定义

   按照之前提到的，可执行脚本的定义将直接被创建成对应的Script类的对象    在这个例子中，Script对应的部分就是第一行println的部分，然后执行的结果就是打印出 "the project name is basic"。    默认的，Project的名字是当前build.gradle所在目录的名字，在这个例子中，build.gradle放在basic目录下，因此，project的name也就是basic.

2)Task定义

  在这个例子中，Gradle将创建一个Task的实例，将其和定义的task内容关联起来。另外，按照之前所说的，当Gradle运行时，我们可以使用访问project属性的方式去访问它。

例如，这个例子中，我们可以使用project.hello来访问这个task。因为这个task hello已经成为project的一个属性，那么当我们使用gradle properties（properties是gradle自带的一个Task,它能列出当前project级别的所有属性，可以使用gradle tasks查看更多内建的Task）来获取project级别的属性列表时，也将会得到'hello'。

另外，有一点要注意的是，在这个例子中，task中使用的$name，并不是Project的name，它是当前Task的name，因为它被使用在Task的scope里。

执行Gradle hello，输出的结果将是：

current project name is test the current task name is hello hello world

http://www.blogjava.net/wldandan/archive/2012/07/05/382246.html

Gradle的Project从本质上说只是含有多个Task的容器，一个Task与Ant的Target相似，表示一个逻辑上的执行单元。我们可以通过很多种方式定义Task，所有的Task都存放在Project的TaskContainer中。

（1）调用Project的task()方法创建Task

在使用Gradle时，创建Task最常见的方式便是：

task hello1 << {
   println 'hello1'
}

这里的“<<”表示追加的意思，即向hello中加入执行过程。我们还可以使用doLast来达到同样的效果：

task hello2 {
   doLast {
      println 'hello2'}
}

另外，如果需要向Task的最前面加入执行过程，我们可以使用doFirst：

task hello3 {
   doLast {
      println 'hello3'}
}

在上面的3个例子中，Gradle的DSL向我们展示了一种非常自然的风格来创建Task，而事实上这些都只是一种内部DSL，也即必须符合groovy的语法要求。上面的task关键字实际上是一个方法调用，该方法属于Project。Project中存在多个重载的task()方法。和Ruby等动态语言一样，在调用groovy方法时，我们不用将参数放在括号里面。

以上我们自定义的3个Task都位于TaskContainer中，Project中的tasks属性即表示该TaskContainer。为此，我们可以新建一个Task来显示这些信息：

task showTasks {
   println tasks.class
   println tasks.size()
}

将以上4个Task放在同一个build.gradle中，再执行gradle showTasks，命令行输出如下：

...
class org.gradle.api.internal.tasks.DefaultTaskContainer_Decorated
4
...

上面的DefaultTaskContainer_Decorated表示tasks类型，而4表示该TaskContainer中包含有4个自定义的Task——包括showTasks本身。

http://www.tuicool.com/articles/Avy2Ir

13.1. The Gradle build language构建语言

Gradle提供了一种“领域专用语言”(domain specific language) 或者 DSL对构建进行描述。这种语言基于Groovy，并加入了其他特性使得描述更简单。

13.2. The Project API

在第七章Chapter 7, Java Quickstart 我们以apply() 方法为例做了描述。咦，这个方法哪来的？当时我们说脚本定义了工程，对于每一个工程Gradle会创建一个 Project 型的实例并将该对象实例和构建脚本进行关联。当构建脚本执行时会配置这个对象：

Getting help writing build scripts

嗨嗨别忘了构建脚本是Groovy代码，用的是Gradle API。而Project 接口就是你最先要了解的访问Gradle API的工具。所以要了解什么标签可用，就得去看Project 接口的文档.

• 脚本中调用的任何方法如果在基本中无定义，都委托给Project对象。

• 属性的访问同上。

咱们试着访问name属性看看 。

Example 13.1. Accessing property of the Project object

build.gradle

println name
println project.name

Output of gradle -q check

> gradle -q check
projectApi
projectApi

哇唔，俩println 语句都打出了同一个属性。前者是自动委托了Project对象，对于没在脚本里定义的属性施行。后者使用了工程命来关联Project对象。 如果你定义的属性和Project的成员一样了，那就必须使用工程名进行界定了

http://somefuture.iteye.com/blog/2009114

随便新建个目录(我这里建了一个名为builds的目录)，cd进去，新建一个build.gradle文件，以下示例都编辑在build.gradle中。

说明：> 后 跟gradle命令。 -q参数会关闭一些命令中的log信息，如 gradle -q hello

定义一个任务，并执行

task hello {     doLast {         println 'Hello world! admin'     } }

> gradle hello

定义一个快捷任务

task hello2 << {         println 'admin Hello world!'      }

> gradle hello2

<< 代表 doLast{}

使用Groovy 语言

task upper << {     String someString = 'mY_nAmE'     println "Original: " + someString      println "Upper case: " + someString.toUpperCase() }

> gradle upper

循环遍历

task foreach << {     10.times { println "the times is $it." } }

> gradle foreach

10.times，循环条件<10；$it 表示循环变量

http://blog.csdn.net/jjwwmlp456/article/details/41350413

A basic Java project  一个基础的java工程

使用java插件在build.gradle：

apply plugin: 'java'

 

Building the project 构建工程

这里使用gradle/samples/java/quickstart  示例工程。shell进该目录。

> gradle build

命令所 运行的任务有 (你可以使用gradle taskName 来单独运行以下的一种任务)： :compileJava :processResources :classes :jar :assemble :compileTestJava :processTestResources :testClasses :test :check :build

 

任务后提示 UP-TO-DATE 表示文件无更新，已为最新

任何执行成功后，会在当前目录下生成build目录，build目录下会生成classes和libs等目录

Intelli J 或 Android Studio 建立的工程的目录有：

  src/main/java/  source code  
src/test/java/   test source code  
src/main/resources/  will be include in the JAR file  
src/test/resources/          will be include in the classpath used to run the tests

 

其他一些 有用的任务： clean 清除build目录 < gradle clean

Deletes the build directory, removing all built files.  assemble 编译打jar包

< gradle assemble

:compileJava :processResources :classes :jar :assemble 会调用这五个task。编译，处理资源，生成字节码，生成jar包      

 

http://blog.csdn.net/jjwwmlp456/article/details/41379841