Converting Java to Groovy

To convert the Java Todo class in Listing 1-1 to Groovy, just rename the file to Todo.groovy. That’s right, Groovy derives its syntax from Java. This is often referred to as copy/paste compatibility. So congratulations, you are a Groovy developer (even if you didn’t know it)! This level of compatibility, along with a familiar API, helps to reduce the Groovy learning curve for Java developers. It also makes it easier to incorporate Java examples found on the Internet into a Groovy application and then refactor them to make them more Groovylike, which is what we will do with Listing 1-1.

To run this Groovy application, from the command line, type the following:

> groovy comapressggTodo.groovy

If you are coming from a Java background, you may be a little surprised that you did not need to first compile the code. Here’s the Java equivalent:

> javac comapressggTodo.java
> java com.apress.bgg.Todo

Running the Java application is a two-step process: Compile the class using javac, and then use java to run the executable class in the JVM. But Groovy will compile to byte code at runtime, saving a step in the development process and thereby increasing Groovy’s productivity. Groovy provides a lot of syntactic sugar and is able to imply more than Java. You’ll see this in action as we make our Groovy application more Groovy by applying some of the Groovy idioms.

Converting a JavaBean to a GroovyBean

Let’s begin by simplifying the JavaBean, which could also be referred to as a Plain Old Java Object (POJO). Groovy has the GroovyBean, which is a JavaBean with a simpler Groovy syntax, sometimes referred to as a Plain Old Groovy Object (POGO). GroovyBeans are publicly scoped by default. Listing 1-2 shows our example using a GroovyBean.

Listing 1-2.  Simple Example Using a GroovyBean

1.   package com.apress.bgg;
2.
3.    import java.util.List;
4.    import java.util.ArrayList;
5.
6.
7.    public class Todo {
8.
9.           String name;
10.          String note;
11.
12.           public static void main(String[] args) {
13.                   List <Todo> todos = new ArrayList<Todo>();
14.                  todos.add(new Todo(name:"1", note:"one"));
15.                  todos.add(new Todo(name:"2", note:"two"));
16.                  todos.add(new Todo(name:"3", note:"three"));
17.
18.                  for(Todo todo : todos) {
19.
20.                  System.out.println(todo.name + " " + todo.note);
21.                  }
22.          }
23.  }

Listing 1-2 is significantly shorter than Listing 1-1, primarily because Groovy has a concept of native properties, which means getters and setters do not need to be declared. By default, all class attributes—such as the name and note attributes on lines 9 and 10—are public properties and automatically generate corresponding getters and setters in the byte code. So if the class is used from Java code, or reflection is used to interrogate the class, you will see the getters and setters. These properties also have a more intuitive usage model. They can be assigned or used directly, as on line 20, where the name and note properties, rather than the getters, are used to generate the output. Also, rather than needing to explicitly create a convenience constructor for initializing a GroovyBean, you can pass named parameters in the constructor to initialize any properties you want, as in lines 14–16.

GroovyBeans have a very useful initialization feature called Named parameters. We can pass a Map to the constructor of a bean that contains the names of the properties, along with an associated initialization value. Every GroovyBean has this built-in Map constructor, which works by iterating the map object and calling the corresponding property setter for each entry in the map.

Suppose we have a GroovyBean Book, which has the properties id and title. We can initialize such bean with a map:

map = [id: 1, title: "Beginning Groovy, Grails and Griffon"]
Book = new Book( map)
We can pass the map directly to the bean:
Book = new Book ( id: 1, title: "Beginning Groovy, Grails and Griffon")

Simplifying the Code

Some of the syntax sugar included in the Groovy language is making semicolons, parentheses, and data typing optional. Other interesting features to simplify code include implicit imports like the java.util.* package, common methods like println() applying to all objects including Java objects, and more flexible strings. Listing 1-3 applies these features to our example.

Listing 1-3.  Simple Example Applying Syntactic Sugar, Implicit Imports, Common Methods,and String Features

1.   package com.apress.bgg;
2.
3.   public class Todo {
4.
5.           String name
6.           String note
7.
8.           public static void main(String[] args) {
9.                  def todos = new ArrayList()
10.                 todos.add(new Todo(name:"1", note:"one"))
11.                 todos.add(new Todo(name:"2", note:"two"))
12.                 todos.add(new Todo(name:"3", note:"three"))
13.
14.                 for(Todo todo : todos) {
15.
16.                          println "${todo.name} ${todo.note}"
17.                 }
18.          }
19.  }

In Listing 1-3, under the package declaration we no longer need to import java.util.List, java.util.ArrayList, and java.util.Iterator. These are implicitly imported since they are in the java.util.* package. Other implicitly included packages are java.lang.*, java.net.*, java.io.*, groovy.lang.*, and groovy.util.*. Also notice that, other than in the for statement (which we will clean up in the next round of refactoring), all the semicolons were removed. On line 16, we used optional parentheses with the implicit println() method. But that is not the only change to line 16. The println() method was modified to use Groovy’s GString format, which is similar to the Apache Ant property format, rather than concatenating two strings. We’ll cover Groovy strings in Chapter 2. At this point, just notice how much simpler this is to read. Line 9 has been changed to use optional typing. The variable todos is no longer typed to List. Groovy uses “duck typing,” which means if it sounds like a duck and walks like a duck, it must be a duck. Do you really care what the type of an object is, as long as you can pass it a message and it will handle the request if it can? If the object cannot handle the request, you will receive a groovy.lang.MissingMethodException or groovy.lang.MissingPropertyException. Of course, where you think typing is necessary, you always have the option of explicitly typing variables.

Using Groovy Collection Notation and Closure

The next step in refactoring the example is to take advantage of Groovy’s collection and map notation, as well as replace the ugly for statement with a more elegant closure. Listing 1-4 shows this version.

Listing 1-4.  Example with the Groovy Collection Notation and Closure

1.   package com.apress.bgg;
2.
3.   public class Todo {
4.
5.          String name
6.          String note
7.
8.          public static void main(String[] args) {

9.                 def todos = [
10.                      new Todo(name:"1", note:"one"),
11.                      new Todo(name:"2", note:"two"),
12.                      new Todo(name:"3", note:"three")
13.                ]
14.
15.                todos.each {
16.                      println "${it.name} ${it.note}"
17.                }
18.         }
19.  }

Notice how the ArrayList was replaced with []. Again, this is just syntactic sugar; Groovy really is instantiating an ArrayList. Similarly, we can create maps with the [:] syntax. To make the code more clean, we can initialize the list without needing to call the add() method for each entry. Then to simplify the iteration, we call the each() method, passing a closure that prints out the string. Notice that, by default, the iteration variable is it. Chapter 2 will provide more explanations and examples of Groovy lists, maps, and closures.

Getting Rid of main()

One bit of Java ugliness left in our example is the main() method. After all these improvements, the main() method now stands out. Fortunately, Groovy has a concept of scripts as well as classes, and we can turn this into a script, removing the need for the main() method. To begin, the file must be renamed to something like Todos.groovy. This is because a script will also be compiled to a class, and if we didn’t change the name, there would be a name clash between the Todo class and the Todo script. Then we simply move the code that currently exists in the main() method outside the Todo class. Note that, in Groovy, any code that is not inside a class is called a script. When the script is run, it will behave the same as before. Listing 1-5 shows the script version.

Listing 1-5.  Example as a Script

1.   package com.apress.bgg;
2.   public class Todo {
3.   String name
4.   String note
5.   }
6.   def todos = [
7.   new Todo(name:"1", note:"one"),
8.   new Todo(name:"2", note:"two"),
9.   new Todo(name:"3", note:"three")
10.  ]
11.  todos.each {
12.  println "${it.name} ${it.note}"
13.  }

Finally, we have elegant, easy-to-read code at a fraction of what we started with in Java. It should be obvious that if we had started with the Groovy idioms to begin with, the Groovy approach would have been much more productive.

Assertion

An assertion is used to validate that an expected condition is true. Assertions in Groovy are more powerful than in Java because assertion in Java works only on Boolean, whereas assertion in Groovy can accept any type. Assertions in Java can be disabled, whereas assertions in Groovy are always executed and are recommended to be used in the production code.

Listing 1-6.  Assertion Example

def list = [1, 2, 'x'] // list of 3 elements
assert list.size() == 3

Annotations for AST Transformation

When the Groovy compiler compiles Groovy scripts and classes, the Groovy parser (the front end of the compiler) creates an Abstract Syntax Tree (AST) before generating the final byte code for the class. The AST is the in-memory representation of the source code, comprising class, method, property, statement, and variables. AST transformation is the capability to add new code (methods, checks) into source code before the final byte code is generated. The objective of the AST transformation is to let developers structure their code while focusing more on the business code rather than on boilerplate code or cross-cutting concerns. Groovy provides annotations you can use to annotate code structures for AST transformation. Here is one example of AST transformation using @Singleton annotation provided by Groovy:

Listing 1-7.  Using Annotations for AST Transformation

@Singleton
class SomeSingleton
{
//..
}

The @Singleton annotation creates a private constructor and a static method, which gives us an instance of the Singleton through AST transformations.

Builder

Generating the simplest XML document in Java is enormously difficult and time consuming. Groovy simplifies generating XML by providing built-in builder classes that make it possible to build a tree-like structure from within the code itself. That is, the structure of the code itself resembles the tree-like structure we are trying to build, thus making the task of generating tree-like structure painless.

Listing 1-8.  Tree-like Structure in XML

<employee>
<name>John Doe</name>
<gender>male</gender>
</ employee >

Listing 1-9.  Groovy Code to Generate Preceding Tree-like Structure

def builder = new groovy.xml.MarkupBuilder()
builder.employee {
name   'John Doe'
gender  'male'
}

Closure

A Groovy closure is a block of reusable code within curly braces {}, which can be assigned to a property or variable, or passed as a parameter to a method. The code within the curly braces is executed when the closure is invoked.

Listing 1-10.  Using Closure

def name = "Chris"
def printClosure = { println "Hello, ${name}" }
printClosure()
name = "Joseph"
printClosure()

Here is the output:

Hello, Chris
Hello, Joseph

GDK

Groovy as a whole comprises Groovy language, libraries specific to Groovy-specific libraries, and GDK. The GDK is Groovy’s extension to some of the existing classes in the JDK. You can access the full API specification at http://groovy.codehaus.org/groovy-jdk.

Metaprogramming

Metaprogramming means writing a program that creates, queries, and manipulates other programs or (more often) itself. Metaprogramming can occur at either compile-time or runtime.

The covenant of compile-time metaprogramming is byte-code generation. In Groovy, compile-time metaprogramming lets you modify the AST before generating final byte code. We illustrated an example of compile-time metaprogramming in the “Annotations for AST Transformation” section. Runtime metaprogramming is centered on enabling dynamic method-invocation and synthesis of methods and classes. In Groovy, runtime metaprogramming is realized using meta-object protocol. The MOP, in Groovy, comprises categories, expandos, and metaclasses.

Listing 1-11.  Runtime Metaprogramming

String.metaClass.firstUpper = {−>

    return delegate[0].toUpperCase() + delegate[1..delegate.length() - 1]
}

println "iiii".firstUpper()

Listing 1-11 shows how you can add an additional method to a class on the fly. We added an additional method to String class, which is immutable.

Here is the output:

Iiii

Native JSON Support

JSON (JavaScript Object Notation) is a lightweight data interchange format, used as an alternative to XML for serializing and transmitting structured data over a network.

As a simple example, data about an employee can be written in JSON as follows:

Listing 1-12.  Example of JSON

var person= {
          "name" : "John Doe",
          "age" : "40"
};

This creates an object that can be accessed using the employee variable. Groovy 1.8 introduced native JSON support through JsonSlurper for reading JSON and JsonBuilder for writing JSON.

Listing 1-13.  Reading JSON

import groovy.json.JsonSlurper
 def slurper = new JsonSlurper()
 def result = slurper.parseText('{"person":{"name":"John Doe","age":40,"cars":["bmw","ford"]}}')

 println result.person.name
 println result.person.age
 println result.person.cars.size()
 println result.person.cars[0]
 println result.person.cars[1]

Here is the output

John Doe
40
2
bmw
ford

Native Support for Lists and Maps

Java has no language-level support for collections that it has for arrays. Groovy enhanced the Java collection classes by adding and improving the declaration syntax and additional methods.

Groovy contains first-class constructs for List and Map. It also adds the new collection type—Range—at the language level, which provides special-purpose syntax for managing ranges of values.

Listing 1-14.  Support for Lists as a Language Feature

authors = [ 'Vishal', 'Chris', 'Joseph', 'Jim' ]
println authors
println authors[0]

Here is the output:

["Vishal", "Chris", "Joseph", "Jim"]
Vishal

Native Support for Regular Expression

Groovy builds regular expression handling right into the language via the =∼ operator and matcher objects.

Object Orientation: Everything is an Object in Groovy

Unlike Java, everything in Groovy is an object; there are no primitive types. As a result, in Groovy, no auto boxing is needed because everything is an object.

For example, Groovy executes 2 + 2 as 2.plus(2). The plus operator is implemented via the plus() method. In Groovy, all operators are method calls. This makes it possible to apply object-orientation to operators; for example, it is possible to overload/override any operator to give a new implementation.

String interpolation

String interpolation is the ability to substitute an expression or variable within a string. Java doesn’t support string interpolation. You must manually concatenate the values. Here is an example of the type of code you need to write in Java:

Listing 1-15.  String Concatenation in Java

String lastName= "Layka";
String fullname= "Vishal " + lastName;
System.out.println(fullname);

Listing 1-16.  String Interpolation in Groovy

def lastName = "Layka"
def fullname = "Vishal ${lastName} " // string interpolation (also called Gstring)
println fullname

Static and Dynamic Typing

Groovy supports both static and dynamic typing when declaring variables. Dynamic typing can be achieved by using the def keyword.

Listing 1-17.  Dynamic and Optional Typing in Groovy

def var = 10
var = "It's a String"

The def keyword is optional in scripts.

Listing 1-18.  Static and Optional Typing in Groovy

String  s1 = " A String " // static
s2 = "Another String " // optional typing :type is left to be determined at the time of assignment.

Static Type Checking

Groovy 2.0 introduces a @TypeChecked annotation, which annotates a method or a class that needs to be static type checked. This type-checked mode, enabled through annotation, indicates the errors at compile time.

The static type checker is built using Groovy’s existing powerful AST transformation mechanisms. Being an optional feature, you are not forced to use it if you don’t need it. To trigger static type checking, just use the @TypeChecked annotation on a method or on a class to turn on checking.

Listing 1-19.  Using TypeChecked Annotation

import groovy.transform.TypeChecked

void doIt() {}

@TypeChecked
void test() {
     
    dott ()//compilation error:cannot find matching method dott()

}Figure 1-1 illustrates the @Typechecked annotation in action in Eclipse.

Static Compilation

Groovy 2.0 also makes it possible to enable static compilation via @CompileStatic. This mode eliminates the runtime overhead of dynamic dispatch.

Listing 1-20.  Using CompileStatic Annotation

import groovy.transform.CompileStatic

@CompileStatic
int doubleIt(int num) {
    2* num
}

assert doubleIt(2) == 4

Using @CompileStatic will statically compile the code, and the generated byte code will run just as fast as java’s byte code. Like the @TypeChecked annotation, @CompileStatic can annotate classes and methods, and @CompileStatic(SKIP) can bypass static compilation for a specific method when its class is marked with @CompileStatic.

Optional Syntax

Now let’s look at the optional syntax.

class Employee{
String name
}
Employee emp = new Employee()
emp.setName("John Doe" )

println emp.name

groovy.lang.*
groovy.util.*
java.lang.*
java.util.*
java.util.regex.*
java.net.*
java.io.*
java.math.BigDecimal, java.math.BigInteger

println ("hello");
println "hello"

String greeting() {
result = "Hello world"
result
}
println greeting()

def greeting() {
result = "Hello world"
result
}
println greeting()

Hello world