58同城网站建设案例邢台123信息网

58同城网站建设案例,邢台123信息网,营销活动推广策划,如何给公司网站做优化Groovy作为一门基于JVM的动态编程语言#xff0c;兼具Java的稳定性与脚本语言的灵活性#xff0c;在自动化测试、DevOps、数据处理等领域被广泛应用。本文将从基础语法到高级特性#xff0c;结合大量可直接编译运行的实例#xff0c;深入剖析Groovy脚本的核心逻辑与实战技巧…Groovy作为一门基于JVM的动态编程语言兼具Java的稳定性与脚本语言的灵活性在自动化测试、DevOps、数据处理等领域被广泛应用。本文将从基础语法到高级特性结合大量可直接编译运行的实例深入剖析Groovy脚本的核心逻辑与实战技巧帮助开发者快速掌握这门高效的编程语言。一、Groovy简介与环境搭建1.1 什么是GroovyGroovy是一门基于JVM的动态脚本语言由James Strachan于2003年创建。它完全兼容Java语法同时吸收了Python、Ruby等脚本语言的优点提供了更简洁的语法、强大的元编程能力和丰富的内置API。Groovy代码可以直接编译为Java字节码无缝运行在JVM上并且能与Java类库完美互操作。权威来源Groovy官方文档1.2 环境搭建Maven方式在Java项目中集成Groovy推荐使用Maven管理依赖。以下是完整的pom.xml配置基于最新稳定版Groovy 4.0.20?xml version1.0 encodingUTF-8? project xmlnshttp://maven.apache.org/POM/4.0.0 xmlns:xsihttp://www.w3.org/2001/XMLSchema-instance xsi:schemaLocationhttp://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd modelVersion4.0.0/modelVersion groupIdcom.jam.demo/groupId artifactIdgroovy-demo/artifactId version1.0-SNAPSHOT/version properties maven.compiler.source17/maven.compiler.source maven.compiler.target17/maven.compiler.target project.build.sourceEncodingUTF-8/project.build.sourceEncoding groovy.version4.0.20/groovy.version lombok.version1.18.30/lombok.version spring-boot.version3.2.5/spring-boot.version fastjson2.version2.0.47/fastjson2.version mybatis-plus.version3.5.5/mybatis-plus.version mysql.version8.0.36/mysql.version /properties !-- 父依赖Spring Boot 最新稳定版 -- parent groupIdorg.springframework.boot/groupId artifactIdspring-boot-starter-parent/artifactId version${spring-boot.version}/version relativePath/ /parent dependencies !-- Groovy核心依赖 -- dependency groupIdorg.codehaus.groovy/groupId artifactIdgroovy-all/artifactId version${groovy.version}/version typepom/type /dependency !-- Spring Boot Starter -- dependency groupIdorg.springframework.boot/groupId artifactIdspring-boot-starter-web/artifactId /dependency !-- Lombok -- dependency groupIdorg.projectlombok/groupId artifactIdlombok/artifactId version${lombok.version}/version scopeprovided/scope /dependency !-- FastJSON2 -- dependency groupIdcom.alibaba.fastjson2/groupId artifactIdfastjson2/artifactId version${fastjson2.version}/version /dependency !-- MyBatis-Plus -- dependency groupIdcom.baomidou/groupId artifactIdmybatis-plus-boot-starter/artifactId version${mybatis-plus.version}/version /dependency !-- MySQL驱动 -- dependency groupIdcom.mysql/groupId artifactIdmysql-connector-j/artifactId version${mysql.version}/version scoperuntime/scope /dependency !-- Swagger3 -- dependency groupIdio.springfox/groupId artifactIdspringfox-boot-starter/artifactId version3.0.0/version /dependency /dependencies build plugins !-- Groovy编译插件 -- plugin groupIdorg.codehaus.gmavenplus/groupId artifactIdgmavenplus-plugin/artifactId version3.0.0/version executions execution goals goalcompile/goal goaltestCompile/goal /goals /execution /executions configuration sourceEncoding${project.build.sourceEncoding}/sourceEncoding targetBytecodeVersion17/targetBytecodeVersion /configuration /plugin plugin groupIdorg.springframework.boot/groupId artifactIdspring-boot-maven-plugin/artifactId configuration excludes exclude groupIdorg.projectlombok/groupId artifactIdlombok/artifactId /exclude /excludes /configuration /plugin /plugins /build /project二、Groovy基础语法兼容Java更简洁2.1 变量定义Groovy支持动态类型和静态类型变量定义可省略类型声明使用def关键字也可显式指定类型兼容Java。2.1.1 基本语法/** * 变量定义示例 * author ken */ // 动态类型def关键字类型由赋值自动推断 def name Groovy // String类型 def age 30 // Integer类型 def isEnable true // Boolean类型 // 静态类型显式指定类型兼容Java String title Groovy语法指南 Integer count 100 Boolean flag false // 常量定义final关键字与Java一致 final String VERSION 4.0.202.1.2 变量作用域Groovy的变量作用域与Java类似分为局部变量、成员变量、静态变量/** * 变量作用域示例 * author ken */ class VariableScopeDemo { // 成员变量实例变量 String memberVar 成员变量 // 静态变量类变量 static String staticVar 静态变量 void testScope() { // 局部变量 def localVar 局部变量 println(局部变量${localVar}) println(成员变量${memberVar}) println(静态变量${staticVar}) } } // 运行测试 new VariableScopeDemo().testScope() // 输出结果 // 局部变量局部变量 // 成员变量成员变量 // 静态变量静态变量2.2 数据类型Groovy的核心数据类型与Java一致基本类型包装类型同时扩展了部分实用类型如GString、Range等。2.2.1 基本数据类型与Java完全兼容/** * 基本数据类型示例 * author ken */ // 整数类型 byte b 10 short s 200 int i 1000 long l 10000000000L // 浮点类型 float f 3.14f double d 3.1415926 // 字符类型 char c A // 布尔类型 boolean bool true // 输出类型信息 println(byte类型${b.class}) // class java.lang.Byte println(int类型${i.class}) // class java.lang.Integer println(double类型${d.class}) // class java.lang.Double println(char类型${c.class}) // class java.lang.Character2.2.2 Groovy扩展类型GString可插值字符串支持在字符串中直接插入变量或表达式用${}包裹比Java的字符串拼接更简洁。/** * GString示例 * author ken */ def name Groovy def version 4.0.20 // 单引号字符串无插值功能与Java一致 def singleQuoteStr Hello, ${name}! // 双引号字符串支持插值GString类型 def doubleQuoteStr Hello, ${name}! Version: ${version} // 三引号字符串支持多行文本和插值 def multiLineStr Hello, ${name}! This is a multi-line string. Version: ${version} println(singleQuoteStr) // 输出Hello, ${name}! println(doubleQuoteStr) // 输出Hello, Groovy! Version: 4.0.20 println(multiLineStr) // 输出 // Hello, Groovy! // This is a multi-line string. // Version: 4.0.20 // 验证类型 println(doubleQuoteStr.class) // class groovy.lang.GString println(singleQuoteStr.class) // class java.lang.StringRange范围类型表示一个连续的区间支持整数、字符、日期等类型语法为start..end闭区间或start..end左闭右开区间。/** * Range示例 * author ken */ // 整数范围闭区间1到5包含5 def intRange 1..5 // 整数范围左闭右开1到5不包含5 def intRangeOpen 1..5 // 字符范围 def charRange a..e // 日期范围 def dateStart new Date() def dateEnd new Date() 7 // 7天后 def dateRange dateStart..dateEnd // 遍历Range println(整数闭区间遍历) intRange.each { println(it) } // 输出1,2,3,4,5 println(整数左闭右开区间遍历) intRangeOpen.each { println(it) } // 输出1,2,3,4 println(字符范围遍历) charRange.each { println(it) } // 输出a,b,c,d,e // Range常用方法 println(intRange是否包含3${intRange.contains(3)}) // true println(intRange的长度${intRange.size()}) // 5 println(intRange的第一个元素${intRange.from}) // 1 println(intRange的最后一个元素${intRange.to}) // 52.3 运算符Groovy支持Java的所有运算符同时扩展了部分实用运算符让代码更简洁。2.3.1 基础运算符与Java一致/** * 基础运算符示例 * author ken */ def a 10 def b 3 // 算术运算符 println(a b ${a b}) // 13 println(a - b ${a - b}) // 7 println(a * b ${a * b}) // 30 println(a / b ${a / b}) // 3.3333333333333335 println(a % b ${a % b}) // 1 println(a ** b ${a ** b}) // 1000幂运算Groovy扩展 // 比较运算符 println(a b ? ${a b}) // false println(a b ? ${a b}) // true println(a b ? ${a b}) // false // 逻辑运算符 def flag1 true def flag2 false println(flag1 flag2 ${flag1 flag2}) // false println(flag1 || flag2 ${flag1 || flag2}) // true println(!flag1 ${!flag1}) // false2.3.2 Groovy扩展运算符安全导航运算符?.避免空指针异常当对象为null时表达式直接返回null而非抛出异常。/** * 安全导航运算符示例 * author ken */ class User { String name Integer age } def user1 new User(name: 张三, age: 25) def user2 null // 正常访问无空指针 println(user1姓名${user1?.name}) // 张三 // 当对象为null时返回null不抛出异常 println(user2姓名${user2?.name}) // null // 对比Java若直接user2.name会抛出NullPointerException** Elvis运算符?:**简化空值判断等价于obj ! null ? obj : 默认值。/** * Elvis运算符示例 * author ken */ def user null def defaultName 未知用户 // 等价于def userName user ! null ? user.name : defaultName def userName user?.name ?: defaultName println(userName) // 未知用户 // 非空场景 def user3 new User(name: 李四, age: 30) def userName3 user3?.name ?: defaultName println(userName3) // 李四安全类型转换运算符as?安全地进行类型转换转换失败时返回null而非抛出ClassCastException。/** * 安全类型转换运算符示例 * author ken */ def obj1 123 def obj2 abc // 安全转换为Integer转换成功返回对应类型 def num1 obj1 as? Integer println(num1类型${num1.class}值${num1}) // class java.lang.Integer值123 // 转换失败返回null def num2 obj2 as? Integer println(num2${num2}) // null // 对比Java(Integer)obj2会抛出ClassCastException展开运算符*用于集合或数组的展开将集合元素作为独立参数传递给方法。/** * 展开运算符示例 * author ken */ def list [1, 2, 3] // 定义一个接收多个参数的方法 def sum(a, b, c) { return a b c } // 使用展开运算符传递集合元素 def total sum(*list) println(总和${total}) // 6 // 字符串展开转换为字符数组 def str abc def charList [*str] println(charList) // [a, b, c]2.4 流程控制语句Groovy的流程控制语句与Java基本一致包括if-else、for、while、switch等但语法更简洁。2.4.1 if-else与Java一致/** * if-else示例 * author ken */ def score 85 if (score 90) { println(优秀) } else if (score 80) { println(良好) } else if (score 60) { println(及格) } else { println(不及格) } // 输出良好2.4.2 for循环扩展了更简洁的语法/** * for循环示例 * author ken */ // 1. 传统for循环与Java一致 for (int i 0; i 5; i) { println(传统循环${i}) } // 2. 增强for循环遍历集合/数组与Java一致 def list [1, 2, 3, 4, 5] for (def item : list) { println(增强循环${item}) } // 3. Groovy简化循环遍历Range for (i in 1..5) { println(简化循环${i}) } // 4. 遍历Map def map [name: Groovy, version: 4.0.20, author: James Strachan] for (entry in map) { println(Map键${entry.key}值${entry.value}) }2.4.3 while与do-while与Java一致/** * while与do-while示例 * author ken */ // while循环 def count 0 while (count 3) { println(while循环${count}) count } // do-while循环至少执行一次 def num 0 do { println(do-while循环${num}) num } while (num 3)2.4.4 switch-case支持更多类型更灵活Groovy的switch支持整数、字符串、表达式、类型判断等比Java更强大。/** * switch-case示例 * author ken */ def obj Groovy switch (obj) { case 1: println(整数1) break case Groovy: println(字符串Groovy) break case [1, 2, 3]: println(集合中的元素) break case Integer: println(Integer类型) break case String: println(String类型) break default: println(默认情况) } // 输出字符串Groovy三、Groovy核心特性相比Java的优势3.1 集合操作List、Map、SetGroovy对Java集合进行了深度扩展提供了大量便捷的方法让集合操作更简洁高效。3.1.1 List列表Groovy的List默认是java.util.ArrayList定义语法为[元素1, 元素2, ...]。/** * List操作示例 * author ken */ // 定义List默认ArrayList def list [1, 2, 3, 4, 5] // 1. 访问元素 println(第一个元素${list[0]}) // 1 println(最后一个元素${list[-1]}) // 5Groovy扩展负索引表示从尾部开始 println(索引1到3的元素${list[1..3]}) // [2, 3, 4]Range切片 // 2. 添加元素 list.add(6) list 7 // Groovy扩展左移运算符等价于add() list.addAll([8, 9]) println(添加元素后${list}) // [1, 2, 3, 4, 5, 6, 7, 8, 9] // 3. 删除元素 list.remove(0) // 删除索引0的元素 list.remove(Integer.valueOf(9)) // 删除值为9的元素 list - 8 // Groovy扩展减号运算符等价于remove() println(删除元素后${list}) // [2, 3, 4, 5, 6, 7] // 4. 遍历List // 方式1each方法最常用 println(each遍历) list.each { element - println(element) } // 方式2eachWithIndex带索引遍历 println(eachWithIndex遍历) list.eachWithIndex { element, index - println(索引${index}${element}) } // 5. 过滤与转换高阶函数 // filter筛选出偶数 def evenList list.findAll { it % 2 0 } println(偶数列表${evenList}) // [2, 4, 6] // map将每个元素乘以2 def doubleList list.collect { it * 2 } println(元素翻倍后${doubleList}) // [4, 6, 8, 10, 12, 14] // 6. 聚合操作 def sum list.sum() // 求和 def max list.max() // 最大值 def min list.min() // 最小值 def average list.average() // 平均值 println(求和${sum}最大值${max}最小值${min}平均值${average}) // 输出求和27最大值7最小值2平均值4.53.1.2 Map映射Groovy的Map默认是java.util.LinkedHashMap定义语法为[键1: 值1, 键2: 值2, ...]键默认是字符串可省略引号。/** * Map操作示例 * author ken */ // 定义Map键默认是字符串可省略引号 def map [name: Groovy, version: 4.0.20, author: James Strachan] // 1. 访问元素 println(name${map.name}) // Groovy点语法推荐 println(version${map[version]}) // 4.0.20括号语法 println(author${map.get(author)}) // James Strachanget方法 println(不存在的键${map.get(desc, 无描述)}) // 无描述get方法带默认值 // 2. 添加元素 map.desc 基于JVM的动态脚本语言 // 点语法添加 map.put(year, 2003) // put方法添加 map [language: Java] // 左移运算符添加 println(添加元素后${map}) // 输出[name:Groovy, version:4.0.20, author:James Strachan, desc:基于JVM的动态脚本语言, year:2003, language:Java] // 3. 删除元素 map.remove(year) map - language // 减号运算符删除 println(删除元素后${map}) // 输出[name:Groovy, version:4.0.20, author:James Strachan, desc:基于JVM的动态脚本语言] // 4. 遍历Map // 方式1遍历entry map.each { entry - println(键${entry.key}值${entry.value}) } // 方式2遍历键和值解构 map.each { key, value - println(键${key}值${value}) } // 方式3遍历键或值 println(遍历键) map.keySet().each { println(it) } println(遍历值) map.values().each { println(it) } // 5. 过滤与转换 // 筛选出值长度大于5的entry def filteredMap map.findAll { key, value - value.toString().length() 5 } println(筛选后${filteredMap}) // 输出[name:Groovy, author:James Strachan, desc:基于JVM的动态脚本语言] // 转换为List键值对数组 def entryList map.collect { key, value - [key: key, value: value] } println(转换为List${entryList})3.1.3 Set集合Groovy的Set默认是java.util.LinkedHashSet定义语法为[元素1, 元素2, ...] as Set或new HashSet([元素1, 元素2, ...])。/** * Set操作示例 * author ken */ // 定义Set去重特性 def set [1, 2, 2, 3, 3, 3] as Set println(Set初始化去重${set}) // [1, 2, 3] // 1. 添加元素 set.add(4) set 5 println(添加元素后${set}) // [1, 2, 3, 4, 5] // 2. 删除元素 set.remove(2) set - 3 println(删除元素后${set}) // [1, 4, 5] // 3. 集合运算 def set1 [1, 2, 3, 4] as Set def set2 [3, 4, 5, 6] as Set // 并集 def union set1 set2 println(并集${union}) // [1, 2, 3, 4, 5, 6] // 交集 def intersection set1.intersect(set2) println(交集${intersection}) // [3, 4] // 差集set1 - set2 def difference set1 - set2 println(差集${difference}) // [1, 2] // 4. 遍历Set set1.each { println(it) }3.2 方法定义与调用Groovy的方法定义比Java更简洁支持可选参数、默认参数、变长参数且方法调用时可省略括号特殊场景。3.2.1 基础方法定义/** * 基础方法定义示例 * author ken */ // 无返回值方法返回类型可省略默认void def printHello(String name) { println(Hello, ${name}!) } // 有返回值方法返回类型可省略由return自动推断 def add(Integer a, Integer b) { a b // Groovy可省略return最后一行表达式结果即为返回值 } // 显式指定返回类型兼容Java Integer multiply(Integer a, Integer b) { return a * b } // 方法调用 printHello(Groovy) // 输出Hello, Groovy! def sum add(10, 20) println(10 20 ${sum}) // 30 def product multiply(10, 20) println(10 * 20 ${product}) // 2003.2.2 可选参数与默认参数Groovy支持为方法参数设置默认值调用时可省略默认参数。/** * 可选参数与默认参数示例 * author ken */ // 带默认参数的方法 def sayHello(String name, String prefix Hello, String suffix !) { ${prefix}, ${name}${suffix} } // 调用方法传入所有参数 def msg1 sayHello(张三, Hi, !!!) println(msg1) // Hi, 张三!!! // 调用方法省略部分默认参数按顺序省略 def msg2 sayHello(李四) println(msg2) // Hello, 李四! // 调用方法指定参数名传递可打乱顺序 def msg3 sayHello(suffix: ~, name: 王五, prefix: Hi) println(msg3) // Hi, 王五~3.2.3 变长参数与Java类似使用...表示变长参数变长参数必须位于方法参数列表的最后。/** * 变长参数示例 * author ken */ // 变长参数方法int... args 等价于 def... args def sumAll(Integer... args) { args.sum() // 变长参数可直接作为数组处理 } // 调用方法传入多个参数 def total1 sumAll(1, 2, 3, 4, 5) println(总和1${total1}) // 15 // 调用方法传入数组需使用展开运算符 def nums [6, 7, 8] def total2 sumAll(*nums) println(总和2${total2}) // 213.2.4 方法调用省略括号当方法调用是语句的最后一个表达式且参数明确时可省略括号增强可读性。/** * 方法调用省略括号示例 * author ken */ def printMsg(String msg) { println(msg) } // 省略括号调用参数明确 printMsg Hello, Groovy! // 等价于 printMsg(Hello, Groovy!) // 链式调用省略括号 def appendStr(String str1, String str2) { str1 str2 } def result appendStr Hello, , Groovy println result // 等价于 println(result)3.3 类与对象Groovy的类定义兼容Java同时提供了大量语法糖如简化的构造器、属性访问器、静态导入等。3.3.1 简化的类定义Groovy自动为类的成员变量生成getter和setter方法无需手动编写。/** * 简化类定义示例 * author ken */ // 定义类成员变量自动生成getter/setter class User { // 成员变量默认是private通过getter/setter访问 String name Integer age String email } // 创建对象使用Map构造器无需手动编写构造器 def user new User(name: 张三, age: 25, email: zhangsanexample.com) // 访问属性通过自动生成的getter/setter语法更简洁 println(姓名${user.name}) // 等价于 user.getName() println(年龄${user.age}) // 等价于 user.getAge() // 修改属性通过自动生成的setter user.age 26 println(修改后的年龄${user.age}) // 263.3.2 构造器Groovy默认提供无参构造器和基于成员变量的Map构造器也可手动定义构造器。/** * 构造器示例 * author ken */ class User { String name Integer age // 手动定义构造器覆盖默认构造器 User(String name, Integer age) { this.name name this.age age } // 重写toString方法Groovy可通过ToString注解简化后续介绍 Override String toString() { User{name${name}, age${age}} } } // 使用手动定义的构造器创建对象 def user1 new User(李四, 30) println(user1) // User{name李四, age30} // 若要使用Map构造器需显式定义无参构造器 class User2 { String name Integer age // 无参构造器 User2() {} // 重写toString Override String toString() { User2{name${name}, age${age}} } } // 使用Map构造器创建对象 def user2 new User2(name: 王五, age: 35) println(user2) // User2{name王五, age35}3.3.3 Groovy注解简化类定义Groovy提供了一系列注解可大幅简化类的编写如ToString、EqualsAndHashCode、TupleConstructor、Data等类似Lombok。/** * Groovy注解简化类定义示例 * author ken */ import groovy.transform.ToString import groovy.transform.EqualsAndHashCode import groovy.transform.TupleConstructor import groovy.transform.Data // ToString自动生成toString方法 ToString class User3 { String name Integer age } def user3 new User3(赵六, 40) println(user3) // User3(赵六, 40) // EqualsAndHashCode自动生成equals和hashCode方法 EqualsAndHashCode class User4 { String name Integer age } def user4_1 new User4(孙七, 45) def user4_2 new User4(孙七, 45) def user4_3 new User4(周八, 50) println(user4_1 user4_2 ? ${user4_1 user4_2}) // true println(user4_1 user4_3 ? ${user4_1 user4_3}) // false // TupleConstructor自动生成带所有成员变量的构造器 TupleConstructor class User5 { String name Integer age } def user5 new User5(吴九, 55) println(user5.name) // 吴九 println(user5.age) // 55 // Data组合ToString、EqualsAndHashCode、TupleConstructor、Getter、Setter Data class User6 { String name Integer age } def user6 new User6(郑十, 60) println(user6) // User6(郑十, 60) def user6_2 new User6(郑十, 60) println(user6 user6_2 ? ${user6 user6_2}) // true3.4 闭包Closure闭包是Groovy的核心特性之一它是一段可执行的代码块能够捕获上下文的变量和方法。闭包可作为参数传递、赋值给变量极大增强了代码的灵活性。3.4.1 闭包基础定义与调用闭包的定义语法为{ [参数列表] - 代码块 }参数列表可选若省略参数列表默认有一个it参数代表闭包的唯一参数。/** * 闭包基础示例 * author ken */ // 1. 无参数闭包 def noParamClosure { println(无参数闭包) } // 调用闭包两种方式 noParamClosure() noParamClosure.call() // 2. 带参数闭包显式定义参数 def paramClosure { String name, Integer age - println(姓名${name}年龄${age}) } paramClosure(张三, 25) paramClosure.call(李四, 30) // 3. 单参数闭包可省略参数列表使用默认参数it def singleParamClosure { println(默认参数it${it}) } singleParamClosure(Groovy) // 输出默认参数itGroovy3.4.2 闭包作为方法参数闭包最常用的场景是作为方法参数实现回调功能类似Java的Lambda表达式但更灵活。/** * 闭包作为方法参数示例 * author ken */ // 定义接收闭包参数的方法 def processList(List list, Closure closure) { list.each { element - closure.call(element) // 调用闭包 } } // 调用方法传递闭包 def list [1, 2, 3, 4, 5] processList(list) { element - println(元素${element * 2}) } // 输出 // 元素2 // 元素4 // 元素6 // 元素8 // 元素10 // 简化写法闭包作为最后一个参数时可放在方法括号外 processList(list) { println(元素${it * 3}) }3.4.3 闭包捕获上下文变量闭包能够捕获定义它的上下文环境中的变量和方法即使在上下文之外执行也能访问。/** * 闭包捕获上下文变量示例 * author ken */ def outerVar 外部变量 // 定义闭包捕获外部变量 def closure { println(捕获外部变量${outerVar}) } // 在上下文之外调用闭包 closure() // 输出捕获外部变量外部变量 // 修改外部变量闭包中也会同步变化 outerVar 修改后的外部变量 closure() // 输出捕获外部变量修改后的外部变量 // 闭包中修改外部变量 def count 0 def incrementClosure { count } incrementClosure() incrementClosure() println(count${count}) // 输出23.4.4 闭包的委托DelegateGroovy闭包有三个重要的属性this、owner、delegate用于指定闭包执行时的上下文。this表示定义闭包的类的实例。owner表示定义闭包的上下文可能是类或另一个闭包。delegate默认与owner一致可手动修改用于实现委托模式。/** * 闭包委托示例 * author ken */ class DelegateDemo { String name DelegateDemo void testClosure() { def closure { println(this${this.name}) println(owner${owner.name}) println(delegate${delegate.name}) } closure() } } new DelegateDemo().testClosure() // 输出 // thisDelegateDemo // ownerDelegateDemo // delegateDelegateDemo // 修改delegate class AnotherDelegate { String name AnotherDelegate } def demo new DelegateDemo() def anotherDelegate new AnotherDelegate() def closure { println(delegate${delegate.name}) } closure.delegate anotherDelegate closure() // 输出delegateAnotherDelegate四、Groovy高级特性4.1 元编程MetaprogrammingGroovy基于JVM实现了强大的元编程能力允许在运行时动态修改类的行为、添加方法、拦截方法调用等。核心机制包括Expando、方法拦截、元类MetaClass。4.1.1 Expando动态类Expando允许动态创建类和添加属性、方法适合快速构建临时对象。/** * Expando示例 * author ken */ // 创建Expando对象 def user new Expando() // 动态添加属性 user.name 张三 user.age 25 // 动态添加方法 user.sayHello { println(Hello, ${name}!) } user.calculate { Integer a, Integer b - a b } // 调用属性和方法 println(姓名${user.name}年龄${user.age}) // 姓名张三年龄25 user.sayHello() // 输出Hello, 张三! def sum user.calculate(10, 20) println(10 20 ${sum}) // 304.1.2 元类MetaClassGroovy为每个类都提供了一个元类MetaClass通过元类可以动态添加静态方法、实例方法或修改现有方法的行为。/** * MetaClass示例 * author ken */ class User { String name Integer age } // 1. 动态为User类添加实例方法 User.metaClass.sayHello { println(Hello, ${name}! 年龄${age}) } // 2. 动态为User类添加静态方法 User.metaClass.static.createUser { String name, Integer age - new User(name: name, age: age) } // 3. 调用动态添加的方法 def user User.createUser(李四, 30) user.sayHello() // 输出Hello, 李四! 年龄30 // 4. 拦截方法调用重写invokeMethod User.metaClass.invokeMethod { String methodName, Object[] args - if (methodName sayHello) { println(拦截sayHello方法自定义实现Hello, ${delegate.name}拦截后) } else { // 调用原方法 delegate.metaClass.getMetaMethod(methodName, args).invoke(delegate, args) } } user.sayHello() // 输出拦截sayHello方法自定义实现Hello, 李四拦截后4.2 异常处理Groovy的异常处理与Java基本一致支持try-catch-finally、抛出异常但语法更简洁且支持多异常捕获。/** * 异常处理示例 * author ken */ def divide(Integer a, Integer b) { if (b 0) { // 抛出异常与Java一致 throw new ArithmeticException(除数不能为0) } a / b } try { def result divide(10, 0) println(结果${result}) } catch (ArithmeticException e) { // 捕获特定异常 println(捕获异常${e.message}) } catch (Exception e) { // 捕获通用异常 println(捕获通用异常${e.message}) } finally { // 最终执行块无论是否异常都会执行 println(异常处理结束) } // 多异常捕获Groovy 3.0支持与Java 7一致 try { def list [1, 2, 3] println(list[10]) // 数组越界异常 divide(10, 0) // 算术异常 } catch (ArrayIndexOutOfBoundsException | ArithmeticException e) { println(捕获多类型异常${e.message}) } finally { println(多异常处理结束) }4.3 文件操作Groovy提供了简洁的文件操作API相比Java的IO操作更高效无需手动关闭流自动资源管理。4.3.1 读取文件/** * 文件读取示例 * author ken */ // 1. 读取文件所有内容一行代码 def content new File(test.txt).text println(文件内容${content}) // 2. 按行读取文件 def file new File(test.txt) // 方式1eachLine自动关闭流 file.eachLine { line, lineNum - println(第${lineNum}行${line}) } // 方式2readLines返回所有行的List def lines file.readLines() lines.each { println(it) } // 3. 读取文件流手动处理 file.withReader { reader - String line while ((line reader.readLine()) ! null) { println(line) } }4.3.2 写入文件/** * 文件写入示例 * author ken */ def file new File(output.txt) // 1. 覆盖写入文件一行代码 file.text Hello, Groovy!\n这是覆盖写入的内容 // 2. 追加写入文件 file.append(\n这是追加的内容) // 3. 按行写入文件 file.withWriter { writer - writer.writeLine(第一行内容) writer.writeLine(第二行内容) } // 4. 写入集合内容 def lines [第三行内容, 第四行内容] file.withWriter { writer - lines.each { writer.writeLine(it) } }4.4 数据库操作结合MyBatis-PlusGroovy可无缝集成MyBatis-Plus实现数据库操作。以下是完整的实战示例基于MySQL 8.0。4.4.1 配置文件application.ymlspring: datasource: url: jdbc:mysql://localhost:3306/groovy_demo?useSSLfalseserverTimezoneAsia/ShanghaiallowPublicKeyRetrievaltrue username: root password: root driver-class-name: com.mysql.cj.jdbc.Driver mybatis-plus: mapper-locations: classpath:mapper/*.xml type-aliases-package: com.jam.demo.entity configuration: map-underscore-to-camel-case: true log-impl: org.apache.ibatis.logging.stdout.StdOutImpl swagger: enabled: true4.4.2 实体类User.groovy/** * 用户实体类 * author ken */ package com.jam.demo.entity import com.baomidou.mybatisplus.annotation.IdType import com.baomidou.mybatisplus.annotation.TableId import com.baomidou.mybatisplus.annotation.TableName import io.swagger.annotations.ApiModel import io.swagger.annotations.ApiModelProperty import lombok.Data import java.time.LocalDateTime Data TableName(t_user) ApiModel(description 用户实体) class User { TableId(type IdType.AUTO) ApiModelProperty(value 主键ID) Integer id ApiModelProperty(value 用户名) String username ApiModelProperty(value 密码) String password ApiModelProperty(value 年龄) Integer age ApiModelProperty(value 创建时间) LocalDateTime createTime ApiModelProperty(value 更新时间) LocalDateTime updateTime }4.4.3 Mapper接口UserMapper.groovy/** * 用户Mapper * author ken */ package com.jam.demo.mapper import com.baomidou.mybatisplus.core.mapper.BaseMapper import com.jam.demo.entity.User import org.springframework.stereotype.Repository Repository interface UserMapper extends BaseMapperUser { }4.4.4 服务类UserService.groovy/** * 用户服务类 * author ken */ package com.jam.demo.service import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl import com.jam.demo.entity.User import com.jam.demo.mapper.UserMapper import org.springframework.stereotype.Service import org.springframework.transaction.annotation.Transactional Service class UserService extends ServiceImplUserMapper, User { /** * 新增用户 * param user 用户实体 * return 新增成功的用户 */ Transactional(rollbackFor Exception.class) User addUser(User user) { save(user) return user } /** * 根据ID查询用户 * param id 主键ID * return 用户实体 */ User getUserById(Integer id) { getById(id) } /** * 更新用户 * param user 用户实体 * return 是否更新成功 */ Transactional(rollbackFor Exception.class) boolean updateUser(User user) { updateById(user) } /** * 根据ID删除用户 * param id 主键ID * return 是否删除成功 */ Transactional(rollbackFor Exception.class) boolean deleteUser(Integer id) { removeById(id) } }4.4.5 控制器UserController.groovy/** * 用户控制器 * author ken */ package com.jam.demo.controller import com.jam.demo.entity.User import com.jam.demo.service.UserService import io.swagger.annotations.Api import io.swagger.annotations.ApiOperation import io.swagger.annotations.ApiParam import lombok.extern.slf4j.Slf4j import org.springframework.beans.factory.annotation.Autowired import org.springframework.util.ObjectUtils import org.springframework.web.bind.annotation.* RestController RequestMapping(/user) Api(tags 用户管理接口) Slf4j class UserController { Autowired UserService userService PostMapping(/add) ApiOperation(新增用户) User addUser(ApiParam(value 用户实体, required true) RequestBody User user) { log.info(新增用户{}, user) return userService.addUser(user) } GetMapping(/{id}) ApiOperation(根据ID查询用户) User getUserById(ApiParam(value 用户ID, required true) PathVariable Integer id) { log.info(查询用户ID{}, id) User user userService.getUserById(id) if (ObjectUtils.isEmpty(user)) { log.warn(用户ID{} 不存在, id) } return user } PutMapping(/update) ApiOperation(更新用户) boolean updateUser(ApiParam(value 用户实体, required true) RequestBody User user) { log.info(更新用户{}, user) if (ObjectUtils.isEmpty(user.getId())) { throw new IllegalArgumentException(用户ID不能为空) } return userService.updateUser(user) } DeleteMapping(/{id}) ApiOperation(根据ID删除用户) boolean deleteUser(ApiParam(value 用户ID, required true) PathVariable Integer id) { log.info(删除用户ID{}, id) return userService.deleteUser(id) } }4.4.6 启动类GroovyDemoApplication.groovy/** * 启动类 * author ken */ package com.jam.demo import org.mybatis.spring.annotation.MapperScan import org.springframework.boot.SpringApplication import org.springframework.boot.autoconfigure.SpringBootApplication SpringBootApplication MapperScan(com.jam.demo.mapper) class GroovyDemoApplication { static void main(String[] args) { SpringApplication.run(GroovyDemoApplication, args) } }4.4.7 SQL脚本创建表t_userCREATE TABLE t_user ( id int NOT NULL AUTO_INCREMENT COMMENT 主键ID, username varchar(50) NOT NULL COMMENT 用户名, password varchar(50) NOT NULL COMMENT 密码, age int DEFAULT NULL COMMENT 年龄, create_time datetime DEFAULT CURRENT_TIMESTAMP COMMENT 创建时间, update_time datetime DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT 更新时间, PRIMARY KEY (id) ) ENGINEInnoDB DEFAULT CHARSETutf8mb4 COMMENT用户表;五、Groovy 与 Java 的差异对比为了帮助开发者快速区分 Groovy 与 Java 的核心差异以下是详细的对比表格涵盖语法、特性、使用场景等关键维度结合实战场景说明差异带来的开发效率影响特性GroovyJava核心差异说明与实战影响变量定义支持 def 动态类型可省略类型声明静态类型也兼容必须显式指定类型Java 10 支持 var 局部变量类型推断Groovy 动态类型适合快速开发、脚本编写Java 静态类型更严谨适合大型项目类型安全控制字符串支持 GString 插值双引号、三引号单引号为普通字符串仅支持字符串拼接或 String.format无插值功能Groovy 字符串插值大幅简化文本拼接尤其适合 SQL 语句、日志打印等场景减少代码冗余集合定义与操作简化语法List 用 [ ]、Map 用 [key:value]提供丰富高阶方法each、findAll、collect 等List/Map 需通过 new 关键字创建高阶方法需借助 Stream APIJava 8Groovy 集合操作代码量仅为 Java 的 1/3 左右无需手动处理迭代器开发效率提升显著方法定义与调用可省略返回类型、return 关键字支持默认参数、命名参数可省略方法调用括号必须显式指定返回类型无默认参数需重载方法调用括号不可省略Groovy 方法语法更灵活默认参数减少重载方法数量命名参数提升多参数调用可读性构造器自动生成 Map 构造器支持new User(name: xxx)语法需手动定义构造器或使用 Lombok 注解仅支持按参数顺序传递Groovy 无需编写构造器即可快速创建对象尤其适合多属性实体类初始化闭包原生支持闭包可作为参数、变量传递支持委托机制无原生闭包需通过 Lambda 表达式Java 8替代功能受限Groovy 闭包更灵活支持上下文捕获、委托模式适合回调、DSL 开发Java Lambda 仅支持函数式接口元编程支持 MetaClass、Expando 动态修改类行为、添加方法不支持运行时动态修改类结构需借助字节码工具如 ASMGroovy 元编程适合 AOP 增强、动态扩展功能Java 需额外依赖框架实现复杂度高异常处理可省略 checked 异常声明支持多异常合并捕获必须声明或捕获 checked 异常多异常捕获需 Java 7 支持Groovy 简化异常处理流程适合脚本开发中快速迭代Java 异常机制更严谨适合企业级项目容错设计文件操作提供简洁 API如 file.text、file.eachLine自动关闭资源需手动处理流的创建与关闭或使用 try-with-resourcesJava 7Groovy 一行代码即可完成文件读写无需关注资源释放Java 文件操作代码繁琐易出现资源泄漏空指针防护提供安全导航运算符?.、Elvis 运算符?:需手动判断 null如 obj ! null ? obj.method() : nullGroovy 空指针防护语法简洁大幅减少空指针异常Java 需编写大量判空代码易遗漏运算符重载支持自定义运算符重载如 、-、* 等不支持自定义运算符重载仅原生类型支持固定运算符Groovy 运算符重载适合领域模型开发如金额、时间计算Java 需通过方法实现类似功能注释支持单行注释//、多行注释/*/、文档注释/* */额外支持 shebang 注释#!仅支持单行、多行、文档注释Groovy shebang 注释适合脚本文件直接运行如 #!/usr/bin/env groovyJava 无此功能5.1 差异核心逻辑动态 vs 静态Groovy 作为动态语言核心设计目标是“简化开发、提升效率”通过动态类型推断、语法糖、原生特性闭包、元编程减少模板代码而 Java 作为静态语言核心目标是“类型安全、性能稳定”通过严格的类型检查、编译期校验保障大型项目的可维护性。两者底层均基于 JVM字节码层面可无缝交互因此实际开发中常采用“Groovy 负责快速开发脚本/工具类Java 负责核心业务逻辑”的混合模式兼顾效率与稳定性。5.2 混合开发实战示例Groovy Java以下示例展示 Groovy 与 Java 混合开发的核心场景Groovy 编写工具类简化文件操作、集合处理Java 编写核心业务服务两者无缝调用。5.2.1 Groovy 工具类FileUtils.groovy/** * 文件操作工具类Groovy 实现简化 IO 操作 * author ken */ package com.jam.demo.util import org.springframework.util.StringUtils class FileUtils { /** * 读取文件内容自动关闭资源支持编码指定 * param filePath 文件路径 * param charset 编码默认 UTF-8 * return 文件内容字符串 */ static String readFile(String filePath, String charset UTF-8) { if (!StringUtils.hasText(filePath)) { throw new IllegalArgumentException(文件路径不能为空) } def file new File(filePath) if (!file.exists() || !file.isFile()) { throw new FileNotFoundException(文件不存在${filePath}) } // Groovy 简化 API自动关闭流 file.getText(charset) } /** * 按行处理文件支持大文件避免内存溢出 * param filePath 文件路径 * param closure 每行处理逻辑闭包参数行内容、行号 */ static void processFileByLine(String filePath, Closure closure) { if (!StringUtils.hasText(filePath) || ObjectUtils.isEmpty(closure)) { throw new IllegalArgumentException(文件路径或处理逻辑不能为空) } def file new File(filePath) if (!file.exists() || !file.isFile()) { throw new FileNotFoundException(文件不存在${filePath}) } // 按行读取自动关闭流闭包传递处理逻辑 file.eachLine { line, lineNum - closure.call(line, lineNum) } } }5.2.2 Java 业务服务类UserBusinessService.java/** * 用户业务服务Java 实现核心业务逻辑 * author ken */ package com.jam.demo.service; import com.jam.demo.entity.User; import com.jam.demo.mapper.UserMapper; import com.jam.demo.util.FileUtils; import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl; import lombok.extern.slf4j.Slf4j; import org.springframework.stereotype.Service; import org.springframework.transaction.annotation.Transactional; import org.springframework.util.ObjectUtils; import java.util.ArrayList; import java.util.List; Service Slf4j public class UserBusinessService extends ServiceImplUserMapper, User { /** * 从文件批量导入用户调用 Groovy 工具类实现文件读取 * param filePath 用户数据文件路径每行格式用户名,密码,年龄 * return 导入成功的用户数量 */ Transactional(rollbackFor Exception.class) public int batchImportUserFromFile(String filePath) { log.info(开始从文件导入用户{}, filePath); ListUser userList new ArrayList(); // 调用 Groovy 工具类的 processFileByLine 方法传递 Java Lambda 作为闭包Groovy 兼容 Java Lambda FileUtils.processFileByLine(filePath, (line, lineNum) - { log.debug(处理第 {} 行数据{}, lineNum, line); if (ObjectUtils.isEmpty(line)) { log.warn(第 {} 行数据为空跳过, lineNum); return; } // 解析行数据 String[] parts line.split(,); if (parts.length ! 3) { log.error(第 {} 行数据格式错误跳过{}, lineNum, line); return; } String username parts[0].trim(); String password parts[1].trim(); Integer age; try { age Integer.parseInt(parts[2].trim()); } catch (NumberFormatException e) { log.error(第 {} 行年龄格式错误跳过{}, lineNum, line); return; } // 构建用户实体 User user new User(); user.setUsername(username); user.setPassword(password); user.setAge(age); userList.add(user); }); // 批量保存用户 if (userList.isEmpty()) { log.warn(无有效用户数据可导入); return 0; } boolean success saveBatch(userList); log.info(用户导入完成有效数据行数{}导入成功{}, userList.size(), success); return success ? userList.size() : 0; } }5.2.3 测试验证Groovy 测试类/** * 混合开发测试类 * author ken */ package com.jam.demo.test import com.jam.demo.service.UserBusinessService import org.springframework.beans.factory.annotation.Autowired import org.springframework.boot.test.context.SpringBootTest SpringBootTest class MixedDevelopmentTest { Autowired UserBusinessService userBusinessService def 测试从文件批量导入用户() { given: 准备测试文件user_import.txt内容如下 def testFile new File(user_import.txt) testFile.text zhangsan,123456,25 lisi,654321,30 wangwu,abc123,35 when: 调用导入方法 def importCount userBusinessService.batchImportUserFromFile(user_import.txt) then: 验证导入结果 importCount 3 def userList userBusinessService.list() userList.size() 3 userList.any { it.username zhangsan it.age 25 } } }5.3 差异总结与选型建议优先选 Groovy 的场景自动化脚本部署脚本、数据迁移脚本、测试脚本工具类开发文件操作、数据格式转换、集合处理DSL 开发领域特定语言如 Gradle 脚本、Jenkins Pipeline快速原型开发需快速迭代验证业务逻辑优先选 Java 的场景大型企业级项目核心业务逻辑需类型安全、可维护性高性能要求的模块静态类型编译优化性能略优于动态类型团队以 Java 开发为主无需额外学习成本的场景混合开发最佳实践用 Groovy 编写“辅助性”代码工具类、脚本、测试用例提升开发效率用 Java 编写“核心性”代码业务服务、数据模型、接口定义保障系统稳定借助 Spring 生态实现两者无缝集成共享依赖与上下文六、Groovy 实战场景从脚本到企业级应用6.1 场景 1自动化测试脚本结合 JUnit 5Groovy 简化的语法和丰富的断言方法让测试脚本更简洁。以下示例实现用户模块的单元测试结合 JUnit 5 和 AssertJ 断言/** * 用户服务单元测试 * author ken */ package com.jam.demo.test import com.jam.demo.entity.User import com.jam.demo.service.UserService import org.junit.jupiter.api.Test import org.springframework.beans.factory.annotation.Autowired import org.springframework.boot.test.context.SpringBootTest import static org.assertj.core.api.Assertions.assertThat SpringBootTest class UserServiceTest { Autowired UserService userService Test void 测试新增用户() { // 准备测试数据 def user new User(username: test_user, password: test123, age: 28) // 执行测试方法 def savedUser userService.addUser(user) // 断言结果 assertThat(savedUser).isNotNull() assertThat(savedUser.getId()).isGreaterThan(0) assertThat(savedUser.getUsername()).isEqualTo(test_user) assertThat(savedUser.getAge()).isEqualTo(28) } Test void 测试根据ID查询用户() { // 先新增用户 def user new User(username: query_user, password: query123, age: 30) def savedUser userService.addUser(user) // 查询用户 def queriedUser userService.getUserById(savedUser.getId()) // 断言结果 assertThat(queriedUser).isNotNull() assertThat(queriedUser.getId()).isEqualTo(savedUser.getId()) assertThat(queriedUser.getUsername()).isEqualTo(query_user) } }6.2 场景 2数据迁移脚本批量处理数据库数据利用 Groovy 简化的数据库操作和集合处理实现从旧表到新表的数据迁移结合 MyBatis-Plus 提升效率/** * 旧用户表到新用户表的数据迁移脚本 * author ken */ package com.jam.demo.script import com.jam.demo.entity.OldUser import com.jam.demo.entity.User import com.jam.demo.mapper.OldUserMapper import com.jam.demo.mapper.UserMapper import com.jam.demo.util.DateUtils import org.springframework.beans.factory.annotation.Autowired import org.springframework.boot.CommandLineRunner import org.springframework.stereotype.Component import lombok.extern.slf4j.Slf4j import com.google.common.collect.Lists Slf4j Component class UserDataMigrationScript implements CommandLineRunner { Autowired OldUserMapper oldUserMapper Autowired UserMapper userMapper Override void run(String... args) throws Exception { log.info(开始执行用户数据迁移脚本) // 1. 分页查询旧表数据避免一次性加载过多数据导致内存溢出 int pageNum 1 int pageSize 1000 while (true) { // MyBatis-Plus 分页查询旧用户数据 def page oldUserMapper.selectPage(new Page(pageNum, pageSize), null) if (page.getRecords().isEmpty()) { break } log.info(处理第 {} 页数据共 {} 条, pageNum, page.getRecords().size()) // 2. 数据转换旧表实体 - 新表实体 def userList page.getRecords().collect { OldUser oldUser - new User( username: oldUser.getUserName(), // 字段名映射旧表 userName - 新表 username password: oldUser.getPassword(), age: oldUser.getAge(), createTime: DateUtils.parse(oldUser.getCreateTimeStr(), yyyy-MM-dd HH:mm:ss), // 日期格式转换 updateTime: new Date() ) } // 3. 批量插入新表分批处理提升效率 Lists.partition(userList, 500).each { batch - userMapper.insertBatchSomeColumn(batch) // MyBatis-Plus 批量插入方法 } pageNum } log.info(用户数据迁移脚本执行完成) } }6.3 场景 3Jenkins Pipeline 脚本DevOps 自动化部署Groovy 是 Jenkins Pipeline 的默认脚本语言利用其闭包和 DSL 特性实现自动化构建、测试、部署流程/** * Jenkins Pipeline 自动化部署脚本 * author ken */ pipeline { agent any // 任意可用的构建代理 environment { // 定义环境变量 PROJECT_NAME groovy-demo GIT_REPO https://gitee.com/xxx/groovy-demo.git BRANCH master JAR_PATH target/groovy-demo-1.0-SNAPSHOT.jar DEPLOY_PATH /opt/apps } stages { // 阶段 1拉取代码 stage(拉取代码) { steps { echo 开始拉取 ${GIT_REPO} 仓库 ${BRANCH} 分支代码 git url: GIT_REPO, branch: BRANCH } } // 阶段 2编译构建 stage(编译构建) { steps { echo 开始编译构建项目 sh mvn clean package -Dmaven.test.skiptrue // 跳过测试编译 } post { success { echo 编译构建成功生成 jar 包${JAR_PATH} } failure { echo 编译构建失败请检查代码或依赖 error 编译构建失败终止 Pipeline } } } // 阶段 3自动化测试 stage(自动化测试) { steps { echo 开始执行自动化测试 sh mvn test } post { success { echo 自动化测试全部通过 } failure { echo 自动化测试存在失败用例请修复后重新构建 error 自动化测试失败终止 Pipeline } } } // 阶段 4部署到服务器 stage(部署到服务器) { steps { echo 开始部署项目到服务器 // 停止旧服务 sh ssh root192.168.1.100 cd ${DEPLOY_PATH} ./stop.sh // 上传新 jar 包 sh scp ${JAR_PATH} root192.168.1.100:${DEPLOY_PATH} // 启动新服务 sh ssh root192.168.1.100 cd ${DEPLOY_PATH} ./start.sh } post { success { echo 项目部署成功访问地址http://192.168.1.100:8080 } failure { echo 项目部署失败请检查服务器连接或启动脚本 } } } } // 流水线执行完成后操作 post { always { echo Pipeline 执行完成无论成功或失败都会执行 // 清理构建产物 sh mvn clean } } }6.4 场景 4自定义 DSL领域特定语言利用 Groovy 的闭包、委托机制实现自定义 DSL简化特定领域的配置或操作。以下示例实现一个简单的“数据同步任务”DSL/** * 数据同步任务 DSL 定义与使用示例 * author ken */ package com.jam.demo.dsl import lombok.Data // 1. 定义 DSL 上下文类存储 DSL 配置信息 Data class SyncTask { String taskName String sourceTable String targetTable ListString columns Closure whereClosure // 过滤条件闭包 Closure transformClosure // 数据转换闭包 } // 2. 定义 DSL 构建器负责解析 DSL 语法绑定闭包委托 class SyncTaskBuilder { SyncTask task new SyncTask() // 任务名称配置 def name(String taskName) { task.setTaskName(taskName) } // 源表配置 def source(String sourceTable) { task.setSourceTable(sourceTable) } // 目标表配置 def target(String targetTable) { task.setTargetTable(targetTable) } // 同步字段配置 def columns(ListString columns) { task.setColumns(columns) } // 过滤条件配置闭包参数 def where(Closure closure) { task.setWhereClosure(closure) closure.delegate task // 绑定闭包委托为 SyncTask closure.resolveStrategy Closure.DELEGATE_FIRST // 优先从委托对象查找属性/方法 } // 数据转换配置闭包参数 def transform(Closure closure) { task.setTransformClosure(closure) closure.delegate task closure.resolveStrategy Closure.DELEGATE_FIRST } // 构建 SyncTask 对象 SyncTask build() { // 校验必填配置 if (!task.getTaskName()) throw new IllegalArgumentException(任务名称不能为空) if (!task.getSourceTable()) throw new IllegalArgumentException(源表不能为空) if (!task.getTargetTable()) throw new IllegalArgumentException(目标表不能为空) if (task.getColumns().isEmpty()) throw new IllegalArgumentException(同步字段不能为空) return task } } // 3. 定义 DSL 入口方法简化构建器创建 def syncTask(Closure closure) { def builder new SyncTaskBuilder() closure.delegate builder closure.resolveStrategy Closure.DELEGATE_FIRST closure.call() return builder.build() } // 4. 使用 DSL 定义数据同步任务 def userSyncTask syncTask { name 用户数据同步任务 source t_old_user target t_user columns [id, username, age, create_time] where { // 过滤条件年龄大于 18 且状态正常 age 18 AND status 1 } transform { // 数据转换将 create_time 格式化为 yyyy-MM-dd HH:mm:ss DATE_FORMAT(create_time, %Y-%m-%d %H:%i:%s) AS create_time } } // 5. 执行数据同步任务解析 DSL 配置生成 SQL 并执行 class SyncTaskExecutor { static void execute(SyncTask task) { println 开始执行任务${task.getTaskName()} // 生成同步 SQL基于 DSL 配置 def columnsStr task.getColumns().join(, ) def whereClause task.getWhereClosure().call() def transformClause task.getTransformClosure().call() def syncSql INSERT INTO ${task.getTargetTable()} (${columnsStr}) SELECT ${transformClause ?: columnsStr} FROM ${task.getSourceTable()} WHERE ${whereClause} println 生成同步 SQL\n${syncSql} // 执行 SQL实际项目中结合 MyBatis/JDBC 执行 // jdbcTemplate.execute(syncSql) println 任务执行完成${task.getTaskName()} } } // 执行同步任务 SyncTaskExecutor.execute(userSyncTask)七、Groovy 性能优化与最佳实践7.1 性能优化关键点Groovy 动态类型带来便利的同时也可能导致性能损耗。以下是针对核心场景的优化方案平衡开发效率与性能静态类型优化对热点代码频繁调用的方法、循环显式指定变量/方法的静态类型避免动态类型推断开销启用 Groovy 静态编译注解CompileStatic将 Groovy 代码编译为静态类型字节码性能接近 Java示例import groovy.transform.CompileStatic /** * 静态编译优化示例 * author ken */ CompileStatic // 类级别静态编译 class PerformanceOptimizedService { // 显式指定静态类型 Integer calculateSum(ListInteger list) { Integer sum 0 for (Integer num : list) { // 静态类型循环避免动态迭代开销 sum num } return sum } }集合操作优化避免在循环中频繁创建集合对象优先使用Lists.newArrayList()预分配容量大集合处理优先使用each闭包内部优化了迭代器避免使用for in循环动态类型迭代开销较大元编程性能优化动态添加方法/属性仅在初始化时执行避免在热点代码中动态修改元类优先使用Expando而非动态修改已有类的元类减少全局影响文件操作优化大文件处理优先使用eachLine按行读取避免text方法一次性加载全部内容到内存批量写入文件时使用withWriter结合缓冲区减少 IO 次数7.2 最佳实践代码规范动态类型与静态类型结合工具类、脚本使用动态类型核心业务逻辑使用静态类型CompileStatic方法命名遵循 Java 规范变量命名使用驼峰命名法提升代码可读性避免过度使用闭包嵌套防止代码复杂度升高依赖管理优先使用 Groovy 内置 API避免重复引入第三方依赖Groovy 版本与 JDK 版本匹配Groovy 4.x 推荐 JDK 11本文示例基于 JDK 17异常处理明确异常边界核心业务逻辑必须捕获特定异常避免全局捕获Exception异常信息需包含上下文如参数值、操作类型便于问题定位测试规范脚本类使用 Groovy 测试框架Spock企业级应用核心逻辑使用 JUnit 5测试用例需覆盖动态特性如闭包、元编程避免运行时异常八、总结与学习资源8.1 核心总结Groovy 作为基于 JVM 的动态脚本语言核心优势在于“简化开发、提升效率”通过兼容 Java 语法、提供丰富语法糖字符串插值、简化集合操作、闭包、强大的元编程能力成为脚本开发、工具类编写、DevOps 自动化的优选语言。与 Java 混合开发时可充分发挥两者优势Java 保障核心业务的类型安全与稳定性Groovy 提升辅助功能的开发效率。掌握 Groovy 的关键在于理解其动态特性与 Java 静态特性的差异结合实战场景灵活选型。8.2 权威学习资源官方文档Groovy 官方文档最权威的语法、特性说明包含大量示例代码Groovy 官方指南入门到进阶的系统学习指南实战书籍《Groovy in Action》Groovy 领域经典书籍深入讲解核心特性与实战场景《Programming Groovy 2》适合 Java 开发者快速上手的入门书籍工具与生态Groovy 在线编辑器无需本地环境直接运行 Groovy 代码Spock 测试框架基于 Groovy 的测试框架支持行为驱动开发BDDGradle 文档Gradle 构建脚本基于 Groovy学习 Gradle 可深化 Groovy 应用社区资源Groovy GitHub 仓库源码与 issue 讨论Stack Overflow Groovy 标签问题解决与经验分享通过本文的系统讲解与实战示例相信开发者已能掌握 Groovy 核心语法与应用场景。建议结合实际项目需求从脚本编写、工具类开发入手逐步深入元编程、DSL 等高级特性充分发挥 Groovy 提升开发效率的优势。