Groovy is an optionally typed, dynamic language that runs on the JVM. It is tightly integrated with the Java programming language. Groovy describes itself as feature-rich and Java-friendly language.

Groovy source code is compiled into Java byte-code by the Groovy compiler. To run Groovy code in a Java virtual machine, only the Groovy JAR file must be present in the classpath at runtime.

Groovy supports standard Java constructs including annotations, generics, static imports, enums, varargs and lambda expression. It provides lots of simplifications compared to the Java programming language and advanced language features as properties, closures, dynamic methods, the Meta Object Protocol (MOP), native support for lists, maps, regular expressions, duck typing and the elvis operator.

A Groovy source files ends with the .groovy extension. This file can contain a Groovy script or a Groovy class. A Groovy script is a code listing which does not include a class definition. Groovy scripts are converted at compile time to a class which extends the groovy.lang.Script class.

The classical "Hello world" program can be written as a short Groovy script.

Groovy runs inside the JVM and can use Java libraries. Every Groovy type is a subclass of java.lang.Object.

Groovy code can call Java code and Java code can call Groovy code. Every Groovy class is compiled into a Java class and you can use the new operator in Java to create instances of the Groovy class. This instance can be used to call methods or to pass as parameter to a fitting Java method. Groovy classes can extend Java classes and Java classes can also extend Groovy classes.

Groovy is almost compatible with the Java 7 sytax, e.g., almost every valid Java 7 construct is valid Groovy code. This makes the migration to Groovy for a Java programmer relatively smooth.

Groovy does currently not support Java 8 lambda expressions.

Groovy focus on simplicity and ease of use as its leading principle. This makes using Groovy very productive.

The enhancements of Groovy compared to Java can be classified as:

The following list contains some of the example how Groovy archives this.

Groovy automatically imports the following packages and classes which can be used in Groovy without specifying the package name.

Groovy allows that an import is shortened for later access, e.g., import javax.swing.WindowConstants as WC.

You can execute a Groovy class or script from your IDE but Groovy provides other options. You can run Groovy code via:

Start the interactive Groovy Shell with the command groovyConsole. This console allows you to test Groovy code.

The Groovy shell is the simplest way to run Groovy program. The groovy shell allow you to type in groovy commands and let them evaluate.

Open a command shell (Start→ Run → cmd under Windows) and start the groovy shell via "groovysh". Type in the following code:

Press enter→ the system will execute your code.

You can also complile Groovy code into Java bytecode to use it from Java. To use the byte code the Groovy runtime library must included in the Java classpath.

To create Java bytecode, run the groovyc Hello.groovy command.

In this exercise you learn how to create Groovy program with the Eclipse IDE.

The following example assumes you have Groovy and the Eclipse IDE installed and configured.

Create a new Groovy project called com.vogella.groovy.first the File  New  Other  Groovy  Groovy Project.

After entering the project name, press the Finish button. This creates a new Groovy project similar to a new Java project but with the required Groovy libraries.

Right click on the source folder and New  Package from the context menu. Create a new package called first.

Create a new Groovy class called FirstGroovy via File  New  Other  Groovy  Groovy Class.

Create the following code.

Right-click the Groovy class, and select Run As  Groovy Script from the context menu.

The above menu entry triggers the execution of the main method in your Groovy class and prints output to Console view of the Eclipse IDE.

Congratulation! You created and ran your first Groovy class.

A Groovy class is defined with the class keyword, similar to Java. All Groovy classes and methods are by default public.

The following is an example Groovy class called Task.groovy.

In Groovy all fields of a class have by default the private access modifier. Groovy creates automatically getter and setter methods for the fields. If you annotate the class or a property with the @Bindable`annotation, Groovy also adds `PropertyChangeSupport to the class or property. Such a Groovy classes fits to the Java beans specification.

Groovy objects are frequently referred to as Plain Old Groovy Objects (POGO).

You can use the getter and setter directly or use the name of the field for access. Groovy also supports the array subscript acessor (object[property]). Groovy uses the getter or setter method, even if you directly use the name of the field. If a field should not be changeable define it as final, in this case Groovy will not provide a setter.

Groovy provides constructors with named parameters in which you can specify the element you would like to set during construction. This constructor is also called map based constructor, as it uses the property:value map syntax.

If such a constructor is used, Groovy calls the default constructor and then calls the setter methods for the attributes. This "constructor with named parameters" works also if you call a Java class from Groovy code as Groovy uses again the default constructor of the Java class and then the methods to set the properties.

The usage of the constructors with named parameters is demonstrated by the following example.

One difference between Java and Groovy is that the == operator will check for equality and not for identity. Java checks if both variables points to the same object while Groovy checks if both variables are equals. To check for identify you can use in Groovy the is() method.

In Groovy null == null returns true. If two references point to the same object it is also true. If an object implements the compareTo method, Comparable this method is used, otherwise the equals method.

Groovy allows to have optional parameter values. Optional parameter values are indicated by =0.

In Groovy you assign default values to parameters in a method. If a default value for a parameter is defined, Groovy offers two method signatures: one with all parameters and one where the parameter with a default value is omitted. If you use multiple parameters with default values then the right most parameter with a default value is first eliminated then the next, etc.

Variables and fields can be typed as in Java or your can use the def keyword to define a variable. As a rule of thumb, use the type if it adds clarity to your code otherwise use def.

At runtime variables and fields are always typed, Groovy infers the type based on your source code. This means that at runtime you receive an error if you try to assign a non fitting type to a variable.

Variables which are not declared can be used in Groovy scripts to indicate that they can be set from outside. Such declarations are only valid in scripts and become part of the scripts binding.

Groovy supports the syntax of generics but does not enforce it. For example, you can put any type into a List<Integer> collection. To enforce type checking in Groovy you can use AST transformations. See Compile-time meta programming and AST transformations to learn more about AST transformations.

All variables in Groovy are objects (reference variables), Groovy does not use primitive variables. Groovy still allows to use the primitives types as a short form for the variable declaration but the compiler translates this into the object.

Numbers are objects in Groovy, as well as variables defined as int, float, double, etc. If you use numbers in your code Groovy assigns a type to it and performs automatically the down- and upcasting for you.

As numbers are object they have also methods for example the times method which executes a block of code the number of times defined by the number.

Create the following class called TypesTest to play with numbers.

The operators, like + or - are also mapped to methods by Groovy.

Groovy supports the Range data type is a Collection. Ranges consists of two values separated by two dots. Ranges can for example be used to define a loop statement.

You can use Strings for the definition of ranges, these ranges follow the alphabet.

Every object can be used as Range long as it implements the previous() and next() methods and the java.util.Comparable interface. The methods map to the ++ and — operators.

Groovy allows to use two different types of String, the java.lang.String and the groovy.lang.GString class. You can also define a single line or a multi-line string in Groovy.

Strings which are quoted in by "" are of type GString (short for Groovy Strings). In GStrings you can directly use variables or call Groovy code. The Groovy runtime evaluates the variables and method calls. An instance of GString is automatically converted to a java.lang.String whenever needed.

The definition of these different types of Strings is demonstrated in the following table.

The tokenize() method tokenize the String into a list of String with a whitespace as the delimiter.

The Groovy JDK adds the toURL() method to String, which allows to convert a String to a URL.

The trim method removes is applied to remove leading and trailing whitespace.

String support operator overloading. You can use + to concatenate strings, - to substract strings and the left-shift operator to add to a String.

Groovy is based on Java regular expression support and add the addition support operators to make the usage of regular expressions easier.

Groovy adds the Slashy string as String declaration. Slashy strings are Strings between two "/" signs. They don’t need escape backslashes in regular expressions.

If you use the ~ operator such a string turns into a regular expression which can be used for pattern matching. You can use special sign (escape characters) in Strings if you put them between slashes.

Groovy also provides the replaceAll method, which allows to define a closure for the replacement.

Groovy treads lists as first class constructs in the language. You define a list via List list = new List[]. You can also use generics. To access element i in a list you can either use list.get(i) or list[i].

Groovy allows direct property access for a list of items. This is demonstrated by the following snippet.

Groovy converts automatically an Array to a List and vice versa. This is demonstrated by the following snippet.

The following lists the most useful methods on List.

The grep method can be used to filter elements in a collection.

List support operator overloading. You can use + to concatenate strings, - to substract lists and the left-shift operator to add elements to a list.

The spread dot operator (spread-dot operator) *. is used to invoke a method on all members of a Collection. The result of this operation is another Collection object.

You can search in a list.

Groovy treads maps as first class constructs in the language.

The items of maps are key–value pairs that are delimited by colons. An empty map can be created via [:]. By default a map is of the java.util.HashMap type. If the keys are of type String, you can avoid the single or double quotes in the map declaration.

The values of a mapped value can get accessed via map[key]. Assignment can be done via map[key]=value. You can also call get(key) or get(key,default). In the second case, if the key is not found and the default is returned, the (key,default) pair is added to the map.

The keySet() method returns a set of keys, a collection without duplicate entries and no guaranteed ordering.

You can call closures on the elements, via the each(), any() and every() method. The any() and every() methods return a boolean depending whether any or every entry in the map satisfies a condition defined by a closure.

As you can see in the above example you can iterate in different ways through a map. The parameter for each can by one parameter and than it is the map entry or two in which case it is the key, value combination.

You can also use the following methods:

The get(key, default_value) allows to add the "default_value" to the map and return it to the caller, if the element identified by "key" is not found in the map. The get(key) method, does not add automatically to the map.

It is possible to use named arguments in method invocation.

All named arguments are used are converted by Groovy them a map and passed into the method as first parameter. All other parameters are passed in afterwards. The method can now extract the parameter from the map and perform its setup.

To convert a list to a map you can use the collectEntries method.

Groovy evaluates a condition defined in a control statement differently from Java. A pure boolean expression is evaluated the same as in Java. In difference to Java every object in Groovy has a boolean value. This means that all objects evaluate either to true or false in a boolean context. The number "0" evaluates to false, all other numbers evaluate to true. Empty collections or null evaluate to false. Every other non-null object evaluates to true.

The if and switch are supported, the if statement supports the Groovy truth, e.g., you can use for example a list as parameter in if and Groovy will evaluate this Groovy truth value.

The switch statement is very flexible, everything which implements the isCase method can be used as classifier.Groovy provides an implementation of the isCase() method to Class (using isInstance), Object (using (equals), Collections (using contains) and regular expressions (using matches). You can also specify a closure, which is evaluated to a boolean value.

If several conditions fit, the first case statement is selected.

To use your custom class in a switch statement implement the isCase method.

You can use safe navigation operator to check safety for null via the ?. operator. This will avoid a NullPointerException if you access properties of an object which is null.

The ?: (called the Elvis operator) is a short form for the Java ternary operator. You can use this to set a default if an expression resolves to false or null.

Groovy supports the standard Java for, the for-each and the while loop. Groovy does not support the do while loop.

While for and while loops are supported the Groovy way of iterating throw a list is using the each() method. Groovy provides this method on several objects include lists, maps and ranges.

This method takes as argument a closure, a block of code which can directly get executed. You can either directly define the name of the variable which the value of each iteration should get assigned to or using the implicit available variable "it".

Groovy provides also the eachWithIndex method which provides two parameters, the first is the element and the second it the index.

In additional your have the methods upto(), downto(), times() on number variables. Also you can use ranges (this is an additional datatype) to execute certain things from a number to another number. This is demonstrated by the following example.

Closures are code fragments or code blocks which can be used without being a method or a class.

A closure in Groovy is defined via the following construct: {list of parameters→ closure body}. The values before the → sign define the parameters of the closure.

For the case that only one parameter is used you can use the implicit defined it variable. The last statement of a closure is implicitly used to define the return value, if no return statement is defined. The usage of it variable on the automatic return statement is demonstrates in the following example.

If you define a closure you can also define default values for its parameters.

The Groovy collections have several methods which accept a closure as parameter, for example the each method.

The Groovy collections have several methods which accept a closure as parameter, for example the each method.

Every Groovy object has a with method which allows to group method and property calls to an object. The with method gets a closure as parameter and every method call or property access in this closure is applied to the object.

Groovy adds several convenient methods the File class from Java. The following example demonstrates how to print out every line to the console and and also how to change the output of a line by adding a prefix.

The File object provides methods like eachFile, eachDir and earchFileRecursively which takes an closure as argument.

Groovy also provides API to write to a file and append to it.

Reading an HTTP page is similar to reading a text file.

Groovy allows to process XML very easily. Groovy provide the XmlSlurper class for this purpose. There are other options but the XmlSlurper is usually considered to be the more efficient in terms of speed and flexibility. XmlSlurper can also be used to transform the XML white parsing it.

XmlSlurper allows to parse an XML document and returns an GPathResult object. You can use GPath expressions to access nodes in the XML tree.

XMLParser allows to parse an XML document and returns an groovy.util.Node object. You can use GPath expressions to access nodes in the XML tree. Dots traverse from parent elements to children, and @ signs represent attribute values.

Introduce in Groovy 2.3 the MarkupTemplateEngine which supports generating XML-like markup (XML, XHTML, HTML5, etc), but it can be used to generate any text based content.

It is compiled statically to be very fast and supports internationalization. It also supports templates as input.

Templates support includes.

The usage of the MarkupBuilder as "old" builder is demonstrated by the following snippet.

The builder in Groovy uses the method names to construct the node and node names. These methods are not defined on the MarkupBuilder class but constructed at runtime.

It is possible to use maps MarkupBuilderin the builder

You can also use the builder to create valid HTML.

An Abstract Syntax Tree (AST) is a in memory representation of code as data. An ADT transformation allows to modify this representation during compile time. This is sometimes called compile-time metaprogramming.

Groovy provides several AST transformations which allows you to reduce the amount of code you have to write.

If a class is annotated with @TupleConstructor Groovy generates a constructor using all fields.

The @EqualsAndHashCode annotation can be applied to a class, creates the equals and hashCode method. Includes fields can be customized.

The @ToString annotation can be applied to a class, generates a toString method, support boolean flags, like includePackage, includeNames, allows to exclude a list of fields.

This annotation typically only considers properties (non-private fields) but you can include them via @ToString(includeFields=true). Via @ToString(excludes=list) we can exclude a list of fields and properties.

Combines @ToString, @EqualsAndHashCode and @TupleConstructor.

This annotation marks all fields in a class as final and ensure that there are no setters generate for the fields. It also creates a constructor for all fields, marks the class as final.

@Delegate can be used on a field. All methods on the delegate are also available on the class with defines the delegate. If several delegates define the same method, it is recommended to override the method. If you do not override Groovy will use the first method it finds.

You can automatically created a Comparator for a Groovy bean by annotating it with @Sortable. Fields are used in the order of declaration.

You can also include/exclude fields.

If the @Memoize annotation is to a method the Groovy runtime caches the result for invocations with the same parameters. If the annotated method is called the first time with a certain set of parameter, it is executed and the result is cached. If the method is called again with the same parameters, the result is returned from the cache.

The AnnotationCollector allows to combine other AST Transformations annotations.

You can use this annotation, it is also possible to override parameters in them.

The Java beans specification requires that Java beans support PropertyChangeSupport for all fields.

The @groovy.beans.Bindable annotation can be applied to a whole class or a method. If the property is applied to a class, all methods will be treated as having the @Bindable annotation. This will trigger Groovy to generated a java.beans.PropertyChangeSupport property in the class and generate methods so that listeners can register and deregister. Also all setter methods will notfiy the property change listener.

The following listing shows the Java version of a Java Bean with one property.

The @Builder can be applied to a class and generates transparently a builder for this class.

Groovy allows to add Maven dependencies to your Groovy script or Groovy class using the @Grab annotation. Before a Groovy program is executed it reads the @Grab annotation, resolves the Maven dependencies, downloads them and adds them to the classpath of the program.

Using the @GrabResolver annotation you can specify the Maven repository you want to use. For example @GrabResolver(name='myrepo', root='http://myrepo.my-company.com/').

The following table lists other commonly used annotations in Groovy code:

You can also define you custom local or global transformations. For a local transformation you would write your own annotation and write a processors for that and use the annotation on an element in your Groovy class. The Groovy compiler calls your processors to transform the input into something else.

Global transformations are applied to every single source unit in the compilation without the need for additional customization.

The Meta-Object Protocol (MOP) is the underlying layer in Groovy which allows you to add methods and properties to an object at runtime. Using MOP you can methods and properties at runtime to existing objects.

If a method is called or a property is accessed in a class and this class does not define this method / property then pre-defined methods are called which can be used to handle this call.

Instances of Groovy object have default implementations of these methods, but an Groovy object can override these methods. The Groovy framework calls the methods at runtime if a method or property cannot be found. This approach is for example used by the Groovy builder pattern, it pretends to have certain method.

Using the .metaclass access you can add properties and methods to an existing class.

In this exercise you learn how to extend a Groovy class using the Meta Object Protocol.

Create the following Groovy class. This class returns a fixed value for every property asked and it fakes method calls.

Test this method via the following Groovy script.

Create the following Groovy class.

Is uses the methodMissing to respond to a toJson method call. This implementation is a bit ugly as it "pollutes" our domain model with "framework" code.

This script trigger the JSON generation.

Groovy allows to created an instance of MetaClass and register it automatic for a certain class. This registration is based on a package naming conversion:

Create the following class in the listed package to register it as MetaClass for your class.

This allows you to clean up your domain model.

Run your small test script again and validate that the conversion to JSON still works.

The following example demonstrates how you can add a method to the String class using closures.

To use Groovy classes in Java classes you need to add the Groovy runtime to the Java classpath.

Create a new Java project "de.vogella.groovy.java". Create package "de.vogella.groovy.java"

Create the following Groovy class.

Create the following Java class.

You should be able to run this Java program. Right-click your project, select "Properties" and check that the build path includes the Groovy libraries.

Maven is a well established build tool in the Java world. Integrating Gradle in the build is trivial. You basically only have to add one dependency to your pom file. To use Groovy code in your plug-in simply add the following dependency to your pom.xml file.

To use Groovy code in your Gradle build, simply add the following dependency to your pom.xml file.