Java动态调用groovy脚本代码教程

深藏阁楼爱情的钟 2024-01-30 06:36 61阅读 0赞

## goovy简介 ##

Goovy是一种基于Java虚拟机（JVM）的动态编程语言，它结合了Python、Ruby和Smalltalk的许多强大特性，并能够与Java完美结合，使用Java所有的库。以下是关于Goovy的详细解释：

### 语法 ###

Goovy的语法非常简洁明了，类似于Python和Ruby。它支持动态类型和静态类型，可以在运行时进行类型检查和推断。Goovy还支持闭包、高阶函数和匿名函数等特性，这些特性使得代码更加简洁、易于阅读和维护。

### 类型系统 ###

Goovy的类型系统非常灵活，支持动态类型和静态类型。在动态类型的情况下，变量的类型会在运行时自动推断。在静态类型的情况下，变量的类型需要在编译时声明。Goovy还支持类型转换和类型检查，使得代码更加健壮和可读。

### 闭包 ###

Goovy支持闭包，闭包可以捕获其创建时所在的词法作用域中的变量。闭包可以作为参数传递给函数，也可以作为函数的返回值。闭包使得代码更加简洁、灵活和可重用。

### 高阶函数 ###

Goovy支持高阶函数，高阶函数是指接受其他函数作为参数或返回函数的函数。高阶函数使得代码更加简洁、易于阅读和维护。

### 反射 ###

Goovy支持反射，反射是指在运行时检查程序的行为和结构的能力。通过反射，可以在运行时获取类的信息、创建对象、调用方法等。反射使得代码更加灵活和可扩展。

### 并发编程 ###

Goovy支持并发编程，它提供了类似于Java的线程和锁等机制，同时也提供了类似于Python的协程和异步编程等机制。这些机制使得开发人员可以更加轻松地编写并发程序，提高程序的性能和可靠性。

### 集成Java库 ###

Goovy可以无缝集成Java库，开发人员可以使用Java所有的库来编写Goovy代码。这使得开发人员可以更加方便地利用现有的Java资源，同时也使得Goovy成为了一种非常灵活的动态脚本语言。

### 应用场景 ###

Goovy适用于各种应用场景，例如Web开发、桌面应用、移动应用、游戏开发等。它既可以作为主要开发语言使用，也可以作为辅助语言使用，与Java完美结合，提高开发效率和代码质量。

总之，Goovy是一种非常强大的动态编程语言，它结合了Python、Ruby和Smalltalk的许多强大特性，并能够与Java完美结合，使用Java所有的库。Goovy的语法简洁明了、类型灵活、支持闭包和高阶函数等特性，使得代码更加简洁、易于阅读和维护。同时，Goovy还支持反射和并发编程等机制，使得程序更加灵活和可扩展。Goovy可以无缝集成Java库，使得开发人员可以更加方便地利用现有的Java资源。总之，Goovy是一种非常优秀的编程语言，适用于各种应用场景，值得广大开发人员学习和使用。

## 引入pom依赖 ##

在maven项目中pom.xml添加如下依赖

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

## 代码实现 ##

**创建一个名为ScriptProvider的groovy脚本辅助类，实现java调用groovy脚本中的方法。完整代码如下：**

import groovy.lang.GroovyClassLoader;
    import groovy.lang.GroovyObject;
    import lombok.extern.slf4j.Slf4j;
    import org.springblade.coalface.modules.opcua.dto.OpcData;
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.stereotype.Component;
    
    import java.io.File;
    import java.io.IOException;
    import java.util.List;
    
    /**
     * @author tarzan
     */
    @Component
    @Slf4j
    public class ScriptProvider {
        
    
        private GroovyObject groovyObject;
    
        @Value("${app.work-face}")
        private  void loadScript(String name){
        
            try (GroovyClassLoader classLoader = new GroovyClassLoader()) {
        
                Class<?> groovyClass = classLoader.parseClass(new File("etc/"+name+".groovy"));
                groovyObject= (GroovyObject) groovyClass.newInstance();
            } catch (InstantiationException | IOException | IllegalAccessException e) {
        
                log.error(e.getMessage());
            }
        }
    
        public  void overloadScript(String filePath){
        
            try (GroovyClassLoader classLoader = new GroovyClassLoader()) {
        
                Class<?> groovyClass = classLoader.parseClass(new File(filePath));
                groovyObject= (GroovyObject) groovyClass.newInstance();
            } catch (InstantiationException | IOException | IllegalAccessException e) {
        
                log.error(e.getMessage());
            }
        }
    
        public float calStentHeight(int i, List<OpcData> dataValues){
        
            Object[] objects = new Object[]{
        i,dataValues};
            Object result=groovyObject.invokeMethod("calStentHeight",objects);
            return Float.parseFloat(result.toString());
        }
    
        public float revisedStentHeight(int i, float value){
        
            Object[] objects = new Object[]{
        i,value};
            Object result=groovyObject.invokeMethod("revisedStentHeight",objects);
            return Float.parseFloat(result.toString());
        }
    
        public float revisedStentStroke(float value) {
        
            Object[] objects = new Object[]{
        value};
            Object result=groovyObject.invokeMethod("revisedStentStroke",objects);
            return Float.parseFloat(result.toString());
        }
    
    }

*  app.work-face 是在spring配置文件中的goovy脚本名称
 *  etc/“+name+”.groovy 是指在项目根目录下 etc文件夹下 的某个 goovy脚本

**groovy脚本代码示例**

import org.springblade.coalface.modules.opcua.dto.OpcData
    
    def calStentHeight(int i,List<OpcData> dataValues){
        
         float d= dataValues.get(i).getValue()
         def f1=0.175
         def f2=0.136
         def e= new BigDecimal(Float.toString(d)).add(f1).add(f2)
        return e.doubleValue()
    }
    
    def revisedStentHeight(int i,float height){
        
        int stentNo=i+1
        if(stentNo<=2||stentNo>=92){
        
            height=height>3.3||height<1.15?3.3:height
        }else{
        
            if(height>1.9){
        
                height=1.9
            }
            if(height<1.15){
        
                height=1.2
            }
        }
        return height
    }
    
    def revisedStentStroke(float stroke){
        
        if(stroke>900F){
        
            stroke=900F
        }
        if(stroke<=0F){
        
            stroke=0F
        }
        return stroke
    }

*  groovy 脚本中可以直接引入java的类，使用java对象的方法和属性

**调用代码示例**

@Resource
      private ScriptProvider scriptProvider;
    
     
      private void test() {
        
          float revised = scriptProvider.revisedStentStroke(modification);    
      }

*  注入ScriptProvider工具类
 *  通过ScriptProvider工具类调用对应grovvy脚本中的方法

## 动态监听脚本 ##

当脚本被修改时候，java代码重新加载groovy脚本中的最新代码，需要一个监听工具类FileSystemWatcher，完整代码如下：

import lombok.AllArgsConstructor;
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.scheduling.annotation.Async;
    import org.springframework.stereotype.Component;
    
    import java.io.IOException;
    import java.nio.file.*;
    
    /**
     * @author tarzan
     */
    @Component
    @AllArgsConstructor
    @Slf4j
    public class FileSystemWatcher {
        
    
        private final ScriptProvider scriptProvider;
    
        @Async
        public void modifyWatch(){
        
            try {
        
                watch(StandardWatchEventKinds.ENTRY_MODIFY);
            } catch (IOException | InterruptedException e) {
        
                log.error(e.getMessage());
            }
        }
    
        @SuppressWarnings({
        "unchecked", "BusyWait"})
        private  void watch(WatchEvent.Kind<Path> eventKind) throws IOException, InterruptedException {
        
            // 定义你想要监听的路径
            Path path = Paths.get("etc");
            // 创建 WatchService
            WatchService watchService = FileSystems.getDefault().newWatchService();
            // 将路径注册到 WatchService，并指定你想要监听的事件类型
            path.register(watchService, eventKind);
    
            while (true) {
        
                // 获取下一个文件系统事件
                WatchKey key = watchService.take();
                for (WatchEvent<?> event : key.pollEvents()) {
        
                    // 获取事件类型
                    WatchEvent.Kind<?> kind = event.kind();
                    if (kind == StandardWatchEventKinds.OVERFLOW) {
        
                        continue;
                    }
                    // 获取发生事件的文件
                    WatchEvent<Path> ev = (WatchEvent<Path>) event;
                    Path fileName = ev.context();
                    // 打印出发生事件的文件名和事件类型
                    boolean eventFlag=!fileName.toFile().getName().endsWith("~");
                    if(eventFlag){
        
                        log.info("etc/"+fileName +" be modified");
                        scriptProvider.overloadScript("etc/"+fileName);
                    }
                }
                // 重置 WatchKey，以便接收下一个事件
                boolean valid = key.reset();
                if (!valid) {
        
                    break;
                }
                //睡眠1秒
                Thread.sleep(1000);
            }
        }
    
    }

*  @SuppressWarnings 用于抑制编译器产生某些警告，@SuppressWarnings(\{“unchecked”, “BusyWait”\})告诉编译器不要对未检查的类型转换和忙等待产生警告。
 *  这个监听工具类，需要在项目启动的时候调用它的监听方法。下面是代码示例：

创建一个启动监听类 AppStartedListener ，当项目启动完成后，就会调用，groovy脚本文件修改事件，当groovy脚本内的代码被修改后，保存groovy脚本时，会触发更新ScriptProvider类中加载的groovy脚本代码，实现动态更新。

import lombok.SneakyThrows;
    import lombok.extern.slf4j.Slf4j;
    import org.springblade.coalface.script.FileSystemWatcher;
    import org.springframework.boot.context.event.ApplicationStartedEvent;
    import org.springframework.context.ApplicationListener;
    import org.springframework.lang.NonNull;
    import org.springframework.stereotype.Component;
    
    import javax.annotation.Resource;
    
    
    /**
     *
     * @author tarzan
     * @date 2023-10-05
     */
    @Slf4j
    @Component
    public class AppStartedListener implements ApplicationListener<ApplicationStartedEvent> {
        
    
        @Resource
        private FileSystemWatcher fileSystemWatcher;
    
        @SneakyThrows
        @Override
        public void onApplicationEvent(@NonNull ApplicationStartedEvent event) {
        
            fileSystemWatcher.modifyWatch();
            log.info("服务初始化。。。");
        }
    
    }