Learning groovy 1: half day workshop

Learning Groovy (in 3 hours)!
Adam L. Davis
The Solution Design Group, Inc.
Author of “Learning Groovy”
(& What’s New in Java 8 & others)
14 years Java Dev.
github.com/adamldavis
/2017-gr8conf-learning-groovy

Java ~ Brian Goetz (Java Language Architect)

<Insert your
hated language
here>
PHP

● Dynamic or Static
● (@CompileStatic @TypeChecked)
● As fast as Java (with static & indy)
● Meta-programming
● Optional semi-colons
● Optional parentheses
● Short-hand for Lists and Maps
● Automatic getters and setters
● A better switch
● Groovy GDK…
Groovy 2.4 Features

● Closures
● Currying
● Method references
● Map/Filter/Reduce as collect, findAll, inject
● Internal iterating using each
● Operator Overloading (+ - * % / …)
● methodMissing and propertyMissing
● AST Transformations
● Traits
…
Groovy 2.4 Features (cont.)

Starting Out
Option 1: Using sdkman.io
– sdk install groovy 2.4.9
Option 2: Download from groovy-lang.org
– Alter your PATH
● Export PATH=$PATH:/usr/lib/groovy/bin
● Option 3: Mac – see http://groovy-lang.org/install.html
● Option π: Windows – see https://github.com/groovy/groovy-windows-installer
Then: $ groovyConsole
IntelliJ IDEA or NetBeans

Dynamic typing
● def keyword
● Parameters’ typing optional
● Possible to mock using a map
– def dog = [bark: { println ‘woof’ }]
● Using @TypeChecked or @CompileStatic you
can make Groovy statically typed in some
classes

Groovy Strings
● ‘normal string’
● “groovy string can contain $variables”
● “can also do expressions ${x + 1}”
● Use triple quote to start/end multi-line strings
‘’’
This is a
Multi-line
String
‘’’

Math, Groovy Truth, and Equals
● Numbers are BigDecimal by default not Double
– 3.14 is a BigDecimal
– 3.14d is a Double
● Groovy truth: null, “”, [], 0 are false
– if (!thing) println “thing was null”
– if (!str) println “str was empty”
● Groovy == means .equals
– For identity use a.is(b)

Property Access
● Everything is public
by default
● Every field has a
getter and setter by
default
● Gotcha’s
– Map access
– String.class->String
● Property access automatically
uses getters and setters
● foo.bar == foo.getBar()
● foo.bar = 2 == foo.setBar(2)

Lists and Maps
● def emptyList = [ ]
● def emptyMap = [:]
● def numList = [1,2,3]
● def strMap = [cars: 1, boats: 2, planes: 3]
● def varMap = [(var1): 1, (var2): 2, (var3): 3]

Maps Continued...
● def map = [cars: 1, boats: 2, planes: 3]
● String key access: map.cars
● OR map[‘cars’]
● Also works for modifying:
– map.cars = 42
– map[‘cars’] = 42

A better switch
● Switch can use types, lists, ranges, patterns…
Switch (x) {
case Map: println “was a map”; break
case [4,5,6]: println “was 4, 5 or 6”; break
case 0..20: println “was 0 to 20”; break
case ~/w+/: println “ was a word”; break
case “hello”: println x; break
case BigDecimal: println “was a BigDecimal”

Groovy GDK
● Adds methods to everything! Adds its own classes...
● Collections: sort, findAll, collect, inject, each,…
● IO: toFile(), text, bytes, withReader, URL.content
● Ranges: x..y, x..<y
– GetAt syntax for Strings and Lists:
● text[0..4] == text.substring(0,5)
● Utilities: ConfigSlurper, Expando, ObservableList/Map/Set

Safe dereference & Elvis operator
● Safe dereference ?.
– String name = person?.name
– Java: person == null ? null : person.getName()
● Elvis operator ?:
– String name = person?.name ?: “Bob”
– Java: if (name == null) name = “Bob”

Closures
● Closure: “a self-containing method” (like Lambda exp.)
– def say = { x -> println x }
– say(‘hello gr8conf’)
– def say = { println it }
– def adder = { x, y -> x + y }
● Closures have several implicit variables:
– it - If the closure has one argument
– this - Refers to the enclosing class
– owner - The same as this unless it is enclosed in another closure.
– delegate - Usually the same as owner but you can change it (this
allows the methods of delegate to be in scope).

Closures Continued...
● When used as last parameter, closure can go
outside parentheses
– methodCalled(param1, param2) { closureHere() }
– methodWithOnlyClosure { closureHere() }

Regex Pattern Matching
● Regex = regular expressions
● Within forward slashes / is a regex
– You don’t need to use double
● =~ for matching anywhere within a string
– if (text =~ /d+/) println “there was a number in it”
● ==~ for matching the whole string
– if (email ==~ /[w.]+@[w.]+/) println “it’s an email”

Meta-programming
● Every class and instance has a metaClass
● String.metaClass.upper =
{ delegate.toUpperCase() }
– “foo”.upper() == “FOO”
● Traits can be used as
mixins
● Maps can be cast to
actual types using as
[bark: {println “Woof!”}]
as Dog

Other Surprises for Java Devs
● Default values for method parameters
● groovy.transform.*
– @EqualsAndHashCode
– @TupleConstructor
– @ToString
– @Canonical
● Generics not enforced by default

Advanced Groovy
● Groovy Design Patterns
– Strategy pattern
– Categories
– Method caching
● DSLs – Domain Specific Languages
– Operator Overloading
● Traits
● Functional Programming
– curry

Spock
Grails
Gradle grooscript
The Groovy Ecosystem
and many others….
Griffon

Gradle
Imperative, not declarative
Relies on plugins
Tasks
Vanilla groovy
Easy to build plugins
Easy to do sub-projects

Spock
Built on JUnit
Somewhat enhanced groovy
“test names can be any string”
given: when: then: expect:
Built-in mocking
Table-syntax for provided test data
Pretty assert output

Thanks!
Adam L. Davis
“Learning Groovy”
github.com/adamldavis
/2017-gr8conf-learning-groovy
adamldavis.com
@adamldavis
groocss.org
@groocss
How? Gedit + https://github.com/aeischeid/gedit-grails-bundle

Learning groovy 1: half day workshop

More Related Content

What's hot

Similar to Learning groovy 1: half day workshop

Recently uploaded

Learning groovy 1: half day workshop