Groovy Programming

Groovy annotations: @TupleConstructor

Fri, 18 May 2012 19:44:47 +0200

If you use an inversion-of-control/dependency injection container like PicoContainer that favors constructor injection, you might have classes that look like this:

class Foo {

 Guh guh

 Keks keks

 Blorb blorb

 Foo(Guh guh, Keks keks, Blorb blorb) {
  this.guh = guh
  this.keks = keks
  this.blorb = blorb
 }

}

Notice the constructor only sets fields? Why should you have to write this glue code yourself?

Fortunately, since 1.8.0, Groovy has a @TupleConstructor annotation that removes the need for a constructor.

@TupleConstructor
class Foo {

 Guh guh

 Keks keks

 Blorb blorb

}

Behind the scenes, Groovy will add an empty constructor, as well as n new constructors, where n is the number of fields in the class. For the Foo class above, Groovy would add

class Foo {

 Foo() {}
 Foo(Guh guh) { … }
 Foo(Guh guh, Keks keks) { … }
 Foo(Guh guh, Keks keks, Blorb blorb) { … }

}

So, the next time you come across constructors that merely set some fields, replace them with @TupleConstructor.

Copy Properties or how to Clone a Class to a different Class

Mon, 06 Feb 2012 19:48:24 +0100

René has asked me how to copy properties/fields of an instance of one class to an instance of another class. I.e. you have

class A {
    int a
}

and

class B {
    int a
}

where B obviously does not extend A. You want to copy all properties of an instance of A to an instance of B.

Copy Properties

The solution is to access the properties property of A, filter it to remove the class and metaClass fields (which can’t be copied) and then use the GroovyObject#setProperty method on an instance of B.

class Copy {
	
	static GroovyObject copy(GroovyObject from, GroovyObject to) {
		from?.properties?.findAll { !(it.key =~ ~/(meta)?[cC]lass/) }?.each {
			try {
				to.setProperty(it.key, from[it.key])
			}
			catch (MissingPropertyException ex) {}
		}
		to
	}
	
	static <T> T copy(GroovyObject from, Class<T> to) {
		copy(from, to.newInstance())
	}

}

Clone a Class to a different Class

The code also lets you instantiate classes which is useful in case you want to clone an instance of A down its class hierarchy.

class A {
    int a
}

class C extends A {
 int foo
}

Calling

A someA = new A(a: 42)
C someC = use (Copy) { someA.copy(C) }

will give you a clone of A that is of type C.

Groovy programming with... with

Wed, 18 Jan 2012 19:46:07 +0100

The with method, which is added to all objects by Groovy, “allows the closure to be called for the object reference self.”

This sounds a bit complicated so here are some easy use cases for with:

Setting fields

Many APIs force you to do endless obj.setSomething(something) calls. In Groovy, …

keks.setFoo(someFoo);
keks.setRolf(copter);
keks.setFnuh(guh);

… becomes…

keks.with {
 foo = someFoo
 rolf = copter
 fnuh = guh
}

PROTIP: This works great with the JEE HttpServletRequest and HttpServletResponse classes.

Removing temporary variables

Conditional blocks in which you access another property of the same object can look like this

if (new File('rofl').exists()) {
 assert new File('rofl').length() > 0;
}

or you might be tempted to use a temporary variable

File f = new File('rofl');
if (f.exists()) {
 assert f.length() > 0;
}

neither of which conveys that it’s all about the file. Groovy makes this easier and more readable:

new File('rofl').with {
 if (exists()) {
  assert length() > 0
 }
}

Harmonizing API access

By going with with, you can turn any API, wether it’s fluent or setter-based into one simple, easy-to-read style.

Cleaner logging with Log4j, Commons Logging and java.util.logging

Mon, 03 Oct 2011 19:10:32 +0200

Logging frameworks are the Java programmer’s finger exercise — think content management systems for PHP programmers.

Most libraries these days use either Log4j or commons-logging, which is fine because SLF4J can replace commons-logging and redirect output from classes using either API to Log4j.

Problems only arise when the odd library uses the java.util.logging log framework. Not only is it initialized globally, it also can’t be replaced on the classpath because of its location in java.*. And its output is ugly.

With the public interest in Log4j, commons-logging and java.util.logging something like 100 : 10 : 0.5 (source: AdWords), not even Sun using the JDK for leverage can turn a mediocre also-ran product into a winner.

This means that java.util.logging must go. Thankfully, there’s a SLF4JBridgeHandler in SLF4J, but how to replace java.util.logging loggers with the SLF4JBridgeHandler?

import java.util.logging.LogManager
import java.util.logging.Logger

import org.slf4j.bridge.SLF4JBridgeHandler

class KillJavaUtilLogging {

    static {
        Logger log = LogManager.logManager.getLogger('')
        while (log.parent) {
            log = log.parent
        }
        log.with {
            handlers.each { removeHandler(it) }
            addHandler(new SLF4JBridgeHandler())
        }
    }

}

Now, simply mentioning KillJavaUtilLogging will redirect all java.util.logging output into SLF4J where it is logged using Log4j (or commons-logging, if you want).

class BlobFilter implements Filter {
    
    {
        KillJavaUtilLogging
    }
}

The corresponding Maven POM dependencies might look like this:

		<dependency>
			<groupId>log4j</groupId>
			<artifactId>log4j</artifactId>
			<version>1.2.16</version>
		</dependency>
		<dependency>
			<groupId>org.slf4j</groupId>
			<artifactId>slf4j-log4j12</artifactId>
			<version>1.6.2</version>
		</dependency>
		<dependency>
			<groupId>org.slf4j</groupId>
			<artifactId>jcl-over-slf4j</artifactId>
			<version>1.6.2</version>
		</dependency>
		<dependency>
			<groupId>org.slf4j</groupId>
			<artifactId>jul-to-slf4j</artifactId>
			<version>1.6.2</version>
		</dependency>

CodeNarc for Eclipse released

Mon, 15 Aug 2011 23:15:27 +0200

My friend René has released CodeNarc for Eclipse which integrates CodeNarc into Eclipse.

CodeNarc tries to find errors and potential problems in Groovy code. The list of code checks is already quite large and covers a lot more than the basics (for example bitwise OR instead of boolean OR).

If you find yourself writing more Groovy and less Java, it might make sense to expand static analysis to dynamic code, just as it is normally done for Java with tools like PMD, CheckStyle or FindBugs.

The Eclipse update sites are

http://codenarceclipse.sourceforge.net/eclipse/release/ for release builds
http://codenarceclipse.sourceforge.net/eclipse/snapshot/ for snapshot builds

Groovy operators: The spread operator is null-safe

Sat, 25 Jun 2011 13:18:10 +0200

Groovy’s spread operator lets you collect a property of objects from a collection. Here’s an example:

[ 1, 2, 3 ]*.toString() == [ '1', '2', '3' ]

This is identical but shorter than calling

[ 1, 2, 3 ].collect { it.toString() }

Keep in mind that, just like .collect, the spread operator is null-safe, i.E. both of these work without throwing any exceptions:

null*.toString()
[ 1, null, 3 ]*.toString()

Performance of four methods of concatenating Strings...

Sun, 22 May 2011 16:49:45 +0200

Performance of four methods of concatenating Strings together

plus: a + a
.concat: a.concat(b)
GString: "${a}${b}".toString()
left shift: a << b

.concat is the fastest method in all cases. If you’d like a more groovy version, a << b is faster than a + b.

Java hangs when converting 2.2250738585072012e-308 -- prevent DOS attacks with Groovy

Wed, 02 Feb 2011 21:26:00 +0100

The big news now is that

Java — both its runtime and compiler — go into an infinite loop when converting the decimal number 2.2250738585072012e-308 to double-precision binary floating-point.

This has a big impact on web applications since many of them use the java.lang.Double#parseDouble(String) method with data input by the user.

While I’m sure most programmers are aware of SQL injection, this is a new threat since user input is usually handled only with try { double foo = Double.parseDouble(input); } catch (NumberFormatException ex) { /* Flip it and reverse it */ } which does not protect against the denial-of-service attack with the value mentioned above.

A Groovy Solution

Fortunately, Groovy makes it easy to protect yourself from this attack. A simple regular expression that tests for /[eE]-\d*30\d/ is all it takes.

Here is an example of my Pearson Correlation Calculator:

Vulnerable Code

def calculateFromTwoColumns(String x, String y) {

    def xTokens = (x ?: '').tokenize(defaultSeparator)
    def yTokens = (y ?: '').tokenize(defaultSeparator)

    correlation(xTokens.collect { it as double }, yTokens.collect { it as double })

}

Safe Code

def calculateFromTwoColumns(String x, String y) {

    def xTokens = (x ?: '').tokenize(defaultSeparator).
        findAll { !(it =~ /[eE]-\d*30\d/).find() }
    def yTokens = (y ?: '').tokenize(defaultSeparator).
        findAll { !(it =~ /[eE]-\d*30\d/).find() }

    correlation(xTokens.collect { it as double }, yTokens.collect { it as double })

}

This will protect against all the values mentioned in the article, such as 0.00022250738585072012e-304, 00000000002.2250738585072012e-308, 2.225073858507201200000e-308, 2.2250738585072012e-00308, 2.2250738585072012997800001e-308.

Count Words in Groovy

Fri, 20 Aug 2010 10:24:48 +0200

This is a little snippet to show you how to get the word count of a text in Groovy.

def text = '''
right about now, the funk soul brother.
check it out now, the funk soul brother.
'''
int words = text
    .collect { it.charAt(0).digit || it.charAt(0).letter ? it : ' ' }
    .join('').tokenize(' ').size()

Long number arithmetic problematic in Groovy

Thu, 10 Jun 2010 14:29:38 +0200

When you divide long numbers in Groovy, you are calling a recursive algorithm that only terminates once an Exception is thrown (org.codehaus.groovy.runtime.typehandling.BigDecimalMath#normalize(BigDecimal)).

This is not a good thing because with Groovy’s inflated call stacks, it means that, for every long division, the entire stack is cloned. And that’s costing CPU cycles and memory.

Problem

long a = 100
long b = 10
double d = a / b

Will cause an Exception to be thrown.

Solution

long a = 100
long b = 10
double d = (double) a / b

Will not cause an Exception to be thrown and will be faster in your average “container” environment.

Background

I noticed this when I was profiling media.io in YourKit.

When you write a simple test case, the numbers are very similar, but when you get stacks that are 30 or more stack elements deep, long division will become slower than double division:

Warming up, this could take 5 s or so
long: 1791
double: 2004
long (deep): 2138

"Groovy creates BigDecimal numbers deliberately. […] 3.5 is a BigDecimal, whereas 3.5f is a..."

Tue, 25 May 2010 19:49:00 +0200

“Groovy creates BigDecimal numbers deliberately. […] 3.5 is a BigDecimal, whereas 3.5f is a float or 3.5d is a double. Also, when creating variables, if you say double constant = 3.14, you’ll get the a double, although def constant = 3.14 will give you a BigDecimal.”

- Comment by Guillaume Laforge on JVM Language developpers: Your house is burning.

foo.class or foo.getClass()? Which one to use?

Sun, 23 May 2010 14:36:13 +0200

Groovy converts calls to foo.x to foo.getX() – that’s common perception.

Now, you might be tempted to write foo.class to access the object’s class.

But when you do that, sometimes null is returned, depending on how much Groovy and Java there is in your project.

The reason

For Groovy objects – which is any class generated from a file with a .groovy extension –, foo.class will be mapped to foo.getProperty('class') which is (most likely) null.

In other words, foo.class works for Java objects but probably not for Groovy objects, which is why you should use foo.getClass().

Three good reasons for Groovy

Sun, 16 May 2010 23:02:53 +0200

It’s easy to learn

If you know Java, you know Groovy. You start by getting rid of boilerplate code such as casts, getters and setters and the public keyword. And semicolons. Then, you replace tedious loops with any, each, find and findAll. Groovy’s operators and metaprogramming might come next.
Wide syntactic range

A while ago, I converted a Ruby script to Groovy and, while the Groovy version was a few characters shorter (thanks to the built-in sum method), it looked 99 % like the original Ruby script.

When I was writing mostly Java, I thought it was designed to make everybody’s code look the same.

I know now that Java doesn’t stop anyone from writing bad or unintelligible code so there’s no benefit of a language that always looks the same.
Killer productivity hacks

It’s easy to increase your productivity if all you know is Java. Groovy has its fair share of ways to make coding easier, but I assume every language has that these days, so let me show you something else.

If you mistype a method name, Groovy suggests possible methods:
```
groovy.lang.MissingPropertyException:
No such property: stdErr for class: fnuh.Guh
Possible solutions: stderr, stdOut
```
That’s smarter than necessary and you can find it at many places in Groovy.

as Groovy as it can go!

Wed, 21 Apr 2010 15:48:00 +0200

“as” is one of the wonderful little things in Groovy.

Instead of boring you with what it is, I searched my workspace for my uses of “as” and let the examples talk instead.

Closures and `as` as a Replacement for Anonymous Inner Classes

def nullIOFileFilter = { true } as IOFileFilter

What it does: Creates a Proxy that implements IOFileFilter (from commons-io) with every method call on the proxy being delegated to the closures (which always returns true). There are many interfaces with one or two methods in Java and this makes it effortless.

The same in Java:

IOFileFilter filter = new IOFileFilter() {

    public boolean accept(File file) {
        return true;
    }

    public boolean accept(File dir, String name) {
        return true;
    }

};

`as` for automatic Array Conversion

['fnuh', 42, 'guh'] as String[]

What it does: Converts the list into a String array. This does more than just calling List#toArray() because 42 clearly isn’t a String but is converted to one.

The same in Java:

String[] stringArray = new String[something.size()];
for (int i = 0; i < something.size(); ++i) {
    Object o = something.get(i);
    stringArray[i] = o instanceof String ? o : o.toString();
}

Sorry, Java.

`as` for String-to-Character Conversion

'%' as char

What it does: Takes the first character of the String and returns it as char.

The desperate Pseudo Object

{} as Configuration

What it does: Creates an object that implements Configuration but doesn’t do anything. Useful in those cases where there are null checks in place but the object doesn’t need to do anything. I touched this before in Dynamic Proxies with Metaprogramming.

Type Conversion

foo(bla.keks as int, doStuff() as String)

What it does: Converts values to primitives and to Strings.

Extend any class with Groovy's categories

Wed, 14 Apr 2010 15:57:22 +0200

Groovy’s category system lets you add new methods to any class. And that’s more fun than you would think.

Using categories combines a static method that takes an instance of the class as its first parameter and any number of additional parameters, the use keyword and a closure:

class Foo {
 static Bar rofl(Keks k) {
  k.doIncredibleThings()
 }
}

Keks keks = createKeks()
use (Foo) {
 keks.rofl()
}

Within the closure, every Keks automagically has a rofl method.

Example: Removing HTML from a String

Here, I’ll use Groovy’s categories to extend java.lang.String with a function that removes HTML (a x.replaceAll('<[^>]+>', '') would have been enough, I know).

First, here’s the method to strip HTML. It’s written in Java – not for a particular reason, I just happened to have it laying around.

public class TextTools {

    public static CharSequence removeHTML(CharSequence s) {
        StrBuilder b = new StrBuilder(s.length());
        char c;
        for (int i = 0; i < s.length(); ++i) {
            if ((c = s.charAt(i)) != '<') {
                b.append(c);
            }
            else {
                while (i < s.length() && s.charAt(i) != '>') {
                    ++i;
                }
            }
        }
        return b;
    }

}

Note that this method assumes that the markup in the CharSequence is well-formed. This is not going to be the case for every page on the web. If you need to parse real-world HTML, take a look at HTTP Builder.

To use the method, I use the TextTools category:

use (TextTools) {
 println '<foo>keks</foo> bar <rofl blorb="bla"/>'.removeHTML()
}

Now, every String inside the closure has a removeHTML method.

Simple mapping with Groovy: ISO-639

Tue, 13 Apr 2010 00:02:00 +0200

One thing I’m sure every programmer hates writing is mapping code – code that converts from one format to another.

Glue code might come in second place. ;-)

In this post, I’ll show you how to make writing mapping code easier and faster with Groovy. We’ll write an ISO-639 converter in Groovy as an example of mapping – on one hand are English language names (such as “German” or “Tibetan”), on the other hand are two-character codes (“de,” “bh”).

The first step is getting the data in a nice format. Wikipedia has a nice table that I copied into OpenOffice. I then removed the unused columns and saved the data as CSV.

The Groovy Code

class ISO639 {

	Map<String, String> nameTo639 = [:]

	String fromName(String name) {
		nameTo639[nameTo639.keySet().find { it.contains(name) }] ?: ''
	}
	
	String from639(String name) {
		nameTo639.entrySet().find { it.value.contains(name) }?.key ?: ''
	}
	
	String swap(String name) {
	    Map.Entry entry = nameTo639.entrySet().find {
                it.value.contains(name) || it.key.contains(name) }
	    (entry?.value?.contains(name) ? entry?.key : entry?.value) ?: '' 
	}

	ISO639() {
		new File(ISO639.getResource('iso-639-1.csv').file).eachLine {
			def parts = it.toLowerCase()
                            .replaceAll('"', '').tokenize('\t')
			nameTo639[parts[1]] = parts[0]
		}
	}

}

All complexity is reduced to a few find method calls. By using find in combination with the entrySet method, mapping in any direction is totally easy and of course easier than in Java.

Groovy's in operator

Mon, 12 Apr 2010 00:01:42 +0200

Groovy’s in operator roughly corresponds to Java’s instanceof operator. Like its Java counterpart, in lets you check if an object is of a certain type.

if (foo in Keks) doIt()

Unfortunately, you cannot shorten usage of the in operator by combining multiple types in a list, like this example:

if (foo in [ Keks, Blorb, Rolf ]) doIt()

However, by using Groovy’s find method, we can express this in a pretty funky way:

if ([ Keks, Blorb, Rolf ].find { foo in it }) doIt()

In Java, this would be more repetitive to do:

if (foo instanceof Keks || foo instanceof Blorb || foo instanceof Rolf) doIt();

Default arguments in Groovy

Sat, 10 Apr 2010 23:59:42 +0200

Groovy supports default arguments (otherwise known as optional parameters) in constructors and methods. This reduces boilerplate code.

Example Constructor Optional Parameter

class Keks {
    Blorb blorb
    Keks(Blorb blorb = null) {
        this.blorb = blorb
    }
}

This lets you construct instances of Keks by typing

Keks keks = new Keks()

as well as

Keks keks = new Keks(someBlorb)

Note that you can also call

Keks keks = new Keks(blorb: someBlorb)

The additional flexibility makes it easy to work with Inversion-of-Control containers because some favour constructor injection and some prefer setter-based injection.

Behind the scenes, Groovy creates a constructor for each variant.

Example Method Optional Parameter

Using default arguments/optional arguments in methods works just like in constructors:

class Keks {
 def foo(Rolf copter = null) {
  copter?.lol()
 }
}

Now, you can call…

new Keks().foo()

…and…

new Keks().foo(roflCopter)

Useful Groovy Operators

Fri, 09 Apr 2010 10:52:00 +0200

Groovy adds a number of interesting operators that make some things that are tedious to do in Java very easy.

The Elvis ?: Operator

The Elvis operator is a compact way to express defaults in case an expression evaluates to false.

cache[name] = obj ?: NULL

This adds obj with a key of name to cache, substituting an Object called NULL if obj evaluates to false.

In Java, the code is less legible:

cache.put(name, obj == null ? NULL : obj);

Note that you can chain expressions with the Elvis operator:

keks(env.blorb ?: d.blorb ?: 'rolf')

The Safe Navigation Operator

The safe navigation operator lets you use path expressions without fear of NullPointerExceptions. It removes the need for if statements or ternary expressions that would be necessary in Java to guard against null objects.

doIt(env.lol?.toInteger() ?: 20)

In this example that uses both the safe navigation and Elvis operators, if env.lol is null, toInteger() is not called and the default of 20 used.

The identical Java code would look like this:

doIt(env.getLol() == null ? 20 : Integer.parseInt(env.getLol()))

Note that using the safe navigation operator does not cancel the evaluation of the expression. If foo returns null, …

wah.foo?.blorb.keks

…this will still throw a NullPointerException.

The Spread Operator

The spread operator, when used on a Collection, returns the result of calling the method on each element of the Collection. Here’s an example:

Collection<Future<?>> futures = // submit some jobs to a queue
Collection<?> objects = futures*.get()

This is identical to

Collection<Future<?>> futures = // submit some jobs to a queue
Collection<?> objects = futures.collect { it.get() }

Dynamic Proxies with Metaprogramming

Thu, 08 Apr 2010 22:41:00 +0200

Groovy’s metaprogramming features are wonderful.

In this example, we combine Groovy’s as automatic Proxy conversion with metaprogramming to create a simple stub for an interface.

Automatic Proxies

Two ways in Groovy to create an implementation of an interface at runtime are: One based on Closures and one based on Maps.

The Closure version usually looks like this

{ it -> it?.toString() } as Foo

The Map-based version looks like this:

[ foo: { 'bar' }, keks: { 'blub' } ] as Rofl

Combining Automatic Proxies with Metaprogramming

Configuration configuration = {} as Configuration
configuration.metaClass.getProperty = { name ->
	switch (name) {
		case 'foo': return 'bar'
		case 'keks': return 42
		case 'blub': return 21
		default: 0
	}
}

The first line creates a proxy that implements the Configuration interface. This proxy delegates all method calls to the empty closure {}. Surprisingly, this closure doesn’t actually need to do something.

The second line appends a getProperty method to the meta class of the proxy (whose class was generated at runtime). The closure has some values hard-coded in it that I need, but nothing else.

You’ll also note that I use Groovy typed. I don’t do this all the time but I think it makes understanding the code easier, helps with the Groovy Eclipse Plugin and it might also come in useful once Groovy gets a little bit less dynamic again.