Second Groovy wrappers tutorial

In the first Groovy wrappers tutorial, we defined a Script interface with one method only. This method had no arguments and a return value. In this tutorial, we will add more methods in our in Script interface.

Overview

We will define a Script interface, and run a Groovy Script as a class which implements this interface from Java.

Modify the Script interface

We will add two method definitions for the Script interface:

• One without a return value
• Another with some arguments

      public interface Script {
        public void doSomething();

        public int compute(int value1, int value2);
      }

Use the existing Groovy script wrapper

We don't need to modify the GroovyScriptWrapper, because we only added methods to our Script interface. It still is:

      public class GroovyScriptWrapperImpl extends GroovyScriptWrapper<Script> {
      }

Define our new Groovy method wrappers

Now we need to define wrapper for our two new methods:

• The doSomething() method with no return value
• The compute(int value1, int value2) method with two int arguments

Define a method wrapper for the method with two arguments

As the method has a return value, we will still extend the AbstractScriptMethodProxy class:

      public class MethodWrapperImpl2 extends AbstractScriptMethodWrapper<Script, Integer> {

        public MethodWrapperImpl2(ScriptWrapper<Script> wrapper) {
          super(wrapper);
        }

        protected Integer executeScriptImpl(Object[] arguments) {
          Integer i1 = (Integer)arguments[0];
          Integer i2 = (Integer)arguments[1];
          return script.compute(i1, i2);
        }
      }

Define a method wrapper for the method with no return value

As it is a method with no return value, we will to extend the AbstractVoidScriptMethodProxy class:

      public class MethodWrapperImpl3 extends AbstractVoidScriptMethodWrapper<Script> {

        public MethodWrapperImpl3(ScriptWrapper<Script> wrapper) {
          super(wrapper);
        }

        protected void executeScriptImpl(Object[] arguments) {
          return script.doSomething();
        }
      }

Use the scripting runtime

Suppose we have the following Groovy script:

      public int execute() {
        return 10;
      }

      public void doSomething() {
        System.out.println("I am here");
      }

      public int compute(int i1, int i2) {
        return i1 + i2;
      }

We create the ScriptWrapper exactly as in the first tutorial:

      ScriptWrapper<Script> wrapper = new GroovyScriptWrapperImpl();

Then we create the wrappers around the compute(int value1, int value2) and doSomething() methods:

      ScriptMethodWrapper<Script, Integer> methodWrapper2 = new MethodWrapperImpl2(wrapper);
      VoidScriptMethodWrapper<Script> methodWrapper3 = new MethodWrapperImpl3(wrapper);

We can now install the Script:

      File file = new File(<our script file>);
      wrapper.installScript(file);

And now we can run all the three methods:

      int value = methodWrapper.executeMethod();
      // value is 10

      int value = methodWrapper2.executeMethod(1, 2);
      // value is 3

      methodWrapper3.executeMethod();
      // the message "I am here" is printed on the console

As you see, if we try do do:

      int value = methodWrapper2.executeMethod(1f, 2f);

The method will throw an exception, because the arguments are not identical to those defined in MethodWrapperImpl2. The next tutorial will explain how to cast automatically the arguments.