前言
最近,小年在项目中使用 Groovy 对业务能力进行了一些扩展,感觉比较有意思,而且效果也不错,所以来分享一下使用经验。
先来简单概述一下小年的项目需求背景:有一个支付业务场景需要接入多个运营商的支付能力,每个运营商在支付后都会返回支付结果,但是每个运营商的支付结果报文格式各不相同。
要实现起来并不难,只需要针对每个运营商的报文格式制定不同的解析规则,当然问题并没有这么 easy
- 运营商的支付结果报文格式可能会变化
- 后面可能还需要接入新的运营商
也就是说,如果运营商改了报文格式,我们的解析规则需要不断调整,并且有新增的运营商,还需要新增适配的解析规则。
项目使用的是 Java 语言开发,如果每次调整解析规则,意味着需要修改代码,测试,发布,回归等一系列繁琐的步骤。
当然,办法总比困难多🤔
除了上面最直接的笨方法,还有两种可行方案:
1、规则引擎,比如开源 Drools、Easy Rules 等
2、动态脚本,比如 Groovy
规则引擎本身的目的就是为了解决业务的复杂性和多变性,但是小年的系统业务流程本身并不复杂,引入规则引擎就有点过于重,反而增加了系统复杂度,所以这个方案就被 Pass 掉了。
最终选用的是 Groovy 动态脚本的方案。可能有的同学第一次听说 Groovy ,包括小年自己也是。
什么是 Groovy?
Groovy 是一种基于 Java 平台的动态编程语言。它结合了静态类型语言和动态类型语言的特性,是一种面向对象的脚本语言,设计目标是提供更简洁、更具表达力的语法,以及更易于使用的 API。
这里我们只需要记住两个重点:
- 动态脚本语言,它允许在运行时动态添加、修改和删除类和方法;
- 与 Java 兼容,语法甚至更加简单;
原理并不复杂,JVM 类加载器动态将 Groovy 代码编译成 Java Class,然后生成 Java 对象在 JVM 上执行。
其实这跟 Nginx + Lua 的组合很相似(静态编译语言 + 动态脚本语言),一套动静组合实现一些需要灵活变动的需求或者规则。
适用场景
营销活动
营销活动这类的场景,可以说是最适合不过。营销活动的套路相信大家也都深有体会,千人千面、大数据杀熟这些套路。
运营同学需要经常性地调整营销策略和规则,不同的场景需要配置不同的规则,所以这时可以利用 Groovy 脚本来快速动态调整规则,快速高效的满足运营产品的需求。
风控规则
风控领域的规则引擎极其适合采用 Groovy 这一技术实现。在对抗黑产的过程中,策略制定人员每天都会产生新的拦截规则。如果每次都要发版,一些被发现的紧急问题或者被薅羊毛的漏洞没办法紧急修复。
因此,通过利用 Groovy 脚本引擎的动态解析执行功能,我们可以将拦截规则抽象成规则脚本,实现快速部署,从而显著提升工作效率。这种方法使得策略人员能够迅速响应风险事件,灵活调整规则,确保对黑产的打击始终保持高效和及时。
快速入门
1、引入依赖
xml
<dependency>
<groupId>org.codehaus.groovy</groupId>
<artifactId>groovy-all</artifactId>
<version>3.0.17</version>
<type>pom</type>
</dependency>
2、新建一个 Hello.groovy
文件,声明一个 say()
方法
groovy
class Hello {
String say(String name) {
return name + "World!"
}
}
3、在 Java 类中用 GroovyClassLoader
加载 Hello.groovy
文件生成 Class ,然后生成实例,最后通过反射调用方法即可。
java
public class QuickStart {
public static void main(String[] args) throws Exception {
// 文件路径
String filePath = "src/main/java/com/zhang/awesome/groovy/Hello.groovy";
File groovyFile = new File(filePath);
GroovyClassLoader groovyClassLoader = new GroovyClassLoader();
// 加载class
Class groovyClass = groovyClassLoader.parseClass(groovyFile);
// 生成实例
GroovyObject groovyObject = (GroovyObject) groovyClass.newInstance();
// 反射调用say方法
Object result = groovyObject.invokeMethod("say", "Hello");
System.out.println("return: " + result.toString());
}
}
是不是非常简单?只需要简单的3个步骤,就可以实现Groovy动态脚本能力,并且 Groovy 语法基本与 Java 是兼容的,所以写起来也是很方便。
进阶指南
Groovy 的使用方式
在 Java 中使用 Groovy 有三种方式:
- GroovyShell
- ScriptEngineManager
- GroovyClassLoader
1、GroovyShell
java
public static void main(String[] args) {
final String script = "Runtime.getRuntime().availableProcessors()";
Binding intBinding = new Binding();
GroovyShell shell = new GroovyShell(intBinding);
final Object eval = shell.evaluate(script);
System.out.println(eval);
}
2、ScriptEngineManager
java
public static void main(String[] args) throws ScriptException, NoSuchMethodException {
ScriptEngineManager factory = new ScriptEngineManager();
// 每次生成一个engine实例
ScriptEngine engine = factory.getEngineByName("groovy");
Bindings binding = engine.createBindings();
// 入参
binding.put("date", new Date());
// 如果script文本来自文件,请首先获取文件内容
engine.eval("def getTime(){return date.getTime();}", binding);
engine.eval("def sayHello(name,age){return 'Hello,I am ' + name + ',age' + age;}");
// 反射到方法
Long time = (Long) ((Invocable) engine).invokeFunction("getTime", null);
System.out.println(time);
String message = (String) ((Invocable) engine).invokeFunction("sayHello", "zhangsan", 12);
System.out.println(message);
}
3、GroovyClassLoader
java
public static void groovyClassLoader() throws InstantiationException, IllegalAccessException {
GroovyClassLoader groovyClassLoader = new GroovyClassLoader();
// 可以是纯Java代码
String helloScript = "package com.vivo.groovy.util" +
"class Hello {" +
"String say(String name) {" +
"System.out.println(\"hello, \" + name)" +
" return name;" +
"}" +
"}";
Class helloClass = groovyClassLoader.parseClass(helloScript);
GroovyObject object = (GroovyObject) helloClass.newInstance();
// 控制台输出"hello, vivo"
Object ret = object.invokeMethod("say", "vivo");
// 打印vivo
System.out.println(ret.toString());
}
Groovy 官方提供 **GroovyClassLoader
**类,支持从文件、URL或字符串中加载解析 Groovy Class
,实例化对象,反射调用指定方法。GroovyShell
、ScriptEngineManager
底层核心也是调用了 GroovyClassLoader
,并且还会存在性能问题。所以一般场景来说还是比较推荐使用 GroovyClassLoader
最佳实践
当然,使用 Groovy 的动态脚本能力并不难,但如果要真正运用整合到项目中,是需要一定的设计模式和方法技巧,小年总结一下主要有这么两点
1. 脚本加载的方式
脚本变更后,如何实时生效?
既然是动态,我们最希望的当然是:调整和修改脚本的代码后,能够实时生效。也就是说应用能够感知脚本的变更,并且能重新Reload。
GroovyClassLoader
支持字符串、文件、URL的方式加载脚本。实现的方式很多,比如可以字符串的话,可以放在配置中心、数据库;文件的话可以放在资源服务器中再通过接口或者配置触发reload等。小年在项目中的使用方式是通过数据库的形式,把脚本代码都放在一个表的字段里,每次都从数据库中读取最新。
2. 规则设计
我们需要尽可能把最频繁变动的部分抽取到脚本中,而并不是把所有代码都丢到脚本来实现。简单来说就是要抽象出最小细粒度的动态规则,这部分才是脚本里面的内容。
举个例子,比如说在营销场景下,针对不同用户的属性(年龄、等级)可以获得不同的抽奖次数,我们在项目中定义一个接口:IRewardRule
java
public interface IRewardRule {
Integer getRewardCount(User user);
}
而获取用户抽奖次数的规则逻辑则是放在 Groovy 脚本中实现 RewardRule.groovy
groovy
class RewardRule implements IRewardRule {
@Override
Integer getRewardCount(User user) {
if (user.getAge() <= 10) {
return 5
}else if (user.getAge() <= 20 && user.getAge() > 10) {
return 3
}else {
return 1
}
}
}
在业务调用的时候我们可以直接用 GroovyClassLoader
生成对应的类,调用 getRewardCount
方法
java
GroovyClassLoader classLoader = new GroovyClassLoader();
Class<?> groovyClazz = classLoader.parseClass(script);
Object instance = groovyClazz.newInstance();
classLoader.clearCache();
IRewardRule rewardRule = clazz.cast(instance);
rewardRule.getRewardCount(user)
具体的Demo可以参考:github.com/Zhang-BigSm...
踩坑指南
内存泄露
GroovyClassLoader
类加载器每次调用 parseClass
方法执行 Groovy 脚本,都会重新编译脚本,调用类加载器进行类加载。我们知道类对象信息是放在 JVM 的 Metaspace 区域中,重复不断地执行 Groovy 脚本意味着会创建大量的类,容易导致 Metaspace 内存溢出,造成内存泄露。
简单了解一下 Groovy 脚本的加载流程, GroovyClassLoader
执行核心方法 parseClass
方法:
java
public Class parseClass(String text) throws CompilationFailedException {
return parseClass(text, "script" + System.currentTimeMillis() +
Math.abs(text.hashCode()) + ".groovy");
}
public Class parseClass(GroovyCodeSource codeSource, boolean shouldCacheSource) throws CompilationFailedException {
synchronized (sourceCache) {
Class answer = sourceCache.get(codeSource.getName());
if (answer != null) return answer;
answer = doParseClass(codeSource);
if (shouldCacheSource) sourceCache.put(codeSource.getName(), answer);
return answer;
}
}
可以看到每次调用 parseClass
方法,都会生成一个 Class 对象,而对象名是 script + System.currentTimeMillis()+Math.abs(text.hashCode()
组成,也就是说,即使是相同内容的脚本,都会被认为是新的代码,进行新的编译和加载。而你的业务逻辑不断重复执行就会一直生成新的类,最终导致 Metaspace
溢出。
而且 GroovyClassLoader 还会缓存类的信息,像上面的 sourceCache.put(codeSource.getName(), answer)
之外,还有 classCache
也会缓存类的对象,所以导致 Class 对象不可被回收
java
protected void setClassCacheEntry(Class cls) {
synchronized (classCache) {
classCache.put(cls.getName(), cls);
}
}
要解决这个性能问题,我们通常是对加载后的 Groovy 脚本进行缓存,避免重复编译加载,可以通过计算脚本的MD5值来生成键值对进行缓存。
通过应用层自己维护一个cache,从而解决 Metaspace 内存溢出的问题。当然,这里还有一个小细节点,在初始化的时候加上同步锁,可以避免并发的问题。
java
private final static Map<String, Object> SCRIPT_CACHE = new ConcurrentHashMap<>();
public synchronized <T> T initialize(String cacheKey, String script, Class<T> clazz) {
if (SCRIPT_CACHE.containsKey(cacheKey)) {
return clazz.cast(SCRIPT_CACHE.get(cacheKey));
}
GroovyClassLoader classLoader = new GroovyClassLoader();
try {
Class<?> groovyClazz = classLoader.parseClass(script);
if (clazz != null) {
Object instance = groovyClazz.newInstance();
// 清除GroovyClassLoader的缓存
classLoader.clearCache();
// 应用缓存
SCRIPT_CACHE.put(cacheKey, instance);
return clazz.cast(instance);
}
} catch (Exception e) {
log.error("initialize exception", e);
}
return null;
}
小结
对于 Java 开发者来说,Groovy 是一门非常容易上手的一门语言。 Groovy 动态加载的能力,非常适用于业务变化多而快的需求,提高开发效率,更快相应需求的变化,提供系统稳定性。
如果你正好也碰到一些需要频繁变动规则的需求,不妨可以考虑一下 Groovy。