第一章：Gradle 日志信息

1.1 概述

  • 在进行项目开发的过程之中，所有重要的数据内容一般都需要通过日志的形式进行输出，既然 Gradle 是以 Groovy 语言编写的可编程的构建工具，那么在进行每一个任务处理的时候也可以进行日志的配置，同时在 Gradle 内部直接提供有各种日志的组件。

1.2 日志输出

  • 所有的日志都是有日志等级的： | 等级 | 描述 | | —- | —- | | ERROR | 错误消息 | | QUIET | 重要消息信息 | | WARN | 警告信息 | | LIFECYCLE | 进度消息信息 | | INFO | 信息消息 | | DEBUG | 调试信息 |
  • 使用不同的日志等级实现日志信息的打印，修改 build.gradle 文件：
  1. task helloTask {
  2.     doFirst {
  3.         logger.log(LogLevel.ERROR,'【ERROR】这是一个 ERROR 级别日志信息')
  4.         logger.quiet('【QUIET】这是一个 QUIET 级别日志信息')
  5.         logger.info('【INFO】这是一个 INFO 级别日志信息')
  6.         logger.log(LogLevel.WARN,'【WARN】这是一个 WARN 级别日志信息')
  7.         logger.debug('【DEBUG】这是一个 DEBUG 级别日志信息')
  8.         logger.lifecycle('【LIFE_CYCLE】这是一个 LIFE_CYCLE 级别日志信息')
  9.     }
  10. }
  • 程序执行命令：
  1. gradle helloTask
  • 程序执行结果：
  1. 14:20:01: 正在执行 'helloTask'…
  4. > Task :helloTask
  5. 【QUIET】这是一个 QUIET 级别日志信息
  6. 【WARN】这是一个 WARN 级别日志信息
  7. 【LIFE_CYCLE】这是一个 LIFE_CYCLE 级别日志信息
  9. BUILD SUCCESSFUL in 58ms
  10. 1 actionable task: 1 executed
  11. 【ERROR】这是一个 ERROR 级别日志信息
  12. 14:20:02: 执行完成 'helloTask'。
  • 这个时候日志的确是提供了，但是默认情况下执行的任务并不会触发所有的日志输出操作，如果要想获得指定类型的日志信息，那么就需要在任务执行的时候进行配置了。

1.3 日志控制

  • 对于不同级别的日志，需要通过任务执行的时候配置不同的日志等级才可以实现输出，对于日志等级有如下的几个配置项： | 选项 | 输出日志级别 | | —- | —- | | 没有日志选项 | LIFECYCLE 或更高 | | -q 或 —quiet | QUIET 或更高 | | -w 或 —warn | WARN 或更高 | | -i 或 —info | INFO 或更高 | | -d 或 —debug | DEBUG 或更高 |

  • 对于所有的日志，肯定要设置输出级别才能准确获取相应的日志信息。

  • 示例：使用 debug 日志范围

  • 程序执行命令： 
  1. gradle helloTask --debug
  • 程序执行结果：
  1. 2021-12-27T14:26:58.616+0800 [QUIET] [org.gradle.api.Task] 【QUIET】这是一个 QUIET 级别日志信息
  2. 2021-12-27T14:26:58.616+0800 [INFO] [org.gradle.api.Task] 【INFO】这是一个 INFO 级别日志信息
  3. 2021-12-27T14:26:58.616+0800 [WARN] [org.gradle.api.Task] 【WARN】这是一个 WARN 级别日志信息
  4. 2021-12-27T14:26:58.616+0800 [DEBUG] [org.gradle.api.Task] 【DEBUG】这是一个 DEBUG 级别日志信息
  5. 2021-12-27T14:26:58.616+0800 [LIFECYCLE] [org.gradle.api.Task] 【LIFE_CYCLE】这是一个 LIFE_CYCLE 级别日志信息

第二章：Gradle 项目源代码打包

2.1 概述

  • 对于任何一个项目来说，除了需要将核心的功能程序（编译后的）进行打包处理之外，实际上还需要考虑的就是开源项目中的源代码的打包操作，对于源代码的打包操作，需要单独配置有一个 Gradle 任务才可以实现。

2.2 源代码任务

  • 如果要想进行源代码的打包，那么需要定义个新的任务，但是这个任务需要继承一个 jar 已有的任务，修改 build.gradle 文件：
  1. // 最终生成的 jar 文件名称：baseName-version-classifier.extension
  2. task sourceJar(type: Jar) { // 定义一个源代码的打包任务
  3.     archiveBaseName.set 'gradle-01' // 生成 jar 文件的名称
  4.     archiveVersion.set '1.0.0' // 定义项目打包版本
  5.     archiveClassifier.set 'sources' // 文件的分类
  6.     from sourceSets.main.allSource // 所有源代码的读取路径
  7.     exclude(['**/*.xml', '**/*.properties']) // 排除配置文件，可选
  8.     destinationDirectory.file("$buildDir/source-jar") // 目标存储路径
  9.     manifest {
  10.         attributes 'packageName': 'com.github.fairy.era',
  11.                 'Built-By': '许大仙',
  12.                 'Built-date': new Date().format('yyyy-MM-dd HH:mm:ss'),
  13.                 'Manifest-Version': archiveVersion
  14.     }
  15. }
  • 完整的 build.gradle 文件：
  1. plugins {
  2.     id 'java' // 配置的是一个 Java 插件（Java 项目）
  3.     id 'java-library'
  4. }
  6. ext {
  7.     jdkVersion = JavaVersion.VERSION_1_8 // 传统的 JDK 版本都是需要自己编写字符串的，而 Gradle 中提供了这样的操作
  8. }
  10. apply from: 'dependencies.gradle' // 引入所有的依赖文件
  12. configurations { // 进行依赖的配置
  13.     implementation {
  14.         canBeConsumed = true
  15.         canBeResolved = true
  16.     }
  17. }
  19. group 'com.github.fairy.era' // 组织名称
  20. version '1.0' // 项目版本
  22. // 定义一个公共的变量描述当前使用的 JDK 版本
  23. sourceCompatibility = jdkVersion
  24. targetCompatibility = jdkVersion
  26. repositories { // 仓库配置
  27.     mavenCentral()
  28. }
  30. dependencies { // 依赖管理
  31. //    compile gradleApi()
  32.     /* junit 5 */
  33.     testImplementation( // 如果有多个依赖，使用 , 隔开
  34.             libraries.'junit-jupiter'
  35.     )
  36.     /* druid */
  37.     implementation( // 如果有多个依赖，使用 , 隔开
  38.             libraries.'druid'
  39.     )
  40. }
  42. tasks.withType(JavaCompile) { // 针对程序编译的任务进行配置
  43.     options.encoding = "UTF-8"
  44. }
  46. def mainClassName = 'com.github.fairy.era.GradleMain' // 程序的主类名称
  48. jar {
  49.     archivesBaseName = 'gradle' // 生成的 jar 文件名称，如果不写此名称则使用项目名称
  50.     manifestContentCharset = 'UTF-8' // 设置整个文件的编码
  51.     metadataCharset = 'UTF-8' // 元数据设置编码
  52.     manifest {
  53.         attributes 'Manifest-Version': getArchiveVersion().getOrNull(), // 程序版本号
  54.                 'Main-Class': "${mainClassName}",// 程序主类名称
  55.                 'Implementation-Title': 'hello-gradle',// 程序主类名称
  56.                 'Implementation-Version': archiveVersion // 版本编号
  57.     }
  58.     into('lib') { // 将程序锁需要的第三方组件包配置到 lib 目录之中
  59.         from configurations.compileClasspath
  60.     }
  61. }
  63. test { // 进行测试任务的配置
  64.     useJUnitPlatform() // 使用 Junit 平台
  65. }
  67. sourceSets { // 建立源代码的目录集合
  68.     main {
  69.         java {
  70.             srcDirs = ['src/main/java']
  71.         }
  72.         resources {
  73.             srcDirs = ['src/main/resources', 'src/main/config']
  74.         }
  75.     }
  76. }
  78. // 最终生成的 jar 文件名称：baseName-version-classifier.extension
  79. task sourceJar(type: Jar) { // 定义一个源代码的打包任务
  80.     archiveBaseName.set 'gradle-01' // 生成 jar 文件的名称
  81.     archiveVersion.set '1.0.0' // 定义项目打包版本
  82.     archiveClassifier.set 'sources' // 文件的分类
  83.     from sourceSets.main.allSource // 所有源代码的读取路径
  84.     exclude(['**/*.xml', '**/*.properties']) // 排除配置文件，可选
  85.     destinationDirectory.file("$buildDir/source-jar") // 目标存储路径
  86.     manifest {
  87.         attributes 'packageName': 'com.github.fairy.era',
  88.                 'Built-By': '许大仙',
  89.                 'Built-date': new Date().format('yyyy-MM-dd HH:mm:ss'),
  90.                 'Manifest-Version': archiveVersion
  91.     }
  92. }

2.3 打包处理

  • 既然此时已经明确的定义一个打包任务，那么就可以直接通过此任务的执行来实现源代码包的生成。
  • 程序执行命令：
  1. gradle sourceJar
  • 程序执行结果：

1.png

2.4 打包时机

  • 当前的操作虽然可以编写任务实现源代码的打包处理操作，但是有一个问题：通常是在程序最终编译的时候才进行打包处理，如果按照以上的方式单独定义一个新的任务，则意味着需要在整个程序之中单独配置任务，能够将这些任务合并在一起？
  • 修改 build.gradle 文件： 
  1. task sourceJar(type: Jar,dependsOn: classes) { // 定义一个源代码的打包任务，并依赖于 classes 这种 Gradle 内置的任务
  2.     archiveClassifier.set 'sources' // 文件的分类
  3.     from sourceSets.main.allSource // 所有源代码的读取路径
  4. }

2.5 命令整合

  • 以上的任务仅仅是对已有的任务做了一个扩展，但是需要注意的是，毕竟现在的需求是将整个源代码的操作放在 build 之中，所以还需要进行一个额外的配置，修改 build.gradle 文件：
  1. // 最终生成的 jar 文件名称：baseName-version-classifier.extension
  2. task sourceJar(type: Jar,dependsOn: classes) { // 定义一个源代码的打包任务，并依赖于 classes 这种 Gradle 内置的任务
  3.     archiveClassifier.set 'sources' // 文件的分类
  4.     from sourceSets.main.allSource // 所有源代码的读取路径
  5. }
  7. artifacts { // 最终的打包操作任务
  8.     archives sourceJar
  9. }
  • 完整的 build.gradle 文件：
  1. plugins {
  2.     id 'java' // 配置的是一个 Java 插件（Java 项目）
  3.     id 'java-library'
  4. }
  6. ext {
  7.     jdkVersion = JavaVersion.VERSION_1_8 // 传统的 JDK 版本都是需要自己编写字符串的，而 Gradle 中提供了这样的操作
  8. }
  10. apply from: 'dependencies.gradle' // 引入所有的依赖文件
  12. configurations { // 进行依赖的配置
  13.     implementation {
  14.         canBeConsumed = true
  15.         canBeResolved = true
  16.     }
  17. }
  19. group 'com.github.fairy.era' // 组织名称
  20. version '1.0' // 项目版本
  22. // 定义一个公共的变量描述当前使用的 JDK 版本
  23. sourceCompatibility = jdkVersion
  24. targetCompatibility = jdkVersion
  26. repositories { // 仓库配置
  27.     mavenCentral()
  28. }
  30. dependencies { // 依赖管理
  31. //    compile gradleApi()
  32.     /* junit 5 */
  33.     testImplementation( // 如果有多个依赖，使用 , 隔开
  34.             libraries.'junit-jupiter'
  35.     )
  36.     /* druid */
  37.     implementation( // 如果有多个依赖，使用 , 隔开
  38.             libraries.'druid'
  39.     )
  40. }
  42. tasks.withType(JavaCompile) { // 针对程序编译的任务进行配置
  43.     options.encoding = "UTF-8"
  44. }
  46. def mainClassName = 'com.github.fairy.era.GradleMain' // 程序的主类名称
  48. jar {
  49.     archivesBaseName = 'gradle' // 生成的 jar 文件名称，如果不写此名称则使用项目名称
  50.     manifestContentCharset = 'UTF-8' // 设置整个文件的编码
  51.     metadataCharset = 'UTF-8' // 元数据设置编码
  52.     manifest {
  53.         attributes 'Manifest-Version': getArchiveVersion().getOrNull(), // 程序版本号
  54.                 'Main-Class': "${mainClassName}",// 程序主类名称
  55.                 'Implementation-Title': 'hello-gradle',// 程序主类名称
  56.                 'Implementation-Version': archiveVersion // 版本编号
  57.     }
  58.     into('lib') { // 将程序锁需要的第三方组件包配置到 lib 目录之中
  59.         from configurations.compileClasspath
  60.     }
  61. }
  63. test { // 进行测试任务的配置
  64.     useJUnitPlatform() // 使用 Junit 平台
  65. }
  67. sourceSets { // 建立源代码的目录集合
  68.     main {
  69.         java {
  70.             srcDirs = ['src/main/java']
  71.         }
  72.         resources {
  73.             srcDirs = ['src/main/resources', 'src/main/config']
  74.         }
  75.     }
  76. }
  78. // 最终生成的 jar 文件名称：baseName-version-classifier.extension
  79. task sourceJar(type: Jar,dependsOn: classes) { // 定义一个源代码的打包任务，并依赖于 classes 这种 Gradle 内置的任务
  80.     archiveClassifier.set 'sources' // 文件的分类
  81.     from sourceSets.main.allSource // 所有源代码的读取路径
  82. }
  84. artifacts { // 最终的打包操作任务
  85.     archives sourceJar
  86. }
  • 程序执行命令：
  1. gradle clean build -x test
  • 程序执行结果：

2.png

第三章：Gradle 打包 javadoc

3.1 概述

  • 一个完整的项目在进行打包的时候一个会有三个 *.jar 文件：主程序（gradle-1.0.jar）、源代码（gradle-1.0-sources.jar）和文档（gradle-1.0-javadoc.jar），如果要生成程序的 javadoc 文档，那么首先一定需要在项目中追加相应的文档说明，同时还需要在 build.gradle 文件中定义有相关的任务处理。

3.2 文档注释

  • 略（一般项目中都需要写文档注释的）。

3.3 Gradle 的任务配置

  • 如果要想生成 javadoc，则需要配置有相关的任务，Gradle 里面已经有了这样的内置任务，我们只需要对 javadoc 任务做一个继承处理即可，修改 build.gradle 文件：
  1. task javaDocTask(type: Javadoc){
  2.     source sourceSets.main.allJava // 定义所有的 Java 源代码的路径
  3. }
  5. tasks.withType(Javadoc){ // 文档生成一定要有乱码处理
  6.     options.encoding = "UTF-8"
  7. }
  9. tasks.withType(JavaCompile) { // 针对程序编译的任务进行配置
  10.     options.encoding = "UTF-8"
  11. }
  • 程序执行命令：
  1. gradle javaDocTask
  • 程序执行结果：

3.png

  • 当命令执行完成之后，会自动在 build/docs/javadoc 目录下生成所有的 JavaDoc 文档。

3.4 打包 JavaDoc

  • 最终在进行项目发布的时候，肯定要生成 javadoc 的 jar 文件，此时就需要定义一个打包任务，修改 build.gradle 文件：
  1. task javaDocJar(type: Jar, dependsOn: javaDocTask) { // 先生成 javadoc，才可以打包
  2.     archiveClassifier.set 'javadoc' // 文件的分类
  3.     from javaDocTask.destinationDir // 通过 javaDocTask 任务中找到目标路径
  4. }

3.5 命令整合

  • javadoc 的生成也应该在整个压缩结构文件生成的同时进行创建，修改 build.gradle 文件：
  1. task javaDocTask(type: Javadoc) {
  2.     source sourceSets.main.allJava // 定义所有的 Java 源代码的路径
  3. }
  5. tasks.withType(Javadoc) { // 文档生成一定要有乱码处理
  6.     options.encoding = "UTF-8"
  7. }
  9. tasks.withType(JavaCompile) { // 针对程序编译的任务进行配置
  10.     options.encoding = "UTF-8"
  11. }
  13. task javaDocJar(type: Jar, dependsOn: javaDocTask) { // 先生成 javadoc，才可以打包
  14.     archiveClassifier.set 'javadoc' // 文件的分类
  15.     from javaDocTask.destinationDir // 通过 javaDocTask 任务中找到目标路径
  16. }
  18. artifacts { // 最终的打包操作任务
  19.     archives sourceJar
  20.     archives javaDocJar
  21. }
  • 完整的 build.gradle 文件：
  1. plugins {
  2.     id 'java' // 配置的是一个 Java 插件（Java 项目）
  3.     id 'java-library'
  4. }
  6. ext {
  7.     jdkVersion = JavaVersion.VERSION_1_8 // 传统的 JDK 版本都是需要自己编写字符串的，而 Gradle 中提供了这样的操作
  8. }
  10. apply from: 'dependencies.gradle' // 引入所有的依赖文件
  12. configurations { // 进行依赖的配置
  13.     implementation {
  14.         canBeConsumed = true
  15.         canBeResolved = true
  16.     }
  17. }
  19. group 'com.github.fairy.era' // 组织名称
  20. version '1.0' // 项目版本
  22. // 定义一个公共的变量描述当前使用的 JDK 版本
  23. sourceCompatibility = jdkVersion
  24. targetCompatibility = jdkVersion
  26. repositories { // 仓库配置
  27.     mavenCentral()
  28. }
  30. dependencies { // 依赖管理
  31. //    compile gradleApi()
  32.     /* junit 5 */
  33.     testImplementation( // 如果有多个依赖，使用 , 隔开
  34.             libraries.'junit-jupiter'
  35.     )
  36.     /* druid */
  37.     implementation( // 如果有多个依赖，使用 , 隔开
  38.             libraries.'druid'
  39.     )
  40. }
  42. def mainClassName = 'com.github.fairy.era.GradleMain' // 程序的主类名称
  44. jar {
  45.     archivesBaseName = 'gradle' // 生成的 jar 文件名称，如果不写此名称则使用项目名称
  46.     manifestContentCharset = 'UTF-8' // 设置整个文件的编码
  47.     metadataCharset = 'UTF-8' // 元数据设置编码
  48.     manifest {
  49.         attributes 'Manifest-Version': getArchiveVersion().getOrNull(), // 程序版本号
  50.                 'Main-Class': "${mainClassName}",// 程序主类名称
  51.                 'Implementation-Title': 'hello-gradle',// 程序主类名称
  52.                 'Implementation-Version': archiveVersion // 版本编号
  53.     }
  54.     into('lib') { // 将程序锁需要的第三方组件包配置到 lib 目录之中
  55.         from configurations.compileClasspath
  56.     }
  57. }
  59. test { // 进行测试任务的配置
  60.     useJUnitPlatform() // 使用 Junit 平台
  61. }
  63. sourceSets { // 建立源代码的目录集合
  64.     main {
  65.         java {
  66.             srcDirs = ['src/main/java']
  67.         }
  68.         resources {
  69.             srcDirs = ['src/main/resources', 'src/main/config']
  70.         }
  71.     }
  72. }
  74. // 最终生成的 jar 文件名称：baseName-version-classifier.extension
  75. task sourceJar(type: Jar, dependsOn: classes) { // 定义一个源代码的打包任务，并依赖于 classes 这种 Gradle 内置的任务
  76.     archiveClassifier.set 'sources' // 文件的分类
  77.     from sourceSets.main.allSource // 所有源代码的读取路径
  78. }
  80. task javaDocTask(type: Javadoc) {
  81.     source sourceSets.main.allJava // 定义所有的 Java 源代码的路径
  82. }
  84. tasks.withType(Javadoc) { // 文档生成一定要有乱码处理
  85.     options.encoding = "UTF-8"
  86. }
  88. tasks.withType(JavaCompile) { // 针对程序编译的任务进行配置
  89.     options.encoding = "UTF-8"
  90. }
  92. task javaDocJar(type: Jar, dependsOn: javaDocTask) { // 先生成 javadoc，才可以打包
  93.     archiveClassifier.set 'javadoc' // 文件的分类
  94.     from javaDocTask.destinationDir // 通过 javaDocTask 任务中找到目标路径
  95. }
  97. artifacts { // 最终的打包操作任务
  98.     archives sourceJar
  99.     archives javaDocJar
  100. }
  • 程序执行命令：
  1. gradle clean build -x test
  • 程序执行结果：

4.png

第四章：Gradle 程序测试控制

4.1 概述

  • 在 Gradle 项目中所有的代码都要有相应的测试用例存在，但是如果说在一些环境下测试用例可能无法正常执行，那么面对这样的情况，就需要每次在编译打包的时候都使用 -x test 来跳过测试。
  • 在 Maven 里面有一种插件，通过配置可以避免执行测试的代码，但是在 Gradle 中并没有这样的插件，如果要想实现测试代码的跳过，就需要手工编写程序。

4.2 错误测试

  • 为了更好的说明问题，首先编写一个错误的测试代码：
  1. package com.github.era.fairy.service;
  3. import com.github.fairy.era.service.IMessageService;
  4. import com.github.fairy.era.service.impl.MessageServiceImpl;
  5. import org.junit.jupiter.api.Assertions;
  6. import org.junit.jupiter.api.Test;
  8. /**
  9.  * @author 许大仙
  10.  * @version 1.0
  11.  * @since 2021-12-21 08:43
  12.  */
  13. public class MessageServiceTest {
  15.     @Test
  16.     public void test() {
  17.         IMessageService messageService = new MessageServiceImpl();
  18.         Assertions.assertEquals("你好啊", messageService.echo("Gradle"));
  19.     }
  20. }
  • 程序执行结果：
  1. > Task :compileJava UP-TO-DATE
  2. > Task :processResources UP-TO-DATE
  3. > Task :classes UP-TO-DATE
  4. > Task :compileTestJava
  5. > Task :processTestResources NO-SOURCE
  6. > Task :testClasses
  7. > Task :test FAILED
  9. expected: <你好啊> but was: <hello Gradle>
  10. 预期:你好啊
  11. 实际:hello Gradle
  12. <点击以查看差异>
  14. org.opentest4j.AssertionFailedError: expected: <你好啊> but was: <hello Gradle>
  15. at com.github.era.fairy.service.MessageServiceTest.test(MessageServiceTest.java:18)
  16. at java.util.ArrayList.forEach(ArrayList.java:1249)
  17. at java.util.ArrayList.forEach(ArrayList.java:1249)
  19. MessageServiceTest > test() FAILED
  20.     org.opentest4j.AssertionFailedError at MessageServiceTest.java:18
  21. 1 test completed, 1 failed
  22. FAILURE: Build failed with an exception.
  23. * What went wrong:
  24. Execution failed for task ':test'.
  25. > There were failing tests. See the report at: file:///D:/project/gradle-01/build/reports/tests/test/index.html
  26. * Try:
  27. Run with --stacktrace option to get the stack trace. Run with --info or --debug option to get more log output. Run with --scan to get full insights.
  28. * Get more help at https://help.gradle.org
  29. BUILD FAILED in 1s
  30. 4 actionable tasks: 2 executed, 2 up-to-date

4.3 代码影响

  • 这样的程序代码在进行编译打包时候，一定会带来无法正常运行的问题。
  • 程序执行命令：
  1. gradle clean build
  • 程序执行结果：
  1. Execution failed for task ':test'.
  2. > There were failing tests. See the report at: file:///D:/project/gradle-01/build/reports/tests/test/index.html
  4. * Try:
  5. Run with --stacktrace option to get the stack trace. Run with --info or --debug option to get more log output. Run with --scan to get full insights.
  • 传统的解决方式就是使用 -x test 命令参数来进行控制，但是太麻烦了。

4.4 测试的控制任务

  • 如果要想解决当前测试代码对整个程序的影响，可以考虑做一个开关，修改 build.gradle 文件：
  1. gradle.taskGraph.whenReady { // 在所有的操作准备好之后触发
  2.     tasks.each { task ->
  3.         if (task.name.contains('test')) { // 如果发现有 test 任务，就跳过
  4.             task.enabled = false // 当前任务不执行
  5.         }
  6.     }
  7. }
  • 当项目中配置了这样的处理之后，实际上最终所有的程序的测试都会失效，因为只要发现是测试的指令，就会关闭任务处理。

第五章：Gradle 多环境配置管理

5.1 概述

  • 一个项目如果要想正常使用，则一般会经历：开发环境、测试环境和线上环境，不同的环境对于一些程序的配置信息也有所不同，那么这样的操作都可以通过 profile 来进行配置。
  • 按照正常的开发逻辑，应该将所有的网络服务器的信息，保存在不同的 profile 文件里面，例如：现在假设在 src/main 目录下创建一个 profiles 公共目录。
  1. .
  2. |-- LICENSE
  3. |-- build.gradle
  4. |-- gradle
  5. |   `-- wrapper
  6. |       |-- gradle-wrapper.jar
  7. |       `-- gradle-wrapper.properties
  8. |-- gradlew
  9. |-- gradlew.bat
  10. |-- settings.gradle
  11. `-- src
  12.     |-- main
  13.     |   |-- config
  14.     |   |   |-- database.properties
  15.     |   |   |-- dubbo.properties
  16.     |   |   `-- redis.properties
  17.     |   |-- java
  18.     |   |-- profiles  # 公共目录
  19.     |   |   |-- dev   # 开发环境
  20.     |   |   |   `-- config
  21.     |   |   |       `-- database.properties
  22.     |   |   |-- prod # 生产环境
  23.     |   |   |   `-- config
  24.     |   |   |       `-- database.properties
  25.     |   |   `-- test # 测试环境
  26.     |   |       `-- config
  27.     |   |           `-- database.properties
  28.     |   `-- resources
  29.     `-- test
  30.         |-- java
  31.         `-- resources

5.2 定义 profile

  • 以上的三个不同的属性文件在项目中的所有 key 的内容是相同的，不同的仅仅是 key 对应的 value ，在程序执行的时候就可以根据不同的环境实现配置的切换。
  • src/main/profiles/dev/config/database.properties：
  1. druid.database.name=gradle-dev
  2. druid.database.username=gradle-dev
  • src/main/profiles/test/config/database.properties：
  1. druid.database.name=gradle-prod
  2. druid.database.username=gradle-prod
  • src/main/profiles/prod/config/database.properties：
  1. druid.database.name=gradle-test
  2. druid.database.username=gradle-test

5.3 Gradle 配置

  • 如果要想让当前的这个 profile 路径生效，则一定要修改 build.gradle 配置文件，在这个配置文件里面定义源代码的访问路径，但是这个路径需要注意的是，里面的 profile 名称是需要动态变更的。 | 环境 | profile 路径 | | —- | —- | | 开发环境 | src/main/profiles/dev
    /config/database.properties | | 测试环境 | src/main/profiles/test
    /config/database.properties | | 生产环境 | src/main/profiles/prod
    /config/database.properties |
  • 修改 build.gradle 文件，获取 env 环境属性：
  1. def env = System.getProperty("env")?:'dev' // 获取 env 的环境属性
  • 对于当前可以接受的 env 环境属性，实际上就属于最终的 src/main/profiles/xxx 的动态内容，最终所需要的 profile 的具体内容就是由这个变量决定的，那么修改 build.gradle 文件：
  1. sourceSets { // 建立源代码的目录集合
  2.     main {
  3.         java {
  4.             srcDirs = ['src/main/java']
  5.         }
  6.         resources {
  7.             srcDirs = ['src/main/resources', 'src/main/config', "src/main/profiles/${env}"]
  8.         }
  9.     }
  10. }
  • 完整的 build.gradle 文件：
  1. plugins {
  2.     id 'java' // 配置的是一个 Java 插件（Java 项目）
  3.     id 'java-library'
  4. }
  6. ext {
  7.     jdkVersion = JavaVersion.VERSION_1_8 // 传统的 JDK 版本都是需要自己编写字符串的，而 Gradle 中提供了这样的操作
  8. }
  10. apply from: 'dependencies.gradle' // 引入所有的依赖文件
  12. configurations { // 进行依赖的配置
  13.     implementation {
  14.         canBeConsumed = true
  15.         canBeResolved = true
  16.     }
  17. }
  19. group 'com.github.fairy.era' // 组织名称
  20. version '1.0' // 项目版本
  22. // 定义一个公共的变量描述当前使用的 JDK 版本
  23. sourceCompatibility = jdkVersion
  24. targetCompatibility = jdkVersion
  26. def env = System.getProperty("env")?:'dev' // 获取 env 的环境属性
  28. repositories { // 仓库配置
  29.     mavenCentral()
  30. }
  32. dependencies { // 依赖管理
  33. //    compile gradleApi()
  34.     /* junit 5 */
  35.     testImplementation( // 如果有多个依赖，使用 , 隔开
  36.             libraries.'junit-jupiter'
  37.     )
  38.     /* druid */
  39.     implementation( // 如果有多个依赖，使用 , 隔开
  40.             libraries.'druid'
  41.     )
  42. }
  44. def mainClassName = 'com.github.fairy.era.GradleMain' // 程序的主类名称
  46. jar {
  47.     archivesBaseName = 'gradle' // 生成的 jar 文件名称，如果不写此名称则使用项目名称
  48.     manifestContentCharset = 'UTF-8' // 设置整个文件的编码
  49.     metadataCharset = 'UTF-8' // 元数据设置编码
  50.     manifest {
  51.         attributes 'Manifest-Version': getArchiveVersion().getOrNull(), // 程序版本号
  52.                 'Main-Class': "${mainClassName}",// 程序主类名称
  53.                 'Implementation-Title': 'hello-gradle',// 程序主类名称
  54.                 'Implementation-Version': archiveVersion // 版本编号
  55.     }
  56.     into('lib') { // 将程序锁需要的第三方组件包配置到 lib 目录之中
  57.         from configurations.compileClasspath
  58.     }
  59. }
  61. test { // 进行测试任务的配置
  62.     useJUnitPlatform() // 使用 Junit 平台
  63. }
  65. sourceSets { // 建立源代码的目录集合
  66.     main {
  67.         java {
  68.             srcDirs = ['src/main/java']
  69.         }
  70.         resources {
  71.             srcDirs = ['src/main/resources', 'src/main/config', "src/main/profiles/${env}"]
  72.         }
  73.     }
  74. }
  76. gradle.taskGraph.whenReady { // 在所有的操作准备好之后触发
  77.     tasks.each { task ->
  78.         if (task.name.contains('test')) { // 如果发现有 test 任务，就跳过
  79.             task.enabled = true // 当前任务不执行
  80.         }
  81.     }
  82. }
  84. // 最终生成的 jar 文件名称：baseName-version-classifier.extension
  85. task sourceJar(type: Jar, dependsOn: classes) { // 定义一个源代码的打包任务，并依赖于 classes 这种 Gradle 内置的任务
  86.     archiveClassifier.set 'sources' // 文件的分类
  87.     from sourceSets.main.allSource // 所有源代码的读取路径
  88. }
  90. task javaDocTask(type: Javadoc) {
  91.     source sourceSets.main.allJava // 定义所有的 Java 源代码的路径
  92. }
  94. tasks.withType(Javadoc) { // 文档生成一定要有乱码处理
  95.     options.encoding = "UTF-8"
  96. }
  98. tasks.withType(JavaCompile) { // 针对程序编译的任务进行配置
  99.     options.encoding = "UTF-8"
  100. }
  102. task javaDocJar(type: Jar, dependsOn: javaDocTask) { // 先生成 javadoc，才可以打包
  103.     archiveClassifier.set 'javadoc' // 文件的分类
  104.     from javaDocTask.destinationDir // 通过 javaDocTask 任务中找到目标路径
  105. }
  107. artifacts { // 最终的打包操作任务
  108.     archives sourceJar
  109.     archives javaDocJar
  110. }

5.4 打包处理

  • 此时给出的是一个 Java 环境属性，所以环境属性可以采用 -D属性名称 = 内容 的形式来进行处理，而后要进行程序的打包配置。
  • 开发环境打包命令（任选其一即可）：
  1. gradle clean build
  1. gradle clean build -Denv=dev
  • 测试环境打包命令：
  1. gradle clean build -Denv=test
  • 生产环境打包命令：
  1. gradle clean build -Denv=prod

5.5 依赖配置

  • 长期以来如果使用 Maven 都会发现有一个核心问题：依赖库的版本永远都是需要固定配置，即使有不同的 profile，依赖库也是无法变更的；但是在 Gradle 里面，将这个问题解决了，在之前为了进行依赖的统一管理，提供有一个 dependencies.gradle 的配置文件，那么如果要想实现不同版本的切换，就可以通过这样的文件形式来进行控制。
  • 下面建立 dependencies-xxx.gradle 的配置文件，其中 xxx 代表 dev、test 和 prod。
  • dependencies-dev.gradle 的内容如下：
  1. // 定义所有要使用的版本号
  2. ext.versions = [
  3.         junitJupiterVersion: '5.8.0',
  4.         druidVersion       : '1.2.6'
  5. ]
  6. // 定义所有的依赖库
  7. ext.libraries = [
  8.         /* junit 5 */
  9.         'junit-jupiter': "org.junit.jupiter:junit-jupiter:${versions.junitJupiterVersion}",
  10.         /* druid */
  11.         druid          : "com.alibaba:druid:${versions.druidVersion}"
  12. ]
  • dependencies-test .gradle 的内容如下：
  1. // 定义所有要使用的版本号
  2. ext.versions = [
  3.         junitJupiterVersion: '5.8.1',
  4.         druidVersion       : '1.2.7'
  5. ]
  6. // 定义所有的依赖库
  7. ext.libraries = [
  8.         /* junit 5 */
  9.         'junit-jupiter': "org.junit.jupiter:junit-jupiter:${versions.junitJupiterVersion}",
  10.         /* druid */
  11.         druid          : "com.alibaba:druid:${versions.druidVersion}"
  12. ]
  • dependencies-prod.gradle 的内容如下：
  1. // 定义所有要使用的版本号
  2. ext.versions = [
  3.         junitJupiterVersion: '5.8.2',
  4.         druidVersion       : '1.2.8'
  5. ]
  6. // 定义所有的依赖库
  7. ext.libraries = [
  8.         /* junit 5 */
  9.         'junit-jupiter': "org.junit.jupiter:junit-jupiter:${versions.junitJupiterVersion}",
  10.         /* druid */
  11.         druid          : "com.alibaba:druid:${versions.druidVersion}"
  12. ]

5.png

5.6 动态导入

  • 修改 build.gradle 文件，针对于依赖配置库进行动态配置：
  1. def env = System.getProperty("env")?:'dev' // 获取 env 的环境属性
  3. apply from: "dependencies-${env}.gradle" // 引入所有的依赖文件
  • 开发环境打包命令：
  1. gradle clean build
  1. gradle clean build -Denv=dev
  • 测试环境打包命令：
  1. gradle clean build -Denv=test
  • 生产环境打包命令：
  1. gradle clean build -Denv=prod
  • 完成的 build.gradle 文件：
  1. plugins {
  2.     id 'java' // 配置的是一个 Java 插件（Java 项目）
  3.     id 'java-library'
  4. }
  6. ext {
  7.     jdkVersion = JavaVersion.VERSION_1_8 // 传统的 JDK 版本都是需要自己编写字符串的，而 Gradle 中提供了这样的操作
  8. }
  10. def env = System.getProperty("env")?:'dev' // 获取 env 的环境属性
  12. apply from: "dependencies-${env}.gradle" // 引入所有的依赖文件
  14. configurations { // 进行依赖的配置
  15.     implementation {
  16.         canBeConsumed = true
  17.         canBeResolved = true
  18.     }
  19. }
  21. group 'com.github.fairy.era' // 组织名称
  22. version '1.0' // 项目版本
  24. // 定义一个公共的变量描述当前使用的 JDK 版本
  25. sourceCompatibility = jdkVersion
  26. targetCompatibility = jdkVersion
  30. repositories { // 仓库配置
  31.     mavenCentral()
  32. }
  34. dependencies { // 依赖管理
  35. //    compile gradleApi()
  36.     /* junit 5 */
  37.     testImplementation( // 如果有多个依赖，使用 , 隔开
  38.             libraries.'junit-jupiter'
  39.     )
  40.     /* druid */
  41.     implementation( // 如果有多个依赖，使用 , 隔开
  42.             libraries.'druid'
  43.     )
  44. }
  46. def mainClassName = 'com.github.fairy.era.GradleMain' // 程序的主类名称
  48. jar {
  49.     archivesBaseName = 'gradle' // 生成的 jar 文件名称，如果不写此名称则使用项目名称
  50.     manifestContentCharset = 'UTF-8' // 设置整个文件的编码
  51.     metadataCharset = 'UTF-8' // 元数据设置编码
  52.     manifest {
  53.         attributes 'Manifest-Version': getArchiveVersion().getOrNull(), // 程序版本号
  54.                 'Main-Class': "${mainClassName}",// 程序主类名称
  55.                 'Implementation-Title': 'hello-gradle',// 程序主类名称
  56.                 'Implementation-Version': archiveVersion // 版本编号
  57.     }
  58.     into('lib') { // 将程序锁需要的第三方组件包配置到 lib 目录之中
  59.         from configurations.compileClasspath
  60.     }
  61. }
  63. test { // 进行测试任务的配置
  64.     useJUnitPlatform() // 使用 Junit 平台
  65. }
  67. sourceSets { // 建立源代码的目录集合
  68.     main {
  69.         java {
  70.             srcDirs = ['src/main/java']
  71.         }
  72.         resources {
  73.             srcDirs = ['src/main/resources', 'src/main/config', "src/main/profiles/${env}"]
  74.         }
  75.     }
  76. }
  78. gradle.taskGraph.whenReady { // 在所有的操作准备好之后触发
  79.     tasks.each { task ->
  80.         if (task.name.contains('test')) { // 如果发现有 test 任务，就跳过
  81.             task.enabled = true // 当前任务不执行
  82.         }
  83.     }
  84. }
  86. // 最终生成的 jar 文件名称：baseName-version-classifier.extension
  87. task sourceJar(type: Jar, dependsOn: classes) { // 定义一个源代码的打包任务，并依赖于 classes 这种 Gradle 内置的任务
  88.     archiveClassifier.set 'sources' // 文件的分类
  89.     from sourceSets.main.allSource // 所有源代码的读取路径
  90. }
  92. task javaDocTask(type: Javadoc) {
  93.     source sourceSets.main.allJava // 定义所有的 Java 源代码的路径
  94. }
  96. tasks.withType(Javadoc) { // 文档生成一定要有乱码处理
  97.     options.encoding = "UTF-8"
  98. }
  100. tasks.withType(JavaCompile) { // 针对程序编译的任务进行配置
  101.     options.encoding = "UTF-8"
  102. }
  104. task javaDocJar(type: Jar, dependsOn: javaDocTask) { // 先生成 javadoc，才可以打包
  105.     archiveClassifier.set 'javadoc' // 文件的分类
  106.     from javaDocTask.destinationDir // 通过 javaDocTask 任务中找到目标路径
  107. }
  109. artifacts { // 最终的打包操作任务
  110.     archives sourceJar
  111.     archives javaDocJar
  112. }