Groovy

**Groovy** ([gruːvi]) je objektovo orientovaný programovací jazyk pre platformu Java. Ide o alternatívu k programovaciemu jazyku Java. Možno naň pozerať ako na skriptovací jazyk pre javovskú platformu. Inšpiráciu čerpal z jazykov Python, Ruby, Perl a Smalltalk. Využíva výhody objektového programovania, ale zároveň poskytuje zjednodušenú "skriptovaciu" syntax, ktorá vie "zabaliť a rozbaliť" často opakované časti kódu. Jedným z jeho cieľov je redukovať "povinný" kód a zjednodušiť tak tvorbu webových, databázových či desktopových aplikácií. Kompilácia je vykonávaná priamo do bajtkódu, takže ho môžeme použiť všade tam, kde funguje Java.

## Nastavenie prostredia
Pre vývoj v jazyku Groovy je treba stiahnuť binárnu distribúciu napr. z domovskej stránky. A mať nainštalované vývojové prostredie Java. Potom už len stačí nastaviť niektoré premenné prostredia:
* Pridať GROOVY_HOME premennú na adresár, v ktorom je uložená distribúcia
* Do PATH premennej pridať cestu do adresára GROOVY_HOME / bin
* A nastaviť JAVA_HOME premennú na adresár, v ktorom je JDK.

Následne je možné spustiť groovy shell príkazom groovysh alebo GUI konzolu príkazom groovyConsole.

## Niektoré vlastnosti jazyka Groovy
Jednoduchým príkladom môže byť vypísanie vety "Ahoj, svet!" na konzolu. V Jave je treba okrem samotného príkazu definovať triedu a hlavnú metódu:

```java
class AhojSvet {
    public static void main(String args[]) {
        System.out.println ("Ahoj, svet!");
    }
}
```


Rovnaký výsledok je v jazyku Groovy možné dosiahnuť napríklad nasledujúcim jednoduchým spôsobom:

```java
println "Ahoj, svet!"
```


Takže Groovy doplní všetok ostatný kód (definíciu triedy a hlavné metódy, detaily syntaxe ako sú zátvorky) potrebný pre preklad v Jave. Jednotlivé príkazy nie je potrebné zakončovať bodkočiarkou.

Ďalším zjednodušením je oblasť dátových typov. Dátový typ sa implicitne nadefinuje podľa vloženej hodnoty. A čo viac, v prípade použitia poľa, zoznamu atď. je možné ľubovoľne vkladať rôzne dátové typy ako je to v nasledujúcom príklade:

```java
zoznamČísel = [1776, -1, 33.3333, "pět", 928734928763]
```


Alebo môžeme vytvoriť jednoduchú mapu nasledovne:

```java
výška = ["Martin":190, "Helena":155, "Viera":"Neuviedla"]
```


Groovy častokrát umožňuje viac variant správnej syntaxe, ako v nasledujúcom príklade:

```java
println "Martinova výška je: " + výška.Martin
println "Martinova výška je: " + výška["Martin"]
println "Martinova výška je: ${výška.Martin}"
```


V poslednom riadku je premenná volaná zvnútra zložených zátvoriek kombinácie znakov $ {}, ktoré upozorňujú, že vo vnútri sa nachádza Groovy výraz.

Ďalej môžeme vložiť jednoduchý cyklus na prechádzanie vyššie uvedenej mapy vrátane podmienky pre vypísanie obsahu:

```java
výška.each {
    if (it.value == "Neuviedla") {
        println it.key + " neuviedol/a svoju výšku."
    } else {
        if (it.value < 170) {
            println it.key + " meria menej než 170 cm."
        } else {
            println it.key + " meria najmenej 170 cm."
        }
    }
}
```


Kľúčové slovo it predstavuje automatickú premennú, do ktorej sa ukladá aktuálna hodnota alebo objekt. V tomto prípade je to aktuálny záznam v mape.

V príklade je vidieť aj použitie booleanovských operátorov, ktoré sú podobné ako v Jave a zahŕňajú nasledujúce možnosti:

```java
==
!=
>
>=
<
<=
```


Na rozdiel od Javy však v Groovy operátor == znamená logickú rovnosť pre všetky typy atribútov. V Jave sa napr. pre porovnanie obsahu dvoch atribútov obsahujúcich reťazec musí použiť metóda equals ().

### Closures
Ďalším zjednodušujúcim prvkom Groovy je tzv. "Closure" [kləužə (r)]. V nasledujúcom príklade je vidieť, ako môžeme celú triedu nahradiť jednoduchým closure:

*Trieda*

```java
public class DruháMocnina {
    public static int umocni(int číslo) {
        return číslo * číslo;
    }
}
```


*Closure*

```java
def c = { číslo -> číslo * číslo }
```


V prvom prípade musíme pre vypísanie mocniny čísla zavolať statickú metódu triedy DruháMocnina. U closure je metóda uložená v atribúte c a pre vypísanie mocniny napr. čísla 99 nám stačí nasledujúci príkaz:
 Println c (99)
Atribút, v ktorom je closure uložená, potom môžeme odovzdávať naprieč programom, ako ktorýkoľvek iný atribút.
Closure sa na prvý pohľad podobá klasickému bloku. Blok je však vykonávaný hneď, ako na neho prekladač natrafí. Closure je potrebné explicitne zavolať.

Predchádzajúce closure môžeme definovať ešte jednoduchšie s využitím kľúčového slova it.
 Def c = {it * it}
Premenná "it" v sebe automaticky ukladá parameter, ktorý je pri volaní closure zadaný.

### Práca so súbormi
Relatívne jednoduchá je aj práca so súbormi. Nasledujúcim scriptom vypíšeme na konzolu obsah textového súboru test.txt, pričom každý riadok bude začínať reťazcom Riadok súboru:

```java
soubor = new File("C:\\test.txt")
tlačRiadokSúboru = { println "Riadok súboru: " + it }
soubor.eachLine(tlačRiadokSúboru)
```

V definícii cesty k súboru sú rovnako ako v Jave použité dve lomky, keďže ide o escape sekvenciu.

### GUI
V Groovy je možné využiť všetky triedy z Javovskej knižnice AWT či Swing. Avšak Groovy poskytuje aj svoj vlastný "SwingBuilder", ktorý vie vytvárať plnohodnotné GUI deklaratívnym spôsobom. Využíva pritom tzv. Builders, ktoré sa postarajú o&nbsp;vytváranie komplexných objektov, ako napríklad vytváranie inštancií potomkov či volanie swingových metód. Nasledujúci príklad vytvorí malé aplikačné okno s tlačidlom, ktoré po každom stlačení vypíše súčet všetkých stlačení od začiatku aplikácie.

```java
import groovy.swing.SwingBuilder
import java.awt.BorderLayout as BL

počet = 0
new SwingBuilder().edt {
    frame(title:'Okno', size:[300,300], show: true) {
        borderLayout()
        textlabel = label(text:"Click the button!", constraints: BL.NORTH)
        button(text:'Click Me',
                actionPerformed: { počet++; textlabel.text = "Kliknuté ${počet} krát."; println "kliknuté" },
                constraints:BL.SOUTH)
    }
}
```


## Grails framework
Jedným z frameworkov postavených na Groovy jazyku je Grails framework. Ten umožňuje rýchlejšie vytváranie náročných webových aplikácií. V súčasnosti je tento framework priamo podporovaný napríklad aj vo vývojovom prostredí NetBeans (od verzie 6.8), ktoré sa o väčšinu základnej konfigurácie postará, a tak si môžeme ľahko vyskúšať ukážkové príklady, ktoré v sebe zahŕňa, alebo ktoré sú k dispozícii na domovskej stránke Grails. Samotný vývoj pomocou tohto frameworku je postavený na princípe "Convention over Configuration". To znamená, že vývojár je čo najviac odľahčený od zdĺhavého rozhodovania a konfigurovania, pričom sa však musí uspokojiť s prednastavenou implementáciou.

Grails sa vyznačuje tzv. architektonickým prístupom model-view-controller (MVC). Výsledkom je prehľadne štruktúrovaná aplikácia, ktorá si, aj v prípade veľkej robustnosti, zachováva relatívne jednoduchú obsluhu a modifikovateľnosť.

## Referencie
* portál o jazyku Groovy 
*  domovská stránka frameworku Grails

## Externé odkazy
* Seriál o jazyku Groovy na root.cz

## Zdroj

Kategória:Programovacie jazyky
Kategória:Java (programovací jazyk)