通过 Groovy 实现业务逻辑的动态变更

Groovy

1、需求的提出
2、为什么是Groovy
3、设计参考
- 1_引入Maven依赖
- 2_GroovyEngineUtils工具类
- 3_GroovyScriptVar类
- 4_脚本规则表设计
- 5_对应的实体类
- 6_数据库访问层
- 7_GroovyExecService通用接口
4、测试
5、其他的注意事项
6、总结

1、需求的提出

在我们日常的开发过程中，经常会遇到一些功能的逻辑变更很频繁的需求，相信大部分小伙伴都会通过加 if 判断来解决（毕竟这样最简单，也可能是因为项目赶时间等一系列客观因素）。长此以往，我们项目代码中可能充斥着大量的 if 代码段，可读性不高。当然网上有很多方式消除 if…else… 代码的方法，比如说使用恰当的设计模式、使用规则引擎等等。

上述所说的可读性不高，不是本文分享内容解决的重点问题，逻辑变更很频繁的需求，还带来的另一个问题就是需要经常重启服务。今天我们分享的就是利用Groovy脚本在Spring Boot项目中实现 $动态编程$ 解决这一问题，使业务逻辑的动态化，极大地提升了开发效率和灵活性。

2、为什么是Groovy

Groovy语言作为一种基于JVM的动态语言，它可以编译为与Java相同的字节码，然后将字节码文件交给JVM去执行，并且可以与Java类无缝地互操作。

Groovy可以透明地与Java库和代码交互，可以 $使用 J a v a 所有的库$ ，并且有着简洁灵活的语法、动态类型和闭包等特性。

Groovy无缝地集成了Java的强大功能，并提供了许多额外的特性，如DSL（领域特定语言）的支持和元编程能力，使得开发者能够以更加简洁和优雅的方式表达复杂的逻辑。

Groovy也可以直接将源文件解释执行。它还极大地清理了Java中许多冗长的代码格式。

Groovy尚未成为主流的开发语言，但是它已经在测试（由于其简化的语法和元编程功能）和构建系统中占据了一席之地。

既支持 面向对象 编程也支持 面向过程 编程，即可以作为 编程语言 也可以作为 脚本语言 。

$D S L$ 其实是 Domain Specific Language 的缩写，中文翻译为领域特定语言（下简称 DSL）；

而与 DSL 相对的就是 $GP L$ ，是General Purpose Language 的简称，即通用编程语言，也就是我们非常熟悉的Java、Python 以及 C 语言等等。

3、设计参考

在与我们项目整合时，可以这样进行设计：基于简单的 CURD 功能将 $G roo v y 代码片$ 放入数据库中进行管理，通过切换对应的 $G roo v y 代码片$ 达到动态变更规则的特性。下面给个模版进行参考，如果有需要再根据自己的需求进行相应的修改（前端也可以使用模版引擎比如 $F ree ma r k$ ）：

1_引入Maven依赖

<dependency><groupId>org.codehaus.groovy</groupId><artifactId>groovy-all</artifactId><version>2.4.5</version>
</dependency>

2_GroovyEngineUtils工具类

package org.example.util;import lombok.AccessLevel;
import lombok.NoArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.codehaus.groovy.jsr223.GroovyScriptEngineImpl;import javax.script.*;
import java.util.Map;
import java.util.Objects;@Slf4j
@NoArgsConstructor(access = AccessLevel.PRIVATE)
public class GroovyEngineUtils{private static final GroovyScriptEngineImpl GROOVY_ENGINE = (GroovyScriptEngineImpl) new ScriptEngineManager().getEngineByName("groovy");/*** 编译脚本* @param script* @return* @throws ScriptException*/public static CompiledScript compile(String script) throws ScriptException {return GROOVY_ENGINE.compile(script);}/*** 执行脚本* @param compiledScript * @param args 脚本参数* @return*/public static Object eval(CompiledScript compiledScript, Map<String, Object> args) {try {return compiledScript.eval(getScriptContext(args));} catch (ScriptException e) {log.error(" exec GroovyEngineUtils.eval error!!!", e);}return null;}/*** 执行脚本* @param script 脚本* @return*/public static Object eval(String script) {try {return GROOVY_ENGINE.eval(script);} catch (ScriptException e) {log.error(" exec GroovyEngineUtils.eval error!!!", e);}return null;}/*** 执行脚本* @param script 脚本* @param args 脚本参数* @return*/public static Object eval(String script, Map<String, Object> args) {try {return GROOVY_ENGINE.eval(script, getScriptContext(args));} catch (ScriptException e) {log.error(" exec GroovyEngineUtils.eval error!!!", e);}return null;}private static ScriptContext getScriptContext(Map<String, Object> args) {ScriptContext scriptContext = new SimpleScriptContext();if (Objects.nonNull(args)) {args.forEach((k, v) -> scriptContext.setAttribute(k, v, ScriptContext.ENGINE_SCOPE));}return scriptContext;}
}

3_GroovyScriptVar类

GroovyScriptVar 类主要作用是在项目启动时，缓存编译后的脚本，也提供了刷新脚本的功能，这样在业务逻辑变更的时候，我们可以通过刷新功能，重新加载脚本。防止了我们重启服务。

package org.example.config;import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j;
import org.example.dao.CommonScriptDao;
import org.example.pojo.CommonScript;
import org.example.util.GroovyEngineUtils;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;import javax.annotation.PostConstruct;
import javax.annotation.Resource;
import javax.script.CompiledScript;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;@Component
@Slf4j
public class GroovyScriptVar {// 缓存编译后的脚本private static final Map<String, CompiledScript> SCRIPT_MAP = new ConcurrentHashMap<>();@Resourcepublic CommonScriptDao commonScriptDao;@PostConstructpublic void init() {refresh();}@SneakyThrowspublic void refresh() {synchronized (GroovyScriptVar.class) {// 从数据库中加载脚本List<CommonScript> list = commonScriptDao.findAll();SCRIPT_MAP.clear();if(CollectionUtils.isEmpty(list)) return;for (CommonScript script : list) {SCRIPT_MAP.put(script.getUniqueKey(), GroovyEngineUtils.compile(script.getScript()));}log.info(" Groovy脚本初始化，加载数量：{}",list.size());}}public CompiledScript get(String uniqueKey){return SCRIPT_MAP.get(uniqueKey);}}

4_脚本规则表设计

create table common_script
(id               int auto_increment comment '主键标识'primary key,unique_key       varchar(32)            null comment '唯一标识',script           mediumtext             null comment '脚本',creator          varchar(128)           null comment '创建人名称',create_date      datetime               null comment '创建时间',last_update_date datetime               null comment '更新时间'
)comment '脚本规则';

5_对应的实体类

与上述的表结构对应即可

package org.example.pojo;import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;import java.time.LocalDateTime;@TableName("common_script") // 指定表名
@Data
@NoArgsConstructor
@AllArgsConstructor
@Builder
public class CommonScript {@TableId(value="id",type = IdType.AUTO)//字段不一致时，通过value值指定table中主键字段名称private Long id;private String uniqueKey;private String script;private String creator;private LocalDateTime createDate;private LocalDateTime lastUpdateDate;
}

6_数据库访问层

当然，这里的 dao 是基于MybatisPlus 的：

package org.example.dao;import com.baomidou.mybatisplus.core.mapper.BaseMapper;import org.apache.ibatis.annotations.Select;
import org.example.pojo.CommonScript;import java.util.List;public interface CommonScriptDao extends BaseMapper<CommonScript> {@Select("select * from common_script")List<CommonScript> findAll();
}

7_GroovyExecService通用接口

package org.example.service;public interface GroovyExecService {/*** 执行脚本的方法*/void exec();/*** 重新加载脚本引擎*/void refresh();
}

Groovy 脚本在项目中使用核心逻辑到这基本就已经完成了。

4、测试

测试脚本，定义一个非常简单的脚本根据不同状态，打印不同返回值：

if ("COMPLETED" == status) {// 如果条件为COMPLETEDreturn "条件为已完成"
}else{return "条件为未完成"
}

测试service：

package org.example.service.impl;import lombok.extern.slf4j.Slf4j;
import org.example.config.GroovyScriptVar;
import org.example.service.GroovyExecService;
import org.example.util.GroovyEngineUtils;
import org.springframework.stereotype.Service;import javax.annotation.Resource;
import javax.script.CompiledScript;
import java.util.HashMap;
import java.util.Map;@Slf4j
@Service
public class GroovyExecServiceImpl implements GroovyExecService {@Resourceprivate GroovyScriptVar groovyScriptVar;@Overridepublic void exec() {Map<String, Object> args=new HashMap<>();args.put("status","COMPLETED");CompiledScript compiledScript = groovyScriptVar.get("test");Object result = GroovyEngineUtils.eval(compiledScript, args);log.info("/// 脚本执行结果{}",(String)result);}@Overridepublic void refresh() {groovyScriptVar.refresh();}
}

执行效果：可以看到项目在启动过程中已经加载了一个脚本并且成功调用了exec方法：

在这里插入图片描述

5、其他的注意事项

如果Groovy脚本没有做好权限控制，将会成为攻击你系统最有力的武器！！！

如果Groovy脚本用不好，还会导致 $OOM$ ，最终服务器宕机——毕竟Groovy脚本中创建的对象也是在JVM堆中的。

下面附上一个 Groovy 脚本通用的封装方法方法，可以通过参数传递配置。为了使这个方法更加通用和健壮，对代码进行一些优化和封装。以下是一个改进后的通用封装方法，并附带详细的注释说明：

import groovy.lang.Binding;
import groovy.lang.GroovyShell;
import groovy.lang.Script;/*** 执行 Groovy 脚本中的指定方法并返回结果。* * @param templateScript 要执行的 Groovy 脚本字符串* @param methodName 要调用的方法名* @param params 传递给方法的参数数组* @return 方法执行的结果* @throws Exception 如果方法调用失败或其他异常*/
public static Object invokeGroovyMethod(String templateScript, String methodName, Object... params) throws Exception {// 创建 Groovy 脚本的变量绑定Binding groovyBinding = new Binding();// 使用 GroovyShell 解析脚本字符串GroovyShell groovyShell = new GroovyShell(groovyBinding);Script script = groovyShell.parse(templateScript);// 检查方法是否存在if (!script.getMetaClass().respondsTo(script, methodName).isEmpty()) {// 调用指定的方法并传递参数Object result = script.invokeMethod(methodName, params);// 清除 Groovy 脚本缓存groovyShell.getClassLoader().clearCache();return result;} else {throw new NoSuchMethodException("方法 " + methodName + " 不存在于脚本中。");}
}

步骤说明：

1. Binding 对象：

Binding groovyBinding = new Binding();：创建一个 Binding 对象，用于将变量绑定到 Groovy 脚本中。

2. GroovyShell 对象：

GroovyShell groovyShell = new GroovyShell(groovyBinding);：创建一个 GroovyShell 对象，用于解析和执行 Groovy 脚本。

3.解析 Groovy 脚本：

Script script = groovyShell.parse(templateScript);：将传入的 Groovy 脚本字符串解析为 Groovy 脚本对象。

4. 检查方法是否存在：

if (!script.getMetaClass().respondsTo(script, methodName).isEmpty()) {：检查脚本中是否存在指定名称的方法。如果方法存在，则继续执行；否则抛出 NoSuchMethodException 异常。

5. 调用方法：

Object result = script.invokeMethod(methodName, params);：调用 Groovy 脚本中的指定方法，并传递参数。

6. 清除 Groovy 缓存：

groovyShell.getClassLoader().clearCache();：清除 Groovy 脚本的类加载器缓存，以避免内存泄漏问题。

7. 返回结果：

return result;：返回方法执行的结果。

使用示例：

public static void main(String[] args) {String groovyScript = "def methodName(config) { return '执行结果: ' + config }";String methodName = "methodName";String configParam = "配置参数";try {Object result = invokeGroovyMethod(groovyScript, methodName, configParam);System.out.println(result);  // 输出: 执行结果: 配置参数} catch (Exception e) {e.printStackTrace();}
}