gradle中的build script詳解

目錄

• 簡介
• project和task
• 一個例子
• task詳細講解
  • task腳本
  • task依賴
  • 動態task
  • 默認task
  • build script的外部依賴

gradle中的build script詳解

簡介

build.gradle是gradle中很是重要的一個文件，由於它描述了gradle中能夠運行的任務，今天本文將會帶你們體驗一下如何建立一個build.gradle文件和如何編寫其中的內容。

project和task

gradle是一個構建工具，所謂構建工具就是經過既定的各類規則，將原代碼或者原文件經過必定的task處理事後，打包生成目標文件的步驟。

因此咱們在gradle中有兩個很是重要的概念，分別是項目和任務。

每個gradle的構建任務能夠包含一個或者多個項目，項目能夠有多種類型，好比是一個web項目或者一個java lib項目等。爲了實現project要完成的目標，須要定義一個個的task來輔助完成目標。

task主要用來執行特定的任務，好比編譯class文件，打包成jar，生成javadoc等等。

一個例子

接下來咱們使用一個具體的例子來說解一下，gradle究竟是怎麼用的。

首先咱們建立一個新的project目錄：

$ mkdir gradle-test
$ cd gradle-test

gradle提供了一個init方法，來方便的建立gradle項目的骨架，咱們用下看：

gradle init
Starting a Gradle Daemon (subsequent builds will be faster)

Select type of project to generate:
  1: basic
  2: application
  3: library
  4: Gradle plugin
Enter selection (default: basic) [1..4] 2

Select implementation language:
  1: C++
  2: Groovy
  3: Java
  4: Kotlin
  5: Scala
  6: Swift
Enter selection (default: Java) [1..6] 3

Split functionality across multiple subprojects?:
  1: no - only one application project
  2: yes - application and library projects
Enter selection (default: no - only one application project) [1..2] 1

Select build script DSL:
  1: Groovy
  2: Kotlin
Enter selection (default: Groovy) [1..2] 1

Select test framework:
  1: JUnit 4
  2: TestNG
  3: Spock
  4: JUnit Jupiter
Enter selection (default: JUnit 4) [1..4] 1

Project name (default: gradle-test):
Source package (default: gradle.test):

> Task :init
Get more help with your project: https://docs.gradle.org/6.7/samples/sample_building_java_applications.html

BUILD SUCCESSFUL in 45s
2 actionable tasks: 2 executed

按照你的須要，通過一系列的選擇以後，就能夠生成一個基本的gradle項目了。

咱們看下生成的文件和目錄：

.
├── app
│   ├── build.gradle
│   └── src
│       ├── main
│       │   ├── java
│       │   │   └── gradle
│       │   │       └── test
│       │   │           └── App.java
│       │   └── resources
│       └── test
│           ├── java
│           │   └── gradle
│           │       └── test
│           │           └── AppTest.java
│           └── resources
├── gradle
│   └── wrapper
│       ├── gradle-wrapper.jar
│       └── gradle-wrapper.properties
├── gradlew
├── gradlew.bat
└── settings.gradle

14 directories, 8 files

其中gradle-wrapper是幫你自動設置和安裝gradle的工具，同時它還提供了gradlew和gradlew.bat這兩個執行文件，用來執行gradle的任務。

咱們主要看其中的兩個配置文件，settings.gradle和build.gradle。

settings.gradle中配置的是gradle中要build的項目信息：

rootProject.name = 'gradle-test'
include('app')

上面的例子中，rootProject.name指定了項目的名字，include('app')表示須要引入一個叫作app的子項目，這個子項目中包含着實際的要打包的內容。

再看一下app中的build.gradle文件：

plugins {
    // Apply the application plugin to add support for building a CLI application in Java.
    id 'application'
}

repositories {
    // Use JCenter for resolving dependencies.
    jcenter()
}

dependencies {
    // Use JUnit test framework.
    testImplementation 'junit:junit:4.13'

    // This dependency is used by the application.
    implementation 'com.google.guava:guava:29.0-jre'
}

application {
    // Define the main class for the application.
    mainClass = 'gradle.test.App'
}

很簡單，指定了插件，倉庫地址，依賴包和應用程序的main class路徑。

一切準備好以後，咱們就能夠進行構建和運行了。

有兩種方式來運行，一種方式就是使用系統自帶的gradle命令，一種方式就是使用剛剛gradle爲你生成的gradlew。

gradle run

> Configure project :app
Repository ${repo.url} replaced by $REPOSITORY_URL .

> Task :app:run
Hello World!

gradle build

> Configure project :app
Repository ${repo.url} replaced by $REPOSITORY_URL .

BUILD SUCCESSFUL in 2s
7 actionable tasks: 6 executed, 1 up-to-date

你還能夠帶上 --scan 參數將build上傳到gradle scan中，獲得更加詳細的構建分析：

./gradlew build --scan

BUILD SUCCESSFUL in 0s
7 actionable tasks: 7 executed

Publishing a build scan to scans.gradle.com requires accepting the Gradle Terms of Service defined at https://gradle.com/terms-of-service.
Do you accept these terms? [yes, no] yes

Gradle Terms of Service accepted.

Publishing build scan...
https://gradle.com/s/5u4w3gxeurtd2

task詳細講解

上面的例子中，咱們使用的都是gradle默認的tasks，並無看到自定義task的使用，接下來咱們將會探討一下，如何在build.gradle編寫本身的task。

這裏咱們使用的groovy來編寫build.gradle，因此咱們能夠像運行代碼同樣來運行它。

task腳本

先建立一個很是簡單的task：

task hello {
    doLast {
        println 'Hello www.flydean.com!'
    }
}

上面定義了一個名叫hello的task，而且會在執行最後輸出 "Hello www.flydean.com!"。

咱們這樣運行：

gradle -q hello
Hello www.flydean.com!

-q的意思是悄悄的執行，將會忽略gradle自身的log信息。咱們把要執行的task名字寫在gradle後面就能夠了。

若是你熟悉ant命令的話，能夠看到gradle的task和ant很相似，不過更加的強大。

由於是groovy腳本，因此咱們能夠在其中執行代碼：

task upper {
    doLast {
        String someString = 'www.flydean.com'
        println "Original: $someString"
        println "Upper case: ${someString.toUpperCase()}"
    }
}

運行結果：

> gradle -q upper
Original: www.flydean.com
Upper case: WWW.FLYDEAN.COM

或者執行times操做：

task count {
    doLast {
        4.times { print "$it " }
    }
}

> gradle -q count
0 1 2 3

task依賴

gradle中的一個task能夠依賴其餘的task：

task hello {
    doLast {
        println 'Hello www.flydean.com!'
    }
}
task intro {
    dependsOn hello
    doLast {
        println "I'm flydean"
    }
}

上面兩個task的順序是無關的，能夠依賴的寫在前面，被依賴的寫在後面，或者反過來都成立。

動態task

除了靜態的task以外，咱們還能夠經過代碼來動態建立task：

4.times { counter ->
    task "task$counter" {
        doLast {
            println "I'm task number $counter"
        }
    }
}

> gradle -q task1
I'm task number 1

咱們還能夠將task看作成爲一個對象，調用gradle的api進行操做：

4.times { counter ->
    task "task$counter" {
        doLast {
            println "I'm task number $counter"
        }
    }
}
task0.dependsOn task2, task3

上面的例子中，咱們調用API手動建立了task之間的依賴關係：

> gradle -q task0
I'm task number 2
I'm task number 3
I'm task number 0

還能夠task之間的屬性調用：

task myTask {
    ext.myProperty = "www.flydean.com"
}

task printTaskProperties {
    doLast {
        println myTask.myProperty
    }
}

默認task

若是不想每次都在調用gradle命令的時候手動指定某個具體的task名字，咱們能夠使用defaultTasks：

defaultTasks 'clean', 'run'

task clean {
    doLast {
        println 'Default Cleaning!'
    }
}

task run {
    doLast {
        println 'Default Running!'
    }
}

task other {
    doLast {
        println "I'm not a default task!"
    }
}

上面的代碼執行gradle和gradle clean run是至關的。

build script的外部依賴

既然build script能夠用groovy代碼來編寫，那麼若是咱們想要在build script中使用外部的jar包怎麼辦呢？

這個時候，咱們能夠將外部依賴放到buildscript()方法中，後面的task就能夠使用引入的依賴了：

import org.apache.commons.codec.binary.Base64

buildscript {
    repositories {
        mavenCentral()
    }
    dependencies {
        classpath group: 'commons-codec', name: 'commons-codec', version: '1.2'
    }
}

task encode {
    doLast {
        def byte[] encodedString = new Base64().encode('hello world\n'.getBytes())
        println new String(encodedString)
    }
}

上面的例子中，encode使用了一個外部的依賴包Base64，這個依賴包是在buildscript方法中引入的。

本文已收錄於 http://www.flydean.com/gradle-build-script/

最通俗的解讀，最深入的乾貨，最簡潔的教程，衆多你不知道的小技巧等你來發現！

歡迎關注個人公衆號:「程序那些事」,懂技術，更懂你！