Wprowadzenie do Grails

W niniejszym artykule chciałbym przedstawić framework Grails na praktycznym przykładzie bazującym na mechanizmie generowania aplikacji na podstawie modelu (scaffolding). Krok po kroku skonfigurujemy środowisko do pracy i uruchomimy naszą pierwszą aplikację. Będzie to stan wyjściowy do dalszej pracy z Grails.

Czym jest Grails

Grails to framework oparty na języku Groovy. Wprowadza on w życie zasadę "konwencji ponad konfigurację". Dynamiczność Groovy wraz z łatwą integracją z rozwiązaniami Java (w końcu korzystamy z tej samej maszyny wirtualnej) pozwalają nam na naprawdę szybkie tworzenie aplikacji i to nie tylko prototypowej, ale w pełni działającej. Dokładając do tego DSL (Domain Specific Language) otrzymujemy doskonały zestaw do pracy. Warto wspomnieć też, że Grails to nie wymyślanie koła od nowa. O ile można zauważyć szereg podobieństw do innych frameworków (nie tylko Java), o tyle pod maską Grails znajdziemy powszechnie stosowane rozwiązania: Spring, Hibernate, Jetty, HSQLDB, SiteMesh. Krzywa uczenia (ang. Learning Curve) jest w tym wypadku bardzo korzystna dla praktycznie każdego programisty Java, niezależnie od doświadczenia i umiejętności. Sprawdźmy to w praktyce, do dzieła.

Pierwsza aplikacja

Aby rozpocząć pracę z Grails musimy najpierw poświęcić chwilkę na przygotowanie środowiska. I tutaj miłe zaskoczenie, ten proces naprawdę zajmuje chwilkę. Co potrzebujemy? Na początek proponuję wykorzystać Netbeans 6.5 oraz Grails 1.1. Taki zestaw da nam praktycznie gotowe środowisko do pracy bez potrzeby dodatkowych instalacji i konfiguracji. Pobieramy NetBeans 6.5 (http://netbeans.org) oraz Grails 1.1 (http://grails.org). NetBeans posiada domyślnie możliwość tworzenia projektów Grails. Natomiast sama paczka z Grails, oprócz framework'u i Groovy, zawiera również serwer Jetty, bazę danych HSQLDB oraz wszelkie potrzebne biblioteki (m. in. Hibernate, Spring, SiteMesh). Po zainstalowaniu NetBeans i rozpakowaniu Grails w dowolnej lokalizacji jedyne co musimy zrobić to wskazać w NetBeans gdzie znajduje się Grails. W menu wybieramy Tools -> Options, zakładka Miscellaneous -> Groovy, a tam w pole Grails Home wpisać odpowiednią lokalizację.

Po przygotowaniu środowiska czas utworzyć nasz pierwszy projekt. Wybieramy z menu File -> New Project..., a następnie Groovy -> Grails Application. Jako nazwę projektu podajemy AddressBook (zrobimy sobie małą bazę adresów). Klikamy Finish i gotowe. Nasz pierwszy projekt Grails czeka na uruchomienie. W tym momencie możemy już uruchomić nasz projekt (przycisk Play lub [F6]). Zobaczymy ekran powitalny, który pozwoli się nam upewnić, że wszystko zrobiliśmy dobrze.

Przejdziemy teraz do implementacji naszej książki adresowej. Na początek zajmiemy się utworzeniem modelu. W Grails klasy modelu nazywane są klasami domenowymi. Klasa domenowa to obiektowa reprezentacja naszego bytu z bazy danych. Z menu kontekstowego projektu wybieramy New -> Grails Domain Class..., podajemy nazwę Contact i zatwierdzamy przyciskiem Finish. W folderze grails-app/domain została utworzona klasa Contact.groovy. W niej możemy zdefiniować właściwości charakteryzujące nasz kontakt z książki adresowej. Dla uproszczenia przykładu zdefiniujemy 4 właściwości: name, phone, email oraz address. Nasza klasa powinna wyglądać jak na listingu.

	class Contact {
            String name
            String phone
            String email
            String address
 
            static constraints = {
            }
        }

Ponieważ Grails wykorzystuje wzorzec MVC, do stworzenia działającej aplikacji potrzebujemy stworzyć jeszcze kontroler, który będzie obsługiwał naszą aplikację. W tym celu z menu kontekstowego projektu wybieramy New -> Grails Controller..., podajemy Contact jako nazwę i zatwierdzamy przyciskiem Finish. W katalogu grails-app/controllers została utworzona klasa ContactController.groovy (na pewno zauważyliście już, że NetBeans ładnie prezentuje te foldery jako Controllers i Domain Classes dla klas domenowych). Utworzony kontroler posiada domyślnie akcję index, jednak na ten moment będziemy chcieli skorzystać z dobrodziejstwa Grails jakim jest scaffolding.

Scaffolding można przetłumaczyć jako rusztowanie. Opcja ta pozwala nam na wygenerowanie interfejsu użytkownika i logiki do wykonywania podstawowych operacji CRUD na naszych danych (Create, Read, Update, Delete). W tym celu potrzebujemy zmodyfikować nasz kontroler, aby wyglądał tak jak na listingu.

	class ContactController {
            def scaffold = true
        }

Teraz jesteśmy gotowi do ponownego uruchomienia naszej aplikacji (przycisk Play lub [F6]). Tym razem powinniśmy zobaczyć stronę powitalną z wypisanymi wszystkimi istniejącymi kontrolerami. W naszym wypadku będzie to tylko ContactController. Po wybraniu kontrolera powinniśmy zobaczyć pustą listę kontaktów, a także ikonkę pozwalającą nam na dodanie nowego kontaktu. Śmiało możemy to wypróbować. Nasza aplikacja nie należy jeszcze do najbardziej rozbudowanych, ale jest już w pełni funkcjonalna. To co rzuca się od razu w oczy, to brak walidacji danych. Możemy tutaj skorzystać z wbudowanego mechanizmu walidacji danych, który doskonale pracuje z mechanizmem scaffolding. Do deklaracji ograniczeń na danych wykorzystamy sekcję constraints w naszej klasie domenowej. Służy ona do określenia nie tylko jakie wartości mogą być przyjmowane przez poszczególne właściwości, ale również do określenia ich kolejności w wygenerowanej aplikacji. Nasza sekcja contraints powinna wyglądać jak na listingu.

        static constraints = {
            name(blank:false)
            phone(matches:"^\\+*\\d+")
            email(email:true)
        }

Kolejność właściwości w tej sekcji zostanie odwzorowana na ekranach wyświetlania szczegółów rekordu, na liście, a także w formularzach dodawania i edycji. Dla właściwości name określiliśmy, że nie może być ona pusta. Należy zapamiętać, że blank stosowane jest dla właściwości tekstowych i określa, czy dana właściwość może być pustym łańcuchem. Istnieje też ograniczenie nullable, jednak określa ono czy dana właściwość może przyjąć wartość null, tak więc może być stosowana nie tylko dla łańcuchów tekstowych. Domyślnie Grails nie pozwala żadnej właściwości na przyjęcie wartości null. W przypadku właściwości phone do walidacji wykorzystujemy wyrażenie regularne (opcjonalny plus na początku "^\\+*" a następnie jedna lub więcej cyfr "\d+"). Dla pola email wykorzystujemy wbudowaną walidację adresów email. Zwykłe adresy pozostawiamy tak jak są, dlatego nie umieszczanych ich w sekcji contraints (chyba, że chcielibyśmy określić ich kolejność inaczej niż domyślna). Po ponownym uruchomieniu aplikacji możemy przetestować naszą walidację. Komunikaty błędów walidacji nie będą może najczytelniejsze na świecie, w szczególności dla numeru telefonu, ale walidacja będzie działała poprawnie.

Gdzie dalej?

Grails i Groovy stały się ostatnio niezwykle modne, więc wszyscy zainteresowani na pewno nie będą mieli problemu ze znalezieniem ciekawej lektury, ciekawych eksperymentów innych programistów, a także wielu wskazówek i dodatków. Poniżej krótka lista odnośników, która może posłużyć jako dobry start:

Oficjalna strona Grails – http://grails.org

Oficjalna strona Groovy - http://groovy.codehaus.org/

Notatnik Jacka Laskowskiego – http://jaceklaskowski.pl

Stronice Chlebika - http://chlebik.wordpress.com/

Wszystkich chętnych do dyskusji zapraszam na swojego bloga, http://tech.mrozewski.pl, gdzie można znaleźć trochę informacji na temat Grails, a także bezpośredni kontakt do mnie.

Wydrukuj