应用开发 | 动态脚本实践：核心场景与基础实现

原创已于 2025-04-04 11:14:35 修改 · 1.2k 阅读

26 ·

CC 4.0 BY-SA版权

文章标签：

#java #开发语言 #javascript

于 2025-04-04 11:09:42 首次发布

文章目录

引言

在现代应用开发中，动态脚本的使用越来越广泛。它允许开发者在不重新部署应用程序的情况下，动态地修改或扩展应用程序的行为。Java提供了多种方式来实现动态脚本，其中最常用的是使用内置的JavaScript引擎（如Nashorn或GraalVM JavaScript引擎）。本文将介绍如何在Java应用中使用动态脚本，并通过一个简单的示例来展示其基本实现。

核心场景

动态脚本的主要应用场景包括但不限于以下几点：

业务规则动态配置：允许业务人员在不修改代码的情况下，动态地调整业务规则。
插件系统：通过动态脚本，可以轻松地实现插件化架构，允许第三方开发者扩展应用功能。
自动化测试脚本：在自动化测试中，动态脚本可以用于编写测试用例，提高测试的灵活性和可维护性。
动态数据处理：在数据处理流程中，可以使用动态脚本来实现复杂的数据转换和处理逻辑。
用户自定义功能：允许终端用户通过简单的脚本语言来定制应用程序的行为。

基础实现

下面是一个简单的Java应用示例，展示了如何使用Java内置的JavaScript引擎来执行动态脚本。

示例代码

1. 脚本引擎类

首先，我们创建一个ScriptEngine类，用于执行JavaScript脚本：

package com.cenho.demo.script;

import jdk.nashorn.api.scripting.ScriptObjectMirror;

import javax.script.Invocable;
import javax.script.ScriptEngineManager;
import javax.script.ScriptException;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class ScriptEngine {

    public Object execute(String scriptContent, List<Object> args) throws ScriptException, NoSuchMethodException {
        javax.script.ScriptEngine engine = new ScriptEngineManager().getEngineByName("nashorn"); // Java 8+ 使用Nashorn引擎
        // 或者在Java 15+ 使用GraalVM JavaScript引擎：engine = new ScriptEngineManager().getEngineByName("graal.js");

        // 执行用户提供的JavaScript脚本
        engine.eval(scriptContent);

        // 调用 handle 函数并传递参数
        Invocable invocable = (Invocable) engine;
        Object result = invocable.invokeFunction("handle", args);

        // 检查结果是否是 ScriptObjectMirror 类型，并尝试转换为 JSON 字符串
        if (result instanceof ScriptObjectMirror) {
            ScriptObjectMirror som = (ScriptObjectMirror) result;
            // 将 ScriptObjectMirror 转换为 Map<String, Object>
            Map<String, Object> resultMap = new HashMap<>();
            for (String key : som.keySet()) {
                Object value = som.get(key);
                // 如果值也是 ScriptObjectMirror，则递归转换
                if (value instanceof ScriptObjectMirror) {
                    value = convertToMap((ScriptObjectMirror) value);
                }
                resultMap.put(key, value);
            }
            return resultMap;
        }
        // 如果结果已经是字符串，则直接返回
        return result;
    }


    // 辅助方法：递归地将嵌套的 ScriptObjectMirror 转换为 Map
    private Map<String, Object> convertToMap(ScriptObjectMirror som) {
        Map<String, Object> map = new HashMap<>();
        for (String key : som.keySet()) {
            Object value = som.get(key);
            if (value instanceof ScriptObjectMirror) {
                value = convertToMap((ScriptObjectMirror) value);
            }
            map.put(key, value);
        }
        return map;
    }
}

2. 用户模型类

为了测试脚本引擎，我们创建一个简单的User类：

package com.cenho.demo.script;

public class User {
    private String name;
    private int age;

    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }

    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

3. 测试类

最后，我们创建一个测试类来验证脚本引擎的功能：

package com.cenho.demo.script;

import org.junit.jupiter.api.Test;

import javax.script.ScriptException;
import java.util.ArrayList;
import java.util.List;

class ScriptEngineApplicationTests {

    @Test
    void test() throws ScriptException, NoSuchMethodException {
        ScriptEngine scriptEngine = new ScriptEngine();

        List<Object> args = new ArrayList<>();
        args.add(new User("张三", 20));
        args.add("是一个大学生");

        String script = "function handle(args){\n" +
                "    return args[0].name+'('+args[0].age+'岁)'+args[1];\n" +
                "}";

        Object result = scriptEngine.execute(script, args);
        System.out.println(result);

        assert result.equals("张三(20岁)是一个大学生");
    }
}

工作原理

上述示例的工作原理如下：

创建脚本引擎：使用ScriptEngineManager创建一个Nashorn JavaScript引擎实例。
执行脚本：使用engine.eval()方法执行JavaScript脚本内容。
调用函数：将引擎转换为Invocable接口，然后调用脚本中定义的handle函数，并传递参数。
处理结果：处理JavaScript返回的结果，如果是复杂对象（ScriptObjectMirror），则将其转换为Java的Map对象。

在测试示例中，我们创建了一个简单的JavaScript脚本，该脚本接收一个参数数组，并返回一个字符串，该字符串由用户的名称、年龄和一个描述组成。

高级用法

1. 脚本缓存

在实际应用中，为了提高性能，我们可以缓存已编译的脚本：

// 创建脚本缓存
private final Map<String, CompiledScript> scriptCache = new ConcurrentHashMap<>();

public Object executeWithCache(String scriptId, String scriptContent, List<Object> args) throws ScriptException, NoSuchMethodException {
    CompiledScript compiledScript = scriptCache.get(scriptId);
    if (compiledScript == null) {
        javax.script.ScriptEngine engine = new ScriptEngineManager().getEngineByName("nashorn");
        Compilable compilable = (Compilable) engine;
        compiledScript = compilable.compile(scriptContent);
        scriptCache.put(scriptId, compiledScript);
    }
    
    // 执行已编译的脚本
    compiledScript.eval();
    
    // 调用函数并处理结果
    Invocable invocable = (Invocable) compiledScript.getEngine();
    return invocable.invokeFunction("handle", args);
}

2. 安全限制

在生产环境中使用动态脚本时，安全性是一个重要考虑因素。我们可以使用以下方法来增强安全性：

沙箱环境：限制脚本对系统资源的访问。
超时机制：设置脚本执行的最大时间，防止无限循环。
内存限制：限制脚本可以使用的最大内存。

// 示例：设置超时机制
public Object executeWithTimeout(String scriptContent, List<Object> args, long timeoutMillis) {
    ExecutorService executor = Executors.newSingleThreadExecutor();
    Future<Object> future = executor.submit(() -> {
        try {
            return execute(scriptContent, args);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    });
    
    try {
        return future.get(timeoutMillis, TimeUnit.MILLISECONDS);
    } catch (TimeoutException e) {
        future.cancel(true);
        throw new RuntimeException("Script execution timed out", e);
    } catch (Exception e) {
        throw new RuntimeException("Script execution failed", e);
    } finally {
        executor.shutdownNow();
    }
}

3. 错误处理

在处理动态脚本时，错误处理是非常重要的。我们应该捕获并适当处理可能发生的各种异常：

public Object executeSafely(String scriptContent, List<Object> args) {
    try {
        return execute(scriptContent, args);
    } catch (ScriptException e) {
        // 处理脚本语法错误
        log.error("Script syntax error: {}", e.getMessage());
        return createErrorResponse("SCRIPT_SYNTAX_ERROR", e.getMessage());
    } catch (NoSuchMethodException e) {
        // 处理方法不存在错误
        log.error("Method not found: {}", e.getMessage());
        return createErrorResponse("METHOD_NOT_FOUND", "The 'handle' function is not defined in the script");
    } catch (Exception e) {
        // 处理其他错误
        log.error("Script execution error: {}", e.getMessage());
        return createErrorResponse("EXECUTION_ERROR", e.getMessage());
    }
}

private Map<String, Object> createErrorResponse(String errorCode, String errorMessage) {
    Map<String, Object> response = new HashMap<>();
    response.put("success", false);
    response.put("errorCode", errorCode);
    response.put("errorMessage", errorMessage);
    return response;
}