groovy学习

groovy 评论

[TOC]

Groovy基础

1.1 def关键字

def value = 1;
value = “zhangsan”

//def 也可以用来定义方法，当方法指明返回值的时候，def关键字可以被省略。

1.2 String

Groovy的string分两种 String）（java.lang.String）和GString (groovy.lang.GString)：

1
2
3
4
5
6
7
8
9
10
11
def value = '我是字符串'

def value1 = "我是字符串,$value,${1+1}"；
def value2 = "我是字符串"；

//支持三引号  java.lang.String
def value3 = """
afsasdf
afdasf
afdasf
"""
1.3 List

  1. 定义 def value = [“a”, “b”, “c”];

  2. value[0] = 4;

  3. 查： value[0]

    默认是ArrayList，可以通过强类型来声明

    LinkedList value = [1,2,3]

1.4 Map
  1. 定义：def value = [“a”:a, “b”:2]
  2. 增, 改：value.a =100 或者 value[“a”] = 100
  3. 查：value.a 或 value[“a”]
1.5 Range
  1. 定义：def value = 1..10
  2. 使用：if（1 in value）
1.6 metaClass

在groovy中可以在运行期间使用metaClass添加方法和属性，以下代码可以被正确执行

1
2
3
4
5
6
7
class A {
    String name
}

A.metaClass.getInfo ={
    prinln "getInfo"
}
1.7闭包

闭包是groovy中一个很重要的东西

  1. 闭包的定义：
1
2
3
4
5
6
7
8
9
10
11
12
13
def value = { String name ->
    println name
}

//闭包的参数类型可以省略
def value = { name ->
    println name
}

//闭包只有一个参数，参数可以省略
def value = {
    println name
}
  1. 闭包的使用
1
value.call("sfas") 或 value("sfas")
  1. 闭包的委托策略：
    1. 闭包有三个相关的对象：
      1. this: 闭包定义出最近的对象（不含闭包）
      2. owner：闭包定出最近的对象或闭包
      3. delegate：闭包的代理对象，默认和owner一致，可以手动设置；
    2. 闭包的委托策略：
      1. Closure.OWNER_FIRST: 默认策略，首先从owner上寻找属性或方法，找不到

…

2：Gradle执行流程

  1. 初始化界面：解析settings.gradle来获取模块信息
  2. 配置阶段：配置每个模块，构建task树
  3. 执行阶段：执行任务

3：Project

3.1： Project相关API
  1. getRootProject：获取根project
  2. getAllProjects：获取所有Project
  3. getSubprojects：获取所有字Project
  4. allprojects：遍历所有project
  5. subprojects：遍历所有子project
3.2：属性相关的API

  1. hasProperty：检测属性是否存在

  2. findProperty：查找属性

  3. 自定义property：

    1. 通过命令行参数定义property：gradle build -P a=1

    2. 通过project.ext定义参数：

      1
      2
      3
      4
      ext.a = 1
      ext {
          a = 1
      }
3.3: Task相关的API
  1. getTasks：获取当前project所有task
  2. task：创建一个task
3.4： 文件相关API
  1. file：获取文件
  2. fileTree：获取文件夹
  3. getBuildDir：获取build文件夹
3.5 Gradle生命周期API

  1. beforeEvaluate：配置阶段开始之前

  2. afterEvaluate：配置阶段结束

    这是一个比较重要的生命周期，当走到这里时，说明所有task’都已经配置完成了，我们可以进行操作加入我们的逻辑，也可以出入我们自定义的task

  3. gradle.buildFinished:执行阶段结束

3.6：其它API
  1. exec：执行外部命令，我们后面会用到这个方法
4：Task

Task是gradle另外一个很重要的东西：

4.1:Task定义
  1. 我们可以通过我们的Project中的Task方法来进行定义一个Task
1
2
3
4
task myTask{
    println "myTask"
}
最后一个参数是闭包，所以这里省略了圆括号
  1. 我们也可以使用Project中的TaskContainer来定义一个Task
1
2
3
project.tasks.create(name: "myTask") {
    println "myTask"
}
4.2:Task基本信息配置
1
2
3
4
5
6
7
8
9
10
11
12
13
14
task myTask (
	group: "wangzhi"
	description: "build"
){
    println "myTask"
}

或

task myTask {
    group "wangzhi"
    description "build"
    println "myTask"
}
4.3: Task依赖

Task可以通过调用dependsOn方法配置他依赖的Task，可以是一个也可以是多个。

1
2
3
4
5
6
task A {
    
}
task B {
    dependsOn A
}

我们执行Task B的时候会先执行Task A，应该Task b依赖Task A

4.4： Task执行

写在我们Task闭包内的代码是执行在Gradle的配置阶段的，执行每一个任务时都会执行一遍，如果想执行在执行阶段，需要将代码写在doFirst或doLast中。

1
2
3
4
5
6
7
8
9
task myTask {
    println "1"
    doFirst {
        println "2"
    }
    doLast {
        println "3"
    }
}

实战 （自定义Plugin）

  1. 创建工程：

    1. androidstudio创建一个工程

    2. src/main下新建两个文件夹，groovy、resources，

      这个这里的名字叫什么都可以

    3. 修改 app文件夹下的build.gradle文件

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      apply plugin: 'groovy' //使用groovy插件
      dependencies {
          implementation gradleApi() //引入gradleApi
      }
      sourceSets {
          main {
              groovy {
                  srcDir 'src/main/groovy' //指定groovy目录
              }
              resources {
                  srcDir 'src/main/resources' //指定resources目录
              }
          }
      }

    4. 在groovy目录新建PublishAppPlugin.groovy文件，实现Plugin接口

      1
      2
      3
      4
      5
      class PublishAppPlugin implements Plugin<Project> {
          void apply(Project project) { //入口
              println "hello plugin"
          }
      }

    5. 在resources/META-INF/gradle-plugins目录中新建com.wanzhi.plugin.publishApp.properties文件，这个文件名就是要是使用我们插件时要 apply的名字，这里叫com.wangzhi.plugin.publishApp,这个文件写入代码：

      1
      implementation-class = com.wangzhi.plugin.publishAppPlugin

    6. 目录结构

  2. 接收必要的参数

    1. 根据我们的需求，我们需要以下参数。

      1. 360加固包的路径
      2. 签名文件的路径、密码信息
      3. 渠道文件的路径
      4. 文件输出路径

    2. 定义扩展形象，新建PublishAppINfoExtension.groovy文件，根据上面的信息，定义相关参数

      1
      2
      3
      4
      5
      6
      7
      8
      9
      class PublishAppInfoExtension {
          String qihuPath //360加固包(jiagu.jar)的文件路径
          String keyStorePath 
          String keyStorePass
          String keyStoreKeyAlias
          String keyStoreKeyAliasPass
          String channelPath 
          String outputPath
      }

    3. 为目标工程定义扩展：

      1
      2
      3
      4
      5
      class PublishAppPlugin implements Plugin<Project> {
          void apply(Project project) {
              project.extensions.create("publishAppInfo", PublishAppInfoExtension.class)
          }
      }

  3. 功能实现:

    1. 自定义Task

      1. 新建PublishAppTask继承DefaultTask
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      class PublishAppTask extends DefaultTask {
          PublisAppTask() {
              group = "zhousaito"
              dependOn "build"
          }
         	@TaskAction
          void doAction() {
              //打包已完成
          }
         
      }

      1. 为目标工程定义我们的Task

        1
        2
        3
        4
        5
        6
        7
        class PublishAppPlugin implements Plugin<Project> {
            @Override
            void apply(Project project) {
                project.extensions.create("publishAppInfo", PublishAppInfoExtension)
                project.tasks.create("publishApp", PublishAppTask.class)
            }
        }
2. @TaskAction 是任务的执行的方法，会在执行阶段执行，因为我们的任务时依赖于build的，所以我们执行任务时，打包已经完成

  1. 加固我们的应用

    这里参考360加固的命令行加固相关文档即可。

    webVIew优化

Zhou SaitoAndroid Developer & Designer

Android开发工程师,半音阶口琴爱好者