Изолированные (sealed) типы, switch-выражения и типы record. Это лишь несколько из новых фич, появившихся в последнем выпуске Groovy 4.0. В этом видео я хочу показать вам десять вещей, которые делают Groovy 4.0 удивительным. Чтобы не делать его слишком затянутым, мы не станем глубоко погружаться в каждую из них. Вместо этого я намерен дать вам краткий обзор новых возможностей.

ℹ️ Репозиторий исходного кода: https://github.com/wololock/groovy-4-examples

Switch-выражение 

В Groovy всегда были гораздо более мощные операторы switch по сравнению с Java. Значения регистра класса, значения регистра регулярного выражения, значения регистра коллекции, значения регистра замыкания или, в конце концов, регистр равных значений. Все эти возможности делали оператор switch объектом первого класса в области Groovy. А теперь, следуя последним обновлениям в языке программирования Java, Groovy также поддерживает и switch-выражение. Основное различие между оператором и выражением switch заключается в том, что последнее использует синтаксис, совместимый с Java, и возвращает значение. Вы по-прежнему можете использовать различные комбинации в качестве регистров, но новый синтаксис сделает ваш код немного элегантнее.

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'
}

Records (Записи)

Records, удобный неизменяемый (иммутабельный) тип "носителя данных", был представлен в Java 16. Теперь он доступен и в Groovy. Синтаксис тот же, хотя Groovy также вводит аннотацию @RecordType, которую можно использовать как взаимозаменяемую. И даже если это не настолько сильно меняет правила игры, как было для Java, все равно приятно видеть, что Groovy идет в ногу с новейшими возможностями, представленными в его родном языке.

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

Изолированные (Sealed) типы

Это еще одна фича, на которую повлияли последние изменения в языке программирования Java. Изолированные типы позволяют вам ограничить, какие классы (или интерфейсы) могут расширять конкретный sealed тип. Это можно сделать как явно (с помощью ключевого слова "permits"), так и неявно (без ключевого слова), если все соответствующие классы хранятся в одном исходном файле. Подобно records, Groovy также вводит аннотацию @Sealed, которую вы можете использовать как взаимозаменяемую, если это вам больше нравится. Когда использовать изолированные типы? Возможно, вы не хотите разрешать кому-либо расширять ваш класс из соображений безопасности. Или, возможно, вы хотите добавить новые методы в интерфейс в будущем, и при этом необходимо иметь строгий контроль над подклассами. Если это так — изолированные типы могут быть именно тем, на что вам следует обратить внимание.

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
    }
}

Средства проверки типов (тайп-чекеры)

Хотя Groovy, в основном, известен благодаря своим динамическим возможностям, он позволяет вам быть гораздо более строгим в проверке типов, чем Java. Недавно добавленный дополнительный модуль groovy-typecheckers представляет регекс-чекер, который поможет вам выявить ошибки в ваших регулярных выражениях во время компиляции. Как в этом примере — в регулярном выражении отсутствует закрывающая скобка. Обычно компилятор сразу не может обнаружить такую проблему, поэтому мы находим ее только во время юнит-теста или рантайма. Здесь я запускаю этот скрипт в GroovyShell, чтобы перехватить ожидаемое исключение 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}/
}

Встроенные макрометоды

Макрометоды позволяют вам получать доступ к структурам данных компилятора AST и манипулировать ими. Вызов макрометода напоминает обычный вызов метода, но это не так — во время компиляции он будет заменен сгенерированным кодом. Вот несколько примеров таких макрометодов. Например, метод SV создает строку с именами переменных и связанными с ними значениями. Метод SVI использует метод Groovy inspect, который выдает немного другой результат — например, он не раскрывает объект range, как показано в этом примере.

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'

Аннотация @POJO

Если вы знакомы с Groovy, то уже знаете, что каждый класс этого языка реализует интерфейс GroovyObject. Здесь нет ничего страшного, если вы остаетесь со своим кодом только в экосистеме Groovy. Однако иногда вы хотите использовать Groovy для написания библиотечного кода, которым можно оперировать и в чистом Java-проекте. Объединить эти две области можно с помощью новой аннотации @POJO . Любой класс, аннотированный @POJO, может быть использован без добавления Groovy во время рантайма. Так же, как и класс PojoPoint, показанный в этом примере. Давайте скомпилируем его и запустим как программу на Java.

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())
    }
}

Контракты Groovy

Контракты Groovy могут стать для вас настоящим благом, если вы устали писать защитный код. Аннотация класса @Invariant определяет утверждения, которые проверяются во время лайфтайма объекта — после вызова конструктора, до и после вызова метода. Аннотация @Requires представляет предварительное условие метода — утверждение, выполняемое перед его вызовом. А аннотация @Ensures работает как постусловие — утверждение, выполняемое после вызова метода. Возможно, кто-то скажет, что эти аннотации с легкостью можно заменить явными утверждениями в теле метода. И это правда. Но если вы действительно хотите, чтобы контракт и бизнес-логика были хорошо разделены, то контракты Groovy — это подходящее решение для начала данного процесса.

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 }}
}

GINQ

GINQ — Groovy-интегрированный язык запросов. Вам понравится эта фича, если вы являетесь поклонником SQL-подобных языков. GINQ позволяет запрашивать коллекции, используя SQL-подобный синтаксис. Как в этом примере. У нас есть JSON-документ, содержащий поле people (люди). Мы используем GINQ, чтобы найти всех людей в возрасте 18+ в порядке убывания, взяв первые три результата и изменив возвращаемые данные так, чтобы они были в верхнем регистре и ограничивались только первыми двумя буквами. Насколько я знаю, команда Groovy планирует расширить GINQ для поддержки баз данных SQL, чтобы вы могли писать SQL-запросы, генерируемые во время компиляции и проверяемые по типу.

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']

Поддержка TOML

В Groovy 3 была добавлена поддержка формата YAML, а теперь в Groovy 4 включена поддержка формата TOML. Это полезно, если вы работаете с таким форматом в своей кодовой базе. Стоит отметить, что вывод, создаваемый классом TomlBuilder, содержит не заголовки таблиц, а имена полей, разделенные точками.

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'
'''

Совместимость с JDK 8

Минимальная версия Java, необходимая для работы Groovy 4, — JDK 8. Вы можете спросить — "но как Groovy обрабатывает, например, записи"? Сейчас я вам это покажу. Беру Java 17 и Groovy 4.0.1. Компилирую этот скрипт в файл класса, и когда мы откроем его в IntelliJ, то увидим, что он создает эквивалент записи на Java, как и ожидалось. Теперь перейдем на Java 8 и проделаем то же самое. Открыв файл класса в IntelliJ, можно увидеть, что теперь сгенерированный класс "эмулирует" поведение записи, но при этом не использует ее родной синтаксис. И в этом вся прелесть переносимости кода Groovy — тот же код и совершенно новые возможности языка, которые работают даже на довольно старой версии Java.

Приглашаем всех желающих DevOps-инженеров и Java-разработчиков на открытое занятие «Настройка пайплайнов в Jenkins 123». На занятии посмотрим на пайплайны в Jenkins: из каких шагов и блоков состоят; научимся писать groovy скрипты для создания пайплайнов и изучим их составные части. Регистрация открыта по ссылке.