Groovy

Instalacja

1. Ściągnij Groovy 1.0 ze strony http://groovy.codehaus.org/Download (lub lokalnie)
2. Ustaw zmienną środowiskową GROOVY_HOME na katalog, gdzie znajduje się rozpakowana dystrybucja
3. Dodaj GROOVY_HOME/bin do zmiennej PATH
4. Ustaw zmienną JAVA_HOME tak, by wskazywała na JDK
5. Uruchom groovysh (konsola) lub groovyConsole (Swing)

Wtyczka do Eclipse'a

http://groovy.codehaus.org/Eclipse+Plugin

Cechy języka

• println "Hello World!"

  Średnik niepotrzebny. Chyba, że chcemy napisać kilka instrukcji w jednej linii.

  Każda instrukcja do czegoś się wylicza. println wylicza się do null.

• Dynamiczne typowanie: x = 1 println x x = new java.util.Date() println x x = -3.1499392 println x x = false println x x = "Hi" println x
• Mapy i listy definiuje się bardzo prosto: myList = [1776, -1, 33, 99, 0, 928734928763] // int[] a = {1, 2, 3}; - nie zadziala! println myList.size() scores = [ "Brett":100, "Pete":"Did not finish", "Andrew":86.87934 ] // Sposoby dostępu do mapy: println scores["Pete"] println scores.Pete // Przypisanie wartości: scores["Pete"] = 3
• Inna składnia pętli: for (i in 0..len-1) // albo for (i in 0..<len)
• == oznacza jav'owe equals. Tożsamość obiektów sprawdzamy za pomocą metody is.
• return jest opcjonalny.
• Metody i klasy są domyślnie publiczne
• throws nie jest sprawdzane przez kompilator.
• Domyślne importy:
  • java.io.*
  • java.lang.*
  • java.math.BigDecimal
  • java.math.BigInteger
  • java.net.*
  • java.util.*
  • groovy.lang.*
  • groovy.util.*
  Zobacz: Groovy JDK

Closures - programowanie funkcyjne

Jest to anonimowy blok kodu wykonywalnego. Może brać argumenty i zwraca wartość jak funkcja. Może korzystać ze zmiennych widocznych w otaczającym kontekście. Można napisać:

{ square -> square * square }

Składnia: { [closureArguments->] statements } closureArguments to opcjonalna lista argumentów oddzielonych przecinkami. Jeśli zostanie pominięta, będziemy mieli closure jednoargumentową (z dostępem do parametru poprzez nazwę it, np. { println it }).

W Javie należałoby zapisać ten kod w otaczającej klasie i metodzie.

Blok można przypisać na zmienną: def c = { it * it } // domyślny parametr it - zawsze występuje c(2) // zwróci 4 c.call(2) // to samo co wyżej

Przypisaną na zmienną closure można potem przekazać jako parametr: public class GVector extends java.util.Vector { public void apply( c ){ for (i in 0..<size()){ this[i] = c(this[i]) } } } def gVect = new GVector() gVect.add(2) gVect.add(3) gVect.add(4) gVect.apply{ value -> println(value) }

Trochę bardziej złożony przykład: class Employee { def salary } def highPaid(emps) { def threshold = 150 return emps.findAll{ e -> e.salary > threshold } } def emps = [180, 140, 160].collect{ val -> new Employee(salary:val) } println emps.size() // prints 3 println highPaid(emps).size() // prints 2

Zmienne związane z closure są dla niej dostępne nawet, gdy zostanie zwrócona na zewnątrz otaczającego kontekstu.

Przykład: public class A { private int member = 20; private String method() { return "hello"; } def publicMethod (String name_) { def localVar = member + 5; def localVar2 = "Parameter: ${name_}"; return { println "${member} ${name_} ${localVar} ${localVar2} ${method()}" } } } A sample = new A(); def closureVar = sample.publicMethod("Xavier"); closureVar(); The above code will print out: 20 Xavier 25 Parameter: Xavier hello

Closures pochodzą od klasy groovy.lang.Closure. Są tzw. First Class Objects.

Z closure można związać na stałe parametry za pomocą tzw. currying'u, np.:

Jak zdefiniować metodę, która bierze closure?

Można teraz wywołać each() z definicją closure poza nawiasami okrągłymi:

Bardziej tradycyjna składnia jest też dostępna. W Groovy'm można unikać nawiasów w wielu sytuacjach, zatem poniższe kombinację są też dopuszczalne:

Zakresy

Zakresy mogą być także użyte w połączeniu ze switch ... case.

Operator *.

assert [1, 3, 5] == ['a', 'few', 'words']*.size()

Indeksowanie

Dynamiczne obiekty (Expandos)

Jest to obiekt, który nie musi mieć z góry zdefiniowanych właściwości i metod.

Wyrażenia regularne

Groovy wspomaga wyrażenia regularne za pomocą wyrażenia ~wzorzec, które kompiluje się do obiektu Javy Pattern z podanego łańcucha znakowego. Groovy posiada też operator =~, które tworzy obiekt Matcher oraz ==~, który dopasowuje wyrażenie regularne.

Iteracja po String'ach, mapach, listach, ...

Switch'owanie po wszystkim

Operator ?.

Gdy przechodzimy po skomplikowanym grafie obiektów i nie chcemy, by rzucany był NullPointerException, możemy użyć operatora ?. zamiast ..

Grails

Cel

Celem Grails jest zapewnienie podobnego do Rails środowiska, które wygląda bardziej znajomo dla programistów Javy, dzięki czemu przejście do tego środowiska ma być łagodniejsze.

Grails bazuje na technologiach takich jak Spring (MVC), Hibernate (mapowanie obiektów i relacji), SiteMesh (interfejs użytkownika).

Inne elementy, na których opiera się Grails, to Dynamic Tag Libraries, Grails Object Relational Mapping, Groovy Server Pages oraz Scaffolding.

Instalacja

1. Ściągnij Grails ze strony http://grails.codehaus.org/Download (lub lokalnie)
2. Utwórz zmienną środowiskową GRAILS_HOME i ustaw tak, by wskazywała katalog z rozpakowanym archiwum
3. Dodaj do zmiennej PATH katalog bin z katalogu GRAILS_HOME
4. W linii poleceń wpisz grails

Tworzenie projektu

Aby utworzyć projekt należy wpisać w konsoli grails create-app. Grails zapyta o nazwę projektu (w przykładzie będzie to my-project) i utworzy strukturę projektu.

%PROJECT_HOME%
    + grails-app
       + conf                 ---> configuration artifacts like data sources
       + controllers          ---> controller artifacts
       + domain               ---> domain classes
       + i18n                 ---> message bundles for i18n
       + services             ---> services
       + taglib               ---> tag libraries
       + util                 ---> special utility classes (e.g., codecs, etc.)
       + views                ---> views
           + layouts              ---> layouts
   + hibernate              ---> optional hibernate config
   + lib
   + spring                 ---> optional spring config
   + src
       + groovy               ---> optional; location for Groovy source files 
                                   (of types other than those in grails-app/*)
       + java                 ---> optional; location for Java source files
   + war
       + WEB-INF

Grails i Eclipse

Grails automatycznie tworzy Eclipse'owe projekty przy tworzeniu aplikacji.

Bug! Nie należy używać katalogu głównego ani ścieżek ze spacjami.

W Eclipse przejdź do Windows -> Preferences... -> Java -> Build path -> Classpath Variables -> New i dodaj zmienną GRAILS_HOME.

Konfiguracja projektu

Źródła danych

W katalogu grails-app/conf utworzone zostały pliki konfiguracyjne dla źródeł danych. Domyślnie ustawione są na bazę danych HSQLDB działającą w pamięci operacyjnej (zobacz: grails-app/conf/DevelopmentDataSource.groovy).

Jeśli chcemy użyć innej bazy danych, wystarczy zmienić odpowiednie wartości w plikach konfiguracyjnych oraz dodać sterownik bazy danych do katalogu lib projektu.

Domain Classes - encje

Domain class jest to klasa utrwalana w bazie danych. Domyślnie wszystkie jej atrybuty są zapamiętywane.

Aby utworzyć domain class, w katalogu głównym projektu wykonaj polecenie grails create-domain-class. Zostaniesz poproszony o podanie nazwy klasy (wpisz np. Book). Klasa zostanie utworzona w katalogu grails-app/domain.

Można dodać teraz dane testowe. Żeby to zrobić, należy zmienić plik grails-app/conf/ApplicationBootStrap.groovy:

Kontrolery

Kontrolery obsługują zapytania i mapują URL'e.

Aby wygenerować kontroler oraz widok (strony GSP) należy wykonać grails generate-all i wpisać nazwę encji (Book z przykładu). Kontroler zostanie wygenerowany do pliku grails-app/controllers/BookController.groovy. Otwórz ten plik i zmień go w następujący sposób, by wykorzystać dynamiczny scaffolding:

Uruchamianie projektu

• Z linii poleceń

  Wykonaj grails run-app.

• Z Eclipse'a

  

  Z listy Run wybierz opcję Run...

  Z listy przycisku Run wybierz opcję Run.... W Java Applications wybierz Run. Zmiany w projekcie wykonane pod Eclipse'em będą automatycznie ładowane.

Zostanie uruchomiony silnik Jetty na porcie 8080. Aby uruchomić Jetty na innym porcie np. 9090 wpisz -Dserver.port=9090 run-app

Lista książek jest dostępna pod adresem http://localhost:8080/my-project/book/list.

Grails Object Relational Mapping (GORM)

Grails wykorzystuje Hibernate 3, ale nie trzeba nic konfigurować.

Domain Class

Jak widzieliśmy w przykładzie jest to zwykła klasa. W czasie wykonania dostaje jednak dwa dodatkowe atrybuty: id oraz version.

Domyślnie wszystkie atrybuty są obowiązkowe oraz są utrwalane w bazie danych. Aby zmienić to zachowanie, wystarczy stworzyć listy wyjątków w klasie:

Można także ustawić wartości domyślne oraz zmienić nazwę mapowanej tabeli:

Modelowanie związków pomiędzy encjami

• Relacje 1-1

  Poniższy kod utworzy relację jednokierunkową:

  class Face { Nose nose }

  Do tego, by relacja była dwukierunkowa, wystarczy napisać:

  class Nose { Face face }
• Relacje 1-n

  Stwórzmy encję Author. Można być autorem wielu książek.

  class Author { static hasMany = [ books : Book ] String name }

  Nie trzeba nic zmieniać w klasie Book.

• Relacje n-m

  Można je definiować za pomocą hasMany po obu stronach relacji. Przynajmniej jedna ze stron musi mieć atrybut belongsTo, który decyduje o tym, która z encji jest "właścicielem" związku, a więc, która będzie powodowała kaskadę uaktualnień.

  class Book { static belongsTo = Author static hasMany = [authors:Author] } // Author jest 'posiadaczem' związku class Author { static hasMany = [books:Book] } // kaskada spowoduje dodanie nowej książki do bazy danych new Author(..) .addBook(new Book(..)) .save()

  Nie można dodać jednak nowego autora do książki i spodziewać się kaskady.

Walidacja danych

Ograniczenia na dane nakłada się za pomocą closure constraints, np.:

Walidujemy dane za pomocą metody validate(). Domyślnie waliduje także save().

Wprowadzone ograniczenia mają wpływ na generowany widok, np. zamiast pól tekstowych generowane są listy, lub zakresy wartości

Więcej o kontrolerach

Kontrolery można tworzyć automatycznie za pomocą polecenia grails create-controller. Taki sam efekt będzie miało utworzenie kontrolera ręcznie. Mapowanie URL'i jest automatyczne.

Podczas wykonania kontroler dostaje metody i parametry, pozwalające na dostęp do sesji, czy też parametrów żądania a także na logowanie błędów, itp. Pełny spis metod i parametrów znajduje się tu.

Kontekst "Flash" jest to pomysł wzięty z Rails, polegający na wprowadzeniu tymczasowego składu dla atrybutów, które mają być dostępne tylko przy następnym żądaniu. Przykład użycia:

Kontroler powinien zwrócić pewien model, którego używa widok przy renderowaniu strony. Model jest mapą:

Jeśli nie będzie zwrócony żaden model, użyte zostaną atrybuty kontrolera.

Widoki

Widok realizowany jest za pomocą stron GSP lub JSP. Zasadnicza różnica pomiędzy nimi jest taka, że w stronach GSP skryptlety pisze się w Groovy'm oraz dostępne są dodatkowe tagi. Tutaj znajduje się lista dostępnych tagów.

Za podłączenie widoków do kontrolerów odpowiada mechanizm konwencji. Na przykład dla kontrolera:

odpowiedni widok znajduje się w katalogu grails-app/views/book i ma nazwę list.gsp.

Layouts

Układ strony można stosować w Grails poprzez SiteMesh. Polega to na dodaniu tagu meta z nazwą layout:

Layout nazwany main.gsp należy umieścić w katalogu grails-app/views/layouts.