如何通过绑定映射将对象中某个名称的所有方法绑定到模板中？

Question

Groovy 模板中的一个正常操作是将命名对象绑定到模板的范围内，如下所示：

map.put("someObject",object)
template.bind(map)

然后，在模板中我可以像这样引用和使用 'someObject'：

someObject.helloWorld()
someObject.helloWorld("Hi Everyone!")
someObject.helloWorld("Hi", "Everyone!")

在模板中，Groovy 还允许我将方法句柄定义为模板中的第一个 class 变量，如下所示：

someObject = someObject.&helloWorld

那么，我可以不用引用对象和方法名来做这些：

 someObject() 
 someObject("Hello World")
 someObject("Hello", "World")

如何在 'template.bind(map)' 阶段像这样绑定方法引用以及自动解析所有参数组合，如脚本中提供的“.&”运算符？

使用 MethodClosure 不起作用 — 这是一个简单的测试和我得到的错误

class TestMethodClass {
        public void test() {
            System.out.println("test()");
        }

        public void test(Object arg) {
            System.out.println("test( " + arg + " )");
        }

        public void test(Object arg1, Object arg2) {
            System.out.println("test( " + arg1 + ", " + arg2 + " )");
        }
    }

    String basic = "<%" +
        " def mc1=testInstance.&test;" +
        "println \"mc1 class ${mc1.getClass()}\";" +
        "println \"mc1 metaclass ${mc1.getMetaClass()}\";" +
        "println mc1.getClass();" +
        "mc1();" +
        "mc1('var1');" +
        "mc1('var1', 'var2');" +
        "testMethod();" +
        " %>";

    Map<Object, Object> bindings = new HashMap<>();
    bindings.put("testInstance", new TestMethodClass());
    bindings.put("testMethod", new MethodClosure(new TestMethodClass(), "test"));

    TemplateEngine engine = new GStringTemplateEngine();
    Template t = engine.createTemplate(basic);
    String result = t.make(bindings).toString();

错误

mc1 class class org.codehaus.groovy.runtime.MethodClosure
mc1 metaclass org.codehaus.groovy.runtime.HandleMetaClass@6069db50[groovy.lang.MetaClassImpl@6069db50[class org.codehaus.groovy.runtime.MethodClosure]]
class org.codehaus.groovy.runtime.MethodClosure
test()
test( var1 )
test( var1, var2 )

groovy.lang.MissingMethodException: No signature of method: groovy.lang.Binding.testMethod() is applicable for argument types: () values: []

一位用户建议我只使用'.call(..)'

"testMethod.call();" +
"testMethod.call(1);" +
"testMethod.call(1,2);" +

但这违背了目的。在那种情况下，我还不如绑定对象而不是 'testMethod' 并在 Groovy 模板中使用常规方法调用正常使用它。所以这不是这里的解决方案。

该解决方案将创建一个绑定，以便可以像这样调用 testMethod()，并为所有重载方法解析，就像 "mc1=testInstance.&test" 提供的那样。

mc1 是一个 MethodClosure，'mc1=testInstance.&test' 做了一些我想在绑定阶段做的魔术！

mc1 的 metaclass 是 'HandleMetaClass'。我还可以从 Java 端自定义设置 methodclosure 的 metaclass。我只想知道如何做到这一点以获得相同的行为。 Groovy 在模板中这样做（从模板解释器的 Java 端）所以我想提前做同样的事情。

请注意，通常情况下，流模板已经创建了自己的委托。当解释模板代码 'def mc1=testInstance.&test;' 时，Groovy compiler/interpreter 在使用 HandleMetaClass 创建 MethodClosure 时使用该委托，然后将其安装在现有委托中。

那么正确的答案 不会根据下面的@Dany 回答安装替换委托 ， 而是与现有委托一起工作并创建正确的对象以方便使用 mc1 而无需“.call”语法。

Answer 1

someObject.&helloWorld 是一个 MethodClosure 实例，代码转换为 new MethodClosure(someObject, "helloWorld")（MetodClosure 来自 org.codehaus.groovy.runtime 包）。这样就可以在Java.

准备地图了

Answer 2

这将起作用：

"<% " +
"def mc1=testInstance.&test;" +
"mc1();" +
"mc1('var1');" +
"mc1('var1', 'var2');" +
"testMethod.call();" +
"testMethod.call(1);" +
"testMethod.call(1,2);" +
" %>"

testMethod.call(...) 有效，因为它被翻译成 getProperty('testMethod').invokeMethod('call', ...)。 testMethod 属性在绑定中定义，它属于 MethodClosure 类型，其中定义了 call 方法。

然而 testMethod(...) 被翻译成 invokeMethod('testMethod', ...)。它失败了，因为没有定义 testMethod 方法，您不能通过绑定定义它。

编辑

Main.java:

public class Main {
    public static void main(String[] args) throws Throwable {
        String basic = "<%" +
                " def mc1=testInstance.&test;" +
                "mc1();" +
                "mc1('var1');" +
                "mc1('var1', 'var2');" +
                "testMethod();" +
                "testMethod(1);" +
                "testMethod(2,3);" +
                " %>";

        Map<Object, Object> bindings = new HashMap<>();
        bindings.put("testInstance", new TestMethodClass());
        bindings.put("testMethod", new MethodClosure(new TestMethodClass(), "test"));

        TemplateEngine engine = new GStringTemplateEngine();
        Template t = engine.createTemplate(basic);
        Closure make = (Closure) t.make();
        make.setDelegate(new MyDelegate(bindings));
        String result = make.toString();
    }
}

MyDelegate.groovy:

class MyDelegate extends Binding {

  MyDelegate(Map binding) {
    super(binding)
  }

  def invokeMethod(String name, Object args) {
    getProperty(name).call(args)
  }
}

或MyDelegate.java:

public class MyDelegate extends Binding{

    public MyDelegate(Map binding) {
        super(binding);
    }

    public Object invokeMethod(String name, Object args) {
        return DefaultGroovyMethods.invokeMethod(getProperty(name), "call", args);
    }
}

Answer 3

'def'表达式具有特殊的语义。添加：

def testMethod = testMethod;

就在您的示例中调用 testMethod() 之前。我不认为单独使用绑定可以达到相同的结果。

编辑：澄清一下，由于在评估 def 表达式时 testMethod 对象没有以任何方式更改，因此您可能无法以通过将其提供为绑定来自动注册为方法的方式构造 testMethod .通过使用模板的元类，您可能会更幸运。

Writable templateImpl = t.make(bindings);
MetaClass metaClass = ((Closure) templateImpl).getMetaClass();

Answer 4

您可以通过更改 ResolveStrategy to OWNER_FIRST 来实现您想要的行为。由于您想直接访问有界闭包（没有 . 符号），因此您需要将闭包方法绑定到 "owner"（模板对象本身），而不是通过绑定映射（委托）提供。

你修改的例子：

String basic = "<%" +
        " def mc1=testInstance.&test;" +
        "println \"mc1 class ${mc1.getClass()}\";" +
        "println \"mc1 metaclass ${mc1.getMetaClass()}\";" +
        "println mc1.getClass();" +
        "mc1();" +
        "mc1('var1');" +
        "mc1('var1', 'var2');" +
        "testMethod();" +
        "testMethod('var1');" +
        " %>";

TemplateEngine engine = new GStringTemplateEngine();

TestMethodClass instance = new TestMethodClass();

// Prepare binding map
Map<String, Object> bindings = new HashMap<>();
bindings.put("testInstance", instance);

Template t = engine.createTemplate(basic);

Closure<?> make = (Closure<?>) t.make(bindings); // cast as closure

int resolveStrategy = make.getResolveStrategy();
make.setResolveStrategy(Closure.OWNER_FIRST);

// set method closure which you want to invoke directly (without .
// notation). This is more or less same what you pass via binding map
// but too verbose. You can encapsulate this inside a nice static                 
// method
InvokerHelper.setProperty(
    make.getOwner(), "testMethod", new MethodClosure(instance, "test")
);

make.setResolveStrategy(resolveStrategy);
String result = make.toString();

希望，这能满足您的要求。

如何通过绑定映射将对象中某个名称的所有方法绑定到模板中？

How do I bind all methods of a certain name in an Object into a template via the binding map?

java

groovy

binding

template-engine