Learning groovy -EU workshop

Beginning Groovy 3.0
Adam L. Davis
The Solution Design Group, Inc.
Author of “Learning Groovy”
(& Reactive Streams in Java & others)
16 years Java Dev.
github.com/adamldavis
/2019-gr8conf
thesdg.com

Java ~ Brian Goetz (Java Language Architect)

<Insert your
hated language
here>
PHP

groovy-lang.org
sdkman.io
Flat learning curve
Smooth Java integration
Vibrant and rich ecosystem
Powerful features
Domain-Specific Languages (DSLs)
Scripting and testing glue
Inspired by Python, Ruby,
Smalltalk, ...

●
Dynamic or Static
●
(@CompileStatic @TypeChecked)
●
As fast as Java (with static & indy)
●
Meta-programming
●
Optional semi-colons
●
Optional parentheses (command chains)
●
Short-hand for Lists and Maps
●
Automatic getters and setters
●
A better switch
●
Groovy GDK…
Groovy pre-2.5 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 pre-2.5 Features (cont.)

Groovy 2.5
●
Groovy 2.5 added support for JDK9+
●
11 new AST transformations
– @AutoFinal, @AutoImplement, @ImmutableBase,
@ImmutableOptions, @MapConstructor,
@NamedDelegate, @NamedParam,
@NamedParams, @NamedVariant,
@PropertyOptions, and @VisibilityOptions
●
Macro feature - makes writing AST
transformations much easier!

Starting Out
Option 1: Using sdkman.io
– sdk install groovy
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 or methodsz

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)
– Groovy 3: a === 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

Groovy 3
●
Groovy 3 sports a completely rewritten parser
(Parrot) that brings Groovy up to parity with the
latest Java 11 syntax along with new Groovy-only
features. It runs on JDK 8 minimum and has better
support for JDK 9/10/11.
●
Java-style: lambda expressions and method
references, array initialization, and do/while loops
●
Support for try-with-resources and “var”
●
New operators: !in !instanceof

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, JsonSlurper, JsonBuilder, ...

in keyword
●
Use the “in” keyword to test inclusion or loops:
– assert 'Groovy' in ['Java', 'Groovy']
– assert 7 in 0..10
– for (i in 0..10) {}
– for (str in strArray) {}

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
– Example: /d+/ matches any number
●
=~ 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”
● ●
Extension Modules!
●
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
●
Dot notation to call methods… object.”method name”
●
groovy.transform.*
– @EqualsAndHashCode
– @TupleConstructor
– @ToString
– @Canonical
●
Generics not enforced by default
– (use @CompileStatic to do it)

Advanced Groovy
●
Groovy Design Patterns
– Strategy pattern
– Categories
– Method caching
●
DSLs – Domain Specific Languages
– Operator Overloading
– Meta-programming, Extension Modules,
Closures, ...
●
Traits: multi-inheritance

More Groovy
●
Groovy Grapes
– @Grab(group=’’, module=’’, version=’’)
●
Functional Programming
– curry
– Closures, etc.

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
/2019-gr8conf
adamldavis.com
@adamldavis
http://bit.ly/Gr8-2019BG
How? Gedit + https://github.com/aeischeid/gedit-grails-bundle

Learning groovy -EU workshop

More Related Content

What's hot (20)

Similar to Learning groovy -EU workshop (20)

Recently uploaded (20)

Learning groovy -EU workshop