Aneb jak a proč Groovy

autor: Václav Pech

Nedávno jsem měl možnost seznámit se s
programovacím jazykem Groovy a musím říct, že mě
nadchl. V tomto článku bych se rád podělil o své
dojmy s ostatními vývojáři, pokusil se vysvětlit, co
zajímavého přináší programovací jazyk Groovy do světa
Javy a proč stojí zato se o Groovy něco dozvědět. Jde
o volné a nenáročné úvodní představení filozofie a
principů Groovy, včetně několika motivačních ukázek
kódu, bez snahy o absolutní úplnost.

Osoby vystupující v příběhu a jejich jména jsou
smyšlené, případná podobnost s žijícími i nežijícími
osobami je veskrze náhodná. Ukázky kódu použité v
příběhu jsou pravé a funkční.

Stalo se jednoho nedávného dne v
jedné softwarové společnosti (záznam z IM historie)

Franta: Čau, jak je?

Bohouš: Nazdar! Prima, a co Ty?

Franta: Pohoda. Máš chvilku?
Potřeboval bych trochu helpnout.

Bohouš: O co 'de? Včera jsme
releasovali, tak mám teď celkem volno.

Franta: Rozjíždím nový projekt a
hodil by se mi někdo, jako jsi ty. Nejdřív bys nám
mohl napsat v Groovy takový …

Bohouš: Aha?! No to bude asi
problém, o Groovy nic nevím.

Franta: To se rychle naučíš, je
to pohoda.

Bohouš: Přece nebudu na starý
kolena utíkat od Javy!

Franta: Jak utíkat? Groovy je
budoucnost Javy.

Bohouš: Loni to na mě zkoušel
Pepa, že prý Ruby je budoucnost.

Franta: To měl docela pravdu.

Bohouš: Houby pravdu, vůbec jsem
tomu jeho kódu nerozuměl, taková náhodná změť znaků.
S Javou to neintegruje, na JBossu to nepustíš, žádné
pořádné IDE to nemá, prostě všechno znova, jak když
jsem začínal s Javou někdy v minulým století.

Franta: Ruby se rychle vyvíjí,
teď už s Javou docela integruje a i ta IDEčka už
jsou. Poslechni si CZ podcast číslo 15.

Bohouš: OK, ale ty po mně chceš
Groovy.

Franta: Groovy je takové
"Ruby v Javě". Syntaxe Groovy je
nadmnožinou syntaxe Javy, tedy zatím s několika málo
výjimkami, ale to se brzy spraví. Takže můžeš dál
psát Java kód, akorát to ukládáš do .groovy souborů a
je z tebe Groovy junior!

Bohouš: Fajn, ale to asi nebude
stačit pro ten tvůj projekt, co?

Franta: Groovy syntaxi se můžeš
učit postupně. Pro Java vývojáře je to celkem snadná
cesta do světa dynamických jazyků.

Bohouš: A co integrace s
existujícím Java kódem?

Franta: Bez obav. Groovy kód
můžeš normálně míchat s Java kódem v jednom projektu,
z Groovy volat Javu, z Javy volat Groovy, extendovat
či implementovat napříč oběma jazyky. Samozřejmě máš
v Groovy k dispozici celé známe JDK, přilinkovat
můžeš Java knihovny, takže dál klidně používej log4j,
hibernate, spring, prostě co chceš a na co jsi
zvyklý. Knihovny se nemusí přepisovat pro Groovy. OK?

Bohouš: OK. A co JBoss?

Franta: Groovy kompiluje do Java
bytecode, klidně piš Groovy i pro EE aplikačky.
Například v Seam 2.0 můžeš teď psát komponenty v
Groovy.

Výhody syntaxe Groovy

Bohouš: Takže s Groovy můžu
krásně žít uvnitř Java světa, ale proč tedy jiná
syntaxe?! Já v Javě napíšu všechno. Nevidím důvod,
proč bych potřeboval nový jazyk. Abych ušetřil pár
řádků kódu? Dneska ti všechna IDEčka kompletují nebo
generují kód, ani nemají problém nepotřebné části
schovat.

Franta: Koukni na tohle:

    company.employees.grep{it.age > 30}.name

Odhadneš, co ten kód dělá? Napovím ti, že kód ve
složených závorkách se nazývá closure a technicky je to
metoda předaná jako parametr metodě grep.
Identifikátor označený it zastupuje v kódu
closury její jediný parametr.

Bohouš: Vyjede všechny starouše
ve firmě, tedy jejich jména.

Franta: No, fajn. Ten kód jasně
říká, co dělá, ne jak to dělá. Takové traverzaci přes
několik objektů a kolekcí v Groovy se říká GPath. Jak
bys to napsal v Javě?

Bohouš: Jednoduše. Iteroval bych
přes ty employees, u každého bych vyhodnotil podmínku
na age a případně ho přidal do resultu.

Franta: Takže nějak takhle:

    final List result=new ArrayList();

    for (final Employee employee : company.getEmployees()) {

        if (employee.getAge()>30) result.add(employee.getName());

    }

Bohouš: No, konečně pěkný kus
kódu.

Franta: Jenže v Groovy by stačil
jeden řádek.

Bohouš: No co, 3x delší.

Franta: Statisticky to vychází
tak 3x – 4x delší v Javě než v Groovy.

Bohouš: Většinu toho kódu ti
stejně nageneroval editor.

Franta: To u toho Groovy kódu
taky.

Bohouš: Kdes na to vzal editor?

Franta: Normálně stáhni plugin
do Eclipse, IDEy nebo NetBeans a můžeš začít.

Bohouš: Počkej, ještě jsem nic
neslíbil.

Franta: Dobře, tak budu
pokračovat v masáži.

Masáž kódem

Bohouš: Skončili jsme u toho, že
editor mi stejně nageneruje většinu toho balastu
kolem, takže mě tolik netrápí, že je Groovy kód
kompaktnější 3x.

Franta: … až 4x.

Bohouš: Klidně 10x, to pro mě
není argument.

Franta: Ale měl by být. Kód
napíšeš jednou, ale potom ho stokrát znovu čteš,
hledáš v něm chyby a ladíš. Nebo třeba někdo jiný to
musí časem pochopit a z různých důvodů upravit. Kód
se píše pro lidi.

Bohouš: Oukej.

Franta: Koukni na tohle:

Jednoduše zapsaný cyklus

    10.times{print 'Huh'}

Násobení stringů pomocí standardně přetížených
operátorů, vypíše aaabb

    String text='a'*3+'b'*2

Třída String v Groovy umí iterovat přes všechny
znaky a na každý zavolat dodaný kód v podobě closure.
Vypíše daný text převedený do upper-case.

    '''

    multi-line text

    which will be printed

    in upper case

    '''.each {print it.toUpperCase()}

Práce s kolekcemi, pro úplnost uvedu, že assert
vyhodnocuje pravdivost podmínek

    ["Joe", "Dave"].each {println it}                                   //vypíše všechny položky pole

    assert ["Joe", "Dave"][0] == "Joe"                                  //první položka pole

    assert ["Joe", "Dave", "Martin"][1..2] == ["Dave", "Martin"]        //docela efektní způsob zápisu výběru části pole

Přidávání do seznamu

    company.employees << new Employee(name:"Bohouš", age:28, status:"junior")

    nebo

    company.employees += new Employee(name:"Bohouš", age:28, status:"junior")



Bohouš: Hezký, ale už jsem
senior.

Franta: Tak sorry.

Bohouš: A co odebírat ze
seznamu, umíš?

Franta: Jo.

    company.employees -= bohous

Bohouš: Proč do toho
konstruktoru předáváš parametry přes jména, např.
'age:28'? To je nutný?

Franta: Není, klidně to dělej
jako do teď v Javě, ale takhle máš možnost zadat jen
některé parametry a nemusiš kvůli tomu definovat
milióny konstruktorů s různými sadami parametrů, nebo
předávat null, když nechceš některý z parametrů
zadávat.


Teď ti ještě ukážu, jak jsou mapy a kolekce
podporovány přímo na úrovni syntaxe jazyka.

    Map map=["joe":10, "dave":12]

Dva různé způsoby přístupu k položkám v mapě

    assert map["dave"] == 12

    assert map.dave == 12

Dva různé způsoby nastavení hodnot položek v mapě

    map.dave = 20

    assert map.'dave' == 20



    map['dave'] = 30

    assert map.'dave' == 30

Groovy přidává nové metody k třídám v JDK, včetně
přetížení operátorů, hlavně ke stringům, číslům,
kolekcím či polím.


Podívej třeba na datumy, tohle v Javě na jeden řádek
nenapíšeš:

    use (TimeCategory) {

        println "Tomorrow: ${1.day.from.today}"



        println "A week ago: ${1.week.ago}"



        println "Date: ${1.month.ago + 1.week + 2.hours - 5.minutes}"

    }

Kolekce toho taky umí hodně navíc, třeba jejich
metody any a every stojí za povšimnutí.

    if (company.employees.any {it.status == 'junior'}) offerTrainingTo(company)



    if (company.employees.every {it.status == 'senior'}) hireForNextProject(company)

Tomuhle vnořování Groovy do Stringů se říká
GString, uvnitř těch složených závorek můžeš psát
libovolný Groovy kód.

    String employeeDescription="Employee ${employee.name}, ${employee.age} years old"

Takový přehlednější substring, všimni si toho
negativního indexu na konci (vrátí string od nulté
pozice do páté pozice od konce).

    //Vytáhne jméno souboru bez přípony

    String fileNameWithoutExtension='tomcat_log_2007_07_10_02x_demo.log'[0..-5]

Regulární výrazy jsou zabudovány přímo do Groovy…

    if ('abcabcabc' ==~ /(abc)+/) {

        println "Je to tam"

    }

… a můžem třeba hned kouknout, jestli se někde na
webu nepíše o Groovy nebo Ruby:

    ['http://www.javalobby.org', 'http://www.theserverside.com', 'http://www.infoq.com'].each {address ->

        [/Groovy/, /Ruby/, /Grails/, /Rails/].each {pattern ->

            if (new URL(address).text =~ pattern) {

                println "O $pattern se píše na $address"

            }

        }

    }

Bohouš: Prima

Buildery

Franta: Taky tě možná zaujme,
jak se v Groovy pracuje s XML. Třeba vytvoření nového
XML dokumentu pomocí Markup Builderu.

    def writer = new StringWriter()

    def xml = new MarkupBuilder(writer)



    xml.invoice() {

        customer() {

            name('Ferda')

            address(type:'Delivery') {

                street('Pod dubem')

                number('10')

            }

            address(type:'Billing') {

                street('Za dubem')

                number('20')

            }

        }

        product(id:'00001') {

            quantity(50)

        }

    }

    println writer.toString()

A jak bude vypadat výsledný XML dokument…?

Bohouš: No, myslím, že je to
zřejmé.

Franta: Buildery jsou užitečné
na práci se stromovými datovými strukturami, třeba v
podobě XML dat, HTML dokumentů, nebo třeba GUI
komponent. Díky tomu potom struktura kódu pracujícího
s hierarchickou datovou strukturou odpovídá vizuálně
i logicky té manipulované struktuře. To samozřejmě
vede k menšímu počtu chyb při psaní a snazšímu
pochopení a úpravám kódu později. Několik takových
builderů budeme potřebovat nadefinovat v tom našem
projektu pro naše vlastní data.

Closures

Bohouš: Ještě něco??

Franta: Třeba properties – getry
a setry pro property se ti vytvoří až za runtime,
pokud je nepotřebuješ upravit vlastním kódem.

Bohouš: To bude v Javě 7 asi
taky.

Franta: Je na čase. Taky by v ní
měly přibýt closures.

Bohouš: To už v Groovy je, že?

Franta: No jasně, s nimi se to
teprve pěkně rozjíždí.

    def triple = {x -> x * 3}              //definice closury ztrojnásobující svůj jediný parametr

    {[1, 2, 3].collect {triple(it)}        //vrátí nový seznam se všemi hodnotami ztrojnásobenými

Closury můžeš ukládat do proměnných nebo fieldů, a tak
změnou closury za běhu změnit chování objektů. Nebo
můžeš fixovat hodnotu některých parametrů closury
pomocí metody curry() a vytvořit tak novou closuru s
upraveným chováním.

    def multiply = {x, y -> x * y}         //obecné násobení dvou čísel

    assert 6 == multiply(2, 3)

    def triple = multiply.curry(3)         //definice nové closury ztrojnásobující svůj jediný parametr, něco jako {3, y -> 3 * y}

    [1, 2, 3].collect() {triple(it)}       //vrátí nový seznam se všemi hodnotami ztrojnásobenými

Bohouš: Paráda.

Franta: To tedy jo.

Shrnutí

Bohouš: Takže z toho, co's
řekl, vyplývá, že Groovy:

  • integruje do Javy, včetně EE,
  • umožňuje využívat všechny existující Java
    knihovny, včetně JDK samotného,
  • obaluje standardní třídy z JDK, zvláště čísla,
    datumy, stringy a kolekce novou funkcionalitou,
  • rozšiřuje syntaxi Javy o podporu properties,
    closures, named parametry a snadnou práci se
    seznamy a mapami,
  • regulární výrazy jsou standardní součástí
    jazyka,
  • GString dovoluje vkládat Groovy kód do stringů,
    což umožňuje definovat vlastně takové jednoduché
    šablony,
  • pro hierarchické datové struktury Groovy nabízí
    koncept builderů, s před-připravenými buildery pro
    XML, HTML, Swing a stromy,
  • nabízí GPath pro snadné traversování mezi
    objeky, včetně kolekcí,
  • zahrnuje ranges (např. 2..5)
    jako samostatný datový typ.

Franta: Přesně. Ještě jsme se
nepustili do několika pokročilejších věcí, třeba:

  • vytváření custom builderů pro vlastní
    hierarchická data,
  • integrovaná práce s textovými šablonami,
  • groovlets pro rychlý vývoj webovských aplikací,
  • práce s relačními databázemi,
  • meta-programming – dynamické vyvolávání metod a
    možnost definovat metodu či celou třídu za běhu,
  • přidávání metod k existujícím knihovním Java a
    Groovy třídám,
  • vytváření interních DSL (Domain Specific
    Language),
  • a ještě pár dalších věcí, na které jsem
    zapomněl.

Pokud budeš mít chuť, můžeš mrknout na tyhle linky:

Franta: Tak co, je Groovy žúžo?

…

…


Poznámka: Groovy neboli
zaběhnutý, zaběhaný, rutinní, prima, bezva, fajn,
žúžo.