Using Groovy for Dynamic Scripting in Java Backend Projects

Introduction

In a payment‑integration project the author needed to handle heterogeneous result formats from multiple operators. Because operator message formats may change and new operators may be added, maintaining static Java parsing code would require frequent code changes, testing, and deployment.

Two feasible solutions were considered: rule engines (Drools, Easy Rules) and dynamic scripts (Groovy). The rule‑engine approach was rejected as over‑engineered, so Groovy was chosen.

What is Groovy?

Groovy is a dynamic programming language for the Java platform that blends static‑typed and dynamic‑typed features, offering a concise, expressive syntax and full Java compatibility.

Dynamic scripting language : classes and methods can be added, modified, or removed at runtime.

Java compatible : syntax is even simpler than Java and runs on the JVM.

The JVM class loader compiles Groovy code into Java classes, which are then executed just like ordinary Java objects.

Applicable Scenarios

Marketing Activities

Marketing rules (e.g., personalized offers, A/B testing) often need frequent adjustments. Groovy scripts allow operators to modify rules quickly without a full release cycle.

Risk‑Control Rules

In anti‑fraud systems, new interception rules must be deployed instantly. Groovy enables on‑the‑fly rule definition, compilation, and execution, dramatically reducing response time to emerging threats.

Quick Start

1. Add the Maven dependency:

<dependency>
    <groupId>org.codehaus.groovy</groupId>
    <artifactId>groovy-all</artifactId>
    <version>3.0.17</version>
    <type>pom</type>
</dependency>

2. Create Hello.groovy with a simple say() method:

class Hello {
    String say(String name) {
        return name + "World!"
    }
}

3. Load and invoke the script from Java using GroovyClassLoader :

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 groovyClass = groovyClassLoader.parseClass(groovyFile);
        GroovyObject groovyObject = (GroovyObject) groovyClass.newInstance();
        Object result = groovyObject.invokeMethod("say", "Hello");
        System.out.println("return: " + result.toString());
    }
}

Advanced Guide

Groovy Usage Options

GroovyShell

ScriptEngineManager

GroovyClassLoader

1. GroovyShell

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

public static void main(String[] args) throws ScriptException, NoSuchMethodException {
    ScriptEngineManager factory = new ScriptEngineManager();
    ScriptEngine engine = factory.getEngineByName("groovy");
    Bindings binding = engine.createBindings();
    binding.put("date", new Date());
    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

public static void groovyClassLoader() throws InstantiationException, IllegalAccessException {
    GroovyClassLoader groovyClassLoader = new GroovyClassLoader();
    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();
    Object ret = object.invokeMethod("say", "vivo");
    System.out.println(ret.toString());
}

Although GroovyClassLoader is the most recommended entry point, all three mechanisms ultimately rely on it.

Best Practices

1. Script Loading Strategy

Scripts should be reloadable at runtime. Storing script text in a database or configuration center allows the application to fetch the latest version and re‑parse it when changes are detected.

2. Rule Design

Only the frequently changing parts of business logic should be extracted into scripts. For example, a reward‑count rule can be defined in RewardRule.groovy while the surrounding Java code remains static.

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
        }
    }
}

Pitfalls

Memory Leak

Each call to GroovyClassLoader.parseClass creates a new class in Metaspace. Repeated parsing without caching leads to Metaspace overflow.

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;
    }
}

Solution: cache compiled scripts (e.g., by MD5) and reuse the class instance, clearing the loader cache when appropriate.

private static final Map
SCRIPT_CACHE = new ConcurrentHashMap<>();

public synchronized
T initialize(String cacheKey, String script, Class
clazz) {
    if (SCRIPT_CACHE.containsKey(cacheKey)) {
        return clazz.cast(SCRIPT_CACHE.get(cacheKey));
    }
    GroovyClassLoader classLoader = new GroovyClassLoader();
    try {
        Class
groovyClazz = classLoader.parseClass(script);
        Object instance = groovyClazz.newInstance();
        classLoader.clearCache();
        SCRIPT_CACHE.put(cacheKey, instance);
        return clazz.cast(instance);
    } catch (Exception e) {
        log.error("initialize exception", e);
    }
    return null;
}

Conclusion

Groovy offers Java developers a lightweight, expressive way to handle rapidly changing business rules, improving development speed and system adaptability. When faced with frequently varying requirements, consider adopting Groovy for dynamic scripting.