niedziela, 12 stycznia 2014

Gradle - Twoja alternatywa w drodze do doskonałych buildów (wprowadzenie)



Ok.
Poznajmy mistrza budowy - gradle.
Książki (baza wiedzy)
 - Gradle effective implementation guide
 - Gradle beyond the basic
 - Building and testing with gradle
 - Gradle in Action (MEAP)


Gradle (imperatywny a zarazem deklaratywny)

Ale do cholery co oznacza język imperatywny ? Oznacza jedynie tyle, że musimy formułować zadanie, przepis. Ty jako programista musisz poinstruować komputer w jaki sposób ten 'baran' ma to zrobić. Mimo tego, że wymaga to więcej wysiłku daje Ci więcej swobody.
Można agregować zadania w jeden wielki task (np tak jak w Antcie).

Natomiast w języku deklaratywnym programista opisuje warunki, jakie musi spełniać końcowe rozwiązanie, a nie szczegółową sekwencję kroków, które do niego prowadzą. Programowanie deklaratywne często traktuje programy jako pewne hipotezy. (np jak w Maven). Możemy wyodrębnić również  następujące jego cechy jak:
 - niezależność
 - bezstanowość
 - deterministyczność


Dla mnie gradle to taki sprytny złodziej :
Zobaczmy co podpierdolił od innych (a oto fakty Wysoki Sądzie):
  Ant:
     - elastyczność
     - pełna kontrola
     - wywoływanie targetów w łańcuchu
     - tworzenie tasków
 Ivy:
   - zarządzanie zależnościami
   - wykorzystuje jego repozytoria
Maven:
  - Convention over configuration
  - Multi-module projects
  - rozszerzalność poprzez pluginy
  - wykorzystuje jego repozytoria
Gant
  -opakowanie kodu Anta w DSL za pomocą języka groovy











Instalacja, Konfiguracja :

GRADLE_OPTS="-Xmx1024m"
GRADLE_HOME="/opt/gradle"

gradle -v - sprawdzamy czy działa, zaraz po instalacji. Wyświetlenie wersji.

Moje pierwsze spostrzeżenia :
 - najbardziej zwięzły
 - brak XML
 - DSL
 - maven , ivy repo

Jak dla mnie do już bardzo fajnie na sam początek.
Szczególnie cieszy mnie DSL. Jeśli używałeś kiedyś Camela, QueryDSL ewentualnie Fest Assert to wiesz o czym mówię.

Wszystko sprowadza się do edytowania i tworzenia pliku build.gradle.
To jest nic innego jak wykonywalny skrypt Groovy'iego.
Tworząc każdego taska stopniowo poznajesz właśnie język Groovy.
Poznasz Groovy'iego zobaczysz, że niektóre rzeczy można zrobić lepiej i szybciej niż w javie (boilerplate code).


Porównajmy go z mavenem

Przykład w maven (minimum) :

Przykład w gradle (minimum):
 
Różnice:









Komendy

gradle  -gui - pokazuje nam jakie taski możemy wykonać. Wystarczy kliknąć.




















gradle --help - wyświetla dodatkowe opcje.

gradle tasks - wyświetla dostępne taski.
Sam plugin java daje następujący wydruk:
gradle install


-Dproperty=value - definiuje zmienna nową zmienną systemową

--info, -i - ustawia poziom logowania

--debug, -d - przełącza na poziom debug , włączając w to stacktrace (przykład)

--quiet, -q - pomija większość outputów na konsoli, pokazuje tylko błędy

dependencies - pokazuje zależności i ich zakresy


gradle [task_name] - wykonuje taska o nazwie [task_name]

gradle -x first second -  pomija pierwszy task (x) 
(definiowanie kolejności wywoływania : second.mustRunAfter(first)  )

gradle fi - domyśla się, że chodzi  o task first. (fi)

gradle -m second - nie wykonuje żadnego taska ale informuje co potencjalnie by wykonał (-m)

gradle [task] --profile - profilowanie taska


















































Budowa skryptu (wybrane cechy):

przykład:

dependsOn - zależności w łańcuchu wywołań

repositories - definiujemy repozytoria np mavena
Mamy dostępne następujące opcje:
 - maven repository (zdalna maszyna lub system plików)
 - maven central repository (centralne repo mavena)
 - maven local repository (lokalne repo mavena)
 - ivy repository (ivy repo na lokalnym lub zdalnym komputerze)
 - flat directory repository (proste repo na lokalnym systemie plików, lub jako zasób sieciowy)
Lifecycle:
   - initialization (determinuje, które projekty wejdą w skład builda)
   - configuration (poskłada wszystkie buildy w całość)
   - execution (zdecyduje, które podzbiory tasków mają być wykonywane)

Scope :
         compile
        - runtime
        - testCompile
        - testRuntime
        - archives
        - default 
      

Publikowanie jara:

Closure (ubogie AOP)
Kod w nawiasach klamrowych jest traktowany jako obiekt, który może być przekazany jako parametr do metody, lub przypisany do zmiennej i wykonany później.

    doFirst(closure) - wykonaj przed zadaniem
    doLast(closure) - wykonaj po zadaniu
    onlyIf(closure) - tryb warunkowy , wykonaj jeśli warunek zwróci true

Task: co możemy z nimi robić (task jest objektem (DefaultTask)):

 - tworzyć ( task({task_name})  w build.gradle)
 - tworzyć własne programowalne (extends DefaultTask)
 - wyznaczać kolejność wywołania (must run after)
 - dodawać zależności
 - definiować łańcuch zależnych wywołań (dependsOn(task))
 - pomijać któryś task z łańcucha wywołań
      ({taskName}.onlyIf(condition).,
       lub użyć -x z linii komend)
 - podawać lokalizację taska (może być zdefiniowany w innym miejscu)
 - dodawać opis (description)
 - podmieniać z innym (overwrite: true)
 - anulować task (task.enable=false, onlyIf, StopExecutionException)
 - wybierać poziom logowania
 - używać skrótów (Task name abbreviation)

Jak widzisz możesz naprawdę zajebiście dużo:)


Pluginy (wymieniam te, które nas będą interesować.)
 - scala
 - groovy
 - java

Co może być fajne :)?
Gradle zakłada layout projektu na wzór z mavena.
src/main/java
src/main/resources
src/test/resources
src/test/java
I to jest zajebiste (CoC). Ale nie zawsze. Załóżmy, że chcemy wyłamać się z tej konwencji. Jak to zrobimy ?

 

 - jetty
 - ear
 - maven
 - war
 - application
 - distribution
 - ivy-publish
 - maven-publish
 - eclipse
 - findbugs
 - checkstyle
 - codearc
 - pmd
 - sonar
 - jococo
 - project-report
 - distribution
 - build-dashboard

Można tworzyć własne pluginy (implements Plugin<Project>)

Dependency
 - External module dependency - biblioteka lub zewnętrzny moduł
 - Project dependency (project()) - zależy od innego projektu
 - File dependency (files(),filesTree()) - kolekcja plików na lokalnym komputerze
 - Client module dependency (module())
 - Gradle API dependency (gradleApi()) - zależy od Gradle API (w przypadku własnych pluginów i tasków)
 - Local Groovy dependency (localGroovy()) - dla bibliotek groovy'iego w przypadku tworzenia własnych pluginów lub taksków
 przykład poniżej:
Properties
Możemy zdefiniować sobie zmienne w skrypcie w ten sposób:
Czytanie z pliku properties jest równe łatwe.
Tworzymy plik gradle.properties i tam deklarujemy zmienne.
Przykładowy sposób odwołania się do nich jest na poniższym listingu.

Tworzenie multi projektów

Żeby stworzyć multi-projekt wystarczy dodać plik settings.gradle do katalogu głównego projektu i powiedzieć mu który projekt należy includować.
w części drugiej zaczniemy pracę już na żywym projekcie "personalBlog".
Poznamy najlepsze praktyki w wykorzystaniu gradle.

PersonalBlog ten będzie bazą do tworzenia następnych postów. Nauczysz się tam jak powinien wyglądać projekt od początku. Od samego zera.

Zaprojektujemy encje, dao, serwisy, integracje, kontrolery, widoki.
Będziemy testować, dużo testować.
Wykorzystamy groovy, scale i inne fajne rzeczy. Ale to już niebawem.

Małe podsumowanie:

Maven zawsze był dla mnie wyznacznikiem jakości.
Przejście z Anta na Mavena to ogromny skok jakości i wygody.
Jak usłyszałem o projekcie Gradle kilka lat temu, pomyślałem sobie niech  próbują....:)
Potem czytam, że projekt Hibernate przechodzi na Gradle, następnie to robi Spring itd.
Wtedy wiedziałem, że w Gradle musi siedzieć moc. To mnie tylko upewniło w przekonaniach.

Tu mogę kontrolować każdy kawałek budowy projektu. Mogę definiować swój własny layout. Mogę w miarę prosty sposób napisać swojego plugina.
Dostaje tak naprawdę wszystko co najlepsze z poprzednich projektów: ant, maven, ivy z tym, że do napisania mam dużo mniej kodu.  
Mniej kodu znaczy lepiej - mniej błędów, łatwiej utrzymywać.
Integruje się z IDE (do eclipse jest świetny plugin (STS - GRADLE IDE))
Jeśli się przekonasz do Gradle a myślę, że po drugim poście na pewno.
Wtedy natychmiast się na niego przesiądziesz - gwarantuje Ci to.
Aha jeszcze jeden ważny argument dla pragmatycznego programisty:
poznając Gradle poznajesz Groovy.


dalej ->


Brak komentarzy:

Prześlij komentarz