vogella.de Home Blog Twitter Java Eclipse Web Technology Algorithms Source Code Browse Revision
Java, Eclipse and Web programming Tutorials
Groovy with Eclipse - Tutorial
Lars Vogel
Version 1.1
Copyright © 2008 - 2010 Lars Vogel
02.02.2010
Revision History
Revision 0.1 12.11.2008 Lars Vogel
Started writing this article
Revision 0.2 02.12.2008 Lars Vogel
First published version
Revision 0.3 10.12.2008 Lars Vogel
Described the Groovy datatypes
Revision 0.4 13.12.2008 Lars Vogel
Added closures
Revision 0.5 26.01.2009 Lars Vogel
Clean-up work
Revision 0.6 15.04.2009 Lars Vogel
Update to Groovy 1.6, moved command line into appendix
Revision 0.7 31.05.2009 Lars Vogel
Improved loop examples, update for Eclipse 3.5
Revision 0.8 15.06.2009 Lars Vogel
Simplified explanation
Revision 0.9 18.07.2009 Lars Vogel
New reference
Revision 1.0 30.07.2009 Lars Vogel
Update to Eclipse 3.5 and new plugin
Groovy
This article gives a short overview of the Groovy language including collections, loops, gstrings, MOP, closures, operator overloading, XML handing and using Groovy together with Java class. It also describes how to use Eclipse for developing Groovy.
This article assumes that you have already Eclipse installed and that you have used Eclipse for Java development. This article was written using Groovy 1.7, Eclipse 3.5 (Galileo) and Java 1.6.
Table of Contents
1. Groovy 1.1. Overview 1.2. Features
2. Installation 2.1. Groovy 2.2. Eclipse Plugin
3. First Groovy project 4. Groovy Classes, Objects and Methods
4.1. Groovy Classes 4.2. Classes and class variables 4.3. Equals, == and the method is() 4.4. Optional Parameters
5. Loops
6. Groovy Datatypes 6.1. Reference variables 6.2. Strings 6.3. Lists and maps 6.4. Ranges
7. Regular expressions 8. Closures 9. Meta Object Protocol 10. Operator overloading 11. Groovy and Files 12. Groovy and XML 13. Example usage of Groovy
13.1. Groovy Classes and class variables 13.2. Elvis operator
14. Grails 15. Using Groovy classes in Java 16. Using Groovy via the command line
16.1. The Groovy shell 16.2. The Groovy Console 16.3. Compile Groovy Classes
17. Thank you 18. Questions and Discussion 19. Links and Literature
19.1. Groovy Links
1. Groovy
1.1. Overview
Groovy is a dynamic language which is based on the Java Virtual machine. Groovy supports standard Java constructs including annotations, generics, static imports, enums, varargs and in addition advanced language features as
Groovy is a dynamic language that runs on the JVM and is tightly integrated with the Java language. Groovy provides lots of simplifications compared to standard Java language features and advanced language features as properties, closures, native support for lists, maps and regular expressions, duck typing and the elvis operator.
Groovy is almost compatible to Java, e.g. almost every Java construct is valid Groovy coding which makes the usage of Groovy for an experience Java programmer easy.
The following assumes that you have already Java programming experience and focus on Groovy specific features.
1.2. Features
While the simplicity and ease of use is the leading principle of Groovy here are a few nice features of Groovy:
Groovy allows to change classes and methods at runtime. For example if a class does not have a certain method and this method is called by another class the called class can decided what to do with this call.
Groovy does not require semicolons to separate commands if they are in different lines (separated by new-lines).
Groovy has list processing and regular expressions directly build into the language. Groovy implements also the Builder Pattern which allows to create easily GUI's,
XML Documents or Ant Tasks. Asserts in Groovy will always be executed.
2. Installation
2.1. Groovy
Download the latest version from Groovy from Groovy Homepage .
You have then to set the GROOVY_HOME environment variable and add%GROOVY_HOME%/bin to your path.
Tip
If you are using MS Windows you can use the windows installer. This will set the environment variables automatically.
2.2. Eclipse Plugin
Use the Eclipse Update manager to install the Groovy Eclipse plugin. The URL for the update manager is: http://dist.springsource.org/release/GRECLIPSE/e3.5/ for Eclipse 3.5. Select the feature "Groovy-Eclipse".
3. First Groovy project
Create a new Groovy project "de.vogella.groovy.project" via File -> New -> Other -> Groovy
Create a new package "de.vogella.groovy.project".
Select File -> New -> Other -> Groovy -> Groovy Class
Create the class "GroovyTest"
Create the following code.
package de.vogella.groovy.first
class GroovyTest{ static void main(def args){ def mylist=[1,2,"Lars","4"] mylist.each{ println it } }}
Select the class, right click and select "Run As" -> "Groovy Script"
This should run your Groovy class and give you output on the shell.
Congratulation! You created and run your first Groovy class.
4. Groovy Classes, Objects and Methods
4.1. Groovy Classes
A Groovy source files ends with the extension .groovy. All Groovy classes are per default public.
Create and run the following groovy class "SumItUp.groovy".
package de.vogella.groovy.first
class SumItUp {
static sum(a,b){ a+b; }
static void main(args){ println sum(1,5) println sum(1,2) }}
4.2. Classes and class variables
In Groovy all fields of a class have per default the access modifier "private" and Groovy provides automatically getter and setter methods for the fields. Therefore all Groovy classes are per default JavaBeans (Plain Old Java Objects).
You can use the getter and setter directly or use the name of the variable for access. Groovy will convert this to the getter and setter method.
Groovy will also directly create constructors in which you can specify the element you would like to set during construction. Groovy archives this by using the default constructor and then calling the setter methods for the attributes.
Tip
This "constructor with named paramters" works also if you call a Java class from Groovy as Groovy will again use the default constructor and then the methods to set the properties.
Have a look at the following example to see this in action.
package de.vogella.groovy.first
public class Person{ String firstName String lastName int age def address static void main(def args) { Person p = new Person() // Use the generated access methods p.setFirstName("Lars") // This will still use the generated access method, it is not a direct access! p.lastName = "Vogel" p.address = ("Homestreet 3"); println(p.firstName + " " + p.lastName); // Use the generated constructor p = new Person(firstName: "Peter", lastName:"Mueller"); println(p.firstName + " " + p.lastName); } }
4.3. Equals, == and the method is()
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.
Tip
Remember == in Groovy check if the objects are equals! This is different in Java.
4.4. Optional Parameters
Groovy allows to have optional parameter values. Optional parameter values are indicated by =0.
class Hello {
static main(args){ println sum(1,5) println sum(1,2,5)
}
static sum(a,b,c=0){ a+b+c; }}
5. Loops
Create a new project "de.vogella.groovy.loops" with the package "de.vogella.groovy.loops" for this example.
Tip
The following examples use closures, which in short are "code objects". More on closures under closures Closures in Groovy .
Groovy supports the standard Java loops but also the the each() method on several objects. In this method you can directly write code which should 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".
package de.vogella.groovy.loops
public class PrintLoop{
public static void main(def args){
def list = ["Lars", "Ben", "Jack"]
// using a variable assignment
list.each{firstName->
println firstName
}
// using the it variable
list.each{println it}
}
}
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. Please see the following example.
package de.vogella.groovy.loops
public class LoopTest{ public static void main(args){ 5.times {println "Times + $it "} 1.upto(3) {println "Up + $it "} 4.downto(1) {print "Down + $it "} def sum = 0 1.upto(100) {sum += 1} print sum (1..6).each {print "Range $it"} } }
6. Groovy Datatypes
Create a new Java project de.vogella.groovy.datatypes. Create the package "de.vogella.groovy.datatypes".
6.1. Reference variables
All variables in Groovy are reference variables (objects), Groovy does not use primitive variables. Groovy still allows to use the primitives types as a short form but always translates this into the object.
Groovy allow static and dynamic typed variables. If you want to use dynamic typed variables you can use the keyword def.
If you use numbers then Groovy will automatically assign a type to it and will also make down- and upcasting for you.
Create the class "TypesTest" to test this.
package de.vogella.groovy.datatypes
public class TypesTest{ public static void main(args){ int i = 1 // Short form for Integer i = new Integer(1) int j = i +3
int k = i.plus(3); // Same as above // Make sure this worked assert(k==4); println i.getClass().getName() println j.getClass().getName() println k.getClass().getName() // Automatic type assignement def value = 1.0F println value.getClass().getName() def value2 = 1; println value2.getClass().getName() value2 = value2 / 2; println value2 println value2.getClass().getName() } }
6.2. Strings
Groovy allows to define Strings in '' and in "". Strings which are quoted in by "" are so-called GStrings (short for Groovy Strings). In GStrings you can directly use variables which will then be evaluated and included in the text.
package de.vogella.groovy.datatypes
public class StringTesting{ public static void main(String[] args) { def name = "John" def s1 = "Hello $name" // $name will be replaced def s2 = 'Hello $name' // $name will not be replaced println s1 println s2 println s1.getClass().getName(); println s2.getClass().getName(); }}
6.3. Lists and maps
Groovy treads lists and maps 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].
package de.vogella.groovy.datatypes
public class Person{ String firstName; String lastName; Person(String firstName, String lastName){ this.firstName = firstName this.lastName= lastName }}
package de.vogella.groovy.datatypes
public class ListMapTest{
public static void main(args){ List<Integer> list = [1,2,3,4] println list[0] println list[1] println list[2] List<Person> persons = list[] Person p = new Person("Jim", "Knopf") persons[0] = p println persons.size() println persons[0].firstName println persons.get(0).firstName }}
You can define maps via Map [key1:value1, key2:value2,...]. An empty map can be created via [:]. The values of a mapped value can get accessed via map[key]. Assignment can be done via map[key]=value.
package de.vogella.groovy.datatypes
public class MapTest{ public static void main(args){ Map map = [:] def map2 = ["Jim":"Knopf", "Thomas":"Edison"] println map2["Jim"] map2["Test"] = "Tester" println map2["Test"] }}
6.4. Ranges
Groovy supports ranges. Every object can be used as long as it implements previous() and next() (which are also represented by the ++ and -- operators).
package de.vogella.groovy.datatypes
public class RangesTest{ public static void main(args){ for (i in 0..9) { println ("Hello $i" ) } }}
7. Regular expressions
For an general overview of regular expression please check Regular Expressions in Java .
Groovy is based on Java regular expression support and add the following operators to make the usage of regular expressions easier:
Table 1.
Construct Description
=~ Find: True if the pattern is contained in a text
==~ Match: True if the complete string matches the pattern
~String Turns a string into a regular expression
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. package de.vogella.groovy.datatypes
public class RegularExpressionTest{ public static void main(String[] args) { // Defines a string with special signs def text = "John Jimbo jingeled happily ever after" // Every word must be followed by a nonword character // Match if (text==~/(\w*\W+)*/){ println "Match was successful" } else { println "Match was not successful" } // Every word must be followed by a nonword character // Find
if (text=~/(\w*\W+)*/){ println "Find was successful" } else { println "Find was not successful" } if (text==~/^J.*/ ){ println "There was a match" } else { println "No match found" } def newText = text.replaceAll(/\w+/, "hubba") println newText } }
8. Closures
Closures are code fragments which can be used without being a method or a class.
A closure is defined via {para1, para2 -> code of the closure}. 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 variable it.
The last statement of a closure is returned as return value.
The groovy collections have several methods which accept a closure as parameter, for example the each method.
package test
public class ClosureTest{ public static void main(args){ List<Integer> list = [5,6,7,8] list.each({line -> println line}) list.each({println it}) }}
9. Meta Object Protocol
The meta object protocol allows to add dynamically at runtime methods and properties.
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.
def methodMissing (String name, args) - Called for missing method void setProperty (String property, Object o ) - called for non existing setter of a
property Object getProperty (String property) - called for non existing getter of a property
package de.vogella.groovy.training
public class AnyMethodExecutor{ def map Object getProperty (String property){ println "Setting this propery" return 5; } void setProperty (String property, Object o ){ println "Hallo" } def methodMissing (String name, args){ def s = name.toUpperCase(); if (s.startsWith("HELLO")) { println "This method stats with Hello. Full name $name" } else { println "This method is missing" } } public static void main (args){ def test = new AnyMethodExecutor (); test.hall(); test.helloMethod(); test.Hallo(); test.test= 5; println test.test; } }
10. Operator overloading
Groovy supports that you can use the standard operations in your own classes. For example if you want to use the operation a+b where a and b are from class Z then you have to implement the method plus(Z name) in class Z.
Groovy will map the operations to the following classes.
Table 2.
Operator Name Method
a+b plus a.plus(b)
a-b minus a.minus(b)
a*b star a.multiply(b)
a/b divide a.div(b)
a%b modulo a.mod(b)
a--, --a decrement a.previous()
a++, ++a increment a.next()
a**b power a.power(b)
a-b minus a.minus(b)
a-b minus a.minus(b)
11. Groovy and Files
Processing files with groovy is simple. The following example will first print out every line to the console and then print again every line to the console with a leading line number.
package mypackage
/* * Writes a files to the console */public class MyFile{ public static void main(def args){ // Write just the content of the file to the console File file = new File("c:/temp/groovy/content.txt") file.eachLine{ line -> println line } // Adds a line number in front of each line to the console def lineNumber = 0; file = new File("c:/temp/groovy/content.txt") file.eachLine{ line -> lineNumber++ println "$lineNumber: $line" }
} }
12. Groovy and XML
Groovy allows to process XML very easily.
package mypackage
public class XmlTest{ static void main(args){ def xmldocument = ''' <persons> <person> <firstname age="3">Jim</firstname> <lastname>Knopf </lastname> </person> <person> <firstname age="4">Ernie</firstname> <lastname>Bernd</lastname> </person> </persons> ''' def persons = new XmlParser().parseText(xmldocument); def allRecords = persons.person.size() println("Number of person is: $allRecords") def person = persons.person[0] // name is the name of the XML tag println("Name of the person tag is:" + person.name()) // text gets the text of the node firstname println(person.firstname.text()) // Lets print out all important information for (p in persons.person){ println "${p.firstname.text()} ${p.lastname.text()}" } } }
13. Example usage of Groovy
13.1. Groovy Classes and class variables
All fields of a class are per default created private with automatic getter and setter. You can use the getter and setter directly or use the name of the variable for access. Groovy will convert this to the getter and setter method.
Groovy will also directly create constructors in which you can specify the element you would like to set during construction.
package de.vogella.groovy.first
public class Person{ String firstName String lastName int age def address static void main(def args) { Person p = new Person() // Use the generated access methods p.setFirstName("Lars") // This will still use the generated access method, it is not a direct access! p.lastName = "Vogel" p.address = ("Homestreet 3"); println(p.firstName + " " + p.lastName); // Use the generated constructor p = new Person(firstName: "Peter", lastName:"Mueller"); println(p.firstName + " " + p.lastName); } }
13.2. Elvis operator
You can use the elvis operator to check if a value is null.
def firstName = user?.firstName // firstName will be null if user is null
14. Grails
Grails is a webframework based on Groovy which allows you to develop a webapplicaiton based on convensions rather then configuration. This idea is similar to the Ruby on Rails idea. See Grails Tutorial for details.
15. Using Groovy classes in Java
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.
package de.vogella.groovy.java
public class Person{ String firstName String lastName int age def address}
Create the following Java class.
package de.vogella.groovy.java;
public class Main { public static void main(String[] args) { Person p = new Person(); p.setFirstName("Lars"); p.setLastName("Vogel"); System.out.println(p.getFirstName() + " " + p.getLastName()); }}
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.
16. Using Groovy via the command line
You can run Groovy code via:
the Groovy shell: groovysh the Groovy interpreter: groovy the Groovy Console : groovyConsole complile Groovy code to classfiles and run it via the Java Virtual machine
16.1. The Groovy shell
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:
println("Hello Groovy")
Press enter-> the system will execute your code.
16.2. The Groovy Console
Start the interactive Groovy Shell with the command groovyConsole. This console allows you to test Groovy code.
16.3. Compile Groovy Classes
You can also complile Groovy code into Java byte-code 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 command "groovyc Hello.groovy".
17. Thank you
Thank you for practicing with this tutorial.
Please note that I maintain this website in my private time. If you like the information I'm providing please help me by donating.
18. Questions and Discussion
For questions and discussion around this article please use the www.vogella.de Google Group . Also if you note an error in this article please post the error and if possible the correction to the Group.
Tip
The following tries to help you in asking good questions: 10 golden rules of asking questions in the OpenSource community .
19. Links and Literature
19.1. Groovy Links
http://groovy.codehaus.org/ Groovy Homepage
http://groovy.codehaus.org/Documentation Groovy documentation
http://grails.codehaus.org Grails Homepage
http://www.ibm.com/developerworks/java/library/j-grails01158/index.html Scott Davis introduction article to Grails
http://www.ibm.com/developerworks/java/library/j-pg04149.html Scott Davis article about loops in Groovy
http://www.ibm.com/developerworks/opensource/library/j-pg05199/index.html Scott Davis about XML processing with Groovy
_s-xclick 6292795
http://www.ibm.com/developerworks/opensource/library/j-pg06239.html Scott Davis about Metaprogramming
Top Related