Gradle学习



目录[-]

• Gradle介绍
• gradle命令行创建项目
• 构建Java应用程序
• Gradle 任务
• 定义task
• 为task分配行为(｀action｀)
• 设置默认任务
• task的配置
• task的方法与属性
• DefaultTask包含的方法
• dependsOn(task) 设置依赖task
• doFirst(closure)
• doLast(closure)
• onlyIf(closure) 只有在onlyIf返回true时才运行task
• DefaultTask包含的属性
• 可以在任务中写Groovy代码
• 为任务分组
• 忽略任务
• 增量构建的任务
• task类型
• 自定义task类型
• 四个位置可以写你的自定义构建代码
• Gradle 守护进程
• Gradle的生命周期
• 项目的属性
• Gradle包装器
• 依赖管理
• Repository管理
• Gradle常用命令

Gradle介绍

Gradle是一种自动化构建工具。

其实，Gradle被设计为一种构建语言，而非一个严格的框架。Gradle的核心使用Java和Groovy语言实现，所以，你可使用Java或者Groovy语言来扩展Gradle。当然，你也可以使用Scala。

gradle命令行创建项目

gradle本身没有创建项目的命令。最好的解决方案就是使用第三方插件来实现。步骤：

1. 新你的项目的文件夹project
2. 进入文件项目文件夹添加文件build.gradle，并加入：
   apply from: 'http://www.tellurianring.com/projects/gradle-plugins/gradle-templates/1.3/apply.groovy'
3. 运行gradle initJavaProject

用到的第三方插件：gradle-templates :

以下就是它的API：

createGradlePlugin - Creates a new Gradle Plugin project in a new directory named after your project.
createGroovyClass - Creates a new Groovy class in the current project.
createGroovyProject - Creates a new Gradle Groovy project in a new directory named after your project.
createJavaClass - Creates a new Java class in the current project.
createJavaProject - Creates a new Gradle Java project in a new directory named after your project.
createScalaClass - Creates a new Scala class in the current project.
createScalaObject - Creates a new Scala object in the current project.
createScalaProject - Creates a new Gradle Scala project in a new directory named after your project.
createWebappProject - Creates a new Gradle Webapp project in a new directory named after your project.
initGradlePlugin - Initializes a new Gradle Plugin project in the current directory.
initGroovyProject - Initializes a new Gradle Groovy project in the current directory.
initJavaProject - Initializes a new Gradle Java project in the current directory.
initScalaProject - Initializes a new Gradle Scala project in the current directory.
initWebappProject - Initializes a new Gradle Webapp project in the current directory.

构建Java应用程序

1. 使用application插件:apply plugin: 'application'
2. 设置主函数:mainClassName = "WebTest"
3. 运行gradle run

Gradle 任务

定义task

task hello

为task分配行为(｀action｀)

task hello << {
    println "hello"
}

<<操作符代表task的doLast方法

task hello { 
    doLast {
        println "hello"
    }
}

还可以

def printTaskName = { task ->
    println "Running ${task.name}"
}

task 'five' {
    doFirst printTaskName
}

task 'two' << printTaskName

重复定义task的行为

task hello <<{
    println "hello"
}   

task world <<{
    println "world"
}

输出：

hello world

使用Action接口定义action

task first {
    doFirst (
        new Action(){
            void execute(task){
                println 'Running ${task.name}'
            }   
        }
    )
}

设置默认任务

defaultTasks 'first', 'second'

task first {
    doLast {
        println "I am first"
    }
}
task second {
    doFirst {
        println "I am second"
    }
}

在gradle命令后不加入任何任务名时，就会执行默认任务。

task的配置

task initializeDatabase
initializeDatabase << { println 'connect to database' }
initializeDatabase << { println 'update database schema' }
initializeDatabase { print 'configuring' }
initializeDatabase { println 'database connection' }

输出：

print 'configuring'
println 'database connection'
println 'connect to database'
println 'update database schema'

配置闭包将会在Gradle的配置期（configuration lifecycle phase）执行。

task的方法与属性

task其实是一个对象，它也会有方法和属性，同时，也会有类型。默认情况下，定义的task继承自DefaultTask。

DefaultTask包含的方法

dependsOn(task) 设置依赖task

// Declare that world depends on hello
// Preserves any previously defined dependencies as well
task loadTestData {
    dependsOn createSchema
}
// An alternate way to express the same dependency
task loadTestData {
    dependsOn << createSchema
}
// Do the same using single quotes (which are usually optional)
task loadTestData {
    dependsOn 'createSchema'
}
// Explicitly call the method on the task object
task loadTestData

loadTestData.dependsOn createSchema

// A shortcut for declaring dependencies
task loadTestData(dependsOn: createSchema)

还可以多重依赖

// Declare dependencies one at a time
task loadTestData {
    dependsOn << compileTestClasses
    dependsOn << createSchema
}
// Pass dependencies as a variable-length list
task world {
    dependsOn compileTestClasses, createSchema
}

// Explicitly call the method on the task object
task world
world.dependsOn compileTestClasses, createSchema

// A shortcut for dependencies only
// Note the Groovy list syntax
task world(dependsOn: [ compileTestClasses, createSchema ])

doFirst(closure)

注意同时定义两个doFirst方法时的输出

task setupDatabaseTests << {
    println 'load test data'
}
setupDatabaseTests.doFirst {
    println 'create database schema'
}
setupDatabaseTests.doFirst {
    println 'drop database schema'
}

$ gradle world
:setupDatabaseTests
drop database schema
create database schema
load test data

也可以这样写：

// Initial task definition (maybe not easily editable)
task setupDatabaseTests << {
    println 'load test data'
}
// Our changes to the task (in a place we can edit them)
setupDatabaseTests {
    doFirst {
        println 'create database schema'
    }
    doFirst {
        println 'drop database schema'
    }
}

doLast(closure)

task setupDatabaseTests << {
    println 'create database schema'
}
setupDatabaseTests.doLast {
    println 'load test data'
}
setupDatabaseTests.doLast {
    println 'update version table'
}

onlyIf(closure) 只有在onlyIf返回true时才运行task

task createSchema << {
    println 'create database schema'
}
task loadTestData(dependsOn: createSchema) << {
    println 'load test data'
}
loadTestData.onlyIf {
    System.properties['load.data'] == 'true'
}


$ build loadTestData
create database schema
:loadTestData SKIPPED
$ gradle -Dload.data=true loadTestData
:createSchema
create database schema
:loadTestData
load test data

DefaultTask包含的属性

• didWork

  apply plugin: 'java'
  task emailMe(dependsOn: compileJava) « {

  if(tasks.compileJava.didWork) {
      println 'SEND EMAIL ANNOUNCING SUCCESS'
  }
  

  }

• enabled

  task templates « {

  println 'process email templates'
  

  }
  task sendEmails(dependsOn: templates) « {

  println 'send emails'
  

  }
  sendEmails.enabled = false

• path，指此task的在构建文件中的路径

  task echoMyPath « {

  println "THIS TASK'S PATH IS ${path}"
  

  }

  $ gradle echoMyPath
  THIS TASK'S PATH IS :echoMyPath

  如果echoMyPath是子项目(subProject)下的一个task，那么它的路径将会是：:subProject:echoMyPath

• logger，实现的日志接口是：org.slf4j.Logger，同时有少量的日志级别添加。

  task logLevel « {

  def levels = ['DEBUG',
                  'INFO',
                  'LIFECYCLE',
                  'QUIET',
                  'WARN',
                  'ERROR']
  levels.each { level ->
      logging.level = level
      def logMessage = "SETTING LogLevel=${level}"
      logger.error logMessage
      logger.error '-' * logMessage.size()
      logger.debug 'DEBUG ENABLED'
      logger.info 'INFO ENABLED'
      logger.lifecycle 'LIFECYCLE ENABLED'
      logger.warn 'WARN ENABLED'
      logger.quiet 'QUIET ENABLED'
      logger.error 'ERROR ENABLED'
      println 'THIS IS println OUTPUT'
      logger.error ' '
  }
  

  }

• description

  task helloWorld(description: 'Says hello to the world') « {

  println 'hello, world'
  

  }

  task helloWorld « {

  println 'hello, world'
  

  }
  helloWorld {

  description = 'Says hello to the world'
  

  }
  // Another way to do it
  helloWorld.description = 'Says hello to the world'

• temporaryDir 临时目录

• Dynamic Properties 动态属性

  task copyFiles {

  // Find files from wherever, copy them
  // (then hardcode a list of files for illustration)
  fileManifest = [ 'data.csv', 'config.json' ]
  

  }
  task createArtifact(dependsOn: copyFiles) « {

  println "FILES IN MANIFEST: ${copyFiles.fileManifest}"
  

  }

  $ gradle -b dynamic.gradle createArtifact
  FILES IN MANIFEST: [data.csv, config.json]

可以在任务中写Groovy代码

为任务分组

def taskGroup = 'base'
task first2(description: 'Base task', group: taskGroup) << {
    println "I am first"
}
task second2(dependsOn: first2, description: 'Secondary task', group: taskGroup) << {
    println "I am second"
}

分组似乎只是用于gradle tasks时，显示更好看。因为同一组的任务分显示在一组里。

忽略任务

• 使用onlyIf断言
  每一个任务都会有一个onlyIf方法，如果方法返回true则执行任务，否则跳过。

  task longrunning {
      onlyIf { task ->
          def now = Calendar.instance
          def weekDay = now[DAY_OF_WEEK]
          def weekDayInWeekend = weekDay in [SATURDAY, SUNDAY]
          return weekDayInWeekend
      }
      doLast {
          println "Do long running stuff"
      }
  }
  

• 实现Spec()方法

  def file = new File('data.sample')
  task 'handleFile' << {
      println "Work with file ${file.name}"
  }
  handleFile.onlyIf(new Spec() {
      boolean isSatisfiedBy(task) {
          file.exists()
  
      }
  })
  

• 抛出异常StopExecutionException

  def printTaskName = { task ->
      println "Running ${task.name}"
  }
  task first << printTaskName
  first.doFirst {
      def today = Calendar.instance
      def workingHours = today[Calendar.HOUR_OF_DAY] in 8..17
      if (workingHours) {
          throw new StopExecutionException()
      }
  }
  task second(dependsOn: 'first') << printTaskName
  

• 设置任务有效或者失效

  task 'listDirectory' {
      def dir = new File('assemble')
      enabled = dir.exists()
      doLast {
          println "List directory contents: ${dir.listFiles().join(',')}"
      }
  }
  

• 使用命令行参数 -x

  gradle third -x second

增量构建的任务

在source发生变化时才执行任务

task convert  {
    def source = new File('source.xml')
    def output = new File('output.txt')
    // Define input file
    inputs.file source
    // Define output file
    outputs.file output
    doLast {
        def xml = new XmlSlurper().parse(source)
        output.withPrintWriter { writer ->
            xml.person.each { person ->
                writer.println "${person.name},${person.email}"
            }
        }
        println "Converted ${source.name} to ${output.name}"

    } 
}

或者

task createVersionDir {
    def outputDir = new File('output')
    // If project.version changes then the
    // task is no longer up-to-date
    inputs.property 'version', project.version
    outputs.dir outputDir
    doLast {
        println "Making directory ${outputDir.name}"
        mkdir outputDir
    }
}

task convertFiles {
    // Define multiple files to be checked as inputs.
    inputs.files 'input/input1.xml', 'input/input2.xml'

    // Or use inputs.dir 'input' to check a complete directory.
    // Use upToDateWhen method to define predicate.
    outputs.upToDateWhen {
        // If output directory contains any file which name
        // starts with output and has the txt extension,
        // then the task is up-to-date.
        new File('output').listFiles().any {
            it.name ==~ /output.*\.txt$/ 
        }
    }
    doLast {
        println "Running convertFiles"
    }
}

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写插件

Gradle 守护进程

Gradle需要运行在一个Java虚拟机中，每一次执行gradle命令就意味着一个新的Java虚拟机被启动，然后加载Gradle类和库，最后执行构建。这样，构建起来会花费大量的时间在Java虚拟机的启动与关闭。

通过Gradle 守护进程，只需要启动一次Java虚拟机，之后就可以再利用，无需再次重启Java虚拟机。这样就达到缩短构建时间的目的。

方法是在执行gradle命令时加上--daemon参数，或者-m参数。中止Gradle守护进程的方法是执行gradle -stop命令。

如果希望能每一次的构建都使用Gradle的守护进程进行，那么可以通过设置Gradle的环境变量来达到目的。方法是添加GRADLE_OPTS="-Dorg.gradle.daemon=true"｀到系统环境变量中。

Gradle的生命周期

1. initialization(初始化)
   在多项目的构建中，决定哪个项目是主项目
2. configuration(配置)
   将所有的task对象装配到一个叫做DAG（for directed acyclic graph）的对象模型中
3. execution(运行)
   根据task之间的依赖执行task

项目的属性

• 项目中默认的属性

  version = '1.0'
  group = 'Sample'
  description = 'Sample build file to show project properties'
  task defaultProperties « {

  println "Project: $project"
  println "Name: $name"
  println "Path: $path"
  println "Project directory: $projectDir"
  println "Build directory: $buildDir"
  println "Version: $version"
  println "Group: $project.group"
  println "Description: $project.description"
  println "AntBuilder: $ant"
  println "customProperty: $customProperty"
  println "customProperty1: $customProperty1"
  println "customProperty2: $customProperty2"
  

  }

• 在项目构建脚本中自定义项目属性

  ext.customProperty = 'customProperty'

  ext {

  customProperty1 = "customProperty1"
  customProperty2 = "customProperty2"
  

  }

• 通过命令行设置项目属性

  gradle -Pversion=1.1 -PcustomProperty=custom showProperties

• 通过系统属性设置项目属性

  gradle -Dorg.gradle.project.version=2.0 -Dorg.gradle.project.customProperty=custom showProperties

• 通过引用外部配置文件设置项目属性
  在项目目录下新建一个纯文本文件：gradle.properties。在此文件中写入键值对，就可以了。

• 从其它构建文件读取配置信息

  • build.gradle
    apply from: 'other.gradle'
  • other.gradle
    println “configuring $project”
    task hello « {

    println 'hello from other script'
    

    }

• 判断项目中是否有设置某个属性

  hasProperty('propertyName')

Gradle包装器

可以在机器中没有gradle的情况下，进行构建

依赖管理

在Gradle的构建文件中，可以将一组依赖定义在一个配置里。每一个配置都有一个名字，同时，它可以继承自其它配置。

每一个Gradle构建文件都有一个ConfigurationContainer对象。可以通过project属性访问这个对象。ConfigurationContainer下可以定义一批配置，但它们至少有一个名称。

configurations {
    commonsLib {
        description = 'Common libraries'
    }
    mainLib {
        description = 'Main libraries'
        extendsFrom commonsLib
    }
}
println configurations['mainLib'].name
println configurations.commonsLib.name


//取消间接依赖下载
dependencies {
    // Configure transitive property with closure.
    compile('org.slf4j:slf4j-simple:1.6.4') {
        transitive = false
    }
    // Or we can use the transitive property
    // as method argument.
    compile group: 'org.slf4j', name: 'slf4j-simple', version:
    '1.6.4', transitive: false
}

//排除某个间接依赖
dependencies {
    // Configure transitive property with closure.
    compile('org.slf4j:slf4j-simple:1.6.4') {
        exclude 'org.slf4j:slf4j-api'
    }
}

//当依赖需要不同版本的jdk时
dependencies {
    // Use artifact-only notation with @ symbol
    // together with classifier jdk16.
    compile('sample:simple:1.0:jdk16@jar')
    // Or we can use the classifier property
    // as method argument.
    compile group: 'sample', name: 'simple', version: '1.0',classifier: 'jdk16'
}

//依赖其它子项目
dependencies {
    compile project(':projectA')
    compile project(':projectB') {
    c   onfiguration = 'compile'
    }
}

//依赖文件或文件夹
dependencies {
    compile files('spring-core.jar', 'spring-aap.jar')
    compile fileTree(dir: 'deps', include: '*.jar')
}

Repository管理

repository支持各种仓库，包括远程和本地的。

repositories {
    mavenLocal()
    mavenCentral()
    maven {
        // Name is optional. If not set url property is used
        name = 'Main Maven repository'
        url = 'http://intranet/repo'
    }
    mavenRepo(name: 'Snapshot repository', url: 'http://intranet/snapshots')

    //XML描述文件和jar包不在同一个地方的时候的定义方式:
    maven {
        url: 'http://intranet/mvn'
        artifactUrls 'http://intranet/jars'
        artifactUrls 'http://intranet/snapshot-jars'
    }

    //有权限控制的仓库
    maven(name: 'Secured repository') {
        credentials {
            username = 'username'
            password = 'password'
        }
        url = 'http://intranet/repo'
    }


    //本地仓库
    repositories {
        flatDir(dir: '../lib', name: 'libs directory')
        flatDir {
            dirs '../project-files', '/volumes/shared-libs'
            name = 'All dependency directories'
        }
    }

}

Gradle常用命令

gradle tasks --all 查看所有的可执行的任务

gradle -m 查看可执行的任务

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