Java动态调用Groove代码

约定不等于承诺〃 2022-11-17 05:57 195阅读 0赞

1 目的

动态执行任务或者扩展功能，需要java动态执行groovy代码

2 项目依赖

<dependencies>
      <dependency>
        <groupId>org.codehaus.groovy</groupId>
        <artifactId>groovy-all</artifactId>
        <version>2.5.2</version>
        <type>pom</type>
      </dependency>
      <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>fastjson</artifactId>
        <version>1.2.49</version>
      </dependency>
    </dependencies>

3 动态执行groovy代码有3种方式

GroovyShell：GroovyShell允许在Java类中（甚至Groovy类）求任意Groovy表达式的值。您可使用Binding对象输入参数给表达式，并最终通过GroovyShell返回Groovy表达式的计算结果。

GroovyClassLoader：用 Groovy 的 GroovyClassLoader ，动态地加载一个脚本并执行它的行为。GroovyClassLoader是一个定制的类装载器，负责解释加载Java类中用到的Groovy类。

GroovyScriptEngine：GroovyShell多用于推求对立的脚本或表达式，如果换成相互关联的多个脚本，使用GroovyScriptEngine会更好些。GroovyScriptEngine从您指定的位置（文件系统，URL，数据库，等等）加载Groovy脚本，并且随着脚本变化而重新加载它们。如同GroovyShell一样，GroovyScriptEngine也允许您传入参数值，并能返回脚本的值。

4 项目结构

![70][]

5 GroovyClassLoader 方式

测试groovy类

package com.chy
     
    import com.alibaba.fastjson.JSON
    import com.alibaba.fastjson.TypeReference
     
    /**
     * groove class
     */
    class TestGroovy {
     
        void print() {
            System.out.println("hello word!!!!");
        }
     
        List<String> printArgs(String str1, String str2, String str3) {
            String jsonString = "[\""+str1+"\",\""+str2+"\",\""+str3+"\"]";
            return JSON.parseObject(jsonString, new TypeReference<List<String>>() {});
        }
     
    }

测试java代码

package com.chy;
     
    import groovy.lang.GroovyClassLoader;
    import groovy.lang.GroovyObject;
    import org.codehaus.groovy.control.CompilerConfiguration;
     
    import java.io.File;
    import java.util.List;
     
    /**
     * @Title: GroovyClassLoaderApp
     * @Description: 演示 GroovyClassLoader 方式
     * @author chy
     * @date 2018/9/12 22:54
     */
    public class GroovyClassLoaderApp {
     
        private static GroovyClassLoader groovyClassLoader = null;
     
        public static void initGroovyClassLoader() {
            CompilerConfiguration config = new CompilerConfiguration();
            config.setSourceEncoding("UTF-8");
            // 设置该GroovyClassLoader的父ClassLoader为当前线程的加载器(默认)
            groovyClassLoader = new GroovyClassLoader(Thread.currentThread().getContextClassLoader(), config);
        }
     
     
        public static void main(String[] args) {
            loadClass();
            System.out.println("======================");
            loadFile();
        }
     
        /**
         * 通过类加载groovy
         */
        private static void loadClass(){
            GroovyObject groovyObject = null;
            try {
                groovyObject = (GroovyObject) GroovyClassLoaderApp.class.getClassLoader().loadClass("com.chy.TestGroovy").newInstance();
            } catch (InstantiationException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
     
            // 执行无参函数
            groovyObject.invokeMethod("print",null);
     
            System.out.println("============================");
     
            // 执行有参函数
            Object[] objects = new Object[]{"abc", "def", "ghi"};
            List<String> ls=(List<String>) groovyObject.invokeMethod("printArgs", objects);
            ls.stream().forEach(System.out::println);
        }
     
        /**
         * 通过文件路径加载groovy
         * @return
         */
        private static boolean loadFile(){
            File groovyFile = new File("src/main/java/com/chy/TestGroovy.groovy");
            if (!groovyFile.exists()) {
                System.out.println("文件不存在");
                return false;
            }
     
            initGroovyClassLoader();
     
            try {
                List<String> result;
                // 获得TestGroovy加载后的class
                Class<?> groovyClass = groovyClassLoader.parseClass(groovyFile);
                // 获得TestGroovy的实例
                GroovyObject groovyObject = (GroovyObject) groovyClass.newInstance();
                // 反射调用printArgs方法得到返回值
                Object methodResult = groovyObject.invokeMethod("printArgs", new Object[] {"chy", "zjj", "xxx"});
                if (methodResult != null) {
                    result =(List<String>) methodResult;
                    result.stream().forEach(System.out::println);
                }
                return true;
            } catch (Exception e) {
                System.out.println(e.getMessage());
            }
            return false;
        }
    }

6 GroovyScriptEngine

FunGroove.groovy

package com.chy.groovy
     
    void print(){
        System.out.println("没有参数!!!!");
    }
     
    //执行方法
    print();

FunArgGroove.groovy

package com.chy.groovy
     
    String printArg(String name){
        System.out.println("参数:"+name);
        return "返回结果:"+name;
    }
     
    //执行方法
    printArg(arg);

java

package com.chy;
     
    import groovy.lang.Binding;
    import groovy.util.GroovyScriptEngine;
    import groovy.util.ResourceException;
    import groovy.util.ScriptException;
     
    import java.io.IOException;
     
    /**
    * @Title: GroovyScriptEngineApp
    * @Description: 演示 GroovyScriptEngine 方式
    * @author chy
    * @date 2018/9/13 0:06
    */
    public class GroovyScriptEngineApp {
     
        public static void main(String[] args) {
            try {
                // GroovyScriptEngine的根路径，如果参数是字符串数组，说明有多个根路径
                GroovyScriptEngine engine = new GroovyScriptEngine("src/main/java/com/chy/groovy/");
     
                Binding binding1 = new Binding();
                Object result1 = engine.run("FunGroove.groovy", binding1);
                if(null!=result1) {
                    System.out.println(result1);
                }
     
                System.out.println("===================================");
     
                Binding binding2 = new Binding();
                // arg 和 参数同名
                binding2.setVariable("arg", "测试参数");
                Object result2 = engine.run("FunArgGroove.groovy", binding2);
                System.out.println(result2);
     
            } catch (IOException e) {
                e.printStackTrace();
            } catch (ResourceException e) {
                e.printStackTrace();
            } catch (ScriptException e) {
                e.printStackTrace();
            }
        }
    }

7 GroovyShell

动态执行groovy代码

public static Object evaluate1(){
            String type = "List<String>";
            String jsonString = "[\"wei.hu\",\"mengna.shi\",\"fastJson\"]";
     
            Binding binding = new Binding();
            binding.setProperty("jsonString", jsonString);
            binding.setProperty("type", type);
            GroovyShell groovyShell = new GroovyShell(binding);
     
            // todo 必须引用 import 否则会出错
            return groovyShell.evaluate(
                    "import com.alibaba.fastjson.JSON;\n" +
                            "import com.alibaba.fastjson.TypeReference;\n" +
                            "TypeReference<"+ type +"> typeReference = new TypeReference<" + type +">(){};\n" +
                            "JSON.parseObject(jsonString, typeReference);"
            );
        }

自动执行有参数的函数

public static void evaluate3() throws CompilationFailedException, IOException {
            Binding binding = new Binding();
            //和参数名称一致
            binding.setProperty("arg", "chy");
            GroovyShell groovyShell = new GroovyShell(binding);
            Object result = groovyShell.evaluate(new File("src/main/java/com/chy/groovy/FunArgGroove.groovy"));
            System.out.println(result.toString());
        }

参考：

[https://blog.csdn.net/chy2z/article/details/82729789][https_blog.csdn.net_chy2z_article_details_82729789]

[70]: /images/20221022/86f170d4c48f4f9796042ee4c1d94f5a.png
[https_blog.csdn.net_chy2z_article_details_82729789]: https://blog.csdn.net/chy2z/article/details/82729789