One good example is the with method. The with method receive a closure as a parameter. Inside it, you can configure the object state, set properties and call any method:

class Person{
 int age
 String name
 String address    
 boolean workDone

 def doVeryExpensiveWork(){
 println 'working....'
 workDone = true
 }

 def String toString(){
 return "Person -> age: ${age}, name: ${name}, address: ${address}, workDone: ${workDone} "
 }
}

def p = new Person()
p.with{
 age = 12
 name = 'andre'
 address = 'my address'
 doVeryExpensiveWork()
}

assert p.age == 12
assert p.name == 'andre'
assert p.address == 'my address'
assert p.workDone

println p

More, you can transform code like this:

Calendar javaCalendar = Calendar.getInstance();
javaCalendar.clear();
javaCalendar.set(Calendar.MONTH, Calendar.JULY);
javaCalendar.set(Calendar.DATE, 19);
javaCalendar.set(Calendar.YEAR, 1986);
Date time = javaCalendar.getTime();

into this one:

//groovy
gcalendar = Calendar.instance
gcalendar.with{
 clear()
 set MONTH, JULY
 set DATE,  19
 set YEAR,  1986
}

assert javaCalendar.time == gcalendar.time

=D

For some time I’ve been studying some dynamic languages. Groovy seems like a good choice,  since I really like java (Erlang and Ruby are in my TODO list).

Some time ago I heard about Apache Camel, an integration framework based on well known Enterprise Integration Patterns.

Looking at suported languages, WOW it has groovy support. So, let’s stop talking and show real code that sends messages from files in a filesystem directory to a gtalk account:

import org.apache.camel.impl.DefaultCamelContext
import org.apache.camel.language.groovy.GroovyRouteBuilder

We need to import DefaultCamelContex, where we configure routes and the policies to use.
Also, we use GroovyRouteBuilder, base class with route management capabilities

@Grab(group='org.apache.camel', module='camel-groovy', version='1.6.0')
@Grab(group='org.apache.camel', module='camel-core', version='1.6.0')
@Grab(group='org.apache.camel', module='camel-xmpp', version='1.6.0')

Uses Grape to retrieve dependencies needed: camel groovy supoort, camel core and camel xmpp component.

class SimpleXMPPRoute extends GroovyRouteBuilder {
     protected void configure(){
         from("file:///tmp/from/?noop=true").
         to("xmpp://talk.google.com:5222/<target_user>?serviceName=gmail.com&user=<sender_user>&password=<sender_passwd>");
     }
}

Here we configure our route inside the configure method. Note that our class extends GroovyRouteBuilder.
First, we define the source of data. The example above uses a File component, scanning a directory for any new (or modified) file.
When modifications are detected, the framework ‘sends’  the file to the XMPP component, which sends the file contents to the specified gtalk user.

def camelCtx = new DefaultCamelContext()
camelCtx.addRoutes(new SimpleXMPPRoute())
camelCtx.start()

Finally, create the camel context, add our xmpp route and start the context. That’s it!

We can integrate several components like databases, jms queues and so on. It’s easy to transform output data from some system and then plug that output as input to others systems, with no acknowledgment of each other .

Simple, isn’t it?

=D

It will be in english, so I can force myself to exercise more that language.

Nowadays almost all my projects are in Java, so expect many java-groovy and so on related posts.

But C, Python and many others crazy computer science topics that I like will be here sometimes.

So, I hope you enjoy. Or not. =D