Page History

The Groovy DSL implementation is built on top of the existing Java-based [DSL], but it additionally allows to use Groovy language features in your routes, particularly [Closures|http://groovy.codehaus.org/Closures] acting as [Processor|Processor], [Expression|Expression], [Predicate|Predicate], or [Aggregation Strategy|Aggregator].

With the Groovy DSL you write your RouteBuilder classes entirely in Groovy, while the [scripting component|Scripting Languages] allows to embed small scripts into Java routes. The Groovy DSL requires Groovy 2.0 or newer and is available as of *Camel 2.11*.

h3.

 Introduction

Because Groovy is syntactically very similar to Java, you can write your Groovy routes just like Java routes. The same Java DSL classes are being used, with the exception that some of the DSL classes get extended with a bunch of new methods at runtime. This is achieved by turning camel-groovy into a Groovy [Extension Module|http://docs.codehaus.org/display/GROOVY/Creating+an+extension+module] that defines extension methods on existing classes.

The majority of the extension methods allow [Closures|http://groovy.codehaus.org/Closures] to be used as parameters e.g. for expressions, predicates, processors. The following example reverses a string in the message body and then prints the value to System.out:

{code

:title

=MyRouteBuilder.java

}
...
   from("direct:test")
      .transform(new Expression() {
         @Override
         public Object evaluate(Exchange e) {
            return new StringBuffer(e.getIn().getBody().toString()).reverse().toString();
         }
      })
      .process(new Processor() {
         @Override
         public void process(Exchange e) {
           System.out.println(e.getIn().getBody());
         }
      });
...

{code

:xml

}
  <plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-eclipse-plugin</artifactId>
    <configuration>
      <additionalProjectnatures>
        <projectnature>org.eclipse.jdt.groovy.core.groovyNature</projectnature>
      </additionalProjectnatures>
      <classpathContainers>
        <classpathContainer>org.eclipse.jdt.launching.JRE_CONTAINER</classpathContainer>
        <classpathContainer>GROOVY_DSL_SUPPORT</classpathContainer>
      </classpathContainers>              
    </configuration>
  </plugin>	  

{code}

h4. Using Closures in your routes

h5. Processor Closures

All Java DSL parameters of type {{org.apache.camel.Processor}} can be replaced by a closure that accepts an object of type {{org.apache.camel.Exchange}} as only parameter. The return value of the closure is disregarded. All closures may also refer to variables not listed in their parameter list. Example:

{code

:java

}
...
   private String someValue
...
   from('direct:test')
      .process { Exchange exchange -> println exchange.in.body + someValue }
      .process { println it.in.body + someValue } // equivalent
...

{code}

h5. Expression Closures

All Java DSL parameters of type {{org.apache.camel.Expression}} can be replaced by a closure that accepts an object of type {{org.apache.camel.Exchange}} as only parameter. The return value of the closure is the result of the expression. Example:

{code

:java

}
...
   private String someValue
...
   from('direct:test')
      .transform { it.in.body.reverse() + someValue }
      .setHeader("myHeader") { someValue.reverse() }
...

{code}


h5. Predicate Closures

All Java DSL parameters of type {{org.apache.camel.Predicate}} can be replaced by a closure that accepts an object of type {{org.apache.camel.Exchange}} as only parameter. The return value of the closure is translated into a boolean value representing the result of the predicate. Example:

{code

:java

}
...
   private String someValue

   // This time, the closure is stored in a variable
   def predicate = { Exchange e -> e.in.body != someValue }
...
   from('direct:test')
      .filter(predicate)
...

{code}


h5. Aggregation Strategy Closures

Java DSL parameters of type {{org.apache.camel.processor.aggregate.AggregationStrategy}} can be replaced by a closure that accepts two objects of type {{org.apache.camel.Exchange}} representing the two Exchanges to be aggregated. The return value of the closure must be the aggregated Exchange. Example:

{code

:java

}
...
   private String separator
...
   from('direct:test1')
      .enrich('direct:enrich') { Exchange original, Exchange resource -> 
         original.in.body += resource.in.body + separator
         original  // don't forget to return resulting exchange
      }
...

{code

:java

|title

=Unmarshal XML with XmlSlurper

}
...
   from('direct:test1')
      .unmarshal().gpath(false) // explicitly namespace-unaware
      // message body is now of type groovy.util.slurpersupport.GPathResult
...
{code}

Currently, marshalling is only supported for {{groovy.util.Node}} objects.

{code

:java

|title

=Marshal XML with XmlNodePrinter

}
...
   from('direct:test1')
      // message body must be of type groovy.util.Node
      .marshal().gnode()
...

 Custom DSL extensions

You can easily define your custom extensions - be it as a Java DSL extension for your Groovy routes or for any other class unrelated to Camel. All you have to do is to write your extension methods and provide a extension module descriptor - the details are described in the [Groovy documentation|http://docs.codehaus.org/display/GROOVY/Creating+an+extension+module]. And as long as you don't require other extension methods, you can even use plain Java code to achieve this!
As an example, let's write two DSL extensions to make commonly used DSL methods more concise:

{code:java|title=MyExtension.java}

import org.apache.camel.Endpoint;
import org.apache.camel.Predicate;

public final class MyExtension {
    private MyExtension() {
        // Utility Class
    }

    // Set the id of a route to its consumer URI
    public static RouteDefinition fromId(RouteDefinition delegate, String uri) {
       return delegate.from(uri).routeId(uri);
    }

    public static RouteDefinition fromId(RouteDefinition delegate, Endpoint endpoint) {
       return delegate.from(endpoint).routeId(endpoint.getEndpointUri());
    }

    // Make common choice pattern more concise

    public static ProcessorDefinition<?> fork(ProcessorDefinition<?> delegate, String uri1, String uri2, Predicate predicate) {
       return delegate.choice().when(predicate).to(uri1).otherwise().to(uri2);
    }

}
{code}

Add a corresponding extension module descriptor to {{META-INF/services}}:

{code|title=META-INF/services/org.codehaus.groovy.runtime.ExtensionModule}
moduleName=my-extension
moduleVersion=2.11
extensionClasses=MyExtension
staticExtensionClasses=
{code}

And now your Groovy route can look like this:

{code:java|title=MyRoute.groovy}
...
   fromId('direct:test1')
      .fork('direct:null','direct:not-null',body().isNull())
...
{code}

Using the plain Java DSL, the route would look something like this:

{code:java|title=MyRoute.java}
...
   from("direct:test1")
      .routeId("direct:test1")
      .choice()
         .when(body().isNull())
            .to("direct:null")
         .otherwise()
            .to("direct:not-null");
...
{code}