Groovy是什么

Groovy是一种在JVM上运行的敏捷开发语言

Groovy 80%的语法和Java完全一致，同时吸取了其它语言的一些灵活性特征

Java编程者想要学习Groovy，只要不刻意去追求高阶用法，基本一天就能学会

Groovy Dependency

plugins {id 'groovy'
}repositories {maven { url 'https://maven.aliyun.com/nexus/content/groups/public/' }google()mavenCentral()
}dependencies {implementation 'org.apache.groovy:groovy:4.0.17'implementation 'org.codehaus.groovy:groovy-all:3.0.21'implementation 'org.apache.ivy:ivy:2.5.2'implementation 'com.google.guava:guava:33+'
}

DSL是什么

DSL全称Domain Specific Language

是一种弱化编程特性，更专注于业务逻辑表达的一种语言

DSL的语法更加简洁，对专业编程能力要求低，尤其适合用于编写命令脚本，比如Gradle脚本就是这种风格

但DSL的简洁性背后，往往都有专业的面向对象风格代码在支撑，但是用户只和DSL这一层打交道

一些比较新的语言，都提供了这种风格的调用方式，比如Groovy DSL，Kotlin DSL

本章要讲的，就是Groovy DSL的实现方式

初识Groovy DSL

def show = { println it }
def square = { Math.pow(it, 2) as int }
def squareRoot = { Math.sqrt(it) as int }def please(action) {[the: { what ->[of: { n -> action(what(n)) }]}]
}please show the square of 100
please show the squareRoot of 100

这是一个完整的Groovy文件

Groovy既可以按脚本的方式，直接执行整个文件

也可以按面向对象的方式，通过静态main方法来启动

可以看到，上半部分是面向对象风格的代码，下半部分是DSL风格的代码

上半部分用于实现DSL，而下半部分则是DSL调用

有了上半部分的支撑，我们可以像讲白话一样，让脚本去完成指定的工作

之所以我们在使用Gradle时，看不到上半部分，是因为Groovy提供了脚本封装功能

我们可以将上半部分代码封装为一个Script，然后使用该Script来执行Gradle脚本

Closure, Delegate, Script & Shell

上面介绍的，是Groovy定义方法的用法之一，主要用来展示DSL语法风格

用过Gradle脚本的应该知道，Gradle脚本是存在多个对象，和对象层级嵌套的

如果通过以上风格来编写代码，必定会非常复杂

Groovy提供了专门的类来解析和执行脚本，主要有

• Closure：闭包代码块，对应Gradle中{ … }的全部内容
• Closure代码块是可以执行的，可以为其指定一个隐藏的context对象，类似于this
• Closure代码块中的代码，实际都是通过这个context对象来执行
• 在Groovy中我们一般把这个context对象称为Delegate，因为代码是交给它来代理执行的
• Script：整个Gradle脚本，可以看成一个大的Closure，这个顶级Closure的context，就是Script
• Shell：用来配置和执行脚本，它可以指定脚本位置，指定用哪个Script执行脚本，还可以向脚本中注入对象等

// GradleScript.groovypackage com.code.groovyabstract class GradleScript extends Script {abstract void script()def email(Closure closure) {def delegateContext = new EmailSpec()def delegatedClosure = closure.rehydrate(delegateContext, this, this)delegatedClosure.resolveStrategy = Closure.DELEGATE_ONLYdelegatedClosure()}@OverrideObject run() {println ''script()println ''return 100}
}class EmailSpec {void from(String from) { println "From: $from" }void to(String... to) { println "To: $to" }void subject(String subject) { println "Subject: $subject" }void body(Closure closure) {def delegateContext = new BodySpec()def delegatedClosure = closure.rehydrate(delegateContext, this, this)delegatedClosure.resolveStrategy = Closure.DELEGATE_ONLYdelegatedClosure()}
}class BodySpec {void p(String content) { System.err.println "    $content" }
}

// GradleShell.groovypackage com.code.groovyimport org.codehaus.groovy.control.CompilerConfiguration// bind property
def binding = new Binding()
binding.setVariable('message', "Gradle Script Run Finished")
binding.setProperty('date', new Date().toString())
binding.setProperty('email.body.date', new Date().toString())
// specify script class
def config = new CompilerConfiguration()
config.scriptBaseClass = GradleScript.class.name
// load and execute shell
def shell = new GroovyShell(binding, config)
def scriptFile = new File('./script.gradle')
def scriptSource = new GroovyCodeSource(scriptFile, 'utf-8')
shell.evaluate(scriptSource)

// script.gradledef binding = binding
email {from 'LiNing@groovy.com'to 'Tom@@groovy.com', 'Jimmy@groovy.com'subject 'Groovy Started'body {p "Hi, let's start learning English now !"p binding['date']p binding['email.body.date']}
}println message

// outputFrom: LiNing@groovy.com
To: [Tom@@groovy.com, Jimmy@groovy.com]
Subject: Groovy StartedHi, let's start learning English now !Fri Mar 15 10:50:44 CST 2024Fri Mar 15 10:50:44 CST 2024
Gradle Script Run Finished

Compilation Customizers

Groovy还提供了一些配置类，用于自定义编译规则

比如自动导入类，向脚本中添加默认变量，修改脚本执行逻辑等

// CustomizerShell.groovyimport groovy.transform.ConditionalInterrupt
import org.codehaus.groovy.ast.Parameter
import org.codehaus.groovy.ast.expr.ClosureExpression
import org.codehaus.groovy.ast.expr.ConstantExpression
import org.codehaus.groovy.ast.stmt.ReturnStatement
import org.codehaus.groovy.control.CompilerConfiguration
import org.codehaus.groovy.control.customizers.ASTTransformationCustomizer
import groovy.util.logging.Log
import org.codehaus.groovy.control.customizers.ImportCustomizer
import org.codehaus.groovy.control.customizers.SecureASTCustomizer// auto import class with alias
def importCustomizer = new ImportCustomizer()
importCustomizer.addImport('Map', 'java.util.concurrent.ConcurrentHashMap')
// inject annotation into script by ast transformation
def annotationCustomizer = new ASTTransformationCustomizer(Log, value: 'LOGGER')
// auto interrupt on matched statement
def statement = new ReturnStatement(ConstantExpression.FALSE)
def expression = new ClosureExpression(Parameter.EMPTY_ARRAY, statement)
def interruptCustomizer = new ASTTransformationCustomizer(ConditionalInterrupt,value: expression,thrown: SecurityException
)
// restrict accessible types by ast transformation
def secureCustomizer = new SecureASTCustomizer()
secureCustomizer.with {allowedReceiversClasses = [Object, String, Integer].asImmutable()
}
// add customizers to shell config
def config = new CompilerConfiguration()
config.addCompilationCustomizers(importCustomizer)
config.addCompilationCustomizers(annotationCustomizer)
config.addCompilationCustomizers(interruptCustomizer)
config.addCompilationCustomizers(secureCustomizer)
// execute with config and script
def shell = new GroovyShell(config)
def scriptFile = new File('./script.gradle')
def scriptSource = new GroovyCodeSource(scriptFile, 'utf-8')
shell.evaluate(scriptSource)

// script.gradle// Logger is injected
println LOGGER.class.name
LOGGER.info 'Hello'// use ConcurrentHashMap with alias
def map = new Map()
map['name'] = 'ConcurrentHashMap'
println map['name']// injected variables are regard as Object type
// so map is allowed as method caller
map.put('name', 'ConcurrentHashMap')// throw exception on return-false statement
Boolean find() {return false
}
println find()// Date is not a allowed type as method caller
new Date().getTime()

DSL Style Customizer

到此为止，我们已经大致了解一个Script是如何被加载和执行的

不知道大家有没有发现，我们像是在写一个编译器，只是这个编译器框架是Groovy封装好的

核心的内容上面已经讲解完了，这一节我们简单演示一下，Groovy内置的一些DSL风格的编译组件

// CompilerCustomizationBuilder.class// register internal customizer factorys
public CompilerCustomizationBuilder() {this.registerFactory("customizers", new CustomizersFactory());this.registerFactory("ast", new ASTTransformationCustomizerFactory());this.registerFactory("imports", new ImportCustomizerFactory());this.registerFactory("inline", new InlinedASTCustomizerFactory());this.registerFactory("secureAst", new SecureASTCustomizerFactory());this.registerFactory("source", new SourceAwareCustomizerFactory());
}// inject customizers to compile config
// closure specify customizers that created by factorys
public static CompilerConfiguration withConfig(CompilerConfiguration config, Closure closure)

// GradleShell.groovyimport groovy.transform.ToString
import groovy.util.logging.Log
import org.codehaus.groovy.control.CompilePhase
import org.codehaus.groovy.control.CompilerConfiguration
import org.codehaus.groovy.control.customizers.builder.CompilerCustomizationBuilderdef config = new CompilerConfiguration()
CompilerCustomizationBuilder.withConfig(config) {inline(phase: CompilePhase.SEMANTIC_ANALYSIS) { source, context, classNode ->println 'visiting $classNode'}imports{normal 'java.util.Date'normal 'groovy.transform.ToString'}ast(Log, value: 'LOGGER')ast(ToString)
}
def script = new File('./script.gradle')
def shell = new GroovyShell(config)
shell.evaluate(script)

// script.gradledef date = new Date()class QQQ {def name = "LiNing"def age = 28
}LOGGER.info date.toString()
LOGGER.info new QQQ().toString()

DSL风格脚本展示

import groovy.json.JsonBuilder
import groovy.json.JsonOutputdef builder = new JsonBuilder()
builder.records {car {name 'HSV Maloo'make 'Holden'year 2006country 'Australia'record {type 'speed'description 'production pickup truck with speed of 271kph'}}
}
String json = JsonOutput.prettyPrint(builder.toString())
println json

def builder = new NodeBuilder()
def userlist = builder.userlist {user(id: '1', firstname: 'John', lastname: 'Smith') {address(type: 'home',street: '1 Main St.',city: 'Springfield',state: 'MA',zip: '12345')address(type: 'work',street: '2 South St.',city: 'Boston',state: 'MA',zip: '98765')}user(id: '2', firstname: 'Alice', lastname: 'Doe')
}
def users = userlist.user.@firstname.join(', ')
println users