Groovy

Learn Another Language

Dan Vega / Joshua Caito http://bit.ly/cfogroovy

Joshua Caito

• Working as an IT professional for 11 years
• Working with ColdFusion since MX 7
• Doctor Who loving, 日本語 speaking, whiskey drinking Buddhist
• CodeCaito.blogspot.com
• Twitter: @J_Caito

Presentation Overview

• Open Source / Alternative language for the JVM
• Object Oriented, dynamic with functional flavor
• Current Version 2.3 / Java 8 Support
• Inspired by languages like
  • Python
  • Ruby
  • Smalltalk

• This wasn't a case of developing a language and then latter porting it over to run on the JVM. From the very beggining Groovy was designed to run on the JVM.
• Because of that there is seemles interop with Java (create and call classes in java from groovy and vice versa)

• Powerful Dynamic Language
• Easy to Learn
• Groovy as a Java superset
• Familiar Syntax for Java Developers

• Powerful dynamic language that is really easy to learn
• Groovy as a Java superset

• Who makes Groovy?
• Guillaume Laforge

What does a Java Class Look Like

What does a Groovy Class Look Like

• The point here is that java syntax for the most part is valid groovy syntax. The compiler for groovy compiles the code down to java byte code. There are a few exceptions where this isn't the case but there are ver few.
• Again most valid java syntax is valid groovy syntax but if all you're going to do is rename the file then keep writing java we want to show you some the things Groovy can do to help you be more productive
• most java code is valid groovy code
• any java developer is a groovy developer

From Java to Groovy Demo

• POJO Plain old Java Object. This is a simple example and there is a lot of noise going on here.
• Person_start.groovy
• Comments / Imports
• Access Modifiers / Semi colons / return statements / parentheses
• Properties / getters & setters / constructors
• Mark a field private and you won't get the generated getters/setters (final will make it read only)

Installation

Groovy Console

Command Line Tools

• Demo features of GroovyConsole
• Options
• Run Some Code
• AST

Data Types

Groovy is a dynamic language

What does that mean?

• We aren't restricted to strict type definitions or compiler checks
• We can keep the same fluid typing we enjoy from ColdFusion

  def x = 11
  x = [ foo : 'bar' ]

• Over all, less things to worry about[Run time validation still matters of course]

The DEF Keyword

def serves two main purposes

• Generic Object instantiation[Well, sort of. We'll cover that in a moment...]
• Scoping your variable

• Byte
• Short
• Integer
• Long
• Float
• Double
• Character
• Boolean
• String

Groovy Strings

Groovy Strings (g-strings) are really powerful

Think ## but cooler, because it's Groovy

Complex Data Types

• Dates
• Ranges
• Lists
• Maps
• Working with Collections

Working with dates in Java

Working with Dates in Groovy

def today = new Date() 
// Sat Apr 12 09:22:10 EDT 2014	
// java.util.Date

def day = new Date('05/19/2014')
//Mon May 19 00:00:00 EDT 2014

def today = new Date()
println today.format('MM/dd/yyyy')
// 04-12-2014
// java.lang.String

def today = new Date()
today.format('MM-dd-yyyy hh:mm a')
// 04-12-2014 09:31 AM

def today = new Date()
def yesterday = today - 1
def tomorrow = today + 1

// Sat Apr 12 09:33:01 EDT 2014
// Fri Apr 11 09:33:01 EDT 2014
// Sun Apr 13 09:33:01 EDT 2014

Working with Dates

Groovy ways to iterate through 2 dates

Date start = new Date()
Date end = new Date() + 7

start.upto(end) { d ->
    println d
}

end.downto(start) { d ->
    println d
}

(start..end).each { d ->
    println d
}

Time Category

import groovy.time.TimeCategory

def now = new Date()
println now // Sat Apr 12 09:38:11 EDT 2014

use( TimeCategory ) {
    println 10.minute.from.now // Sat Apr 12 09:48:11 EDT 2014 
    println 10.hours.ago // Fri Apr 11 23:38:11 EDT 2014
    println 10.weeks.from.now // Sat Jun 21 00:00:00 EDT 2014
    println 3.days.ago // Wed Apr 09 00:00:00 EDT 2014
    println 1.year.from.now // Sun Apr 12 00:00:00 EDT 2015
}

Working with dates in Groovy

Ranges

• Ranges allow you to create a list of sequential values.
• These can be used as Lists since Range extends java.util.List.

def range = 1..10
println range
// [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

def reverseRange = 10..1
println reverseRange
// [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]

println range.class.name
// groovy.lang.IntRange

def range = 1..10

println range.size() // 10
println range.get(2) // 3
println range.contains(5) // true
println range.from // 1
println range.to // 10
println range instanceof java.util.List // true

Ranges - Not just for numbers

def range = 'a'..'p'
println range

// [a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p]

enum Days {
    MONDAY,TUESDAY,WEDNESDAY,THURSDAY,
    FRIDAY,SATURDAY,SUNDAY
}

def workWeek = Days.MONDAY..Days.FRIDAY
def weekend = Days.SATURDAY..Days.SUNDAY
def week = Days.MONDAY..Days.SUNDAY

println workWeek
println weekend
println week

// [MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY]
// [SATURDAY, SUNDAY]
// [MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY]

Lists

def list = []
println list.class.name
//java.util.ArrayList

def list = [1,2,3,4,5]
println list
// [1, 2, 3, 4, 5]

def list = [1,"two",3,"four",new Date(),["Mon","Tue","Wed"]]
println list
// [1, two, 3, four, Sat Apr 12 13:26:16 EDT 2014, [Mon, Tue, Wed]]

List Manipulation

def list = []

list.add(1)
list.putAt(1,2) //equivalent method to [] when value being changed
list[2] = 3
list.push(4)
list << 5

assert list == [1,2,3,4,5]

def list = [1,2,3,4,5]

assert list[1] == 2 // indexing starts at 0
assert list.getAt(1) == 2 //equivalent method to []
assert list.get(1) == 2 //alternative method
assert list[-1] == 5 //use negative indices to count from the end

def list = [1,2,3,4,5]

assert list.remove(2)
assert list == [1,2,4,5]
list.pop()
assert list == [1,2,4]

list.clear()
assert list == []

Maps

def map = [:]

// map.foo will always look for property foo so class will never work here
println map.class.name 

// java.util.LinkedHashMap
println map.getClass().name

def map = [first:'Dan',last:'Vega',email:'danvega@gmail.com']

println map
// [first:Dan, last:Vega, email:danvega@gmail.com]

assert [1:'a', 2:'b', 1:'c' ] == [1:'c', 2:'b'] //keys unique

Maps

Maps can be made up of complex data

class Person {
    String first
    String last
}

def p = new Person(first:"Dan",last:"Vega")

def map = [
    key:"value",
    numbers: [1,2,3,4,5],
    person: p,
    now: new Date()
]

println map
[key:value, numbers:[1, 2, 3, 4, 5], 
person:Person@60aed478, now:Sat Apr 12 15:40:19 EDT 2014]

Map Keys

def map = [first:"Dan",last:"Vega"]
def keys = map.keySet()

println keys[0].class.name //java.lang.String
println keys[1].class.name //java.lang.String

If you really want a variable to become the key, you have to wrap it between parentheses: [(a):1]

def a = 1
def map = [first:"Dan",last:"Vega",(a):new Date()]
def keys = map.keySet()

println keys[0].class.name //java.lang.String
println keys[1].class.name //java.lang.String
println keys[2].class.name //java.lang.Integer

Maps

def map = [first:"Dan",last:"Vega",email:'danvega@gmail.com']

map.first = "Daniel"
assert map.first == "Daniel"
map["first"] = "Dan"
assert map.first == "Dan"

assert map["first"] == "Dan"
assert map.get('first') == "Dan"
assert map.get('fullName','Dan Vega') == "Dan Vega"

We can check the contents of a map with various methods

def map = [first:"Dan",last:"Vega",email:'danvega@gmail.com']

assert [:].isEmpty()
assert !map.isEmpty()
assert map.containsKey('email')
assert map.containsValue('danvega@gmail.com')

Collections DEMO

Groovy Truth

Groovy provides us with standard boolean operators for determining 'truthiness'

def a = true
def b = true
def c = false
assert a
assert a && b
assert a || c
assert !c

But it also tries to coerce non-boolean objects into boolean examples

Empty collections are coerced to false.

def numbers = [1,2,3]
assert numbers //true, as numbers is not empty
numbers = []
assert !numbers //true, as numbers is now an empty collection

Iterators and Enumerations with no further elements are coerced to false.

assert ![].iterator() // false because the Iterator is empty
assert [0].iterator() // true because the Iterator has a next element
def v = new Vector()
assert !v.elements()  // false because the Enumeration is empty
v.add(new Object())
assert v.elements()   // true because the Enumeration has more elements

Non-empty maps are coerced to true.

assert ['one':1]
assert ![:]

Matching regex patterns are coerced to true.

assert ('Hello World' =~ /World/) //true as matcher has at least one match

Non-empty Strings, GStrings and CharSequences are coerced to true.

// Strings
assert 'This is true'
assert !''
//GStrings
def s = ''
assert !("$s")
s = 'x'
assert ("$s")

Non-zero numbers are coerced to true.

assert !0 //yeah, 0s are false, like in Perl
assert 1  //this is also true for all other number types

Non-null object references are coerced to true.

assert new Object()
assert !null

null does not implicitly coerce to anything, it can only be used as a state test against other values

assert null == false //Will fail
assert null == true //Also fails

assert !null == true //These test will pass as we're testing against state
assert !!null == false

Logical Branching, Loops, & Operators

Logical Branching

if( groovyIsAwesome )
	println( 'WOOT!' )
else
	youMustBeLying()

Nothing new or exciting here...

The Switch Statement

The switch statement in Groovy does allow us to do more than we're used to with ColdFusion

def x = 'This is interesting'

switch( x ) {
    
    case ~/(?i)\bthis.*/:
        println 'first'

    case String:
        println 'second'

    case 'This is interesting':
        println 'third'
        break

}

Looping

0.upto(4) { println( 'Hello World!' ) }
4.times { println( 'Hi World!' ) }

for( x in 0..1 ) {println 'hi'}

def x = [ 1:'dog', 2:'cat', 3:'bird' ]
for( i in x ) { println i.value }

Operators

The elvis operator

that seems really neat (I know! Right?) but there are quite a few fun operators Groovy brings to the table

• Spread Operator - *.
• Safe Navigation Operator - ?.
• Regular Expression Operators - =~ / ==~
• Spaceship Operator - <=>

Overloading Operators

Groovy comes with a _ton_ of operators predefined you can also overload

def x = 'Hello World!'
def y = x - 'World!'
println y

Closures

The Traditional Way

def myNumbers = [1,2,3,4,5,6,7,8,9,10]

def totalNumbers(numbers){
    def total = 0;

    for(number in numbers){
        total += number
    }

    total
}

// 55
println totalNumbers(myNumbers)

Total Even Numbers

def myNumbers = [1,2,3,4,5,6,7,8,9,10]

def totalEvenNumbers(numbers){
    def total = 0;
    for(number in numbers){
        if(number % 2 == 0) total += number
    }
    total
}

// 30
println totalEvenNumbers(myNumbers)

Total Odd Numbers

def myNumbers = [1,2,3,4,5,6,7,8,9,10]

def totalOddNumbers(numbers){
    def total = 0;
    for(number in numbers){
        if(number % 2 != 0) total += number
    }
    total
}

// 30
println totalOddNumbers(myNumbers)

The Groovy Way

def myNumbers = [1,2,3,4,5,6,7,8,9,10]

def totalNumbers(numbers, selector){
    def total = 0;
    for(number in numbers){
        if(selector(number)){
            total += number
        }
    }
    total
}

println totalNumbers(myNumbers, { true } ) // 55
println totalNumbers(myNumbers, { it % 2 == 0 } ) // 30
println totalNumbers(myNumbers, { it % 2 != 0 } ) // 25

println totalNumbers(myNumbers) { true } // 55
println totalNumbers(myNumbers) { it % 2 == 0 } // 30
println totalNumbers(myNumbers) { it % 2 != 0 } // 25

Closure Basics

• A block of code
• May be passed as arguments
• May accept parameters
• May return a value

// the times method accepts a closure as an argument
3.times( {println "Hello Closures!"} )

// If the last argument is a closure you can omit the parentheses
3.times {println "Hello Closures!"}

def myClosure = {
    println "Hello Closures!"
}

// we could call it directly 
myClosure()

// or pass it around as a method argument
3.times(myClosure)

Closure arguments

3.times {
    // if i dont declare an argument list
    // the closure accepts 1 parameter and its called it
    println it
}

// 0
// 1
// 2

3.times { number ->
    println number
}

3.times { int number ->
    println number
}

printFullName = { firstName,lastName ->
    println "${firstName} ${lastName}"
}

printFullName("Dan","Vega")

Closures

Hopefully this code starts to make sense now

def list = ["one","two","three","four","five"]

// loop over a list
list.each {
    println it
}

def map = [first:"Dan",last:"Vega",company:"FirstComp"]

// loop over a map
map.each { key, value ->
    println "${key}: ${value}"
}

Curried Closure

Closures with prebound parameters are called curried closures. When we curry a closure, we're asking the parameters to be prebound.

def addNumbers = { x, y -> x + y }
def addToTen = addNumbers.curry(10)
assert 14 == addToTen(4)

addNumbers.rcurry(10)
addNumbers.ncurry(index,obj)

Closure Scope

• this: refers to the instance of the enclosing class where a Closure is defined
• owner: the enclosing object (this or a surrounding Closure)
• delegate: by default the same as owner, but changeable

class Foo {

   def closure = {
       println "${this.class.name},${owner.class.name},${delegate.class.name}"
       def innerClosure = {   
           //delegate = owner.delegate 
           println "${this.class.name},${owner.class.name},${delegate.class.name}"
       }
       innerClosure()
   }
   
}

def foo = new Foo().closure()

Closure Delegation

Groovy Closures support method delegation, and provide capabilities for method dispatching-much like JavaScript's support for prototypal inheritance.

class ClosureDemo {
    def foo() {
        def c = {
            write 'hello from foo.c'
        }
        c()
    }
}

def demo = new ClosureDemo()
demo.foo()

Closure Demos

Meta-Programming

Meta-Programming is one of the coolest features of Groovy!

So what is Meta-Programming?

Meta-Programming is the writing of computer programs that write or manipulate other programs (or themselves).

Groovy impliments Meta-Programming at runtime with Meta Object Protocol and the ExpandoMetaClass

Every java.lang.Class is supplied with a special "metaClass" property that will give you a reference to an ExpandoMetaClass instance.

The Expando class

Straight from the source, here's the list of all the stuff you can do with the ExpandoMetaClass

• Borrowing Methods — Borrowing methods from other classes
• Constructors — Adding or overriding constructors
• Domain-Specific Language
• Dynamic Method Names — Dynamically creating method names
• GroovyObject Methods — Overriding invokeMethod, getProperty and setProperty
• Interfaces — Adding methods on interfaces
• Methods — Adding or overriding instance methods
• Overriding static invokeMethod — Overriding invokeMethod for static methods
• Properties — Adding or overriding properties
• Runtime Discovery — Overriding invokeMethod for static methods
• Static Methods — Adding or overriding static methods

Dynamically adding properties

class Developer { 
    String firstName, lastName
    def makeExcuse(){ println "I'm compiling!" }
}

josh = new Developer( firstName : 'Joshua', lastName : 'Caito' )
josh.metaClass.isTeamLead = true
gettingARaise = josh.isTeamLead ?: false 
println "Josh is getting a raise? ${gettingARaise}"

Adding methods dynamically

class Developer { 
    String firstName, lastName
    def makeExcuse(){ println "I'm compiling!" }
}

josh = new Developer( firstName : 'Joshua', lastName : 'Caito' )

Developer.metaClass.work = { Integer hours ->
    println """I promise I'll work ${hours} hours today
    or my name isn't ${firstName} ${lastName}!"""
}

dan = new Developer( firstName : 'Dan', lastName : 'Vega' )

try{ josh.work(3) } catch( e ) { josh.makeExcuse() }
dan.work(8)

Borrowing Methods

class Manager { 
    String firstName = 'Big'
    String lastName = 'Cheese'
}

boss = new Manager()

try{ boss.work(3) } catch( e ) {
    println "I've delegated that, I swear!"
}

boss.metaClass.work = josh.&makeExcuse
boss.work()

Adding Missing Methods

Using the ExpandoMetaClass, we can also invoke the methodMissing() method

This can be VERY useful

• Grails is an Open Source, full stack, web application framework for the JVM.
• It takes advantage of the Groovy programming language and convention over configuration
• Rapid Application Development
• Current version 2.3.8
• Inspired by Ruby on Rails, Django & others

The Grails Stack

Getting Started

• Download http://www.grails.org
• Current Version 2.3.8
• Create A New Project using your IDE
• grails create-app

Grails Plugins

• Build tool with built in dependency management
• Conventions through plugins
• Full access to tasks and dependency tree
• Easy to write your own tasks
  • Either in the build file
  • or view Groovy/Java classes
• Default build tool for Android
• http://www.gradle.org

Unit Testing & Testing With Spock

IDE Support

Resources

THE END / Q&A

BY Josh Caito / Dan Vega

If you liked our presentation (or even if you didn't), please be sure to leave feedback!