Jenkins共享库之Groovy语法

Jenkins同享库的应用 – ()

上一篇文章咱们了解了jenkins 同享库的应用，在里面也用到了groov的语法，这可能是jenkins门槛稍微高一点的应用，不过没关系，我会慢慢带你们熟悉这门言语，后边的文章会逐步用同享库的办法，完结构建安卓，node，java等代码的编译，最终也会给你一套能够自动化辨认，项目言语然后进行不同言语项目构建的办法。

首要咱们来布置一下groovy的环境。

拜访Groovy的官网

http://www.groovy-lang.org/

咱们能够看到，它是又Apache基金会办理的一个项目，和它的一些长处。点击Download，咱们会看到许多版别

由于jenkins是运转的2.X的版别，所以咱们也下载2.x的版别，能够直接下载windows的版别。连接如下:

https://groovy.jfrog.io/artifactory/dist-release-local/groovy-windows-installer/groovy-2.5.15/

下载后完结安装，就会发现桌面上有一个Groovy Console的 图标。咱们就能够用这个作为开发东西，来运转咱们的groovy程序。

老规矩，先输出一下Hello World.

println("Hello World")

然后ctrl + r 运转

我会从数据类型，条件判别，循环操控，和函数来简述一下Grovvy的简单应用。

01 数据类型

字符串string

字符串表明咱们能够运用，单引号、双引号、三引号三种办法。这儿必定要留意，如果要引证变量，那么必定要用双引号，单引号会原样输出。

在写Jenkins的构建过程中，对字符串的操效果的最多的仍是split的办法，有的时候咱们会将url传过来的信息，切割一下取出咱们想要的内容，拼写途径或者文件名称一类的。

比方,相似如下的操作

def srcName = srcUrl.split("/")[-1]
srcDir = "${workspace}/${srcTmp}"

这儿还用def这个关键字。那么除了split的办法，操作字符串还有没有其他的办法呢，当然是有。

• contains(): 是否包括特定内容 回来true false
• size(): length() 字符串数量巨细长度
• toString(): 转换成string类型
• indexOf(): 元素的索引
• endsWith(): 是否指定字符结尾
• minus() plus(): 去掉、增加字符串
• reverse(): 反向排序
• substring(1,2): 字符串的指定索引开始的子字符串
• toUpperCase() toLowerCase(): 字符串巨细写转换
• split(): 字符串切割 默认空格切割 回来列表

让咱们来举几个比方，首要要界说两个变量，一个数字，一个字符串，然后对其进行操作

def str = "test"
def num = 1
println(str.contains("te"))
println(str.contains("le"))
println(str.size())
println(num.toString())
println(str.reverse())
println(str.toUpperCase())

咱们在编译器中试一下，效果如下

列表list

• + - += -=: 元素增加削减
• isEmpty(): 是否为空判别
• add(): 增加元素
• intersect([2,3]) disjoint([1]): 取交集、判别是否有交集
• flatten(): 合并嵌套的列表
• unique(): 去重
• reverse() sort(): 回转 升序
• count(): 元素个数
• join(): 将元素按照参数链接
• sum() min() max(): 求和 最小值 最大值
• contains(): 包括特定元素
• remove(2): removeAll()
• each{}: 遍历
• trim: 去除字符串前后的空格

def list1 = ["a", "b", "c"]
def list2 = ["d", "e", "f"]
def list3 = []
def list4 = ["a", "b", "c", "d", "e", "f"]
def list5 = ["a", "b", "c",["d", "e", "f"]]
def list6 = ["a", "b", "c", "a"]
println(list1 + list2)
println(list1.isEmpty())
println(list3.isEmpty())
println(list1.intersect(list2))
println(list4.intersect(list2))
println(list5.flatten())
println(list6.unique())

输出

[a, b, c, d, e, f]
false
true
[]
[d, e, f]
[a, b, c, d, e, f]
[a, b, c]

映射map

在Jenkins构建中，map是运用的适当频频的一种数据架构。咱们经常拿来界说变量，比方

    def args = [
            env: env.Environment,
            workspace: "/var/lib/jenkins/workspace/cicd-projects",
            groupName: env.GroupName,
            projectName: null,
            gitBranch: env.Branch,
            gitUrl: env.RepositoryURL,
            extra: null,
            envType: env.EnvType
    ];

运用的时候能够如下写法

    stage('Pre') {
        if (args.projectName == null) {
            echo "projectName 为空"
        }
        echo "git地址：$args.gitUrl"
        echo "git分支：$args.gitBranch"
        echo "项目组：$args.groupName"
        echo "项目名：$args.projectName"
        echo "环境：$args.env"
        echo "a,b环境: $args.envType"
        echo "附加参数：$args.extra"
    }

对于map也有一些操作的办法

• size(): map巨细
• [’key’]: .key get() 获取value
• isEmpty(): 是否为空
• containKey(): 是否包括key
• containValue(): 是否包括指定的value
• keySet(): 生成key的列表
• each{}: 遍历map
• remove(‘a‘): 删去元素（k-v）

比方：

groovy:000> [:]
===> [:]
groovy:000> [1:2]
===> [1:2]
groovy:000> [1:2][1]
===> 2
groovy:000> [1:2,3:4,5:6]
===> [1:2, 3:4, 5:6]
groovy:000> [1:2,3:4,5:6].keySet()
===> [1, 3, 5]
groovy:000> [1:2,3:4,5:6].values()
===> [2, 4, 6]
groovy:000> [1:2,3:4,5:6] + [7:8]
===> [1:2, 3:4, 5:6, 7:8]
groovy:000> [1:2,3:4,5:6] - [7:8]
===> [1:2, 3:4, 5:6]

02 条件句子

if句子

在Jenkinsfile中可用于条件判别。他的基本结构如下：

if (表达式) {
   //xxxx
} else if(表达式2) {
   //xxxxx
} else {
   //
}

咱们能够用来判别项目，什么想用引证相应的东西。

if (buildType == 'maven'){
    Home = tool '/usr/local/apache-maven'
    buildHome = "${Home}/bin/mvn"
} else if (buildType == 'ant'){
    Home = tool 'ANT'
    buildHome = "${Home}/bin/ant"
} else if (buildType == 'gradle'){
    buildHome = '/usr/local/bin/gradle'
} else{
    error 'buildType Error [maven|ant|gradle]'
}

switch句子

switch句子的结构如下：

switch("${buildType}"){
    case ”maven":
    //xxxx
        break;
    case ”ant":
    //xxxx
        break;
    default:
    //xxxx
}

下面我来举个比方，咱们能够用另外的一个办法判别项目，回来呼应的构建

switch (projectType){
    case "java-gradle":
        return new JavaGradleBuild(steps, args);
    case "java-maven":
        return new JavaMavenBuild(steps, args);
    case "android":
        return new AndroidBuild(steps, args);
    case "web":
        return new WebBuild(steps, args);
    case "node":
        return new NodeBuild(steps, args);
    default:
        return new Build(steps,args);
}

咱们能够将每一种构建写成一个groovy文件，然后判别呼应的类型，回来一个new出来的实例，这部分内容。我会在后边的文章详细说明。

03 循环句子

for循环句子

test = [1,2,3]
for ( i in test){
    ///xxxxxx
    break;
}

比方,咱们有一个列表，要遍历列表中内容来进行操作

langs = ['java','python','groovy']
for ( lang in langs ){
    if (lang == "java"){
        println("lang error in java")
    }else {
        println("lang is ${lang}")
    }
}

while循环句子

while(true){
    //xxxx
}

04 函数和类

咱们能够用def来界说一个函数

def PrintMes(info){
    println(info)
    return info
}
response = PrintMes("DevOps")
println(response)

咱们能够用def来界说一个类中的办法。具体改怎样写呢

比方，咱们有一个文件build.groovy咱们想让他作为一个进口文件判别项目的类型，然后运转呼应的构建。咱们又创建了一个JavaMavenBuild.groovy的文件来寄存，构建用Maven东西来编译的Java程序。那咱们需要怎样做呢

比方，咱们将这两个文件放于/src/com/devops/pipeline/build的途径下。咱们在JavaMavenBuild.groovy文件的榜首行用package关键字声明一下package com.devops.pipeline.build，然后咱们创建一个class，如下：

class JavaGradleBuild extends Build {
    JavaGradleBuild(steps, args) {
        super(steps, args);
        if (args.env == 'prod') {
            ...
        }
    }
}

这样咱们在build.groovy文件中，就能够用new JavaMavenBuild(steps, args);的办法来引证它了。

最终我来总结一下，今天首要介绍了数据类型，条件判别，循环操控，和函数。Groovy作为脚本言语大部分内容仍是比较简单，可能在类的地方有一些麻烦。这儿要留意一些写法，比方字符串'''和''三引号和双引号的区别。当咱们在构建中，调用一个dockerfile进行容器构建的时候，咱们会传一些变量到进去，在java -jar ...的命令中用，就需要留意这些写法。