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

binding java template-engine groovy

2022-09-02 13:57:33

Groovy 模板中的常规操作是将命名对象绑定到模板的作用域中，如下所示：

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

然后，在模板中，我可以引用并使用“someObject”，如下所示：

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

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

someObject = someObject.&helloWorld

然后，我可以在不参考对象和方法名称的情况下执行这些操作：

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

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

使用方法关闭不起作用 - 这是一个简单的测试和我得到的错误

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 的元类是一个“HandleMetaClass”。我还可以从Java端自定义设置方法闭合的元类。我只是想知道如何做到这一点以获得相同的行为。Groovy在模板中这样做（从模板解释器中的Java端），所以我想提前做同样的事情。

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

然后，正确的答案不会按照下面的@Dany答案安装替换委托，而是使用现有的委托并创建正确的对象，以便在没有“.call”语法的情况下方便使用mc1。

答案 1

这将工作：

"<% " +
"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', ...)testMethodMethodClosurecall

但是，已转换为。它失败，因为没有定义任何方法，并且您无法通过绑定定义它。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);
    }
}

答案 2

您可以通过将 ResolveStrategy 更改为 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();

希望这符合您的要求。