Drei Begriffe, die man unbedingt auseinanderhalten sollte. Wieso und warum, das erkläre ich im folgenden Abschnitt! Ich setze in diesem Artikel voraus, dass jeder der ihn liest weiß was HTML und eventuell auch ein DOM-Baum ist.

Also zunächst zu den Taglibraries:

Taglibraries sind prinzipiell kleine Werkzeugkästen mit denen man viel mit wenig Aufwand erreicht. Die so genannten Tags werden in den Webseitenquelltext eingesetzt und zur Laufzeit durch entsprechende Codeabschnitte automatisch ersetzt.
Grails bietet ebenfalls eine Taglibrary an, es handelt sich hierbei um die Groovy Taglibrary. Die Referenz hierzu befindet sich hinter dem folgenden Link.

Hier ein Beispiel:

<select name="dropdown">
  <option>Wert 1</option>
  <option>Wert 1</option>
  <option>Wert 1</option>
  <option>Wert 1</option>
  <option>Wert 1</option>
</select>

Die Beispiel würde eine Auswahlbox erzeugen. Wenn wir das Ganze mit Grails und der GSP Taglibrary machen, dann ensteht folgendes:

class TestController {
  def index = {
    [list:["Wert 1","Wert 2","Wert 3","Wert 4","Wert 5"]]
  }
}

<g:select name="dropdown" from="${list}" />

Das Ergebnis ist am Ende das selbe. Nun fragt Ihr euch, warum sollte ich das denn so umständlich verpacken, wenn ich es auch direkt in HTML schreiben kann. Ganz einfach, denn wir wollen in unserer Applikation in Zukunft auch dynamisch Werte in die Ausgabeseiten generieren lassen. Bisher hat das Grails für uns gemacht, aber wir kommen auch immer wieder an Stellen, an denen wir das selber machen müssen. Schaut einfach mal in die Views, die Grails euch automatisch generiert hat und vergleicht den Inhalt mal mit dem Inhalt zum Link, der zur Groovy Taglibrary führt.

Actions

Actions sind prinzipiell Funktionen, nur dass Sie entweder über die URL, einen Link, oder andere HTML Elemente angesprochen werden. Eine Action wird immer wie folgt deklariert:

def actionName = {
  // hier passiert was
  def neueListe = ['a','b','c']  
 
  // hier wird die Seite zu der Action aufgerufen und die Liste übergeben
  [list:neueListe]
}

Auch hier empfehle ich euch einmal die automatisch generierten Actions in den Controllerklassen euch anzuschauen.

Functions

Functions gibt es prinzipiell überall. in Domain-, Service-, oder Controllerklassen. Functions können Parameter aufnehmen und am Ende etwas zurückgeben. Beides ist optional!

!!Im Gegensatz zu Java ist es in Groovy nicht möglich Functions (Methoden) zu überladen!!

Ein Beispiel für eine Function:

def functionName(parameter1) {
  // hier passiert was
  def neueListe = ['a','b','c',parameter1]  
 
  // hier wird die Seite zu der Action aufgerufen und die Liste übergeben
  return neueListe
}

Functions werden standardmäßig nicht mitgeneriert, aber auch die werden wir später sicherlich auch brauchen.

Das war jetzt mal ein grober Abriss in ein paar verschiedene Begrifflichkeiten. Im nächsten Post werden wir dann endlich mal den Code anfassen.

Im vorigen Abschnitt habe ich ja schon erläutert, wie man aus den erstellten Domainklassen Controller und Views generieren kann, wieso eigentlich noch das Thema Scaffolding?

Was ist eigentlich Scaffolding?

Scaffolding bedeutet nichts anderes, als das während der Entwicklung der Software kein  Augenmerk auf die Standardoperationen der Domainklassen gelegt werden muss. Hier sprechen wir vom CRUD (Create, Read, Update, Delete) Schema.

class BohnensackController {
  def scaffold = true
}

Standardmäßig füllt Grails beim Ausführen des Befehls “grails generate-all Bohnensack”, oder “grails create-controller Bohnensack” die Controllerklasse schon mit den benötigten CRUD-Actions, ist aber wie im oberen Beispiel das scaffold-Flag gesetzt, wird zur Laufzeit dieser Code generiert und Grails bietet standardmäßig folgende Actions auf den Domainklassen an:

• list
• show
• edit
• delete
• create
• save
• update

Somit weisst du ab sofort, dass es vollkommend ausreichend ist, lediglich Controllerklasse wie oben beschrieben zu füllen, so lange nicht der Wunsch besteht benutzerdefinierte Actions anzubieten, aber dazu kommen wir auch noch.

Puhh, hab ich mich damit schwer getan ein Einstiegsprojekt für den Blog zu finden, doch heute Nacht kam die Erleuchtung

Ob Sie jetzt wirklich sinnvoll ist die Idee, oder nicht, das wird sich sicherlich noch zeigen…

Thema: The CoffeeBeanProject

Idee: Tool um Kaffeesorten zu speichern und zu bewerten.

Hintergrund: Endlich habe ich einen Kaffeevollautomaten, aber bin noch auf der Suche nach dem richtigen Kaffee und da ich direkt an der Schweizer Grenze wohne, habe ich gleich doppelt so viel Auswahl!

Und nun geht es los …

Als erstes überlegen wir uns das grundlegende “Domain Model”. Was wollen wir eigentlich abbilden in unserer Applikation und wie pressen wir das in Software?

Meine vorab getätigten Überlegungen habe ich mal in Visio skizziert:

Erste Schritte in Grails:

1. Projekt anlegen

Kommandozeile öffnen und in ein beliebiges Verzeichnis wechseln!

grails create-app CoffeeBeanProject

Hurra! Das Projekt ist angelegt!

2. Domainklassen erzeugen

• grails create-domain-class Bohnensack
• grails create-domain-class Bohne
• grails create-domain-class Bewertung
• grails create-domain-class Laden
• grails create-domain-class Artikel

Damit haben wir die grundlegende Basis geschaffen und gehen über zum füllen der Domainklassen.

3. Domainklassen Leben einhauchen.

Eine Domainklasse ist immer wie folgt aufgebaut:

class DomainKlassenName {
  // Hier folgen die Attribute
  String name
  String vorname
  Date geburtstag
 
  // Hier implementieren wir Standard Methoden
  String toString() {
    return name + ", " + vorname
  }
 
  // Hier folgen die Einschränkungen Constraints
  constraints {
    name(nullable:false)
    vorname(nullable:false)
    geburtstag(max:(new Date()-365)) // du musst mindestens ein Jahr alt sein
  }
}

4. Views und Controller generieren

• grails generate-all Bohnensack
• grails generate-all Bohne
• grails generate-all Bewertung
• grails generate-all Laden
• grails generate-all Artikel

5. Run App
grails run-app

Wenn alles funktioniert hat, dann lässt sich die Applikation nun über folgende URL aufrufen: http://localhost:8080/CoffeeBeanProject

Die ersten sind meist auch die Schwierigsten und die Tücken, die Grails bietet, sind meist auch nicht direkt ersichtlich. Der Teufel steckt ja bekanntlich im Detail

Also zunächst was ist eigentlich Grails?

Für alle, die zufällig auf diesen Artikel gestoßen sind, Grails ist ein Webframework, was es ermöglichen soll schnell und einfach Applikationen zu entwickeln und online zu stellen. Unter der Haube von Grails steckt Groovy (eine dynamisch typisierte Sprache), eine Sprache die auf der Java Syntax aufbaut und versucht viele Unschönheiten zu beseitigen. Dabei wird der Groovy Code später in Bytecode umgewandelt und läuft somit in einer JAVA VM. Einige Vorteile von Groovy sind dynamische Datentypen, Maps, Listen, reguläre Ausdrücke (Regular Expressions) und Closures.
Aber zurück zu Grails: Grails arbeitet und anderem mit Hibernate und untersützt somit das Ablegen von Objekten in einer relationalen Datenbank. Neben der Möglichkeit Webanwendungen mit Unit-Tests zu bestücken bietet Grails ein relativ simples Kommandozeilentool an, mit dem wirklich alles direkt von einer zentralen Stelle aus gesteuert werden kann.

Genug Geschwätz, legen wir endlich los !

Zunächst liste ich einige Downloadquellen von Tools auf, die für die Arbeit mit Grails sinnvoll sind, aber nicht unbedingt alle benötigt werden im ersten Schritt.

Installation der benötigten Software

Zunächst musst du den aktuellen Build des GRAILS Projektes herunterladen und diesen auf deinem Computer an einem geeigneten Ort entpacken. Danach ist es unbedingt notwendig seinem System die Installation, falls noch nicht geschehen mitzuteilen. Hier zu legen wir zwei Umgebungsvariablen an. Das geht am einfachsten über: Rechtsklick Arbeitsplatz -> Eigenschaften -> Erweitert -> Umgebungsvariablen

Nun legen wir zunächst folgende Variable an:

GRAILS_HOME -> c:/pfad/zum/grails/verzeichnis

Danach erweitern wir die Path Variable um folgenden Wert:

;%GRAILS_HOME%/bin

Danach benötigen wir die Netbeans Installation (Java oder All Package). Sobald Netbeans installiert ist, sollte folgende Oberfläche erscheinen (beim Mac sieht das etwas anders aus, als unter Windows).

Nun ist alles bereit zum Erstellen der ersten Applikation und das geschieht im nächsten Post

Hallo und Herzlich willkommen auf dem Grails Blog!

… no grails application at all ! But now it is time to change the web !

Was wird hier in Zukunft passieren?

Der Grails Blog soll in Zukunft die Entstehung einer Grails Applikation dokumentieren und häufige Probleme und Anfängerfehler aufdecken. Ziel soll es sein, alte Hasen und blutige Anfänger an das Thema Grails heranzuführen. Schritt für Schritt soll so der Blog immer größer werden.
Neben der Entwicklung der Applikation sollen aber auch Themen wie das Testen und das automatische Builden der Applikation aufgegriffen werden.

Wie sieht der nächste Schritt aus?

Im nächsten Post beschäftigen wir uns mit der Einrichtung der Development Umgebung und im speziellen mit Netbeans.