DEV Community: Szymon Stepniak

Groovy 4.0: 10 New Features That Make It AWESOME!

Szymon Stepniak — Thu, 14 Apr 2022 18:52:52 +0000

The latest Groovy 4.0 introduced many interesting features. In this video, I share with you my TOP 10 new features that make the latest Groovy awesome!

Shownotes

Feature #1: Switch Expression

Groovy has always had much more powerful switch statements compared to Java. Class case values, regular expression case values, collection case values, closure case values, or at the end, equal values case. All these options made the switch statement a first-class citizen in the Groovy world. And now, following the latest updates in the Java programming language, Groovy also supports a switch expression. The main difference between a switch statement and a switch expression is that the latter introduces a syntax compatible with Java and returns a value. You can still use a variety of combinations as cases, but the new syntax will make your code a bit more elegant.

switch (value) {
    case null -> 'just a null'
    case 0 -> 'zero'
    case 1 -> 'one'
    case { it instanceof List && it.empty } -> 'an empty list'
    case List -> 'a list'
    case '007' -> 'James Bond'
    case ~/\d+/ -> 'a number'
    default -> 'unknown'
}

Feature #2: Records

Records, a handy immutable "data carrier" type, were introduced in Java 16. Now, they are also available in Groovy. The same syntax, though Groovy also introduces a @RecordType annotation that you can use interchangeably. And even if this is not that a game-changer as it was for Java, it's good to see Groovy heading up with the latest features introduced in its mother language.

record Point(int x, int y) {}

def p1 = new Point(0, 0)
def p2 = new Point(2, 4)
def p3 = new Point(0, 0)

assert p1.x() == 0
assert p1.y() == 0
assert p2.x() == 2
assert p2.y() == 4
assert p1.toString() == 'Point[x=0, y=0]'
assert p2.toString() == 'Point[x=2, y=4]'
assert p1 == p3

Feature #3: Sealed Types

Another feature influenced by the latest changes in the Java programming language. Sealed types allow you to restrict which classes (or interfaces) can extend the specific sealed type. It can be done either explicitly (using the "permits" keyword) or implicitly (without any keyword) if all relevant classes are stored in the same source file. Similar to records, Groovy also introduces the @Sealed annotation that you can use interchangeably if this is your preference. When to use sealed types? Maybe you don't want to allow anyone to extend your class for security reasons. Or perhaps you want to add new methods to the interface in the future, and you want to have strict control over affected subclasses. If that's the case - sealed types might be something you want to look at.

import groovy.transform.ToString

sealed interface Tree<T> { }

@Singleton
final class Empty implements Tree {
    String toString() { "Empty" }
}

@ToString
final class Node<T> implements Tree<T> {
    final T value
    final Tree<T> left, right

    Node(T value, Tree<T> left, Tree<T> right) {
        this.value = value
        this.left = left
        this.right = right
    }
}

Feature #4: Type Checkers

Even though Groovy is mainly known for its dynamic capabilities, it allows you to be much stricter in type checking than Java. The newly added groovy-typecheckers optional module introduces a regex checker that can help you catch errors in your regular expressions at the compile time. Just like in this example - we have a regular expression missing a closing parenthesis. Typically, the compiler cannot detect this kind of issue, so we either find it in the unit test or at the runtime. Here I run this script in the GroovyShell, so I can catch the expected MultipleCompilationErrorsException.

import groovy.transform.TypeChecked

@TypeChecked(extensions = 'groovy.typecheckers.RegexChecker')
def testRegexChecker() {
    def date = '2022-04-03'

    assert date ==~ /(\d{4})-(\d{1,2})-(\d{1,2}/
}

Feature #5: Built-in Macro Methods

Macro methods allow you to access and manipulate the compiler AST data structures. The macro method call looks like a regular method call, but that's not the case - it will be replaced by the generated code at the compile time. Here are a few examples of such macro methods. For instance, the SV method creates a string with variable names and associated values. The SVI one uses Groovy's inspect method, which produces a bit different output - for instance, it does not unroll the range object as shown in this example.

def num = 42
def list = [1 ,2, 3]
def range = 0..5
def string = 'foo'

assert SV(num, list, range, string) == 'num=42, list=[1, 2, 3], range=[0, 1, 2, 3, 4, 5], string=foo'

assert SVI(range) == 'range=0..5'

assert NV(range) instanceof NamedValue

assert NV(string).name == 'string' && NV(string).val == 'foo'

Feature #6: `@Pojo` annotation

If you are familiar with Groovy, you already know that every Groovy class implements the GroovyObject interface. There's nothing to worry about if you only stay with your code in the Groovy ecosystem. But sometimes, you want to use Groovy to write a library code that can be used in a pure Java project as well. You can bring those two worlds together with the new ' @POJO ' annotation. Any class annotated with the @POJO annotation can be used without adding Groovy at the runtime. Just like the PojoPoint class shown in this example. Let's compile it and run it as a Java program.

import groovy.transform.CompileStatic
import groovy.transform.Immutable
import groovy.transform.stc.POJO

@POJO
@Immutable
@CompileStatic
class PojoPoint {
    int x, y

    static void main(String[] args) {
        PojoPoint point = new PojoPoint(1,1)
        System.out.println(point.toString())
    }
}

Feature #7: Groovy Contracts

Groovy contracts might be a blessing if you are tired of writing defensive code. The @Invariant class annotation defines assertions that are checked during an object's lifetime - after the constructor call, before, and after the method call. The @Requires annotation represents a method precondition - an assertion executed before the method call. And the @Ensures annotation works as a method postcondition - an assertion executed after the method call. Some may say that these annotations can be easily replaced by explicit assertions in the method's body. And that's true. But if you want to keep the contract and the business logic nicely separated, Groovy contracts sound like a good place to start.

import groovy.contracts.Ensures
import groovy.contracts.Invariant
import groovy.contracts.Requires

@Invariant({ speed >= 0 })
class Rocket {
    int speed = 0
    boolean started = false

    @Requires({ !started })
    Rocket startEngine() { tap {started = true }}

    @Requires({ started })
    Rocket stopEngine() { tap { started = false }}

    @Requires({ started })
    @Ensures({ old.speed < speed })
    Rocket accelerate(int value) { tap { speed += value }}
}

Feature #8: GINQ

Groovy-Integrated Query language. You will love this feature if you are a fan of SQL-like languages. GINQ allows you to query collections using a SQL-like syntax. Just like in this example. We have a JSON document containing the people field. We use GINQ to find all people that are 18+, in descending order, taking the first three results and modifying the returned data to be upper-cased and limited to the first two letters only. As far as I know, the Groovy team plans to extend GINQ to support SQL databases so that you can write a compile-time generated and type-checked SQL queries.

import groovy.json.JsonSlurper

def json = new JsonSlurper().parseText '''
    {
        "people": [
            {"name": "Alan", "age": 11},
            {"name": "Mary", "age": 26},
            {"name": "Eric", "age": 34},
            {"name": "Elisabeth", "age": 14},
            {"name": "Marc", "age": 2},
            {"name": "Robert", "age": 52},
            {"name": "Veronica", "age": 32},
            {"name": "Alex", "age": 17}
        ]
    }
    '''

assert GQ {
    from f in json.people
    where f.age >= 18
    orderby f.age in desc
    limit 3
    select f.name.toUpperCase().take(2)

}.toList() == ['RO', 'ER', 'VE']

Feature #9: TOML Support

Groovy 3 added YAML format support, and now Groovy 4 adds TOML format support as well. Helpful if you are working with such a format in your codebase. It is worth mentioning that the output produced by the TomlBuilder class does not produce table headers but dot-separated field names instead.

import groovy.toml.TomlBuilder
import groovy.toml.TomlSlurper

String input = '''
# This is a TOML document (taken from https://toml.io)

title = "TOML Example"

[owner]
name = "Tom Preston-Werner"
dob = 1979-05-27T07:32:00-08:00

[database]
enabled = true
ports = [ 8000, 8001, 8002 ]
data = [ ["delta", "phi"], [3.14] ]
temp_targets = { cpu = 79.5, case = 72.0 }

[servers]

[servers.alpha]
ip = "10.0.0.1"
role = "frontend"

[servers.beta]
ip = "10.0.0.2"
role = "backend"
'''

def toml = new TomlSlurper().parseText(input)

assert toml.title == 'TOML Example'
assert toml.owner.name == 'Tom Preston-Werner'
assert toml.database.ports == [8000, 8001, 8002]
assert toml.servers.alpha.ip == '10.0.0.1'
assert toml.servers.beta.ip == '10.0.0.2'


TomlBuilder builder = new TomlBuilder()
builder {
    title 'This is TOML document'
    servers {
        alpha {
            ip '10.0.0.1'
        }
        beta {
            ip '10.0.0.2'
        }
    }
}
assert builder.toString() ==
'''title = 'This is TOML document'
servers.alpha.ip = '10.0.0.1'
servers.beta.ip = '10.0.0.2'
'''

Feature #10: JDK 8 Compatibility

The minimum Java version required to run Groovy 4 is JDK 8. You may ask - "but how does Groovy handle, e.g., records"? Let me show it to you. Here I have Java 17 and Groovy 4.0.1. I'm gonna compile this script to the class file, and when we open it in IntelliJ, we can see that it produces a Java native record equivalent as expected. Now I'm gonna switch to Java 8, and let's do the same thing. When we open the class file in IntelliJ, we can see that now the generated class "emulates" a record behavior but does not use the native record syntax. And that's the beauty of Groovy code portability - the same code and brand new language features that work even with a pretty old Java version.

Source Code

wololock / groovy-4-examples

Groovy 4 Examples

Install the latest Groovy

sdk install groovy

Get SDKMAN - https://sdkman.io/

Run a single script with `groovy` command

cd examples/

groovy 01_basic_switch_expressions.groovy

Run a single script using Gradle

./gradlew -q runScript -PmainClass=01_basic_switch_expressions

Run all scripts using Gradle

chmod +x ./runall.sh

./runall.sh

View on GitHub

Groovy script startup time from 2.1s to 0.013s with GraalVM 🚀

Szymon Stepniak — Fri, 06 Nov 2020 10:27:50 +0000

If you're like me, you use Groovy for scripting automated tasks. I appreciate that I can implement a powerful script executed on JVM in a single file, and I can do it in just several code lines. The only downside is a long startup time - Groovy needs to start the JVM and compile the code before it gets executed. It may not be a problem in most cases. However, if your script does its job in, let's say, 100 milliseconds, spending additional 1.5-2 seconds sounds like a waste of time.

In this video, I explain how to compile a Groovy script (compatible with Groovy 2.x) to the native executable file using Groovy 3 and GraalVM 20.2 (OpenJDK 11)

Source code

wololock / gttp

`gttp` - simple HTTP server in Groovy

Inspired by http://melix.github.io/blog/2019/03/simple-http-server-graal.html

Install Groovy

$ sdk install groovy 3.0.5

Install GraalVM 20.2 (JDK 11)

$ sdk install java 20.2.0.r11-grl

$ sdk use java 20.2.0.r11-grl

$ gu install native-image

Compile `gttp`

$ groovyc --compile-static gttp.groovy

Run `gttp` with `native-image-agent`

$ java -agentlib:native-image-agent=config-output-dir=conf/ -cp ".:$GROOVY_HOME/lib/groovy-3.0.5.jar" gttp

Build native image

$ native-image --allow-incomplete-classpath \
  --report-unsupported-elements-at-runtime \
  --initialize-at-build-time \
  --initialize-at-run-time=org.codehaus.groovy.control.XStreamUtils \
  --no-fallback \
  --no-server \
  -H:ConfigurationFileDirectories=conf/ \
  -cp ".:$GROOVY_HOME/lib/groovy-3.0.5.jar" \ 
  gttp

Run `gttp` as a standalone executable file

$ ./gttp
Listening at http://localhost:8080/

Change default port

$ ./gttp 9000
Listening at http://localhost:9000/

Change default base directory to `/tmp`

$ ./gttp 9000 /tmp
Listening at http://localhost:9000/

Alternative: setup environment & build in a docker container

You can also use attached Dockerfile to install all required components, compile Groovy script to Java bytecode, and generate standalone executable file using native-image tool.

$ sh ./build-with-docker.sh

View on GitHub

Shownotes

Step 0: Install GraalVM and Groovy using SDKMAN!

Install SDKMAN - https://sdkman.io/install
List available Java versions - sdk list java
Install the latest GraalVM - sdk install java 20.2.0.r11-grl (NOTE: version 20.2.0.r11-grl is the latest at the time of writing this article.)
Switch to GraalVM (if not set as default) - sdk use java 20.2.0.r11-grl
Install native-image tool - gu install native-image
Install Groovy 3.0.5 (or other latest) - sdk install groovy 3.0.5
Use installed Groovy (if not set as default) - sdk use groovy 3.0.5

Step 1: Clone `gttp` repository

git clone https://github.com/wololock/gttp.git

cd gttp

Step 2: Run program as a Groovy script

groovy gttp.groovy

Step 3: Compile script using `groovyc`

groovyc --compile-static gttp.groovy

Step 4: Run Groovy script as a Java program

export CP=".:$GROOVY_HOME/lib/groovy-3.0.5.jar"

java -cp $CP gttp

Step 5: Generate GraalVM native-image metadata

java -agentlib:native-image-agent=config-output-dir=conf/ -cp "$CP" gttp

Step 6: Compile Groovy script to the native image

native-image --allow-incomplete-classpath \
--report-unsupported-elements-at-runtime \
--initialize-at-build-time \
--initialize-at-run-time=org.codehaus.groovy.control.XStreamUtils \
--no-fallback \
--no-server \
-H:ConfigurationFileDirectories=conf/ \
-cp $CP gttp

Step 7: Run the program

./gttp

DEV Community: Szymon Stepniak

Groovy 4.0: 10 New Features That Make It AWESOME!

Shownotes

Feature #1: Switch Expression

Feature #2: Records

Feature #3: Sealed Types

Feature #4: Type Checkers

Feature #5: Built-in Macro Methods

Feature #6: @Pojo annotation

Feature #7: Groovy Contracts

Feature #8: GINQ

Feature #9: TOML Support

Feature #10: JDK 8 Compatibility

Source Code

wololock / groovy-4-examples

Groovy 4 Examples

Install the latest Groovy

Run a single script with groovy command

Run a single script using Gradle

Run all scripts using Gradle

Groovy script startup time from 2.1s to 0.013s with GraalVM 🚀

Source code

wololock / gttp

gttp - simple HTTP server in Groovy

Install Groovy

Install GraalVM 20.2 (JDK 11)

Compile gttp

Run gttp with native-image-agent

Build native image

Run gttp as a standalone executable file

Change default port

Change default base directory to /tmp

Alternative: setup environment & build in a docker container

Shownotes

Step 0: Install GraalVM and Groovy using SDKMAN!

Step 1: Clone gttp repository

Step 2: Run program as a Groovy script

Step 3: Compile script using groovyc

Step 4: Run Groovy script as a Java program

Step 5: Generate GraalVM native-image metadata

Step 6: Compile Groovy script to the native image

Step 7: Run the program

Feature #6: `@Pojo` annotation

Run a single script with `groovy` command

`gttp` - simple HTTP server in Groovy

Compile `gttp`

Run `gttp` with `native-image-agent`

Run `gttp` as a standalone executable file

Change default base directory to `/tmp`

Step 1: Clone `gttp` repository

Step 3: Compile script using `groovyc`