Groovy - przydatne informacje

Filed Under Category Grails, Groovy by radoslaw.holewa

Dzisiaj kilka przydatnych linków dla wszystkich zainteresowanych Groovy:

  • Strona domowa projektu

    • Strona projektu Groovy, znajdziecie tam specyfikację języka, tutoriale i masę linków do różnego typu blogów i portali poświęconych językowi Groovy.

  • Grails

    • Strona domowa najpopularniejszego frameworku webowego napisanego w Groovy

  • Groovy on Grails

    • Agregator blogów o Groovy i Grails.

  • Gradle

    • Narzędzie do budowania aplikacji stworzonych przy pomocy języka Groovy (i nie tylko).

  • GroovyMag

    • Magazyn developerów Groovy, bardzo ciekawy lecz płatny :)

  • Grails Podcast

    • Podcast poświęcony Groovy i Grails.

  • Hosting aplikacji napisanych w Grails

    • Najlepszy hosting aplikacji Grails.

  • Groovy Zone

    • Wydzielona część DZone w całości poświęcona Groovy.

  • Grails Jobs

    • Szukasz pracy jako deweloper Grails? W takim razie ta strona jest warta Twojej uwagi.

  • Groovy Blogs

    • Kolejny agregator blogów o Groovy.

  • Grails Tutorials

    • BARDZO przydatna strona z linkami HOWTO w Groovy i Grails.

  • IntelliJ IDEA

    • Bezsprzecznie najlepsze środowisko do Groovy i Grails.

  • About Groovy

    • Newsy, Podcasty, Książki o Groovy i Grails - wszystko w jednym miejscu.

  • Grails Crowd

    • Szukasz projektów napisanych w Groovy lub Grails? Musisz odwiedzić powyższą stronę.

  • Grails success stories

    • Lista tzw. “success stories” na oficjalnej stronie Grails.

  • Groovy Awards

    • Kto jest najlepszym developerem Groovy? Sprawdź na Groovy Awards.

  • Groovy Live

    • Znacie Try Ruby!? Jeśli tak to czas na Groovy Live, co prawda w chwili obecnej po chińsku ale w niczym to nie przeszkadza :)

December 12, 2008 | 2 Comments 

Grails - wprowadzenie

Filed Under Category Grails, Groovy by radoslaw.holewa

Zapewne część z Was zna przynajmniej ze słyszenia Ruby on Rails. RoR jest frameworkiem, który zdobył uznanie i popularność dzięki świeżemu podejściu do tworzenia aplikacji webowych. Cechą charakterystyczną RoR jest przedkładanie konwencji nad konfigurację, sprowadza się to do tego, że prawie cała struktura aplikacji tworzona jest w oparciu o pewną z góry założoną hierarchię, dzięki temu programista poświęca zdecydowanie mniej czasu na zajmowanie się projektowaniem i konfigurowaniem aplikacji, zyskując w zamian czas na tworzenie właściwego kodu, który ma realizować pewne założenia biznesowe. O samym Ruby on Rails przeczytacie więcej tutaj, ja natomiast zajmę się innym frameworkiem, który wzorowany jest na RoR, a napisany został w Groovym, są nim tytułowe Grailsy.
Grailsy, to podobnie jak Rails’y framework webowy podczas tworzenia którego przewodnią myślą było hasło “Convention over Configuration”.
Dzieki temu Grailsy umożliwiają szybkie tworzenie aplikacji, duża część aplikacji jest automatycznie generowana, a programista jest jedynie zmuszony dostarczyć model danych na podstawie którego zostanie wygenerowana warstwa prezentacji oraz kontrolery.
Grailsy jednak w przeciwieństwie do Ruby on Rails powinny być bliższe programistom języka Java, powodów jest tutaj kilka, wśród nich na uwagę zasługuje fakt, iż zostały napisane w Groovym, a więc języku skryptowym stworzonym z myślą o JVM, integrują się one również mocno ze sztandarowymi frameworkami Javy, a mianowicie Springiem i Hibernate, integracja ta pozwala programistom Java na wykorzystanie posiadanych umiejętności i łatwiejszy start z Grailsami.
Zalet Grailsów jest wiele (wady też się znajdą :P), najlepiej jednak będzie poznać je w praktyce.

Utwórzmy więc pierwszą prostą aplikację, aplikacja ta pozwoli na wprowadzanie notatek przy pomocy interfejsu webowego. Aby przystąpić do działania należy pobrać Groovy’ego i Grailsy, a następnie je zainstalować. Ja proponuję pobrać obie paczki w wersji spakowanej, bez instalatora. Instalacja sprowadzi się wtedy do rozpakowania paczek oraz zdefiniowania zmiennych środowiskowch GROOVY_HOME i GRAILS_HOME.
Gdy już zainstalujecie Groovy i Grails, należy sprawdzić czy są one widoczne w systemie, w tym celu wpiszcie następujące komendy w wierszu poleceń:

Aby sprawdzić wersję Groovyego:

groovy -v

U mnie Groovy wypisał na konsoli:

Groovy Version: 1.5.6 JVM: 10.0-b23

To znak, że jest widoczny w systemie :)

Aby sprawdzić wersję Grailsów:

grails

Tu trochę więcej informacji:

Welcome to Grails 1.0.3 - http://grails.org/
Licensed under Apache Standard License 2.0
Grails home is set to: C:\Progs\grails\grails-1.0.3

No script name specified. Use ‘grails help’ for more info or ‘grails interactive’ to enter interactive mode

Jeśli udało Wam się wykonać obie komendy to możecie przystąpić do napisania aplikacji:

1. Tworzymy strukturę projektu wpisując:

grails create-app notes

gdzie notes to nasza nazwa aplikacji, po wykonaniu komendy zostanie utworzona struktura projektu (w kolejnym wpisie zostanie ona bliżej opisana).

2. Utwórzmy pierwszą klasę, która będzie odpowiadała pojedyńczej notatce (aby to zrobić musicie znajdować się w katalogu aplikacji):

grails create-domain-class Note

Po jej wykonaniu zobaczycie mniej-więcej takie logi:

Welcome to Grails 1.0.3 - http://grails.org/
Licensed under Apache Standard License 2.0
Grails home is set to: C:\Progs\grails\grails-1.0.3

Base Directory: D:\projects\notes
Note: No plugin scripts found
Running script C:\Progs\grails\grails-1.0.3\scripts\CreateDomainClass.groovy
Environment set to development
[copy] Copying 1 file to D:\projects\notes\grails-app\domain
Created Domain Class for Note
[copy] Copying 1 file to D:\projects\notes\test\integration
Created Tests for Note

Nasza klasa jest już gotowa!

3. Dodajmy pola do utworzonej właśnie klasy:

class Note {

  String title
  String description

}

Jest to bardzo prosta klasa, notka będzie zawierała jedynie tytuł i opis.

4. Wygenerujmy pozostałe części aplikacji używając do tego klasy z modelem:

grails generate-all Note

Po zakończeniu wykonania komendy pojawią się logi:

Generating views for domain class Note …
Generating controller for domain class Note …
Finished generation for domain class Note

To znak, że Grailsy zakończyły generację kontrolera i widoków, Wasza aplikacja jest już gotowa!
Czas ją uruchomić:

grails run-app

Wykonanie komendy objawi się podobnymi do poniższych logami:

Welcome to Grails 1.0.3 - http://grails.org/
Licensed under Apache Standard License 2.0
Grails home is set to: C:\Progs\grails\grails-1.0.3

Base Directory: D:\projects\sample\notes
Note: No plugin scripts found
Running script C:\Progs\grails\grails-1.0.3\scripts\RunApp.groovy
Environment set to development
[groovyc] Compiling 2 source files to C:\Documents and Settings\radek\.grails\1.0.3\projects\notes\classes
[copy] Copying 1 file to C:\Documents and Settings\radek\.grails\1.0.3\projects\notes
Running Grails application..
2008-11-04 20:50:50.337::INFO: Logging to STDERR via org.mortbay.log.StdErrLog
2008-11-04 20:50:51.603::INFO: jetty-6.1.4
2008-11-04 20:50:51.743::INFO: No Transaction manager found - if your webapp requires one, please configure one.
2008-11-04 20:50:51.056:/notes:INFO: Set web app root system property: ‘notes-development-0.1′ = [D:\projects\sample\no
tes\web-app\]
2008-11-04 20:50:51.056:/notes:INFO: Initializing log4j from [file:C:\Documents and Settings\radek/.grails/1.0.3/projec
ts/notes/resources/log4j.properties]
2008-11-04 20:50:51.071:/notes:INFO: Initializing Spring root WebApplicationContext
[0] spring.GrailsWebApplicationContext Refreshing org.codehaus.groovy.grails.commons.spring.GrailsWebApplicationContext@
3534c1: display name [org.codehaus.groovy.grails.commons.spring.GrailsWebApplicationContext@3534c1]; startup date [Tue N
ov 04 20:50:53 CET 2008]; parent: org.springframework.web.context.support.XmlWebApplicationContext@1fe1e26
[0] spring.GrailsWebApplicationContext Bean factory for application context [org.codehaus.groovy.grails.commons.spring.G
railsWebApplicationContext@3534c1]: org.springframework.beans.factory.support.DefaultListableBeanFactory@1da5362
2008-11-04 20:50:56.241:/notes:INFO: Initializing Spring FrameworkServlet ‘grails’
2008-11-04 20:50:57.397::INFO: Started SelectChannelConnector@0.0.0.0:8080
Server running. Browse to http://localhost:8080/notes

W powyższych logach widać, iż aplikacja uruchamiana jest za pomocą wbudowanego w Grailsy kontenera servletów Jetty, podczas startu aplikacji inicjalizowany jest również kontekst Springa, widać to w tej lini:

2008-11-04 20:50:51.071:/notes:INFO: Initializing Spring root WebApplicationContext

Spring springiem ale czas zobaczyć naszą aplikację, uruchamiamy w przeglądarce podany na końcu link: http://localhost:8080/notes.

I oto co widzimy:

Jest to domyślny i zarazem główny ekran aplikacji, wyświetla on listę dostępnych kontrolerów, kliknijmi na NoteController i następnie na opcję “Add Note”, a znajdziemy się na ekranie dodawania notki:

Po uzupełnieniu pól klikamy “Create” i naszym oczom ukazuje się lista stworzonych notek z poziomu której możemy przeglądać szczegóły poszczególnych notek (poniżej ekran szczegółów notki):

Właśnie utworzyłeś swoją pierwszą notkę za pomocą samodzielnie napisanej aplikacji w Grailsach!
Prawda, że proste i przyjemne?

Na zakończenie pozostawiam Wam rozpoznanie pozostałych podstron aplikacji, które to składają się na tzw CRUD (Create, Read, Update, Delete) i pozwalają nie tylko na dodawanie i wyświetlanie listy notatek, ale również na ich aktualizowanie i usuwanie.

November 4, 2008 | 2 Comments 

Kilka powodów dla których warto wybrać Groovy’ego

Filed Under Category Groovy by radoslaw.holewa

W poprzednim wpisie rozwodziłem się nad wyborem mojego kolejnego języka programowania. Niezależnie od Waszych opini czy wybór był słuszny, a argumentacja właściwa postanowiłem dziś przedstawić kilka powodów dla których warto zainteresować się językiem Groovy. Ponieważ moim zdaniem przykład jest zdecydowanie więcej wart niż czysta teoretyczna dywagacja, stąd przedstawię kilka przykładów kodu w Groovy które moim zdaniem mogą przekonać Was do poświęcenia większej ilości czasu temu językowi.

1. Pętle

Poniższy przykład wypisuje w kolejnych liniach liczby od 0 do 9:

0.upto(9) {
  println it
}

Liczby te możemy również wypisać w następujący sposób:

10.times {
  println it
}

2. Wypisywanie wartości zmiennych w łańcuchu znaków

Jeśli chcemy wstawić wartość zmiennej w łańcuchu znaków możemy to zrobić w następujący sposób:

1.upto(3) {
  println “Aktualne wywołanie ma numer: ${it}, pozostało jeszcze ${3 - it} wywołań”
}

Wywołanie tego kodu sprawi, że otrzymamy następujący wynik:

Aktualne wywołanie ma numer: 1, pozostało jeszcze 2 wywołań
Aktualne wywołanie ma numer: 2, pozostało jeszcze 1 wywołań
Aktualne wywołanie ma numer: 3, pozostało jeszcze 0 wywołań

3. Closures

Przygotujmy sobie metodę która pozwoli na wykonanie kolejno n jednakowych operacji:

def runOperation( n, operationClosure) {
  1.upto(n) {
    operationClosure(it);
  }
}

A teraz wykonajmy pięciokrotnie wypisanie aktualnej wartości licznika wywołań:

runOperation(5) {
  println it
}

W wyniku otrzymamy:

1
2
3
4
5

4. Operacje na kolekcjach

Zdefiniujmy następującą mapę:

members = [‘Warszawa JUG’ : 268, ‘Polish JUG’: 398]

Wypiszmy teraz liczbę członków na podstawie mapy:

members.each {  key, value ->
  println “${key} ma ${value} członków”
}

W wyniku wykonania powyższego fragmentu otrzymamy:

Warszawa JUG ma 268 członków
Polish JUG ma 398 członków

O proszę, Polish JUG ma już 398 członków!

5. Tworzenie XML

Utwórzmy XML na podstawie zdefiniowanej wcześniej mapy:

builder = new groovy.xml.MarkupBuilder()
builder.jugi{
  members.each{ key, value ->
    jug(nazwa: key, czlonkowie: value)
  }
}

W wyniku wykonania otrzymamy następujący XML:

<jugi>
  <jug nazwa=‘Warszawa JUG’ czlonkowie=‘268′ />
  <jug nazwa=‘Polish JUG’ czlonkowie=‘398′ />
</jugi>

Prawda, że łatwe i bardzo przyjemne?

Oczywiście to nie wszystko, Groovy posiada dużo większe możliwości a przedstawione powyżej przykłady to tylko drobna namiastka tego co może Was spotkać przy zgłębianiu tajemnic tego języka.
Więcej o Groovy i Grails w kolejnych wpisach.

October 31, 2008 | 4 Comments 

Wybór nowego języka programowania

Filed Under Category Grails, Groovy by radoslaw.holewa

Od pewnego czasu myślałem o poznaniu kolejnego języka programowania, przez ostatnie miesiące przyglądałem się kilku: Scala, Ruby, Groovy, Python, C#. Starałem się specjalnie nie szukać języka, który miałby swoją implementację na platformie Java, jednak istnienie takiej implementacji mimo wszystko było istotnym atutem, stąd też początkowy zbiór ograniczyłem do języków powiązanych z platformą Java: Scala, Ruby (JRuby), Groovy, Python (Jython).
Po tym pierwszym etapie selekcji przyszedł czas na przeczytanie artykułów i różnych tutoriali dotyczących wcześniej przedstawionych języków. O ile składnia Groovy’ego jest bardzo zbliżona do Javy, a właściwie to w wielu przypadkach można przekopiować kod Javy do pliku z rozszerzeniem .groovy i uruchomić bez dodatkowych modyfikacji, o tyle poznanie składni pozostałych języków wymagało większego wysiłku, dzięki temu Groovy zapunktował u mnie jako język na naukę którego będę musiał poświęcić mniej czasu :)
Trzeci etap podejmowania wyboru skupiła się na pytaniu: “Czy język ma być dynamiczny?”, po zachwalaniu przez Wiktora Gworka języków dynamicznych postanowiłem dać szansę trójce: Groovy, Ruby (JRuby), Python (Jython).
Wybór już znacznie uproszczony, zostało 3 z 5 :)
Czas na dalszą eliminację… nauka nowego języka powinna być przyjemna, nie jestem tradycjonalistą i zawsze jestem otwarty na nowe propozycje ale w tym wypadku chciałem używać narzędzi do których jestem przyzwyczajony i o których wiem, że są najwyższej jakości, a gwarancję taką dawał mi IntelliJ IDEA, do którego dostępne są dwie firmowane przez JetBrains wtyczki: JetGroovy oraz IntelliJ Ruby Plugin, wtyczka do Pythona również istnieje niestety nie jest ona regularnie aktualizowana… w ten sposób ograniczyłem wybór do Groovy’ego i Ruby’ego.
Nadszedł czas na porównanie frameworków do tworzenia aplikacji webowych, zapewne wszyscy wiedzą, że w świecie Ruby’ego królują Railsy, podobnie jest w przypadku Groovy’ego dla którego głównym frameworkiem webowym są wzorowane na Railsach Grailsy. Obydwa frameworki cechują się podejściem convention over configuration, jednakże cechą która zadecydowała wyborze Grails‘ów jest ich powiązanie ze Spring‘iem i Hibernate. Powiązanie to nie było dla mnie bez znaczenia, oba frameworki są mi znane, oba też stanowią niekwestionowany standard w swoich kategoriach.
Jak więc widzicie, w sposób mniej lub bardziej słuszny wybrałem język za którego rozpoznanie zabrałem się ostatnio, jest nim Groovy. Aktualnie kończę czytać świetną książkę Programming Groovy (zachęcam do wypożyczenia z biblioteczki Polish JUG), której recenzję umieszczę w najbliższym czasie, zapoznałem się również wstępnie z Grails’ami, a nawet stworzyłem swoje pierwsze aplikacje webowe napisane w Grails!
Na koniec chciałem jeszcze dodać, iż spotkała mnie miła niespodzianka dotycząca NetBeans, czyli drugiego środowiska które używam, otóż powstaje plugin do NetBeans pozwalający na tworzenie aplikacji w Groovy i Grails, więcej szczegółów na jego temat znajdziecie na oficjalnej stronie wtyczki.

October 26, 2008 | Leave a Comment