Groovy DSL：如何让两个委托类处理DSLScript的不同部分？

Question

假设我有这样的DSL

setup {name = "aDSLScript"}
println "this is common groovy code"
doStuff {println "I'm doing dsl stuff"}

通常会有一个实现方法“设置”和“doStuff”的委托类。此外，还可以编写要执行的通用Groovy代码（println...）。

我正在寻找的是一种分两步执行的方法。在第一步中，只应处理setup方法（无论是println还是println）。第二步处理其他部件。

目前，我有两个授权课程。一个实现“setup”，另一个实现“doStuff”。当然，两者都执行println语句。

Answer 1

我找到了一种拆分DSL脚本执行的方法。我使用CompilationCustomizer从AST中删除除doFirst{}之外的所有语句。所以第一次运行只会执行doFirst。第二次运行执行其他所有操作。以下是一些代码：

class DoFirstProcessor {
    def doFirst(Closure c) {
        c()
    }
}

class TheRestProcessor {
    def doStuff(Closure c) {
        c()
    }

    def methodMissing(String name, args) {
        //nothing to do
    }
}

def dsl = "
println 'this is text that will not be printed out in first line!'

doFirst { println 'First things first: e.g. setting up environment' }

doStuff { println 'doing some stuff now' }

println 'That is it!'
"


class HighlanderCustomizer extends CompilationCustomizer {
    def methodName

    HighlanderCustomizer(def methodName) {
        super(CompilePhase.SEMANTIC_ANALYSIS)
        this.methodName = methodName
    }

    @Override
    void call(SourceUnit sourceUnit, GeneratorContext generatorContext, ClassNode classNode) throws CompilationFailedException {
        def methods = classNode.getMethods()
        methods.each { MethodNode m ->
            m.code.each { Statement st ->
                if (!(st instanceof BlockStatement)) {
                    return
                }
                def removeStmts = []
                st.statements.each { Statement bst ->
                    if (bst instanceof ExpressionStatement) {
                        def ex = bst.expression
                        if (ex instanceof MethodCallExpression) {
                            if (!ex.methodAsString.equals(methodName)) {
                                removeStmts << bst
                            }
                        } else {
                            removeStmts << bst
                        }
                    } else {
                        removeStmts << bst
                    }
                }
                st.statements.removeAll(removeStmts)
            }
        }
    }
}

def cc = new CompilerConfiguration()
cc.addCompilationCustomizers new HighlanderCustomizer("doFirst")
cc.scriptBaseClass = DelegatingScript.class.name

def doFirstShell = new GroovyShell(new Binding(), cc)
def doFirstScript = doFirstShell.parse dsl
doFirstScript.setDelegate new DoFirstProcessor()
doFirstScript.run()

cc.compilationCustomizers.clear()
def shell = new GroovyShell(new Binding(), cc)
def script = shell.parse dsl
script.setDelegate new TheRestProcessor()
script.run()

我做了另一个变化，我在一个步骤中执行DSL。查看我的博客帖子：http://hackserei.metacode.de/?p=247

Answer 2

您可以创建一个类来拦截脚本中的方法调用，并让它协调以下方法调用。我是通过反射来完成的，但如果您愿意，您可以采用声明式。这些是模型和脚本类：

class FirstDelegate {
  def setup(closure) { "firstDelegate.setup" }
}

class SecondDelegate {
  def doStuff(closure) { "secondDelegate.doStuff" }
}


class MethodInterceptor {
  def invokedMethods = []

  def methodMissing(String method, args) {
    invokedMethods << [method: method, args: args]
  }

  def delegate() {
    def lookupCalls = { instance ->
      def invokes = instance.metaClass.methods.findResults { method ->
        invokedMethods.findResult { invocation ->
          invocation.method == method.name ? 
              [method: method, invocation: invocation] : null 
        }
      }

      invokes.collect { invoked ->
        invoked.method.invoke(instance, invoked.invocation.args) 
      }
    }

    return lookupCalls(new FirstDelegate()) + lookupCalls(new SecondDelegate())
  }
}

下面是脚本和断言：

import org.codehaus.groovy.control.CompilerConfiguration

def dsl = '''
setup {name = "aDSLScript"}
println "this is common groovy code"
doStuff {println "Ima doing dsl stuff"}
'''


def compiler = new CompilerConfiguration()
compiler.scriptBaseClass = DelegatingScript.class.name

def shell = new GroovyShell(this.class.classLoader, new Binding(), compiler)

script = shell.parse dsl

interceptor = new MethodInterceptor()

script.setDelegate interceptor

script.run()

assert interceptor.invokedMethods*.method == [ 'setup', 'doStuff' ]

assert interceptor.delegate() == 
    ['firstDelegate.setup', 'secondDelegate.doStuff']

注意，我没有费心拦截println调用，这是一种默认的groovymethods，因此处理起来有点麻烦。

让类Method odInterceptor实现方法委托（）也不是一个好主意，因为这允许用户定义的脚本调用它。