Groovy Programming

The Ternary Operator in Groovy

Wed, 04 Jul 2018 11:38:42 +0200

The Ternary Operator is a shortcut for the following code:

if (A) {
    B
}
else {
    C
}

The Ternary Operator reduces this code down to

A ? B : C

As you can see, the Ternary Operator operates on three expressions, contrary to the Elvis operator that operates on two.

When to use the Ternary Operator

I like to use the Ternary Operator in cases where A, B and C are reasonably small expressions. Keep in mind that readability is a big concern for software projects long-term and that some verbosity may be better than byte-saving techniques.

Ternary Operator Examples in Groovy

The following examples are taken from the eproxy project.

….setSharedCache(OnGoogleAppEngineOrDevserver.CONDITION ? true : cacheIsShared)

This forces the sharedCache property to always be true on Google App Engine.

long end = m.group(2) ? m.group(2) as long : contentLength

This is converting m.group(2) to a long if the value is truthy and defaults to contentLength otherwise.

Still alive

Wed, 04 Jul 2018 00:43:16 +0200

After eight years of not posting anything to this blog, I’ll be posting new code snippets from past projects in the coming days.

They’ll be Groovy, I promise.

Groovy String Concatenation

Sun, 24 Jan 2016 22:22:07 +0100

I’m trying to come up with as many ways to concatenate strings as possible.

Plus

String s = 'foo' + 'bar'

Left Shift Operator

String s = ('foo' << 'bar') as String // The Left Shift Operator returns a StringBuffer.

Array join

String s = [ 'foo', 'bar' ].join('')

String#concat

String s = 'foo'.concat('bar')

Inject

[ 'foo', 'bar' ].inject(new StringBuffer(), { a, b -> a.append(b); return a }).toString()

With!

new StringBuilder().with { append('foo'); append('bar') }.toString()

Automatic service layer performance tracking to Google Analytics

Tue, 14 Jul 2015 17:36:15 +0200

After publishing the Google Analytics Measurement Protocol server-side client (!) EAIO uses to send performance data to Google Analytics, here is the code that intercepts Spring’s service layer using Groovy’s Interceptor feature and tracks the timing of some method calls.

This code by default intercepts method calls on classes annotated with @Component, @Service and @Repository.

In Google Analytics, automatic alerts for various method calls can then be set up. For example, I receive an email once the ClientService#getClient(long) method takes longer than 20 ms on average per day.

The first class is the MethodTimingBeanPostProcessor. This class iterates over all Spring beans annotated with the annotations above that extend GroovyObject (necessary for the meta-programming interception).

package com.eaio.util.performance;

import groovy.lang.GroovyObject;
import groovy.lang.ProxyMetaClass;

import java.beans.IntrospectionException;

import org.springframework.beans.BeanInstantiationException;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.context.annotation.Conditional;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Repository;
import org.springframework.stereotype.Service;

import com.eaio.googleanalytics.GoogleAnalyticsService;
import com.eaio.util.googleappengine.OnGoogleAppEngine;

/**
 * Groovy metaprogramming-based interception for {@link Service} instances.
 *
 * @author <a href="mailto:johann@johannburkard.de">Johann Burkard</a>
 * @version $Id: MethodTimingBeanPostProcessor.java 7035 2015-04-21 19:29:43Z johann $
 */
@Component
@Conditional(OnGoogleAppEngine.class)
public class MethodTimingBeanPostProcessor implements BeanPostProcessor, ApplicationContextAware {

    private ApplicationContext applicationContext;

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.applicationContext = applicationContext;
    }

    /**
     * @see org.springframework.beans.factory.config.BeanPostProcessor#postProcessBeforeInitialization(java.lang.Object, java.lang.String)
     */
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }

    /**
     * @see org.springframework.beans.factory.config.BeanPostProcessor#postProcessAfterInitialization(java.lang.Object, java.lang.String)
     */
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        if (beanQualifiesForGoogleAnalyticsTimingInterception(bean) && beanIsNotGoogleAnalyticsService(bean)) {
            GoogleAnalyticsTimingInterceptor interceptor = applicationContext.getBean(GoogleAnalyticsTimingInterceptor.class);
            try {
                ProxyMetaClass proxiedDAO = ProxyMetaClass.getInstance(bean.getClass());
                proxiedDAO.setInterceptor(interceptor);
                ((GroovyObject) bean).setMetaClass(proxiedDAO);
            }
            catch (IntrospectionException e) {
                throw new BeanInstantiationException(bean.getClass(), e.getLocalizedMessage(), e);
            }
        }
        return bean;
    }

    /**
     * Prevents infinite loops.
     */
    boolean beanIsNotGoogleAnalyticsService(Object bean) {
        return !(bean instanceof GoogleAnalyticsService);
    }

    /**
     * Selects beans whose classes have a {@link Service}, {@link Component} or {@link Repository} annotation and implement {@link GroovyObject}.
     */
    boolean beanQualifiesForGoogleAnalyticsTimingInterception(Object bean) {
        return (bean.getClass().isAnnotationPresent(Service.class) ||
                bean.getClass().isAnnotationPresent(Component.class) ||
                bean.getClass().isAnnotationPresent(Repository.class)) && bean instanceof GroovyObject;
    }

}

The next class is the GoogleAnalyticsTimingInterceptor. This Interceptor implementation uses a ThreadLocal to store commons-lang3′s StopWatch instances in. The StopWatch is wrapped in a custom data structure called StackSlot that manages borrows and returns of the StopWatch instance. This prevents any method calls between services from distorting method timings.

package com.eaio.util.performance;

import groovy.lang.Interceptor;

import org.apache.commons.lang3.time.StopWatch;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Conditional;
import org.springframework.stereotype.Component;

import com.eaio.googleanalytics.GoogleAnalyticsService;
import com.eaio.util.StackSlot;
import com.eaio.util.googleappengine.OnGoogleAppEngine;

/**
 * Thread-safe {@link Interceptor} that tracks timing to {@link GoogleAnalyticsService}.
 *
 * @author <a href="mailto:johann@johannburkard.de">Johann Burkard</a>
 * @version $Id: GoogleAnalyticsTimingInterceptor.java 7444 2015-06-14 12:52:53Z johann $
 */
@Component
@Conditional(OnGoogleAppEngine.class)
public class GoogleAnalyticsTimingInterceptor implements Interceptor {

    @Autowired
    private GoogleAnalyticsService googleAnalyticsService;

    private ThreadLocal<StackSlot<StopWatch>> stopWatches = new ThreadLocal<StackSlot<StopWatch>>() {

        @Override
        protected StackSlot<StopWatch> initialValue() {
            return new StackSlot<StopWatch>(new StopWatch());
        }

    };

    /**
     * @see groovy.lang.Interceptor#beforeInvoke(java.lang.Object, java.lang.String, java.lang.Object[])
     */
    @Override
    public Object beforeInvoke(Object object, String methodName, Object[] arguments) {
        StopWatch watch = stopWatches.get().increment();
        if (watch != null && !watch.isStarted()) {
            watch.start();
        }
        return null;
    }

    /**
     * @see groovy.lang.Interceptor#afterInvoke(java.lang.Object, java.lang.String, java.lang.Object[], java.lang.Object)
     */
    @Override
    public Object afterInvoke(Object object, String methodName, Object[] arguments, Object result) {
        StopWatch watch = stopWatches.get().decrement();
        if (watch != null && watch.isStarted()) {
            int time = (int) watch.getTime();
            watch.reset();
            googleAnalyticsService.trackTiming(object.getClass().getSimpleName(), methodName, time);
        }
        return result;
    }

    /**
     * @see groovy.lang.Interceptor#doInvoke()
     */
    @Override
    public boolean doInvoke() {
        return true;
    }

}

The StackSlot class is little more than an object and a counter that is incremented and decremented. The object is only returned when the counter is 0.

package com.eaio.util;

/**
 * <em>Single-threaded</em> ADT that returns an Object only if an internal counter is 0. {@link #increment()} attempts to acquire the object and
 * increases the counter. {@link #decrement()} attempts to acquire the object and decreases the counter.
 * <p>
 * The number of increments and decrements must be symmetrical for obvious reasons.
 *
 * @author <a href="mailto:johann@johannburkard.de">Johann Burkard</a>
 * @version $Id: StackSlot.java 7411 2015-06-10 20:46:03Z johann $
 */
public class StackSlot<T> {
    
    private int counter = 0;
    
    private final T t;
    
    public StackSlot(T t) {
        this.t = t;
    }
    
    public T increment() {
        return counter++ == 0 ? t : null; 
    }
    
    public T decrement() {
        return --counter == 0 ? t : null;
    }
    
}

As with the GoogleAnalyticsService, the com.eaio:grabbag:2.5 (or greater) dependency from http://repo.eaio.com/maven2 is required for the OnGoogleAppEngine conditional class. If this code is used somewhere else, this conditional can of course be removed.

With the GoogleAnalyticsService configured, you should see service-level method call performance in Google Analytics automatically.

Google Analytics Measurement Protocol in Groovy

Tue, 12 May 2015 22:34:06 +0200

In the last two years that I didn’t blog here, I wrote a lot of code that I migrated into my latest project, EAIO. Some of that code will be released here.

After tinymeasurement, a JavaScript client for the measurement protocol, here is an implementation of the Measurement Protocol in Groovy.

This class was designed to be used with Spring Boot on Google App Engine. It is not using HttpClient but rather URL#getText(Map) because one can’t connect to Google Services using the Socket API (which is what HttpClient uses).

Apart from Spring Boot, the dependencies of this class are commons-lang and com.eaio:grabbag:2.5 (or greater) – grabbag primarily for the OnGoogleAppEngine Conditional that prevents unit tests or local testing from sending data to Google Analytics.

In application.properties, the following keys are required:

http.userAgent=${project.name}/${build}

#
# Google Analytics
#

googleanalytics.propertyID=UA-.......-..
googleanalytics.hostName=xxx.xxx
googleanalytics.siteSpeedSampleRate=0.02
# Socket and read timeout
googleanalytics.timeoutInMs=150

The timeout values are set low for a reason I’ll outline in a later post.

In Spring, a Random instance needs to be set up, preferably a SecureRandom.

package com.eaio.googleanalytics

import static java.util.Collections.*
import static org.apache.commons.lang3.StringUtils.*
import groovy.transform.CompileStatic
import groovy.transform.PackageScope
import groovy.util.logging.Slf4j

import org.apache.commons.lang3.exception.ExceptionUtils
import org.apache.commons.lang3.text.StrBuilder
import org.apache.commons.lang3.time.StopWatch
import org.springframework.beans.factory.InitializingBean
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.beans.factory.annotation.Value
import org.springframework.context.annotation.Conditional
import org.springframework.stereotype.Service
import org.springframework.web.util.UriComponentsBuilder

import com.eaio.util.googleappengine.OnGoogleAppEngine

/**
 * Pings back some data to Google Analytics to track eaio usage. Only enabled on GAE.
 *
 * @author <a href="mailto:johann@johannburkard.de">Johann Burkard</a>
 * @version $Id: GoogleAnalyticsService.groovy 7670 2015-09-20 13:00:36Z johann $
 */
@Conditional(OnGoogleAppEngine)
@CompileStatic
@Service
@Slf4j
class GoogleAnalyticsService implements InitializingBean {

    @Value('${http.userAgent}')
    String userAgent
    
    @Value('${googleanalytics.propertyID}')
    String propertyID
    
    @Value('${googleanalytics.hostName}')
    String hostName
    
    /**
     * Ranges between 0 to 1.
     */
    @Value('${googleanalytics.siteSpeedSampleRate}')
    Double siteSpeedSampleRate
    
    @Value('${googleanalytics.timeoutInMs}')
    Integer timeoutInMs

    @Autowired
    Random random
    
    private Map<String, Object> defaultParams

    @Lazy
    private URI googleAnalyticsCollect = 'http://www.google-analytics.com/collect'.toURI()

    /**
     * Calling this method tracks an <tt>/init</tt> pageview.
     */
    @Override
    void afterPropertiesSet() {
        defaultParams = (Map<String, Object>) [ v: 1I, tid: propertyID, dh: hostName, cid: UUID.randomUUID(), aip: 1 ]
        trackPageview('/start')
    }

    void trackPageview(String path, Map<String, Object> params = null) {
        track(((Map<String, Object>) [ t: 'pageview', dp: abbreviate(path, 2048I) ]) + (params ?: EMPTY_MAP))
    }

    void trackEvent(String category, String action, String label = null, Integer value = null, Map<String, Object> params = null) {
        track(((Map<String, Object>) [ t: 'event', ec: abbreviate(category, 150I), ea: abbreviate(action, 500I), el: abbreviate(label, 500I), ev: value ]) + (params ?: EMPTY_MAP))
    }

    void trackTiming(String category, String variable, int time, String label = null, Map<String, Object> params = null) {
        if (time >= 0I && time < 3600000I && (!siteSpeedSampleRate || random.nextDouble() <= siteSpeedSampleRate)) {
            track(((Map<String, Object>) [ t: 'timing', utc: abbreviate(category, 150I), utv: abbreviate(variable, 500I), utt: time, utl: abbreviate(label, 500I) ]) + (params ?: EMPTY_MAP))
        }
    }

    void trackException(String category, Throwable thrw, String label, Map<String, Object> params = null) {
        StrBuilder builder = new StrBuilder(4096I)
        thrw.printStackTrace(new PrintWriter(builder.asWriter()))
        trackEvent(category, minifyStack(builder as String), label, null, params)
    }
    
    def trackTiming(String category, String variable, String label = null, Map<String, Object> params = null, Closure c) {
        StopWatch watch = new StopWatch()
        watch.start()
        def out
        try {
            out = c()
        }
        finally {
            trackTiming(category, variable, (int) watch.time, label, params)
        }
        out
    }
    
    @PackageScope
    String minifyStack(String stack) {
        (stack ?: '').replaceAll('\\s*[\r\n]\\s*at\\s*', ' > ').replaceAll('(?:\\w+\\.)+([A-Z][\\w$]*\\s)', '$1').replaceAll('(?:\\w+\\.)+([A-Z][\\w$]*\\.[^(]+)\\([^)]+\\)', '$1')
    }

    /**
     * Uses {@link HttpURLConnection} because you cannot reach Google services with the socket API from within Google App Engine.
     */
    void track(Map<String, Object> params) {
        UriComponentsBuilder builder = UriComponentsBuilder.fromUri(googleAnalyticsCollect)
        
        (defaultParams + params).findAll { it.value != null && it.value != '' }.each {
            builder.queryParam(it.key, it.value)
        }
        
        URI target = builder.build().toUri()

        StopWatch watch = new StopWatch()
        watch.start()
        try {
            target.toURL().getText([ connectTimeout: timeoutInMs, readTimeout: timeoutInMs, requestProperties: [ 'User-Agent': userAgent ]])

            log.info('request to {} on {} took {} ms', googleAnalyticsCollect, googleAnalyticsCollect.host, watch.time)
        }
        catch (IOException e) {
            log.info('could not send {} to Google Analytics in {} ms: {}', target, watch.time, ExceptionUtils.getRootCauseMessage(e))
        }
    }

}

Creating a truly scalable Thread Pool with ThreadPoolExecutor

Tue, 10 Jul 2012 22:01:31 +0200

Doug Lea’s ThreadPoolExecutor is a very useful part of the java.util.concurrent library. It implements a configurable thread pool that is easy to use and control.

Thread pools are used to move work that might take longer to complete away from the main application, as well as constraining how much of this work can be done in parallel with the application.

However, when used with an unbounded queue, you will find that ThreadPoolExecutor never allocates more than one thread, even when higher maximum pool sizes are allowed.

The problem is caused by this code block:

        if (poolSize >= corePoolSize || !addIfUnderCorePoolSize(command)) {
            if (runState == RUNNING && workQueue.offer(command)) {
                if (runState != RUNNING || poolSize == 0)
                    ensureQueuedTaskHandled(command);
            }
            else if (!addIfUnderMaximumPoolSize(command))
                reject(command); // is shutdown or saturated
        }

You can see that ThreadPoolExecutor delegates the decision whether to add an additional thread to the pool to the workQueue. This queue however doesn’t know about the ThreadPoolExecutor containing it and, since it’s unbounded, will always accept a new object.

In other words, it is impossible to set up ThreadPoolExecutor so that the number of threads scales up and down dynamically.

Making ThreadPoolExecutor truly scalable

To create a ThreadPoolExecutor instance that scales the number of threads up and down, the BlockingQueue needs to have a reference to the ThreadPoolExecutor and needs to delegate method calls to offer to an underlying BlockingQueue only if the current thread pool size is equal to the ThreadPoolExecutor’s maximum pool size.

In all other cases, the BlockingQueue should return false to indicate that a new thread should be added to the pool.

A Groovy solution

Groovy makes it particularly easy to implement such a queue class. By using the @Delegate annotation, delegating code is generated at compile-time and only overriding methods need to be implemented.

Also, the @TupleConstructor and @Synchronized annotations reduce code bloat and make writing thread-safe code easier.

@TupleConstructor
class DynamicBlockingQueue<E> {
    
    @Delegate
    BlockingQueue<E> queue
    
    ThreadPoolExecutor executor

    @Synchronized
    boolean offer(def e) {
        !executor || executor.poolSize == executor.maximumPoolSize ?
            queue.offer(e) : false
    }

}

Use this class like this:

LinkedBlockingQueue<Runnable> delegate =
    new LinkedBlockingQueue<Runnable>()
DynamicBlockingQueue queue = new DynamicBlockingQueue(queue: delegate)
ThreadPoolExecutor executor =
    new ThreadPoolExecutor(0, 42 /* maximum number of threads */,
    10, TimeUnit.SECONDS, queue)
queue.executor = executor

// Use your ThreadPoolExecutor

Maven Users

For everybody using Maven, my grabbag project already includes the class above. Add a dependency to Groovy 1.8.0 or greater, this artifact…

		<dependency>
			<groupId>com.eaio</groupId>
			<artifactId>grabbag</artifactId>
			<version>1.6.2</version>
		</dependency>

… and use the com.eaio.concurrent.DynamicBlockingQueue class.

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.