java - Groovy 脚本在运行时重新加载

Question

我希望能够从我的 Java 应用程序执行 groovy 脚本。如果需要，我想在运行时重新加载 groovy 脚本。根据他们的tutorials ，我可以做类似的事情:

long now = System.currentTimeMillis();
for(int i = 0; i < 100000; i++) {
    try {
        GroovyScriptEngine groovyScriptEngine = new GroovyScriptEngine("");                
        System.out.println(groovyScriptEngine.run("myScript.groovy", new Binding()););
    } catch (Exception e) {
        e.printStackTrace();
    }
}
long end = System.currentTimeMillis();

System.out.println("time " + (end - now));//24 secs

myScript.groovy

"Hello-World"

这工作正常，每次我在 myScript.groovy 中更改一行时都会重新加载脚本。

问题是这效率不高，它所做的就是每次从文件中解析脚本。

还有其他选择吗？例如，更智能的东西可以检查脚本是否已经解析，如果自上次解析以来没有更改，则不会再次解析它。

Answer 1

<<因评论而编辑>>

就像其中一条评论中提到的那样，如果您需要性能，则必须将解析(缓慢)与执行(快速)分开。

对于脚本源的响应式(Reactive)重新加载，我们可以使用 java nio watch service :

import groovy.lang.*
import java.nio.file.*

def source = new File('script.groovy')
def shell  = new GroovyShell()
def script = shell.parse(source.text)

def watchService = FileSystems.default.newWatchService()
source.canonicalFile.parentFile.toPath().register(watchService, StandardWatchEventKinds.ENTRY_MODIFY)

boolean keepWatching = true 
Thread.start { 
  while (keepWatching) {
    def key = watchService.take()
    if (key.pollEvents()?.any { it.context() == source.toPath() }) {
      script = shell.parse(source.text)
      println "source reloaded..."
    }
    key.reset()
  }
}

def binding = new Binding()
def start = System.currentTimeMillis()
for (i=0; i<100; i++) {
  script.setBinding(binding)
  def result = script.run()
  println "script ran: $result"
  Thread.sleep(500)
} 
def delta = System.currentTimeMillis() - start
println "took ${delta}ms"

keepWatching = false

上面启动了一个单独的观察程序线程，该线程使用 java watch 服务来监视父目录中的文件修改，并在检测到修改时重新加载脚本源。这假定 java 版本 7 或更高版本。 sleep 只是为了更容易地使用代码，如果测量性能，自然应该将其删除。

将字符串 System.currentTimeMillis() 存储在 script.groovy 中并运行上述代码将使其每秒循环两次。在循环期间对 script.groovy 进行修改会导致:

~> groovy solution.groovy 
script ran: 1557302307784
script ran: 1557302308316
script ran: 1557302308816
script ran: 1557302309317
script ran: 1557302309817
source reloaded...
script ran: 1557302310318
script ran: 1557302310819
script ran: 1557302310819
source reloaded...

只要对源文件进行更改，就会打印 source reloaded... 行。

我不确定Windows，但我相信至少在Linux上，java在幕后使用fsnotify系统，这应该使文件监视部分具有高性能。

需要注意的是，如果我们真的不走运，脚本变量将被两行之间的观察者线程重置:

  script.setBinding(binding)
  def result = script.run()

这会破坏代码，因为重新加载的脚本实例没有绑定(bind)集。为了解决这个问题，我们可以使用锁:

import groovy.lang.*
import java.nio.file.*
import java.util.concurrent.locks.ReentrantLock

def source = new File('script.groovy')
def shell  = new GroovyShell()
def script = shell.parse(source.text)

def watchService = FileSystems.default.newWatchService()
source.canonicalFile.parentFile.toPath().register(watchService, StandardWatchEventKinds.ENTRY_MODIFY)

lock = new ReentrantLock()

boolean keepWatching = true 
Thread.start { 
  while (keepWatching) {
    def key = watchService.take()
    if (key.pollEvents()?.any { it.context() == source.toPath() }) {
      withLock { 
        script = shell.parse(source.text)
      }
      println "source reloaded..."
    }
    key.reset()
  }
}

def binding = new Binding()
def start = System.currentTimeMillis()
for (i=0; i<100; i++) {
  withLock { 
    script.setBinding(binding)
    def result = script.run()
    println "script ran: $result"
  }
  Thread.sleep(500)
} 
def delta = System.currentTimeMillis() - start
println "took ${delta}ms"

keepWatching = false

def withLock(Closure c) {
  def result
  lock.lock()
  try { 
    result = c()
  } finally { 
    lock.unlock()
  }
  result
}

这使代码有些复杂，但可以让我们免受并发问题的影响，而这些问题往往很难追踪。