Das produktive Web-Framework für die Java
Werbung
• Scaffolding, DomainKlassen, Controller, Datenbindung, Views • URL-Mappings • Mehrsprachigkeit und Internationalisierung • Ajax • GORM: Groovy ObjectRelational Mapping • Deklarative Transaktionen mit Grails-Service • Integration von Grails in bestehende Systeme • Plugin-Entwicklung • Sicherheit • Webservices • Spring • Legacy-Integration mit Hibernate • Grundlagen von Groovy • Kapitel zum Download im Internet: Webflows erstellen Den Sourcecode sowie ein zusätzliches Kapitel finden Sie zum kostenlosen Download im Internet unter www.it-fachportal.de/5094. Grails liefert die Antworten auf die lange Suche nach besseren Alternativen in der Java-Welt in Form eines Frameworks, das die üblichen Probleme beim Entwickeln von Webapplikationen unaufdringlich und elegant löst. Wenn Framework und Programmiersprache für Ihr Projekt auf Basis der Java-Plattform frei zu wählen sind, kann Ihnen Grails Funktionen bieten, die Sie in keinem anderen Framework finden werden. Dieses Buch liefert Ihnen alle Informationen, die Sie benötigen, um sofort produktiv zu arbeiten. ISBN 978-3-8266-5937-9 Mit diesem Buch erhalten Sie ein umfassendes Praxis-Handbuch zu Grails. Angefangen bei den Basiskonzepten bis hin zu fortgeschrittenen Anwendungen und Themen lernen Sie das beeindruckende Spektrum und die Stärken von Grails kennen. Trotz der umfangreichen Funktionalitäten sind die Lösungen einfach – und beim Durcharbeiten der Beispiele lernen Sie nebenbei vielleicht eine ganz neue Methode für die Entwicklung von Webanwendungen kennen. Sie lernen unter anderem, wie Sie mit Groovy und Grails schnell Prototypen von Anwendungen, dynamische TagLibraries und Rich Domain Models erstellen und wiederverwendbare Services anbieten können. So können Sie sich auf das Wichtige konzentrieren: die Geschäftslogik Ihrer Anwendungen. ISBN 978-3-8266-5548-7 Mit diesem Buch werden Sie ein begeisterter GrailsAnhänger und -Profi! Diese deutsche Übersetzung des englischen Standardwerkes zu Grails wurde vollständig auf die neue Version 1.2 aktualisiert. Über die Autoren: Graeme Keith Rocher ist Software-Ingenieur und Leiter der Grails-Entwicklung bei SpringSource, dem Unternehmen hinter dem Spring-Framework, auf dem Grails aufbaut. In seiner gegenwärtigen Rolle leitet Graeme Rocher die laufende Entwicklung des Grails-Frameworks und ist für dessen Produktstrategie und Innovation verantwortlich. Jeff Brown ist Software-Ingenieur bei SpringSource und Mitglied des Groovy- und Grails-Entwicklungsteams. 5094_Grails_2_U4_RS_korr2.indd 1 Das produktive Web-Framework für die Java-Plattform Insiderwissen aus erster Hand von Grails-Entwicklern Internationalisierung, Ajax, GORM, Plugins, Sicherheit, Webservices Einsatz von Spring und Hibernate ISBN 978-3-8266-5898-3 Regalsystematik: (Web)Programmierung (D) 17x24cm Grails 1.2 Basiswissen, Konzepte, Architektur ISBN 978-3-8266-5094-9 ISBN 978-3-8266-5094-9 Probekapitel und Infos erhalten Sie unter: [email protected] www.it-fachportal.de Graeme Rocher • Jeff Brown Fachkorrektur von Marc-Oliver Scheele Außerdem zum Thema: Grails 1.2 • Basiswissen, Konzepte und Architektur von Grails Lernen Sie von dem Projektgründer und dem Key-Committer, wie Sie mit Grails – das leichtgewichtige Open-Source Web Application Framework auf Basis von Groovy – erfolgreich leistungsfähige Applikation für die Java-Plattform entwickeln. € 49,95 Einführung in Groovy Graeme Rocher Jeff Brown Aus dem Inhalt: 5094 0812 28,5 mm 05.02.2010 13:27:57 00_____Grails1-2_5094.book Seite 23 Freitag, 5. Februar 2010 2:26 14 Kapitel 1 Das Wesen von Grails Einfachheit ist die ultimative Perfektion. – Leonardo da Vinci Wollen Sie Grails verstehen, müssen Sie zunächst seine Ziele kennen: die Enterprise-JavaWebentwicklung erheblich zu vereinfachen, die Webentwicklung auf die nächste Abstraktionsebene zu heben, Entwicklern Funktionen zur Verfügung zu stellen, die es auf anderen Plattformen bereits seit Jahren gibt, und dabei die Flexibilität der zugrunde liegenden Technologien in aller Vielfalt und Reife zu bewahren. Schreiben Sie mühselig zahlreiche, lahmlegende XML-Konfigurationsdateien? Quälen Sie sich mit einem Buildsystem, das einfache Änderungen nicht in wenigen Sekunden, sondern in langen Minuten testet? Mit Grails macht die Entwicklung auf der Java-Plattform wieder Spaß. Es reißt Barrieren nieder und gibt Benutzern Zugriff auf APIs, damit Sie sich allein auf Ihre Geschäftsprobleme konzentrieren können. Keine Konfiguration, kein Overhead, sofortiger Turnaround. Wie ist das möglich? Grails nutzt bewährte Konzepte wie etwa Convention over Configuration (CoC, Konvention statt Konfiguration), Don’t Repeat Yourself (DRY, Wiederhole dich nicht) und sinnvolle Defaults, die mit der knappen Groovy-Sprache und mehreren domänenspezifischen Sprachen (DSLs) realisiert werden, die Ihnen die Arbeit erleichtern. Als angehender Grails-Entwickler kommt Ihnen dies vielleicht wie Schummelei vor. Sollten Sie nicht mehr Mühe haben? Schließlich können Sie zwei Stunden hartes Körpertraining auch nicht in zwanzig Minuten zusammenquetschen, oder? Wo ist der Haken? Als Entwickler können Sie sicher sein, auf den Schultern von Giganten zu stehen, denen wir die Technologien verdanken, die Grails zugrunde liegen: Spring, Hibernate und natürlich die Java-Plattform. Grails realisiert die besten Funktionen aus Frameworks in dynamischen Sprachen, wie Ruby on Rails, Django oder TurboGears, für die Java Virtual Machine (JVM). 1.1 Einfachheit und Power Grails hebt sich von Konkurrenzprodukten deutlich durch sein Design ab. Grails versucht nicht, das Rad neu zu erfinden, sondern greift auf bewährte Frameworks wie Spring und Hibernate zurück. So kann es arbeitserleichternde Funktionen liefern, ohne dafür Robustheit zu opfern. Grails basiert auf einigen der in ihren Kategorien beliebtesten Open-SourceTechnologien: 쐽 Hibernate: De-facto-Standard für Objekt-relationales Mapping (ORM) in der Java-Welt 쐽 Spring: Sehr beliebter Inversion of Control (IoC) Container und Wrapper-Framework für Java 쐽 SiteMesh: Ein robustes und stabiles Layout-Framework © des Titels »Grails 1.2« (ISBN 978-3-8266-5094-9) 2010 by Verlagsgruppe Hüthig Jehle Rehm GmbH, Heidelberg Nähere Informationen unter: http://www.it-fachportal.de/5094 23 00_____Grails1-2_5094.book Seite 24 Freitag, 5. Februar 2010 2:26 14 Kapitel 1 Das Wesen von Grails 쐽 Tomcat: Ein bewährter und weit verbreiteter Servlet-Container 쐽 HSQLDB: Eine reine Java-Implementierung eines relationalen Datenbankmanage- ment-Systems (RDBMS). NEU in 1.2 Hinweis Bis einschließlich Version 1.1 wurde Grails mit dem Jetty-Servlet-Container ausgeliefert. Da die Grails-Anwendungen im Produktivbetrieb jedoch meist auf dem Tomcat-Server laufen, wird nun folgerichtig auch während der Entwicklung standardmäßig auf Tomcat gesetzt. Nutzer, die Jetty für die Entwicklung von Grails-Applikationen bevorzugen, können über folgende Kommandos Tomcat deinstallieren und Jetty wieder als integrierten Servlet-Container zum Standard machen: grails uninstall-plugin tomcat grails install-plugin jetty Die Konzepte von ORM und IoC sind für einige Leser vielleicht neu. ORM ist einfach eine Methode, um Objekte aus der objektorientierten Welt Tabellen einer relationalen Datenbank zuzuordnen. ORM ist zusätzliche Abstraktion über SQL, die es Entwicklern ermöglicht, über ihr Domain-Modell nachzudenken, statt sich mit SQL herumzuschlagen. Mit IoC können Objekte so verknüpft werden, dass ihre Dependencies zur Laufzeit bereitstehen. So müssen etwa persistente Objekte gespeichert oder aus einer Datenquelle abgerufen werden. IoC nimmt dem Entwickler die Aufgabe ab, die erforderliche Datenquelle zu referenzieren. Doch diese Konzepte sind im Moment nicht so wichtig. Sie werden später ausführlicher erläutert. Sie profitieren von Grails, weil es diese Frameworks mit der Groovy-Sprache durch eine weitere Abstraktionsschicht einhüllt. Als Entwickler bemerken Sie nicht, dass Sie eine Springund Hibernate-Anwendung erstellen. Sie werden bestimmt keine einzige Hibernate- oder Spring-XML-Zeile schreiben; aber sie ist da, falls Sie sie brauchen. Abbildung 1.1 zeigt das Verhältnis von Grails zu diesen Frameworks und dem Enterprise Java Stack. Abb. 1.1: 24 Der Grails-Stack © des Titels »Grails 1.2« (ISBN 978-3-8266-5094-9) 2010 by Verlagsgruppe Hüthig Jehle Rehm GmbH, Heidelberg Nähere Informationen unter: http://www.it-fachportal.de/5094 00_____Grails1-2_5094.book Seite 25 Freitag, 5. Februar 2010 2:26 14 1.2 Grails, die Plattform 1.2 Grails, die Plattform Haben Sie bei Grails gedacht: »Bloß nicht noch ein Web-Framework!«? Das wäre verständlich; denn es gibt Dutzende von Web-Frameworks für Java. Doch Grails ist anders: Es ist nicht nur ein Web-Framework, sondern eine komplette Umgebung. Es ist eine Plattform mit anspruchsvollen Zielen: Es will alle Aufgaben von der View- bis hinunter zur PersistenzSchicht abdecken. Außerdem will Grails durch sein Plugin-System (siehe Kapitel 12) Probleme lösen helfen, für die es keine vorgefertigten Lösungen bereithält. Mit Grails können Sie Searching, Job Scheduling, Enterprise Messaging, Remoting und mehr implementieren. Der schiere Umfang der von Grails abgedeckten Aufgaben könnte Albträume über endlose Konfigurationssitzungen auslösen. Doch selbst bei seinen Plugins verwendet Grails Convention over Configuration und vernünftige Defaults zur Arbeitserleichterung. Sie sollten Grails nicht nur als ein weiteres Web-Framework, sondern als die Plattform betrachten, auf der Sie Ihre nächste Web-2.0-Anwendung realisieren wollen. 1.3 Leben im Java-Ökosystem Mit Grails können Sie – dank Groovy – nicht nur Ihre bekannten und beliebten Java-Frameworks nutzen, sondern auch alle Vorteile von Java und der JVM. Keine andere dynamische Sprache für die JVM ist mit Java so integriert wie Groovy. Es arbeitet per Design auf jeder Ebene nahtlos mit Java zusammen. Beginnend mit der Syntax hat es folgende weitere Ähnlichkeiten: 쐽 Die Groovy-Grammatik ist von der Java-5-Grammatik abgeleitet; deshalb ist der meiste gültige Java-Code zugleich gültiger Groovy-Code. 쐽 Groovy verwendet dieselben grundlegenden APIs wie Java; deshalb sind Ihre zuverlässi- gen Javadocs immer noch gültig! 쐽 Groovy-Objekte sind Java-Objekte. Dieses hat weitreichende Konsequenzen, die vielleicht nicht sofort deutlich werden. So kann etwa ein Groovy-Objekt java.io.Serializable implementieren und per Remote Method Invocation (RMI) versendet oder mit Session-Replication Tools in Clustern verpackt werden. 쐽 Mit dem Joint Compiler von Groovy sind zirkuläre Referenzen zwischen Groovy und Java möglich, ohne dass es zu Problemen beim Kompilieren kommt. 쐽 Mit Groovy können Sie leicht dieselben Profiling- und Überwachungs-Tools sowie alle existierenden und künftigen Java-Technologien verwenden. Die nahtlose Integration mit Java und die Java-ähnliche Syntax sind die wesentlichen Gründe für den Wirbel, der um Groovy gemacht wurde. Endlich eine Sprache mit ähnlichen Fähigkeiten wie Ruby oder SmallTalk, die direkt in der JVM lief. Das Potenzial, Java-Code mit dynamischem Groovy-Code zu kombinieren, bietet ungeahnte Möglichkeiten. Außerdem können Sie in Groovy statische und dynamische Typen mischen und so bei Bedarf die Sicherheit der statischen Typisierung mit der Leistungsstärke und Flexibilität der dynamischen Typisierung kombinieren. Die starke Integration mit Java macht Groovy immer beliebter, insbesondere bei der Entwicklung von Webanwendungen. Jede Programmierplattform drückt mit unterschiedlichen Idiomen im Wesentlichen dieselben Konzepte aus. In der Java-Welt haben wir Servlets, Filter, Tag-Bibliotheken und Java Server Pages (JSP). Bei einem Wechsel auf eine neue Platt© des Titels »Grails 1.2« (ISBN 978-3-8266-5094-9) 2010 by Verlagsgruppe Hüthig Jehle Rehm GmbH, Heidelberg Nähere Informationen unter: http://www.it-fachportal.de/5094 25 00_____Grails1-2_5094.book Seite 26 Freitag, 5. Februar 2010 2:26 14 Kapitel 1 Das Wesen von Grails form müssen Sie alle diese Konzepte, ihre APIs und Idiome mehr oder weniger mühsam neu lernen. Neues zu lernen, ist an sich nicht schlecht, doch in der Praxis immer mit Kosten verbunden. Diese können ein größeres Hindernis darstellen, neue Technologien zu übernehmen, die von den Standards oder Konventionen abweichen, die auf der Java-Plattform oder in Ihrem Unternehmen definiert sind. Zusätzlich hat Java Standards für Deployment, Management, Sicherheit, Benennung und mehr. Grails will als Plattform die Essenz von Frameworks wie Rails, Django oder CakePHP mit der reifen Umgebung der Java Enterprise Edition (Java EE) und ihren APIs verknüpfen. Grails gehört jedoch zu den Technologien, die für sich selbst sprechen: Im Moment, wo Sie damit arbeiten, geht Ihnen ein kleines Licht auf. Deshalb wollen wir schnell mit der Beispielanwendung beginnen, die das Buch durchzieht: gTunes. Unser gTunes-Beispiel führt Sie schrittweise durch die Entwicklung eines Musikladens im Stile von Apple, Amazon oder Napster. Eine derartige Anwendung bietet vom E-Commerce bis RESTful-APIs und RSSoder Atom-Feeds zahlreiche interessante Möglichkeiten. Wir hoffen, dass Sie dadurch Grails und seine Funktionen gründlich kennen lernen. 1.4 Grails installieren Grails zu installieren, ist fast so einfach wie seine Anwendung, aber Sie müssen mindestens eine Voraussetzung erfüllen. Grails erfordert eine gültige Installation des Java SDK 1.5 oder neuer. Sie bekommen es bei Sun Microsystems unter http://java.sun.com. Nach der Installation des Java SDK müssen Sie die Umgebungsvariable JAVA_HOME auf den Installationsordner setzen und JAVA_HOME/bin zu Ihrer PATH-Variablen hinzufügen. Anmerkung Wenn Sie unter Mac OS X arbeiten, ist Java bereits installiert! Dennoch müssen Sie die JAVA_HOME in Ihrer ~/.profile-Datei setzen. Testen Sie Ihre Installation in einer Eingabeaufforderung mit java -version: $java -version Der Output sollte (bis auf die Versionsnummern) dem aus Listing 1.1 ähneln. java version "1.6.0_10" Java(TM) 2 Runtime Environment, Standard Edition (build 1.6.0_10-b05-237) Java HotSpot(TM) Client VM (build 1.6.0_10-119, mixed mode, sharing) Listing 1.1: Java ausführen Wie bei vielen anderen Java-Frameworks wie Apache Tomcat oder Apache Ant erfordert die Installation einige einfache Schritte: Laden Sie Grails von http://grails.org herunter; entpacken Sie die Zip-Datei in ein Verzeichnis Ihrer Wahl; erstellen Sie eine GRAILS_HOMEVariable, die auf dieses Verzeichnis zeigt; fügen Sie das GRAILS_HOME/bin-Verzeichnis in Ihre PATH-Variable ein. Testen Sie die Installation in einer Eingabeaufforderung mit grails: 26 © des Titels »Grails 1.2« (ISBN 978-3-8266-5094-9) 2010 by Verlagsgruppe Hüthig Jehle Rehm GmbH, Heidelberg Nähere Informationen unter: http://www.it-fachportal.de/5094 00_____Grails1-2_5094.book Seite 27 Freitag, 5. Februar 2010 2:26 14 1.5 Ihre erste Anwendung erstellen $ grails Wurde Grails erfolgreich installiert, sollte der Output des Befehls dem aus Listing 1.2 ähneln. Welcome to Grails 1.2 - http://grails.org/ Licensed under Apache Standard License 2.0 Grails home is set to: /Developer/grails-1.2 No Skript name specified. Use 'grails help' for more info or 'grails interactive' to enter interactive mode Listing 1.2: Grails ausführen Listing 1.2 sagt Ihnen, dass Sie durch Eingabe von grails help mehr über Grails erfahren können. Grails zeigt dann u.a. eine Liste der verfügbaren Befehle an. Wenn Sie zusätzlich den Namen eines Befehls angeben, erhalten Sie mehr Informationen über diesen Befehl. Das folgende Beispiel demonstriert dies für den Befehl create-app: $ grails help create-app Listing 1.3 zeigt ein Beispiel für den typischen Output des help-Befehls. Usage (optionals marked with *): grails [environment]* create-app grails create-app -- Creates a Grails application for the given name Listing 1.3: Hilfe über einen Befehl Die Befehlszeilenschnittstelle von Grails wurde mit einem anderen Groovy-basierten Projekt namens Gant (Groovy Ant Scripting; http://gant.codehaus.org/) erstellt, das das beliebte Apache-Ant-Buildsystem (http://ant.apache.org/) einkapselt und eine nahtlose Mischung von Ant Targets und Groovy-Code ermöglicht. Näheres zur Grails-Befehlszeile erfahren Sie in Kapitel 11. 1.5 Ihre erste Anwendung erstellen In diesem Abschnitt erstellen Sie Ihre erste Grails-Anwendung. Sie heißt gTunes und enthält einen einfachen Controller. Sie führen zu diesem Zweck die folgenden Schritte aus: 1. Erstellen Sie die neue Anwendung mit dem Befehl grails create-app gTunes. 2. Navigieren Sie mit dem Befehl cd gTunes in das gTunes-Verzeichnis. 3. Erstellen Sie mit dem Befehl grails create-controller store einen Storefront-Controller. 4. Schreiben Sie Code, um den Benutzer mit einer Meldung zu begrüßen. 5. Testen Sie Ihren Code mit grails test-app. 6. Führen Sie die Anwendung mit grails run-app aus. © des Titels »Grails 1.2« (ISBN 978-3-8266-5094-9) 2010 by Verlagsgruppe Hüthig Jehle Rehm GmbH, Heidelberg Nähere Informationen unter: http://www.it-fachportal.de/5094 27 00_____Grails1-2_5094.book Seite 28 Freitag, 5. Februar 2010 2:26 14 Kapitel 1 Das Wesen von Grails 1.5.1 Schritt 1: Die Anwendung erstellen Einfach? Zweifellos! Zunächst führen Sie den Befehl create-app aus, den Sie aus dem vorigen Abschnitt kennen. Geben Sie den Befehl wie folgt in ein Befehlsfenster ein: $ grails create-app Wenn Sie (¢) drücken, fordert Grails Sie auf, einen Projektnamen einzugeben (siehe Listing 1.4). Geben Sie dann gTunes ein und drücken Sie (¢). Alternativ können Sie auch direkt grails create-app gTunes eingeben. Dann führt Grails automatisch die entsprechenden Aktionen aus. Running script /Developer/grails-dev/GRAILS_1_2/scripts/CreateApp_.groovy Environment set to development Application name not specified. Please enter: gTunes Listing 1.4: Eine Anwendung mit dem Befehl create-app erstellen Grails erstellt automatisch eine Grails-Anwendung namens gTunes mit allen erforderlichen Verzeichnissen. Im nächsten Schritt navigieren Sie im Befehlsfenster zu der neuen Anwendung: cd gTunes Abb. 1.2: Die gTunes-Anwendungsstruktur An diesem Punkt haben Sie eine neue saubere Grails-Anwendung mit sämtlichen Standardeinstellungen. Abbildung 1.2 zeigt einen Screenshot der Verzeichnisstruktur der Anwendung. Sie werden die Struktur einer Grails-Anwendung und die Aufgaben der verschiedenen Dateien und Verzeichnisse im Laufe dieses Buches näher kennen lernen. Beachten Sie jedoch, dass Grails Verzeichnisse für Controller, Domain-Objekte (Models) und Views erstellt hat. 28 © des Titels »Grails 1.2« (ISBN 978-3-8266-5094-9) 2010 by Verlagsgruppe Hüthig Jehle Rehm GmbH, Heidelberg Nähere Informationen unter: http://www.it-fachportal.de/5094 00_____Grails1-2_5094.book Seite 29 Freitag, 5. Februar 2010 2:26 14 1.5 Ihre erste Anwendung erstellen 1.5.2 Schritt 2: Einen Controller erstellen Grails ist ein MVC-Framework, das heißt, es arbeitet mit Models, Views und Controllern, um die Concerns (Aufgaben- oder Verantwortungsbereiche) sauber zu trennen. Viele WebFrameworks trennen mit dem MVC Pattern (Model View Controller Pattern) Benutzerschnittstelle und Geschäftslogik (siehe Wikipedia, http://de.wikipedia.org/wiki/ Model_View_Controller). Controller sind zentrale Komponenten einer Grails-Anwendung, die den Verkehr der Anfragen und Antworten zwischen den Views und den Models steuern. Weil die gTunes-Anwendung einen Online-Musikladen nachbildet, nennen wir unseren Controller store (Laden). Grails hilft Ihnen mit mehreren Befehlen, passende Klassen für die verschiedenen Bereiche einer Grails-Anwendung zu erstellen, etwa mit dem create-controller-Befehl einen Controller. Doch Sie müssen diese Befehle nicht verwenden. Wenn Sie die verschiedenen Konzepte in Grails besser kennen, können Sie eine Controller-Klasse genauso leicht mit einem Texteditor Ihrer Wahl oder einer integrierten Entwicklungsumgebung (IDE) erstellen. Hier wollen wir jedoch den create-controller-Befehl verwenden. Er hat wie createapp, ein Argument, mit dem Sie den Namen des gewünschten Controllers spezifizieren können: $ grails create-controller store Lehnen Sie sich zurück, während Grails den Rest erledigt. [copy] Copying 1 file to /Developer/grails-dev/gTunes/grails-app/controllers Created Controller for Store [mkdir] Created dir: /Developer/grails-dev/gTunes/grails-app/views/store [copy] Copying 1 file to /Developer/grails-dev/gTunes/test/unit Created ControllerTests for Store Listing 1.5: Einen Controller mit dem Befehl create-controller erstellen Grails erstellt mit dem create-controller-Befehl zwei Klassen: einen neuen Controller namens StoreController im grails-app/controllers-Verzeichnis und einen zugehörigen Testfall im test/unit-Verzeichnis (siehe Abbildung 1.3). Weil Groovy dynamisch arbeitet, sollten Sie in jedem Grails-Projekt eine möglichst umfassende Code Coverage oder Test Coverage (Code- oder Test-Abdeckung) anstreben. Code Coverage ist ein Maß aus dem Software-Testing. Es beschreibt, zu welchem Grad der Sourcecode eines Programms getestet worden ist. Grails generiert zu jedem Controller automatisch einen Test. Dynamische Sprachen wie Groovy, Ruby und Python werden längst nicht so stark vom Compiler unterstützt wie statisch typisierte Sprachen wie etwa Java. Einige Fehler, die in diesen Sprachen zur Compile-Zeit entdeckt werden, bleiben bei dynamischen Sprachen bis zur Laufzeit im Code, darunter auch die Methoden-Resolution. Doch was Sie in dynamischen Sprachen an Compiler-Unterstützung verlieren, wird durch deren Ausdrucksstärke ausgeglichen. © des Titels »Grails 1.2« (ISBN 978-3-8266-5094-9) 2010 by Verlagsgruppe Hüthig Jehle Rehm GmbH, Heidelberg Nähere Informationen unter: http://www.it-fachportal.de/5094 29 00_____Grails1-2_5094.book Seite 30 Freitag, 5. Februar 2010 2:26 14 Kapitel 1 Das Wesen von Grails Der neu erstellte StoreController Abb. 1.3: Leider verführt der Komfort des Compilers Java-Entwickler oft dazu, das Testen ganz zu vergessen. Doch natürlich ist der Compiler kein Ersatz für geeignete Unit-Tests. In diesem Buch werden wir immer wieder die automatisierten Testverfahren demonstrieren, mit denen Sie von Grails unterstützt werden. 1.5.3 Schritt 3: Eine Meldung ausgeben Zurück zu dem StoreController. Standardmäßig erstellt Grails den Controller und definiert für ihn eine einzige Action namens index. Sie ist per Konvention die Standardaction des Controllers. Listing 1.6 zeigt den StoreController mit seiner standardmäßigen indexAction. class StoreController { def index = {} } Listing 1.6: Die standardmäßige index-Action Die index-Action scheint nicht viel zu tun; doch per Konvention weist ihre Deklaration Grails an, automatisch eine View namens grails-app/views/store/index.gsp darzustellen. Views werden erst in Kapitel 5 behandelt. Deshalb wollen wir hier zwecks Einfachheit etwas weniger Anspruchsvolles versuchen. Grails’ Controller verfügen über mehrere implizite Methoden (siehe Kapitel 4), darunter render, eine Mehrzweckmethode, die unter anderem einfache textuelle Antworten darstel- len kann. Listing 1.7 zeigt, wie Sie die einfache Meldung »Willkommen im gTunes-Store!« ausgeben können. class StoreController { def index = { render "Welcome to the gTunes store!" 30 © des Titels »Grails 1.2« (ISBN 978-3-8266-5094-9) 2010 by Verlagsgruppe Hüthig Jehle Rehm GmbH, Heidelberg Nähere Informationen unter: http://www.it-fachportal.de/5094 00_____Grails1-2_5094.book Seite 31 Freitag, 5. Februar 2010 2:26 14 1.5 Ihre erste Anwendung erstellen } } Listing 1.7: 1.5.4 Eine Meldung mit der render-Methode ausgeben Schritt 4: Den Code testen Der voranstehende Code ist einfach genug, doch selbst der einfachste Code sollte getestet werden. Öffnen Sie die Testsuite StoreControllerTests.groovy, die weiter vorne im Verzeichnis test/unit generiert worden ist. Listing 1.8 zeigt einen Ausschnitt aus dieser Datei. class StoreControllerTests extends grails.test.ControllerUnitTestCase { void testSomething() { } } Listing 1.8: Ausschnitt aus der generierten Testsuite StoreControllerTests.groovy In Grails werden Tests in Unit-Tests und Integrationstests unterteilt. Integrationstests ziehen die gesamte Umgebung einschließlich der Datenbank hoch und laufen deshalb meist langsamer. Außerdem sollen sie normalerweise die Interaktion zwischen mehreren Klassen testen. Deshalb muss Ihre Anwendung kompletter sein, bevor Sie sie ausführen können. Dagegen laufen Unit-Tests schneller, erfordern aber mehr Mocks und Stubs. Stubs sind Klassen, die beim Testen echte Methoden simulieren, indem sie beliebige fest einprogrammierte Werte zurückgeben. Mocks machen im Wesentlichen dasselbe, verfügen aber zusätzlich über »Erwartungen«. So kann etwa ein Mock spezifizieren, dass es »erwartet«, dass eine bestimmte Methode wenigstens einmal (oder, falls erforderlich, zehn Mal) aufgerufen wird. Im weiteren Verlauf des Buches wird der Unterschied zwischen Unit-Tests und Integrationstests klarer werden. Um den StoreController in seinem gegenwärtigen Status zu testen, können Sie den Wert der Antwort zusichern, die an den Benutzer gesendet wurde (siehe zum Beispiel Listing 1.9). class StoreControllerTests extends grails.test.ControllerUnitTestCase { void testRenderHomePage() { controller.index() assertEquals "Welcome to the gTunes store!", controller.response.contentAsString } } Listing 1.9: Die index-Action von StoreController testen Hier wird mit einer eingebauten Testfunktion von Grails der Inhalt des response-Objekts geprüft. Bei einem Test wandelt Grails das normale HttpServletResponse-Servlet-Objekt in ein Spring-Objekt namens MockHttpServletResponse um, das über Hilfs-Properties wie contentAsString verfügt, mit denen Sie das Ergebnis eines Aufrufs der renderMethode prüfen können. Dennoch sollten Sie sich noch nicht zu viele Gedanken über diesen Code machen. Das Buch enthält zahlreiche Beispiele, die Sie mit dem Testen in Grails zunehmend vertrauter machen. © des Titels »Grails 1.2« (ISBN 978-3-8266-5094-9) 2010 by Verlagsgruppe Hüthig Jehle Rehm GmbH, Heidelberg Nähere Informationen unter: http://www.it-fachportal.de/5094 31 00_____Grails1-2_5094.book Seite 32 Freitag, 5. Februar 2010 2:26 14 Kapitel 1 Das Wesen von Grails 1.5.5 Schritt 5: Die Tests ausführen Mit dem Befehl grails test-app können Sie die Tests ausführen und prüfen, ob alles erwartungsgemäß funktioniert. Der Befehl führt alle Tests in der Anwendung aus und gibt die Ergebnisse im Verzeichnis test/reports aus. Mit dem Befehl grails test-app StoreController können Sie außerdem die StoreControllerTests selektiv ausführen. Listing 1.10 zeigt einen typischen Output einer Ausführung des test-app-Befehls. ------------------------------------------------------Running 1 unit test... Running test StoreControllerTests...PASSED Tests Completed in 703ms ... ------------------------------------------------------Tests passed: 1 Tests failed: 0 ------------------------------------------------------Tests passed. View reports in /Developer/grails-dev/gTunes/test/reports Listing 1.10: Tests mit grails test-app ausführen Die Reports werden als XML-, HTML- und einfache Textdateien im Verzeichnis test/ reports gespeichert. Abbildung 1.4 zeigt den generierten HTML-Report in einem Browser – er ist definitiv besser lesbar als das XML-Gegenstück! Abb. 1.4: Generierter HTML-Testreport Hinweis Falls Sie in Ihren Tests Logging-Ausgaben produzieren, erscheinen diese standardmäßig nicht im Output auf der Konsole (im JUnit-Report können Sie eingesehen werden). Um die Ausgaben auf der Konsole verfolgen zu können, rufen Sie den Test mit folgenden Parametern auf: grails test-app -echoOut -echoErr 32 © des Titels »Grails 1.2« (ISBN 978-3-8266-5094-9) 2010 by Verlagsgruppe Hüthig Jehle Rehm GmbH, Heidelberg Nähere Informationen unter: http://www.it-fachportal.de/5094 NEU in 1.2 00_____Grails1-2_5094.book Seite 33 Freitag, 5. Februar 2010 2:26 14 1.5 Ihre erste Anwendung erstellen 1.5.6 Schritt 6: Die Anwendung ausführen Nachdem Sie den Code getestet haben, können Sie das Programm mit dem Befehl grails run-app ausführen, der standardmäßig bei Port 8080 einen lokalen Grails-Server startet. Grails verwendet standardmäßig den verbreiteten und robusten Tomcat (http://tomcat.apache.org) Container als Server, aber natürlich können Sie Grails in jedem ServletContainer ab Version 2.4 oder neuer deployen. (Deployment wird in Kapitel 11 behandelt.) Führen Sie das Programm wie folgt aus: $ grails run-app Grails startet und zeigt dann einen URL an, über den Sie auf die Grails-Instanz zugreifen können. ... Environment set to development Running Grails application… Server running. Browse to http://localhost:8080/gTunes Listing 1.11: Eine Anwendung mit run-app ausführen Wird ein Bind-Error wie der Folgende angezeigt, liegt wahrscheinlich ein Port-Konflikt vor: Server failed to start: java.net.BindException: Address already in use Dieser Fehler tritt normalerweise auf, wenn bereits ein weiterer Container, wie etwa Jetty (http://www.mortbay.org), an Port 8080 läuft. Sie können dieses Problem umgehen, indem Sie Grails an einem anderen Port ausführen, indem Sie mit dem server.port-Argument einen alternativen Wert übergeben: grails -Dserver.port=8087 run-app In diesem Fall wird Grails dann an Port 8087 gestartet. Abgesehen von Port-Konflikten sollte Grails jetzt laufen und bereit sein, Anfragen zu verarbeiten. Öffnen Sie Ihren Lieblings-Browser und navigieren Sie zu dem URL, der Ihnen von Grails’ run-app-Befehl in Listing 1.11 angezeigt wird. Sie sollten zunächst die Grails-Begrüßungsseite sehen (siehe Abbildung 1.5). Der Begrüßungsbildschirm wird standardmäßig mit einer Groovy-Server-Pages-Datei (GSP-Datei; im Verzeichnis grails-app/views/index.gsp) angezeigt, aber Sie können den Speicherort dieser Datei durch URL-Mappings ändern (siehe Kapitel 6). In Abbildung 1.5 werden die verfügbaren Controller angezeigt, darunter der weiter vorne erstellte StoreController. Wenn Sie diesen Link anklicken, wird eine Seite mit der weiter vorne implementierten Meldung »Willkommen im gTunes-Store!« angezeigt (siehe Abbildung 1.6). © des Titels »Grails 1.2« (ISBN 978-3-8266-5094-9) 2010 by Verlagsgruppe Hüthig Jehle Rehm GmbH, Heidelberg Nähere Informationen unter: http://www.it-fachportal.de/5094 33 00_____Grails1-2_5094.book Seite 34 Freitag, 5. Februar 2010 2:26 14 Kapitel 1 Das Wesen von Grails Abb. 1.5: Die Standardbegrüßungsseite von Grails Abb. 1.6: StoreController gibt 1.6 eine Meldung aus. Zusammenfassung Erfolg! Ihre erste Grails-Anwendung läuft. In diesem Kapitel haben Sie die ersten Schritte unternommen, um Grails zu lernen, indem Sie Grails installiert und eingerichtet haben. Außerdem haben Sie Ihre erste Grails-Anwendung mit einem einfachen Controller erstellt. Als Nächstes erfahren Sie, wie Sie mit Grails schnell neue Projekte anstoßen können. Danach lernen Sie, wie Sie mit Grails prototypische CRUD-Funktionen (Create, Read, Update, Delete) generieren können, die Sie dann ausbauen können. 34 © des Titels »Grails 1.2« (ISBN 978-3-8266-5094-9) 2010 by Verlagsgruppe Hüthig Jehle Rehm GmbH, Heidelberg Nähere Informationen unter: http://www.it-fachportal.de/5094
