devbox
IT小白
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Android中Gradle实用指南_gradle def

作者：IT小白 | 2024-03-15 20:56:26

赞

踩

gradle def

https://juejin.im/post/58eae7e5a22b9d0058a88a56

Android中Gradle实用指南

Gradle让Android中的依赖管理、库管理、渠道管理以及一些动态地编译配置变得极为方便！！
本文是对Gradle在Android项目中进阶使用的知识点整理和简要讲解
较为详细的Gradle教科书Github
Gradle脚本配置文档：Google Github

目录

  • Android工程中的Gradle
  • 常用的Gradle Task
  • 动态参数配置
  • Project:build.gradle
    • 全局属性配置
    • 整体结构和描述
  • Module: build.gradle
    • defaucltConfig
    • signConfigs
    • buidlTypes
    • sourceSets
    • productFlavors
    • compileOptions
    • lintOptions
    • build.gradle 图形化配置
  • dependencies项目依赖
  • 自定义方法def
  • Gradle编译提速优化
    • 性能检测
    • 禁用Task达到提速
    • AAPT
    • Gradle编译优化
  • 认识Task
  • 自定义Plugin
    • build.gradle中直接定义
    • 当前工程中定义
    • 独立Module自定义插件
  • 最后

Android工程中的Gradle

下面简述对我们工程最重要的几个Gradle文件，后续也会围绕他们进行详细讲解和补充
（请仔细看代码中的注释哈）

  • 工程Project 中的 build.gradle : 工程控制Gradle编译配置
  • 模块module中的 build.gradle ： 控制每个Module的编译过程
  • gradle.properties : gradle动态参数的配置文件
  • local.properties ： 本地的配置，如：SDK位置
  • gradle-wrapper.properties ：gradle本地代理，声明了指向目录和版本
    • distributionUrl : 指定gradle版本不存在时，就从Value的地址中去下载。很多时候，我们只要版本换成我们本地存在的gradle版本就可以了
  • settings.gradle ： 配置Gradle中的Module管理

    常用Gradle Task

    ~ 表示 gradlew (Mac 使用gradle ,没有w)
  • gradlew task -all : 罗列出所有Task ，同时携带具体作用和相互关系

  • gradlew assembleDebug : 导出所有渠道测试包

    • ~ assembleRelease : 导出所有渠道正式包
    • ~ assembleBaiduDebug --stacktrace : 导出指定渠道测试包，同时携带异常信息

  • ~ --stop : 立即停止编译

  • ~ check : 检查任务
  • ~ build : 执行了 check和assemble
  • ~ clean ： 清除所有中间编译结果

动态参数配置

在Gradle中动态配置资源参数
我们可以根据各自的需求在不同的领域（如：buildType 的debug, defaultConfig ...）下去动态替换或配置我们项目中所使用到的资源，如 log 开关， 针对不同渠道的对应内容字段，不同版本定义引入的不同值等等

首先说清一点，对于动态资源在build.gradle中多个领域中的使用，会遵循一下顺序来进行覆盖：
buildType > productFlavor > defaultConfig > Manifest中的配置 > 依赖的第三方库的配置 > 任意领域中的默认值（也就是没有设置值）

  1. Manifest占位符： 可以动态配置Manifest的参数
  1.         在Manifest的Application节点下
  2.         //这里以友盟为例
  3.         <!-- 友盟统计相关meta-data -->
  4.         <meta-data
  5.             android:name="UMENG_APPKEY"
  6.             android:value="balabalabala" />
  7.         <meta-data
  8.             android:name="UMENG_CHANNEL"
  9.             android:value="${UMENG_CHANNEL_VALUE}" />
  10.  
  11. 在build.gradle中对参数进行动态配置
  12.  productFlavors {
  13.         baidu {
  14.             manifestPlaceholders = [UMENG_CHANNEL_VALUE: "baidu"]
  15.         }
  16. }
  1. gradle.properties 的使用
    • 系统属性：
      配置： systemProp.proName=123
      使用：System.properties['proName']
    • 自定义属性 ：
      配置： 有key： ray.proName=123 ，无key : proName = 123
      使用： 有key： project。property('proName') , 无key ： proName
  1. gradle.properties中的配置
  2.  
  3. #使用系统参数配置
  4. systemProp.keyStore=ray.jks
  5. #使用key/value键值对配置
  6. ray.keyPassword=123456
  7. #属性配置
  8. mKeyAlias=ray
  9.  
  10. build.gradle中的使用
  11. //签名打包
  12.         release {
  13.             //签名文件所在路径
  14.             storeFile file(System.properties['keyStore'])
  15.             //签名密码
  16.             storePassword "111111"
  17.             //别名
  18.             keyAlias mKeyAlias
  19.             keyPassword project.property('ray.keyPassword')
  20.         }
  1. BuildConfig文件
    • 在app/build/generated/source/buildConfig文件夹下面
    • 使用： buildConfigField "String" , "key" , "\"value\""
      配置buildConfig中的属性参数 String ： 参数类型（int,boolean...）, key : 属性的名字， value ： 属性的值， \ 为转义字符
  1. resValue 动态修改工程资源
    • 和buildConfig 类似， resValue("string","key","value")
    • 其中string 表示 会在 app/build/generated/res/resValue/.../generated.xml中生成对应的String 的 key 和Value， 代码中可以直接getResources().getString(R.string.key);获取到value
    • 注意： 因为Gradle编译的时候会将脚本配置和string.xml文件中配置进行merge，所以string.xml中已经存在的key在编译前要删除，否则会报错
  1. //下面模拟在不同渠道下修改资源参数
  2. productFlavors{
  3. baidu{
  4.   buildConfigField "String" , "productCode" , "\"baidu 1.0\""
  5.   resValue("string","productName","baidu")
  6. }
  7. }

Project : build.gradle

全局属性配置

  1. 在project : build.gradle 的buildscript中声明ext和自定义属性，然后在其他module中就可以直接使用这个属性了
    如下：
  1.  
  2. Project : build.gradle
  3. buildscript {
  4.     //自定义工程使用的属性
  5.     ext {
  6.         kotlin_version = '1.1.0'
  7.         compile_version = 25
  8.     }
  9.  
  10.     //声明依赖Android Gradle 插件版本
  11.     dependencies {
  12.         classpath 'com.android.tools.build:gradle:2.3.0'
  13.         classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
  14.     }
  15. }
  16.  
  17. Module : build.gradle 中使用
  18. Android
  19. {
  20. compileSdkVersion compile_version
  21. }
  22. dependencies
  23. {
  24.  compile "org.jetbrains.kotlin:kotlin-reflect:$kotlin_version"
  25.  }
  1. 新建自己的Gradle属性文件 text.gradle ， 然后在Project中引入，最后就可以在其他的module中直接使用了，具体应用可以参考印象笔记Github
    如下：
  1. text.gradle 编写如下：
  2. ext {
  3.     kotlinVersion = "1.1.0"
  4.     rxjavaLibVersion = "1.2.0"
  5.  
  6.     dependencies = [
  7.             // Rx
  8.             rxJava: "io.reactivex:rxjava:$rxjavaLibVersion"
  9.     ]
  10. }
  11.  
  12. Project : build.gradle 中引入
  13. //就是引入他的相对根目录路径
  14. apply from: 'config/text.gradle'
  15.  
  16. Module : build.gradle 中使用
  17. rootProject.ext.XXXXX
  18.  
  19. dependencies {
  20.  
  21.  def dependencies=rootProject.ext.dependencies
  22.  
  23.     compile dependencies.rxJava
  24.  
  25.     compile "org.jetbrains.kotlin:kotlin-stdlib:$rootProject.ext.kotlinVersion"
  26.  
  27. }

整体结构与描述

  1. //声明引入的参数配置文件
  2. apply from: 'config/dependencies.gradle'
  3. apply from: 'config/text.gradle'
  4.  
  5. //编译配置
  6. buildscript {
  7.  
  8.     //自定义参数
  9.     ext {
  10.         kotlin_version = '1.1.0'
  11.         compile_version = 25
  12.     }
  13.  
  14.     //Gradle指定使用jcenter代码仓库
  15.     repositories {
  16.         jcenter()
  17.     }
  18.     //声明依赖Android Gradle 插件版本
  19.     dependencies {
  20.         classpath 'com.android.tools.build:gradle:2.3.0'
  21.         classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
  22.     }
  23. }
  24.  
  25. //这里可以为项目整体配置属性
  26.  allprojects{
  27.     repositories {
  28.         jcenter()
  29.     }
  30. }
  31.  
  32. //任务：每次构建的时候删除指定目录
  33. task clean(type: Delete) {
  34.     delete rootProject.buildDir
  35. }

Module : build.gradle

控制每个Module的编译过程以及具体的参数配置

defaultConfig

基本配置信息

  1.   //默认配置
  2.     defaultConfig {
  3.         //包名
  4.         applicationId "com.rayhahah.gradledemo"
  5.         //最低版本
  6.         minSdkVersion 19
  7.         //目标版本
  8.         targetSdkVersion 25
  9.         //版本代码
  10.         versionCode getVersinCode()
  11.         //版本
  12.         versionName "1.0"
  13.         //自动化测试
  14.         testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
  15.  
  16.         resValue "int","test","1"
  17.     }

signConfigs

签名配置信息

  1. signingConfigs {
  2.  
  3.         //debug模式签名文件
  4.         debug {}
  5.         //签名打包
  6.         release {
  7.             //签名文件所在路径
  8.             storeFile file("ray.jks")
  9.             //签名密码
  10.             storePassword "111111"
  11.             //别名
  12.             keyAlias "rayhahah"
  13.             keyPassword "111111"
  14.         }
  15.  
  16.         //自定义签名配置
  17.         ray{
  18.             //和上面的属性一致，根据个人需求实现不同配置
  19.         }
  20.     }

buildTypes

编译类型 ： 指定编译不同类型情况下的不同配置信息
这里是列举了部分属性和方法，全部的方法和属性请看官网文档

  1. //构建配置
  2.     buildTypes {
  3.         release {
  4.  
  5.             //是否启用资源优化
  6.             minifyEnabled
  7.              //启用舍弃无用资源，只有当开启混淆才能够启用
  8.             shrinkResources false
  9.             //指定混淆文件
  10.             proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
  11.  
  12.             //指定我们release包的输出文件名就是我们的渠道名字
  13.             applicationVariants.all { variant ->
  14.                 variant.outputs.each { output ->
  15.                     def outputFile = output.outputFile
  16.                     if (outputFile != null && outputFile.name.endsWith(".apk")) {
  17.  
  18.                         def fileName = "${variant.productFlavors[0].name}" + ".apk"
  19.                         output.outputFile = new File(outputFile.parent, fileName);
  20.                     }
  21.                 }
  22.             }
  23.         }
  24.  
  25.         debug {
  26.  
  27.         }
  28.  
  29.         //继承
  30. //        rayhahah.initWith(debug)
  31.  
  32.         //自定义buildType
  33.         rayhahah {
  34.             //指定签名配置文件
  35.             signingConfig signingConfigs.debug
  36.             //包名增加后缀
  37.             applicationIdSuffix ".ray"
  38.  
  39.         }
  40.     }

sourceSets

配置资源逻辑组

  • 通过指定资源 文件夹路径构建自己的工程目录
  1. 指定Android所需要文件夹所在具体路径
  2.  
  3. sourceSets {
  4. //这样的配置适用于将Eclipse中的项目结构迁移到AndroidStudio中
  5.         main {
  6.             //指定src资源目标目录
  7.             java.srcDirs = ['src']
  8.             //指定asset的目标目录
  9.             assets.srcDirs = ['assets']
  10.             //指定res的目标目录
  11.             res.srcDirs = ['res']
  12.             //指定依赖C文件的目标目录
  13.             jni.srcDirs = ['jni']
  14.              //指定依赖so文件的目标目录
  15.             jniLibs.srcDirs = ['libs']
  16.             //指定Manifest的目标文件路径
  17.             manifest.srcFile 'AndroidManifest.xml'
  18.         }
  19.  }
  • 常用！ 给自己的layout分包管理！！ 
  1. 1. 在res下新建文件夹 layouts（其实叫什么都无所谓）
  2. 2. 然后在 layouts下 新建你要分的包 如： activity，fragment 或按照业务模块来分
  3. 3. 在分包内新建Android resource directory -> layout 不要改名字
  4. 4. 在module：build gradle 如下配置
  5. 5. 然后将以前的layout文件拷贝到对应分包的layout下就可以使用了
  6.  
  7. PS:只有在Project目录才能看到，Android目录结构是看不到的
  8.  
  9.  sourceSets {
  10.         main {
  11.             res.srcDirs = [
  12.                     'src/main/res/layouts/activity',
  13.                     'src/main/res/layouts/fragment',
  14.                     'src/main/res/layouts',
  15.                     'src/main/res'
  16.  
  17.             ]
  18.         }
  19.     }

productFlavors

打包渠道配置信息（仔细看代码注释）

  1. //多渠道打包配置
  2. //利用Manifest占位符动态参数配置
  3. productFlavors {
  4.         baidu {
  5.             manifestPlaceholders = [UMENG_CHANNEL_VALUE: "baidu"]
  6.         }
  7.  
  8.         wandoujia {
  9.             manifestPlaceholders = [UMENG_CHANNEL_VALUE: "wandoujia"]
  10.         }
  11.  
  12.         googleplayer {
  13.             manifestPlaceholders = [UMENG_CHANNEL_VALUE: "googleplayer"]
  14.         }
  15.  
  16.         //不想每一个都去配置渠道名称也可以用下面这个函数
  17.         //这个函数可以将 Manifest中的占位符替换成 每个渠道的名字
  18.         productFlavors.all {
  19.             flavor -> flavor.manifestPlaceholders = [UMENG_CHANNEL_VALUE: name]
  20.         }
  21.     }

compileOptions

  1.  //编译配置项
  2.     //主要配置Java编译版本
  3.     compileOptions {
  4.         sourceCompatibility org.gradle.api.JavaVersion.VERSION_1_8
  5.         targetCompatibility org.gradle.api.JavaVersion.VERSION_1_8
  6.     }

lintOptions

  1.  
  2.     //lint配置项
  3.     lintOptions {
  4.  
  5.         //启用出错停止grgradle构建
  6.       abortOnError false
  7.  
  8.       // true--检查所有问题点，包含其他默认关闭项
  9.       checkAllWarnings true
  10.  
  11.       // 关闭指定问题检查
  12.       disable 'TypographyFractions','TypographyQuotes'
  13.       // 打开指定问题检查
  14.       enable 'RtlHardcoded','RtlCompat', 'RtlEnabled'
  15.       // 仅检查指定问题
  16.       check 'NewApi', 'InlinedApi'
  17.  
  18.       // true--生成HTML报告(带问题解释，源码位置，等)
  19.       htmlReport true
  20.       // html报告可选路径(构建器默认是lint-results.html )
  21.       htmlOutput file("lint-report.html")
  22.  
  23.       // 忽略指定问题的规则(同关闭检查)
  24.       ignore 'TypographyQuotes'
  25.     }

build.gradle 图形化配置

AndroidStuido 给我们提供了十分友好地对于Build.gradle 图形化配置的界面，使用如下：

  • File -> Project Structure -> 选择需要配置的 Module —> 选择需要配置的领域
    如图十分直观：

图形化界面

dependencies 项目依赖

  1. build.gradle中dependencies中的配置解析
  1. //dependencies ： 当前Android Module构建过程中所依赖的所有库
  2. dependencies {
  3.     //依赖指定目录下所有指定后缀的文件
  4.     compile fileTree(dir: 'libs', include: ['*.jar'])
  5.     //测试工具依赖
  6.     testCompile 'junit:junit:4.12'
  7.     //远程库的依赖 （当从远程库中下载一次过后，就会缓存到本地了）
  8.     //默认远程库配置为 jcenter() 
  9.     compile 'com.android.support:appcompat-v7:25.2.0'
  10.  
  11.     //依赖指定文件（这里依赖的是jar包）
  12.     compile file('libs/test-1.0.0.jar')
  13.     //依赖本地项目库
  14.     compile project(':testLibrary')
  15.  
  16.     //格式：  groupId: com.squareup.retrofit2
  17.     //         artifactId : retrofit
  18.     //         version:  2.1.0
  19.     // SNAPSHOT : 表示依赖 retrofit 及其依赖的所有项目，如果他所依赖的项目在本项目中重复出现依赖，则只依赖retrofit项目中的。
  20.     // @aar :  表示只依赖retrofit，不依赖他所依赖的项目
  21.     compile ('com.squareup.retrofit2:retrofit:2.1.0-SNAPSHOT@aar')
  22.     {
  23.          //强制刷新远程库，避免远程库刷新，本地未更新
  24.          transitive = true        
  25.           //exclude : 单独去除okhttp3的依赖
  26.          exclude module ： 'com.squareup.okhttp3:okhttp:3.3.0' 
  27.     }
  28.  
  29. }

  1. so库依赖

    • 在src/main目录下创建jniLibs，然后将so文件拷贝进去就可以了
    • 当然也可以通过sourceSet指定jniLib的目标目录来自定义管理依赖的so文件存放

  2. 本地Module依赖

    • 在build.gradle的dependencies 领域中添加 compile project(':testLibrary')
    • 在setting.gradle 中添加module到include中 如：include ':app',':testLibrary'

方法def定义

在Gradle中你可以写方法供 配置信息动态调用

  1. //自定义函数
  2. def getVersinCode() {
  3. //    ......
  4. }
  5.  
  6. Android{
  7.     defaultConfig{
  8.         versionCode getVersinCode()
  9.     }
  10. }

Gradle编译提速优化

检测

  • gradlew build -profile : 编译工程同时生成编译性能分析文件，在根目录build/reports/profile/profile-xxxx.xxx....html ，通过浏览器打开以后
    如图： 我们需要优化的就是Task Execution

profile.html

  • 往下拉，可以看到TaskExcution的详细参数

TaskExcution

可以看到lint耗时最多，然后我们就可以根据自己项目中的具体情况来做优化

禁用Task达到提速

  • 根据上面的耗时来对应禁用Task来达到提速的效果
  • 在Project:build.gradle 中的 buildScript中动态配置编译时禁用即可， 代码：gradle.startParameter.excludedTaskNames.add('lint') 就可以实现禁用了，具体需要继续禁用的可以根据项目输出的编译分析文件来作出添加和调整

AAPT

aapt即Android Asset Packaging Tool，在SDK的build-tools目录下。该工具可以查看，创建， 更新ZIP格式的文档附件(zip, jar, apk)。也可将资源文件编译成二进制文件，尽管你可能没有直接使用过aapt工具，但是build scripts和IDE插件会使用这个工具打包apk文件构成一个Android 应用程序（百度百科）

  • 在Debug模式下，我们需要优化AAPT来大量提速我们的编译(记得在release下改回来)
  1. aaptOtions{
  2.     cruncherEnabled = false
  3. }

Gradle编译优化

  • 提升Gradle本身编译速度
    • gradle.properties中配置
  1. //开启守护线程支持
  2. org.gradle.daemon=true
  3.  
  4. //开启并行编译
  5. org.gradle.parallel=true
  6. //按需编译
  7. org.gradle.configureondemand=true
  8.  
  9. //手动配置Gradle编译时内存分配
  10. # Default value: -Xmx10248m -XX:MaxPermSize=256m
  11. org.gradle.jvmargs=-Xmx2048m -XX:MaxPermSize=512m -XX:+HeapDumpOnOutOfMemoryError -Dfile.encoding=UTF-8
  12.  
  13. # 开启JNI编译支持过时API
  14. android.useDeprecatedNdk=true
  • build.gradle中配置
  1. //增加编译内存到4g
  2. dexOptions{
  3.     incremental true    
  4.     javaMaxHeapSize "4g"
  5. }

认识Task

  • Task基本使用：
  1.  
  2. task testTask << {
  3.  
  4.     println 'testTask << print'
  5.  
  6.     // 表示在task最前面来执行的过程
  7.     doFirst {
  8.         println 'testTask do first'}
  9.     // << 和 doLast表示对当前task追加执行过程，效果是一样的
  10.     doLast{
  11.         println 'testTask do last!'}
  12. }
  13.  
  14. //task之间的依赖 dependsOn
  15. //当执行存在依赖的task时，会先执行他的父类也就是依赖目标
  16. task testDependsOn(dependsOn:testTask){
  17.     println 'testDependsOn default print '
  18. }
  19. //或者
  20. testDependsOn.dependsOn testTask
  21. //当执行testDependsOn是 打印顺序： testDependsOn  default print -> testTask do first -> testTask << print -> testTask do last!
  22. //顺序总结为：
  23. //1.不加doLast和doFirst的最先执行
  24. //2.依赖task优先级高于自己的doFirst和doLast
  25. //3.同一个task中的doLast按从上向下顺序执行
  26. //4.同一个task中的doFirst按从下到上倒序执行
  27. //5.同一个task的doFirst优先级高于doLast
  28.  
  29. //显示声明类型为Copy， 不声明默认为defaultTask
  30. task testCopy(type : Copy){
  31.     //将当前gradle文件从src目录拷贝到dst目录
  32.     from "src"
  33.     into "dst"
  34. }
  35. //每一个特定的Task类型还可以含有特定的Property，比如Copy的from和to等。
  36.  
  37. //自定义property
  38. ext.testProperty = ""
  39.  
  40. task testExtProperty << {
  41.     //直接使用自定义的property
  42.     println testProperty
  43. }
  • 自定义Task:
  1. //局部自定义Task
  2. //直接在build.gradle中自定义Task
  3. //但是也只能在当前module中引用
  4. class TestCustomTask extends DefaultTask {
  5.     //@Optional，表示在配置该Task时，message是可选的。
  6.     @Optional
  7.     String message = 'I am jjx'
  8.     //@TaskAction表示该Task要执行的动作,即在调用该Task时，hello()方法将被执行
  9.     @TaskAction
  10.     def hello() {
  11.         println "hello world $message"
  12.     }
  13. }
  14.  
  15. //hello使用了默认的message值
  16. task hello(type: TestCustomTask)
  17.  
  18. //重新设置了message的值
  19. task helloOne(type: TestCustomTask) {
  20.     message = "I am a android developer"
  21. }
  22.  
  23.  
  24. 全局自定义Task
  25. 如果需要自定义大量的Task，就要新建一个Gradle文件来统一管理
  26. 通过apply来引入使用
  27. //这是插件
  28. apply plugin: 'com.android.application'
  29. //这里gradle-quality.gradle就是另外单独定义了task的gradle
  30. apply from: '../build-config/gradle-quality.gradle'

自定义Plugin

自定义Plugin可以让我们在工程编译根据需求中自动去完成一些操作
下面就是一个编译后自动打印当前时间的Plugin

build.gradle中直接定义

  1. 与自定义Task十分类似
  2. 可以在build.gradle中自定义plugin
  3. apply plugin: DateAndTimePlugin
  4.  
  5. dateAndTime {
  6.     timeFormat = 'HH:mm:ss.SSS'
  7.     dateFormat = 'MM/dd/yyyy'
  8. }
  9.  
  10. class DateAndTimePlugin implements Plugin<Project> {
  11.     //该接口定义了一个apply()方法，在该方法中，我们可以操作Project，
  12.     //比如向其中加入Task，定义额外的Property等。
  13.     void apply(Project project) {
  14.         //加载Extension
  15.         project.extensions.create("dateAndTime", DateAndTimePluginExtension)
  16.  
  17.         //使用Extension配置信息
  18.         project.task('showTime') << {
  19.             println "Current time is " + new Date().format(project.dateAndTime.timeFormat)
  20.         }
  21.  
  22.         project.tasks.create('showDate') << {
  23.             println "Current date is " + new Date().format(project.dateAndTime.dateFormat)
  24.         }
  25.     }
  26. }
  27. //每个Gradle的Project都维护了一个ExtenionContainer，
  28. //我们可以通过project.extentions进行访问
  29. //比如读取额外的Property和定义额外的Property等。
  30. //向Project中定义了一个名为dateAndTime的extension
  31. //并向其中加入了2个Property，分别为timeFormat和dateFormat
  32. class DateAndTimePluginExtension {
  33.     String timeFormat = "MM/dd/yyyyHH:mm:ss.SSS"
  34.     String dateFormat = "yyyy-MM-dd"
  35. }

工程中定义

其实本质上就是对上面的自定义Plugin结构化拆解

  1. Plugin目录创建

    • 在根目录下创建buildSrc
    • 子目录结构如下：buildSrc/src/main/groovy/com/ray 和 buildSrc/src/main/resources/META-INF/gradle-plugins

  2. 创建buildSrc/build.gradle ， 配置如下

  1. apply plugin:'groovy'
  2.  
  3. dependecies{
  4.     compile gradleApi()
  5.     compile localGroovy()
  6. }
  1. Plugin 逻辑实现
    自定义Plugin的主要实现逻辑
    在buildSrc/src/main/groovy/com/ray 下创建DateAndTimePlugin
  1. class DateAndTimePlugin implements Plugin<Project> {
  2.     void apply(Project project) {
  3.         //加载Extension
  4.         project.extensions.create("dateAndTime", DateAndTimePluginExtension)
  5.  
  6.         //使用Extension中的配置信息
  7.         project.task('showTime') << {
  8.             println "Current time is " + new Date().format(project.dateAndTime.timeFormat)
  9.         }
  10.  
  11.         project.tasks.create('showDate') << {
  12.             println "Current date is " + new Date().format(project.dateAndTime.dateFormat)
  13.         }
  14.     }
  15. }
  1. Extension实现
    Extension相当于Gradle配置信息（相当于实体类），然后主项目的build.gradle 通过Extension传递配置（相当于赋值）

同样在buildSrc/src/main/groovy/com/ray下创建DateAndTimePluginExtension

  1. //每个Gradle的Project都维护了一个ExtenionContainer，
  2. //我们可以通过project.extentions进行访问
  3. //比如读取额外的Property和定义额外的Property等。
  4. //向Project中定义了一个名为dateAndTime的extension
  5. //并向其中加入了2个Property，分别为timeFormat和dateFormat
  6. class DateAndTimePluginExtension {
  7.     String timeFormat = "MM/dd/yyyyHH:mm:ss.SSS"
  8.     String dateFormat = "yyyy-MM-dd"
  9. }

  1. Plugin命名
    自定义外部引用时Plugin的名字
    在buildSrc/src/main/resources/META-INF/gradle-plugins 下创建
    timePlugin.properties ,内容只有一行代码 ： implementation-class = com.ray.DateAndTimePlugin

  2. Plugin的使用
    主项目中apply plugin:'timePlugin'
    可选：配置Extension :

  1. timePlugin{
  2.     //动态修改和配置Extension属性
  3.     //这里修改了日期格式
  4.     timeFormat = 'MM/dd/yyyy'
  5. }

独立Module自定义插件

  1. 新建plugin目录结构如图：

ModulePlugin目录

  1. buildSrc/build.gradle的修改 如下：
  1. apply plugin: 'groovy'
  2. //增加Maven的支持
  3. apply plugin: 'maven'
  4.  
  5. version = 1.0
  6. group = 'com.ray.plugin'
  7. archivesBaseName = 'timeplugin'
  8. repositories.mavenCentral()
  9.  
  10. dependencies {
  11.     compile gradleApi()
  12.     groovy localGroovy()
  13. }
  14.  
  15. //将插件部署到repo目录下
  16. uploadArchives {
  17.     repositories.mavenDeployer {
  18.         repository(url: uri('../repo'))
  19.     }
  20. }
  1. 发布：和其他Module一样发布到中央库中
  2. 使用插件，主项目中配置如下：
  1. apply plugin: 'timePlugin'
  2.  
  3. buildscript {
  4.     repositories {
  5.         maven {
  6.             url uri('../repo')
  7.         } }
  8.     dependencies {
  9.         classpath group: 'com.ray.plugin', name: 'timePlugin',
  10.                 version: '1.0'
  11.     }
  12. }

最后

以上就是总结的Gradle实用的进阶指南，让我们可以更加随心所欲地去管理我们的工程。以后如果有一些新的认识或者想法，我也会在这里实时更新的。也算是自己对Gradle认识和学习的总结整理吧。
正确使用Gradle的配置是为了让我们开发更加便捷、效率更高，千万不要本末倒置了。
文中哪里有错误的话，欢迎大家指出纠正
如果文章对你有用的话，请点赞鼓励一下哈O(∩_∩)O~~~~

参考和感谢以下博文和项目：

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/IT小白/article/detail/244456
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号