Hedley Proctor

In Java configuration properties can only be key-value pairs e.g. Wouldn’t it be nice to be able to group configuration properties? This is exactly what you can do in Groovy using the ConfigSlurper class. It allows you to write config files like the following: These properties are read in as a map of maps, and you can access each property by using the dot operator on the configuration object: For more info, see: http://groovy.codehaus.org/ConfigSlurper

In my job we often have spreadsheets of data that we want to quickly turn into SQL scripts. (Yes, I know there are plenty of ways of importing spreadsheets into databases, but our DBAs want SQL scripts!) This is fairly simple task and could be done just by manually editing the CSV file and doing a few regular expression. However, one little annoyance is that you need to quote some of the columns in order to create a valid SQL script. Writing a Java program to do this would be quite time consuming, but with Groovy it is very quick. Here is the script I wrote: You can see how much easier this is with Groovy – the files can be defined in a single line of code and you’re not forced to deal with lots of possible exceptions when doing the file IO. In addition, Groovy provides a very useful iteration closure – eachWithIndex – that allows you to iterate over a collection and be given both the object and its index on each iteration.

A closure is a block of code (i.e. a function). In Java, to define a block of code, you would have to write a method or a class, but in Groovy you can write a closure and assign it to a variable, or simply declare it inline, when you want to use it. You can write methods to accept closures, which means you can write powerful and flexible APIs far more easily than with Java. In Java, if you want callers to be able to pass objects in to your API,  you would typically find yourself using the strategy pattern to define an interface that the classes of those objects must implement. Even if the caller only needs to write a couple of lines of code, this means that you have to write an interface, and they have to write an entire class, just to contain that code. By contrast, with Groovy, you can just write a method that declares that it accepts a closure. I’ll give a very simple example. I work in eCommerce, so let’s use the example of an eCommerce platform that uses a class called PromotionManager to deal with the promotions on the website. When writing this class, you don’t know all of the ways the rest of the platform might like to interact with the promotions. You need to provide a very flexible way of accessing the promotions, whilst still hiding the implementation details. With Groovy you could write a method like forEachPromo that iterates over all promotions and invokes a closure on each one: So, for example, if a caller wanted to print out each promotion, they could call your API with: For more details about closures, check out: http://groovy.codehaus.org/Closures+-+Informal+Guide

Consider the following Java code:

public class Customer{
private int id;
private String firstName;
private String lastName;
public void setId(int id){
this.id = id;
}
public void setFirstName(String firstName){
this.firstName = firstName;
}
public void setLastName(String lastName){
this.lastName = lastName;
}
public int getId(){
return id;
}
public String getFirstName(){
return firstName;
}
public String getLastName(){
return secondName;
}
}

In Groovy this would be defined as:

class Customer{
int id
String firstName
String lastName
}

In Groovy, if you don’t put an access modifier on an instance variable, it is assumed to be private,and Groovy generates public getters and setters for it. This means classes aren’t littered with getter and setter code, but just contain code that actually does stuff.

One of the technologies I’ve been playing around with recently is the Groovy language. It’s an interesting language as it offers a number of features not found in Java. Some of the these are features of the language itself, some are just additional libraries.

Some of the language features are:

• No need for getters and setters.
• Closures
• Mixins
• Native lists and maps
• Native regular expressions
• Native support for markup languages like HTML or XML
• Native interaction with Java.

and some of the library features are:

• Simplified file IO.
• Simplified database and SQL usage.
• Simplified XML parsing.
• Better support for configuration files with the ConfigSlurper class.
• Built in support for creating mocks and stubs for testing purposes.

If you haven’t already played around with Groovy, I’d strongly encourage you to take a look. The main website is:

http://groovy.codehaus.org

You can get the Eclipse plugin from:

http://groovy.codehaus.org/Eclipse+Plugin