Groovy

• Zainstalować SDKMAN i dodać najnowszą wersję języka
• Uruchomić groovysh lub groovyConsole do szybkich prób
• Napisać pierwszy skrypt i wykonać go poleceniem groovy
• Dodać zależność ad hoc przez @Grab do testu biblioteki
• Połączyć kod z biblioteką Javy i uruchomić na JVM

Groovy: szybki przegląd możliwości i zastosowań

Język powstał, by programistom JVM dać produktywność znaną ze skryptów i jednocześnie zachować bezbolesną integrację z istniejącym kodem Javy. Kluczowe filary to: interoperacyjność klas i bibliotek, zwięzła składnia (listy, mapy, zasięgi, operator Elvisa, bezpieczna nawigacja), bogate rozszerzenia GDK, mocne wsparcie dla DSL, opcjonalna statyczna kontrola typów oraz dojrzały ekosystem narzędzi do testów i automatyzacji. W praktyce oznacza to mniej szablonowego kodu i szybszą pętlę feedbacku.

Na czym polega różnica w ergonomii względem Javy?

Codzienna praca upraszcza się przez konstrukcje, które eliminują boilerplate i zwiększają czytelność. Zwróć uwagę na trzy obszary: składnię kolekcji, łańcuchy i wyrażenia lambda (closures).

// Listy, mapy, zakresy
def nums = [1, 2, 3]
def user = [name: 'Ala', age: 28]
def range = 1..5          // 1,2,3,4,5

// GString i wtrącenia
def who = 'Świat'
println "Cześć, ${who.toUpperCase()}!"

// Closures i metody kolekcyjne
def squares = nums.collect { it * it }.findAll { it > 3 }

// Bezpieczna nawigacja i Elvis
def city = user.address?.city ?: 'brak danych'

Dostęp do właściwości może używać skróconej notacji (person.name zamiast person.getName()), a operator bezpiecznej nawigacji (?.) minimalizuje NullPointerException. Dodatkowo wzbogacone API GDK dodaje metody do klas Javy (np. File.eachLine), co redukuje liczbę pomocniczych konstrukcji.

Jak działa interoperacyjność z ekosystemem JVM?

Kompilator generuje bytecode kompatybilny z JVM, więc można bezpośrednio używać klas Javy, adnotacji i bibliotek. Możliwe jest także odwrotnie – wywoływanie kodu Groovy z Javy, zwłaszcza gdy klasy są skompilowane z typami publicznymi. Dla szybkich prototypów przydaje się mechanizm @Grab (Grape), który pobiera zależności bez konfiguracji projektu build.

@Grab('org.jsoup:jsoup:1.17.2')
import org.jsoup.Jsoup

def doc = Jsoup.connect('https://example.org').get()
println doc.title()

Taki skrypt można uruchomić bez tworzenia plików build, co oszczędza czas w zadaniach typu integracja, ETL czy ad hoc scraping. W większych projektach standardem pozostaje Gradle lub Maven.

Kiedy wybrać kompilację dynamiczną, a kiedy statyczną?

Tryb dynamiczny zwiększa elastyczność i produktywność w skryptach, DSL i kodzie glue. Gdy ważna jest przewidywalność typów i wydajność, używa się @CompileStatic lub @TypeChecked. Tryb statyczny włącza sprawdzanie typów w czasie kompilacji i często poprawia wydajność dzięki minimalizacji wywołań refleksji.

import groovy.transform.CompileStatic

@CompileStatic
int sum(List<Integer> xs) {
  int s = 0
  for (def x : xs) s += x
  return s
}

W praktyce projekty łączą oba podejścia: rdzeń usług i biblioteki kompilowane statycznie, a warstwa skryptów konfiguracyjnych pozostaje dynamiczna. Taki kompromis daje i bezpieczeństwo, i szybkość iteracji.

Jak tworzyć czytelne DSL i automatyzację procesów?

Język oferuje budowniczych (builders), operatory i closures z delegacją, które układają się w czytelny zapis domenowy. To naturalne miejsce dla konfiguracji, pipeline’ów czy opisów zadań. Poprzez ustawienie delegate i strategy w closure można decydować, skąd rozwiązywane są wywołania metod i właściwości.

class Task {
  String name
  List<Closure> steps = []
  def step(Closure c) { steps << c }
  def run() { steps.each { it() } }
}

def task = new Task(name: 'backup')
task.with {
  step { println 'Zrzut bazy' }
  step { println 'Szyfrowanie' }
  step { println 'Wysyłka do S3' }
}
task.run()

Tego typu konstrukcje skalują się od prostych scenariuszy po złożone DSL do przetwarzania danych czy orkiestracji zadań.

Praktyka: jak wejść w środowisko w 10 minut?

Najwygodniej skorzystać z SDKMAN na systemach macOS, Linux i WSL. Po instalacji wpisz:

sdk install groovy
groovy -v
groovysh          // interaktywna konsola

Następnie stwórz plik hello.groovy i uruchom go.

// hello.groovy
println 'Witaj, JVM!'

Wypróbuj też wbudowane narzędzia JSON i plikowe rozszerzenia GDK.

import groovy.json.JsonSlurper
def data = new JsonSlurper().parseText('{"a":1,"b":2}')
new File('out.txt').withWriter('UTF-8') { it << data.toString() }

W IntelliJ IDEA włącz wsparcie dla języka, by mieć podpowiedzi, refaktoryzację i szybkie uruchamianie skryptów.

Jakie rozszerzenia GDK faktycznie przyspieszają pracę?

W praktyce najczęściej używa się: File.eachLine/withReader/withWriter, URL.text do prostych pobrań, operacji na kolekcjach (collect, find, groupBy), Date/Time z dodatkowymi metodami, builderów JSON/XML oraz operatorów przeciążonych dla wyrażeń regularnych i porównań. Zmniejsza to liczbę pomocniczych klas narzędziowych.

Czy język jest dobrym wyborem do testów i CI/CD?

Silną stroną ekosystemu są testy oparte na czytelnych DSL oraz skrypty automatyzacji. Framework Spock dostarcza specyfikacje BDD z potężną parametryzacją i mockowaniem, Geb ułatwia testy przeglądarkowe, a skrypty konfiguracyjne nadają się do definiowania zadań CI/CD i pipeline’ów. Naturalność składni zwiększa czytelność scenariuszy testowych.

// szkic specyfikacji Spock (plik .groovy)
class SumSpec extends spock.lang.Specification {
  def "sumuje liczby dodatnie"() {
    expect:
    a + b == wynik
    where:
    a | b || wynik
    1 | 2 || 3
    3 | 4 || 7
  }
}

Wydajność i koszty utrzymania: jakie są realia?

Tryb dynamiczny dodaje narzut na rozwiązywanie wywołań i refleksję, a start aplikacji zwykle jest nieco wolniejszy niż w czystej Javie. Różnica często nie ma znaczenia w skryptach i narzędziach automatyzujących, natomiast w usługach o wysokich wymaganiach zaleca się @CompileStatic, unikanie nadmiernej dynamiki w krytycznych ścieżkach, profilowanie oraz normalne praktyki JVM (warmup, właściwe parametry GC). Aktualna, wspierana gałąź 4.x współpracuje ze współczesnymi wersjami JDK (np. 11–21) i otrzymuje poprawki bezpieczeństwa.

Jak dbać o jakość: lint, typowanie i kontrakty?

Do kontroli stylu i potencjalnych błędów służy CodeNarc z regułami dostosowanymi do realiów języka. Adnotacje @TypeChecked/@CompileStatic wychwytują błędy typów wcześniej, a adnotacje AST (np. @Immutable, @Canonical) eliminują ręczne pisanie metod pomocniczych i zmniejszają powierzchnię błędów. Testy w Spock łatwo integrują się z JaCoCo i raportowaniem w CI.