build.gradle模板文件

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的外部依赖

在编写Gradle脚本的时候，在build.gradle文件中经常看到这样的代码：

buildScript {
    repositories {
         mavenCentral()
    }
}

repositories {
     mavenCentral()
}

这样子很容易让人奇怪，为什么repositories要声明两次呢？buildscript代码块中的声明与下半部分声明有什么不同？

其实答案非常简单。buildscript中的声明是gradle脚本自身需要使用的资源。可以声明的资源包括依赖项、第三方插件、maven仓库地址等。而在build.gradle文件中直接声明的依赖项、仓库地址等信息是项目自身需要的资源。

gradle是由groovy语言编写的，支持groovy语法，可以灵活的使用已有的各种ant插件、基于jvm的类库，这也是它比maven、ant等构建脚本强大的原因。虽然gradle支持开箱即用，但是如果你想在脚本中使用一些第三方的插件、类库等，就需要自己手动添加对这些插件、类库的引用。而这些插件、类库又不是直接服务于项目的，而是支持其它build脚本的运行。所以你应当将这部分的引用放置在buildscript代码块中。gradle在执行脚本时，会优先执行buildscript代码块中的内容，然后才会执行剩余的build脚本。
举个例子，假设我们要编写一个task，用于解析csv文件并输出其内容。虽然我们可以使用gradle编写解析csv文件的代码，但其实apache有个库已经实现了一个解析csv文件的库供我们直接使用。我们如果想要使用这个库，需要在gradle.build文件中加入对该库的引用。

buildscript {
    repositories {
        mavenLocal()
        mavenCentral()
    }

    dependencies {
        classpath 'org.apache.commons:commons-csv:1.0'
    }
}

import org.apache.commons.csv.*

task printCSV() {
    doLast {
        def records = CSVFormat.EXCEL.parse(new FileReader('config/sample.csv'))
        for (item in records) {
            print item.get(0) + ' '
            println item.get(1)
        }

    }
}

buildscript代码块中的repositories和dependencies的使用方式与直接在build.gradle文件中的使用方式几乎完全一样。唯一不同之处是在buildscript代码块中你可以对dependencies使用classpath声明。该classpath声明说明了在执行其余的build脚本时，class loader可以使用这些你提供的依赖项。这也正是我们使用buildscript代码块的目的。

而如果你的项目中需要使用该类库的话，就需要定义在buildscript代码块之外的dependencies代码块中。所以有可能会看到在build.gradle中出现以下代码：

repositories {
    mavenLocal()
    mavenCentral()
}

dependencies {
    compile 'org.springframework.ws:spring-ws-core:2.2.0.RELEASE',
            'org.apache.commons:commons-csv:1.0'
}


buildscript {
    repositories {
        mavenLocal()
        mavenCentral()
    }

    dependencies {
        classpath 'org.apache.commons:commons-csv:1.0'
    }
}

import org.apache.commons.csv.*

task printCSV() {
    doLast {
        def records = CSVFormat.EXCEL.parse(new FileReader('config/sample.csv'))
        for (item in records) {
            print item.get(0) + ' '
            println item.get(1)
        }

    }
}

示例2：

既然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
'.getBytes())
        println new String(encodedString)
    }
}

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

首先是一个项目包含group、name、version 。

1、settings.gradle

settings.gradle是用来管理多项目的，里面包含了项目的name

/**
 * rootProject.name 项目名称
 * include 模块名称
 */
rootProject.name = 'micro-service-framework'
include 'framework-base'
include 'framework-web'
include 'framework-redis'

2、build.gradle

// buildscript 代码块中脚本优先执行
buildscript {
　　// ext 用于定义动态属性
    ext {
        //spring boot 版本
        bootVersion = '2.0.6.RELEASE'
    }
　　// 自定义 Thymeleaf 和 Thymeleaf Layout Dialect 的版本
　　ext['thymeleaf.version'] = '3.0.3.RELEASE'
　　ext['thymeleaf-layout-dialect.version'] = '2.2.0'

　　// 自定义 Hibernate 的版本
　　ext['hibernate.version'] = '5.2.8.Final'


 
    //私服地址，这个地址适用于gradle自身，比如删除，下面的springboot插件就会找不到
    repositories {
        mavenCentral()
        maven { url 'http://maven.aliyun.com/nexus/content/groups/public/' }
            maven {
        url 'https://nexus.xxx.net/repository/maven-public/'
        credentials {
            username = "zhanghao"
            password = "mima"
        }
    }
    }
 
    // 依赖关系
    dependencies {
        //classpath 声明说明了在执行其余的脚本时，ClassLoader 可以使用这些依赖项----springboot gradle插件配置
        classpath("org.springframework.boot:spring-boot-gradle-plugin:${bootVersion}")
    }
}
 
 
allprojects {
    //导入使用的插件
    apply plugin: 'java'
    apply plugin: 'maven'
    //如果导入该插件，你需要指定main class，否则不能打包
    //apply plugin: 'org.springframework.boot'
    apply plugin: 'io.spring.dependency-management'
    //这个插件用于发布jar包到私服
    apply plugin: 'maven-publish'
 
    //jdk编译版本
    sourceCompatibility = 1.8
 
    //jar包的group ，version配置
    group 'net.178le.micro'
    version '0.0.1-SNAPSHOT'
 
    //私服地址，
    repositories {
        maven { url 'http://maven.aliyun.com/nexus/content/groups/public/' }
    }
 
    /**
     * 导入了springboot,spring cloud的pom文件，能够免去自己管理版本
     * PS: 在Spring官网指导上面有另外一种配置，那种配置需要配置main class，一会说明
     */
    dependencyManagement {
        imports {
            mavenBom "org.springframework.boot:spring-boot-starter-parent:${bootVersion}"
            mavenBom "org.springframework.cloud:spring-cloud-dependencies:Finchley.SR2"
        }
    }
 
 
    //私服发布配置
    publishing {
        publications {
            maven(MavenPublication) {
                //指定group/artifact/version信息，可以不填。默认使用项目group/name/version作为groupId/artifactId/version
                groupId = project.group
                artifactId = project.name
                version = project.version
                //如果是war包填写components.web，如果是jar包填写components.java
                from components.java
 
                //配置上传源码
                artifact sourceJar {
                    classifier "src"
                }
 
            }
        }
        repositories {
            maven {
                def releasesUrl = "http://你的私服ip:8081/repository/maven-releases/"
                def snapshotsUrl = "http://你的私服ip:8081/repository/maven-snapshots/"
                url = version.endsWith('SNAPSHOT') ? snapshotsUrl : releasesUrl
                credentials {
                    username = 'admin'
                    password = 'admin123'
                }
            }
        }
    }
 
}
 
//这里的配置对子项目生效
subprojects {
 
    dependencies {
        testCompile("org.springframework.boot:spring-boot-starter-test")
        compile("com.google.guava:guava:28.0-jre")
    }
}
 
//打包源码
task sourceJar(type: Jar) {
    from sourceSets.main.allJava
}

说明：

apply：是应用的插件

dependencies：是用于声明这个项目依赖于哪些jar

在处理依赖时分：

complile（编译时）
runtime（运行时）
testCompile（测试编译时）
testRuntime（测试运行时）

repositories：是一个仓库gradle会根据从上到下的顺序依次去仓库中寻找jar

这里可以进行配置，其中mavenLocal()表示使用本地maven仓库；mavenCentral()使用maven中心仓库。使用固定的地址，这里可以使用阿里云（maven {url 'http://maven.aliyun.com/nexus/content/groups/public/'}）的镜像下载速度会快一些，然后也可以使用公司内部的私服地址。

buildscript：buildscript代码块中的repositories和dependencies的使用方式与直接在build.gradle文件中的使用方式几乎完全一样，不同之处是

在buildscript代码块中你可以对dependencies使用classpath声明。该classpath声明说明了在执行其余的build脚本时，class loader可以使用这些你提供的依赖项。这也正是我们使用buildscript代码块的目的。

而如果你的项目中需要使用该类库的话，就需要定义在buildscript代码块之外的dependencies代码块中。

项目依赖：

dependencies {
    //依赖framework-base
    compile project(':framework-base')
    compile('org.springframework.boot:spring-boot-starter-data-redis')
}

gradle几个命令：

gradle cleanEclipse eclipse

gradle eclipse

gradle dependencies

gradle调试

在命令后面增加--stacktrace，可查看详细的错误信息

例如：

D:space2021gateway2-starter>gradle clean publish --stacktrace

错误

错误1：Cannot upload checksum for module-maven-metadata.xml. Remote repository doesn't support sha-512

Cannot upload checksum for module-maven-metadata.xml. Remote repository doesn't support sha-512. Error: Could not PUT 'https://xxxxx/repository/maven-snapshots/com/transsne
way2-starter/maven-metadata.xml.sha512'. Received status code 400 from server: Invalid path for a Maven 2 repository

two things at play here:

First a copy/paste mistake in the nightly version. Please use 6.0.1-20191115103811+0000 as the version, or https://services.gradle.org/distributions-snapshots/gradle-6.0.1-20191115103811+0000-bin.zip for the gradle-wrapper.properties
The instructions need to be corrected:
- Adding -Dorg.gradle.internal.publish.checksums.insecure=true on the CLI
- Adding systemProp.org.gradle.internal.publish.checksums.insecure=true to gradle.properties

https://github.com/gradle/gradle/issues/11308

我的解决办法是在项目的根目录下，加了一个gradle.properties文件

systemProp.org.gradle.internal.publish.checksums.insecure=true

错误2：解决Maven 报 Return code is: 400 , ReasonPhrase:Repository version policy: SNAPSHOT does not allow vers...

在做契约测试的项目中，想把契约测试的stub放在独立的目录下，

在nexus上创建Privileges（format=maven2）的contract-test，

maven2 Version pollcy有3个选择项：Release、Snapshot、mixed

maven2 Layout pollcy：Strlct（严格的）、Permissive（松散的）

选择Permissive后，错误解决。

参考：https://www.jianshu.com/p/630206347112

相关阅读:
JavaScript和DOM
CSS补充以及后台页面布局
 HTML标签和CSS基础
 基于SQLAlchemy实现的堡垒机
 PymySQL
SQLAlchemy
负数取模
 list
算法(3)
python初识(3)
原文地址：https://www.cnblogs.com/duanxz/p/3738541.html