Groovy im Einsatz

Inhalt

Vorwort

Vorwort zur deutschen Ausgabe

Einleitung

Danksagungen

Über dieses Buch

Aufbau

Wer sollte dieses Buch lesen?

Code-Konventionen

Aktualisierungen

Die Autoren

1 Ihr Weg zu Groovy

1.1 Die Groovy-Story

1.1.1 Was ist Groovy?

1.1.2 Gutes Zusammenspiel mit Java: nahtlose Integration

1.1.3 Power in Ihrem Code: eine reichhaltige Sprache

1.1.4 Community-gesteuert, aber von Unternehmen gestützt

1.2 Was Groovy für Sie tun kann

1.2.1 Groovy für Java-Profis

1.2.2 Groovy für Skriptprogrammierer

1.2.3 Groovy für pragmatische, extreme und agile Programmierer

1.3 Groovy ausführen

1.3.1 „Hello World“ auf groovysh

1.3.2 Die groovyConsole

1.3.3 Der Befehl groovy

1.4 Groovy kompilieren und ausführen

1.4.1 Groovy mit groovyc kompilieren

1.4.2 Ein kompiliertes Groovy-Skript mit Java ausführen

1.4.3 Kompilieren und Ausführen mit Ant

1.5 IDE- und Editor-Unterstützung für Groovy

1.5.1 Das Plugin für IntelliJ IDEA

1.5.2 Das Eclipse-Plugin

1.5.3 Groovy-Unterstützung in anderen Editoren

1.6 Zusammenfassung

Teil 1 Die Programmiersprache Groovy

2 Die Ouvertüre: Groovy-Grundlagen

2.1 Allgemeines Aussehen des Codes

2.1.1 Kommentare in Groovy

2.1.2 Vergleich der Syntax von Groovy und Java

2.1.3 Kurz und gut

2.2 Testen der Sprache durch Zusicherungen

2.3 Groovy auf einen Blick

2.3.1 Klassen deklarieren

2.3.2 Verwendung von Skripten

2.3.3 GroovyBeans

2.3.4 Umgang mit Text

2.3.5 Zahlen sind Objekte

2.3.6 Listen, Maps und Ranges

2.3.7 Code als Objekt: Closures

2.3.8 Groovy-Kontrollstrukturen

2.4 Groovys Platz in der Java-Umgebung

2.4.1 Meine Klasse ist deine Klasse

2.4.2 GDK: Die Groovy-Bibliothek

2.4.3 Der Groovy-Lebenszyklus

2.5 Zusammenfassung

3 Die einfachen Groovy-Datentypen

3.1 Objekte, Objekte überall

3.1.1 Das Typsystem von Java: Basistypen und Referenztypen

3.1.2 Die Antwort ist Groovy – alles ist ein Objekt

3.1.3 Zusammenwirken mit Java – automatisches Boxing und Unboxing

3.1.4 Kein zwischengeschaltetes Unboxing

3.2 Das Konzept der optionalen Typisierung

3.2.1 Typen zuweisen

3.2.2 Statische versus dynamische Typisierung

3.3 Operatoren überschreiben

3.3.1 Überschreibbare Operatoren

3.3.2 Überschriebene Operatoren in Aktion

3.3.3 Automatische Typumwandlung

3.4 Umgang mit Strings

3.4.1 Varianten von Stringliteralen

3.4.2 Der Umgang mit GStrings

3.4.3 Von Java zu Groovy

3.5 Arbeiten mit regulären Ausdrücken

3.5.1 Angabe von Patterns in Stringliteralen

3.5.2 Anwendung von Patterns

3.5.3 Patterns in Aktion

3.5.4 Patterns und Performance

3.5.5 Patterns für die Klassifizierung

3.6 Arbeiten mit Zahlen

3.6.1 Automatische Typumwandlung mit numerischen Operatoren

3.6.2 GDK-Methoden für numerische Typen

3.7 Zusammenfassung

4 Die mengenwertigen Groovy-Datentypen

4.1 Der Umgang mit Ranges

4.1.1 Ranges spezifizieren

4.1.2 Ranges sind Objekte

4.1.3 Ranges in Aktion

4.2 Der Umgang mit Listen

4.2.1 Listen angeben

4.2.2 Der Umgang mit Listenoperatoren

4.2.3 Verwenden von Listenmethoden

4.2.4 Listen in Aktion

4.3 Der Umgang mit Maps

4.3.1 Maps angeben

4.3.2 Verwendung von Map-Operatoren

4.3.3 Maps in Aktion

4.4 Hinweise zu Groovy-Collections

4.4.1 Nebenläufige Änderungen

4.4.2 Der Unterschied zwischen Kopier- und Änderungs-Semantik

4.5 Zusammenfassung

5 Closures

5.1 Eine sanfte Einführung in Closures

5.2 Ein Fall für Closures

5.2.1 Verwendung von Iteratoren

5.2.2 Ressourcenbehandlung

5.3 Deklarieren von Closures

5.3.1 Die einfache Deklaration

5.3.2 Zuweisungen zur Deklaration verwenden

5.3.3 Methoden als Closures referenzieren

5.3.4 Die verschiedenen Möglichkeiten im Vergleich

5.4 Verwendung von Closures

5.4.1 Aufrufen einer Closure

5.4.2 Weitere Closure-Methoden

5.5 Gültigkeitsbereiche

5.5.1 Der einfache Gültigkeitsbereich einer Variablen

5.5.2 Der allgemeine Gültigkeitsbereich von Closures

5.5.3 Gültigkeitsbereiche: der klassische Akkumulator-Test

5.6 Rückgabe aus Closures

5.7 Unterstützung für Entwurfsmuster

5.7.1 Beziehung zum Besuchermuster

5.7.2 Beziehung zum Erbauermuster

5.7.3 Beziehung zu anderen Mustern

5.8 Zusammenfassung

6 Groovy-Kontrollstrukturen

6.1 Die Groovy-Wahrheit

6.1.1 Boolesche Tests auswerten

6.1.2 Zuweisungen in Booleschen Tests

6.2 Bedingte Ausführung

6.2.1 Die ganz bescheidene if-Anweisung

6.2.2 Der Bedingungsoperator ?:

6.2.3 Die switch-Anweisung

6.2.4 Plausibilitätsprüfung mit Zusicherungen

6.3 Schleifen

6.3.1 while-Schleifen

6.3.2 for-Schleifen

6.4 Blöcke und Methoden abbrechen

6.4.1 Normale Beendigung: return/break/continue

6.4.2 Exceptions: throw/try-catch-finally

6.5 Zusammenfassung

7 Dynamische Objektorientierung nach Groovy-Art

7.1 Definieren von Klassen und Skripten

7.1.1 Definieren von Feldern und lokalen Variablen

7.1.2 Methoden und Parameter

7.1.3 Mit dem Operator ?. sicher dereferenzieren

7.1.4 Konstruktoren

7.2 Organisieren von Klassen und Skripten

7.2.1 Beziehung zwischen Datei und Klasse

7.2.2 Organisieren von Klassen in Packages

7.2.3 Weitere Überlegungen zum Klassenpfad

7.3 Fortgeschrittene OO-Merkmale

7.3.1 Vererbung

7.3.2 Interfaces

7.3.3 Multimethoden

7.4 GroovyBeans

7.4.1 Deklaration von Beans

7.4.2 Umgang mit Beans

7.4.3 Bean-Methoden für alle Objekte

7.4.4 Felder, Zugriffsmethoden, Maps und Expando

7.5 Power-Features

7.5.1 Objekte mit GPaths abfragen

7.5.2 Den Spread-Operator injizieren

7.5.3 Kategorienmix mit use

7.6 Meta-Programmierung in Groovy

7.6.1 Das Konzept der MetaClass

7.6.2 Methoden aufrufen und abfangen

7.6.3 Abfangen von Methoden

7.7 Zusammenfassung

Teil 2 Die Groovy-Bibliothek

8 Builder

8.1 Learning by doing – Verwendung eines Builders

8.2 Erstellen von Objektbäumen mit NodeBuilder

8.2.1 NodeBuilder in Aktion – der Builder-Code

8.2.2 Das Builder-Konzept

8.2.3 Intelligente Builder mit Logik

8.3 Arbeiten mit MarkupBuilder

8.3.1 Erstellen von XML

8.3.2 Erstellen von HTML

8.4 Aufgaben automatisieren mit AntBuilder

8.4.1 Von Ant-Skripten zu Groovy-Skripten

8.4.2 Wie AntBuilder funktioniert

8.4.3 Intelligente Automatisierungsskripte mit Logik

8.5 GUIs ganz easy mit SwingBuilder

8.5.1 Passwort lesen mit dem SwingBuilder

8.5.2 Erstellen von Swing-Widgets

8.5.3 Widgets anordnen

8.5.4 Referenzieren von Widgets

8.5.5 Swing-Actions

8.5.6 Verwendung von Modellen

8.5.7 Von den Teilen zum Ganzen

8.6 Eigene Builder erstellen

8.6.1 Unterklassen für BuilderSupport

8.6.2 Das DebugBuilder-Beispiel

8.7 Zusammenfassung

9 Das GDK

9.1 Objekte

9.1.1 Interaktive Objekte

9.1.2 Bequemlichkeitsmethoden von Object

9.1.3 Iterative Object-Methoden

9.2 Arbeiten mit Dateien und I/O

9.2.1 Durchquerung des Dateisystems

9.2.2 Eingabequellen lesen

9.2.3 Ausgaben schreiben

9.2.4 Filter und Konvertierungen

9.2.5 Serialisierte Objekt-Streams

9.3 Threads und Prozesse

9.3.1 Groovy-Multithreading

9.3.2 Integrieren externer Prozesse

9.4 Die Arbeit mit Templates

9.4.1 Das Format von Templates

9.4.2 Templates in Aktion

9.4.3 Templates für Fortgeschrittene

9.5 Groovlets

9.5.1 „Hello World“

9.5.2 Die Groovlet-Bindung

9.5.3 Templates und Groovlets

9.6 Zusammenfassung

10 Datenbankprogrammierung mit Groovy

10.1 Grundlegende Datenbankoperationen

10.1.1 Datenbankzugriff einrichten

10.1.2 SQL ausführen

10.1.3 Daten abfragen

10.1.4 Von den Teilen zum Ganzen

10.2 DataSets für SQL ohne SQL

10.2.1 DataSet-Operationen verwenden

10.2.2 DataSets auf Datenbank-Views

10.3 Organisieren der Datenbankarbeit

10.3.1 Überblick über die Architektur

10.3.2 Verhalten der Anwendung spezifizieren

10.3.3 Implementierung der Infrastruktur

10.3.4 Ein transparentes Domain-Modell

10.3.5 Implementierung der Anwendungsschicht

10.4 Groovy und ORM

10.5 Zusammenfassung

11 Groovy-Integration

11.1 Vorbereitung auf die Integration

11.1.1 Richtig integrieren

11.1.2 Abhängigkeiten einrichten

11.2 Ausdrücke und Skripte auswerten mit GroovyShell

11.2.1 Aller Anfang ist leicht

11.2.2 Übergabe von Parametern in einer Bindung

11.2.3 Dynamische Klassen zur Laufzeit generieren

11.2.4 Skripte parsen

11.2.5 Skripte oder Klassen ausführen

11.2.6 Weitere Parametrisierung von GroovyShell

11.3 Die Groovy-Skript-Engine

11.3.1 Einrichten der Engine

11.3.2 Skripte ausführen

11.3.3 Abweichenden Ressourcenkonnektor definieren

11.4 Der GroovyClassLoader

11.4.1 Groovy-Klassen parsen und laden

11.4.2 Was war zuerst da: Die Henne oder das Ei?

11.4.3 Ein benutzerdefinierter Resource-Loader

11.4.4 Sicherheit in der Sandbox

11.5 Spring-Integration

11.5.1 GroovyBeans mit Spring verdrahten

11.5.2 Aktualisierbare Beans

11.5.3 Inline-Skripte

11.6 Mustang und JSR-223

11.6.1 Einführung in JSR-223

11.6.2 Der Skript-Engine-Manager und seine Skript-Engines

11.6.3 Kompilierbare und aufrufbare Skript-Engines

11.7 Die Wahl des richtigen Integrationsmechanismus

11.8 Zusammenfassung

12 Arbeiten mit XML

12.1 XML-Dokumente lesen

12.1.1 Arbeiten mit einem DOM-Parser

12.1.2 Daten lesen mit dem Groovy-Parser

12.1.3 Lesen mit einem SAX-Parser

12.1.4 Lesen mit einem StAX-Parser

12.2 XML verarbeiten

12.2.1 Vor Ort-Verarbeitung

12.2.2 Streaming-Verarbeitung

12.2.3 Kombination mit XPath

12.3 Verteilte Verarbeitung mit XML

12.3.1 Überblick über Webdienste

12.3.2 RSS und ATOM lesen

12.3.3 Ein REST-basiertes API

12.3.4 XML-RPC

12.3.5 Anwendung von SOAP

12.4 Zusammenfassung

Teil 3 Groovy für jeden Tag

13 Tipps und Tricks

13.1 Was Sie sich merken sollten

13.1.1 Gleichheit versus Identität

13.1.2 Klammern richtig setzen

13.1.3 Rückkehr aus Methoden und Closures

13.1.4 Methoden aufrufen im Builder-Code

13.1.5 Qualifizierter Zugriff auf „this“

13.1.6 Numerische Typen

13.1.7 Ant

13.1.8 Skripte sind Klassen, nur anders

13.2 Nützliche Codefragmente

13.2.1 Eine Collection mischen

13.2.2 Text durcheinanderwürfeln mit regulären Ausdrücken

13.2.3 Fortschrittsanzeige auf der Konsole

13.2.4 Selbstkommentierende Einzelschritte

13.2.5 GString für Fortgeschrittene

13.3 Groovy auf der Kommandozeile

13.3.1 Kommandozeilenskripte auswerten

13.3.2 Die Optionen print und line

13.3.3 Der Lauschmodus

13.3.4 Vor-Ort-Bearbeitung auf der Kommandozeile

13.4 Automatisierungsskripte

13.4.1 Konsistente Unterstützung für Kommandozeilenoptionen

13.4.2 Klassenpfad mit RootLoader erweitern

13.4.3 Ausführungsfahrplan für Skripte

13.5 Beispiele für die Automatisierung von Tasks

13.5.1 Scraping von HTML-Seiten

13.5.2 Automatisieren von Webaktionen

13.5.3 Versionskontrolle inspizieren

13.5.4 Pragmatische Codeanalyse

13.5.5 Weitere interessante Punkte

13.6 Layout des Arbeitsbereichs

13.6.1 IDE-Setup

13.6.2 Debugging

13.6.3 Profiling

13.6.4 Refactoring

13.7 Zusammenfassung

14 Unit Testing mit Groovy

14.1 Erste Schritte

14.1.1 Tests schreiben ist einfach

14.1.2 GroovyTestCase: Eine Einführung

14.1.3 GroovyTestCase

14.2 Unit Testing für Groovy-Code

14.3 Unit Testing für Java-Code

14.4 Tests organisieren

14.5 Fortgeschrittene Testmethoden

14.5.1 Testen wird groovy

14.5.2 Stubs und Mocks

14.5.3 GroovyLogTestCase

14.6 IDE-Integration

14.6.1 Verwenden von GroovyTestSuite

14.6.2 Verwenden von AllTestSuite

14.6.3 Fortgeschrittene IDE-Integration

14.7 Tools für Groovy-Testing

14.7.1 Code-Abdeckung mit Groovy

14.7.2 JUnit-Erweiterungen

14.8 Build-Automatisierung

14.8.1 Build-Integration mit Ant

14.8.2 Build-Integration mit Maven

14.9 Zusammenfassung

15 Windows wird Groovy

15.1 Scriptom herunterladen und installieren

15.2 Scriptom intern

15.2.1 Jacob

15.2.2 Instanzieren einer ActiveX-Komponente

15.2.3 Methoden aufrufen

15.2.4 Zugriff auf Properties und Rückgabewerte

15.2.5 Event-Unterstützung

15.3 Praxis-Szenario: Automatisieren der Lokalisierung

15.3.1 Entwurf des Dokumentformats

15.3.2 Entwurf des Thesaurus

15.3.3 Erstellen eines Word-Dokuments

15.3.4 Erstellung des endgültigen Dokuments

15.4 Automatisierung weiterer Anwendungen

15.4.1 Zugriff auf die Windows-Registrierung

15.4.2 Ein eigenes Automatisierungssystem programmieren

15.5 Verfügbare Dokumentation

15.6 Zusammenfassung

16 Ich sehe das Licht: Grails

16.1 Die Ausgangssituation

16.1.1 Grails installieren

16.1.2 Die ersten Schritte

16.2 Erstellen des Domain-Modells

16.2.1 Die Use Cases

16.2.2 Beziehungen designen

16.3 Implementierung des Domain-Modells

16.3.1 Scaffolding der Domain-Klassen

16.3.2 Scaffolding der Views und Controller

16.3.3 Testen der Webanwendung

16.3.4 Vervollständigen des Domain-Modells

16.4 Anpassen der Views

16.4.1 Bootstrapping von Daten

16.4.2 Arbeiten mit Groovy Server Pages

16.4.3 Arbeiten mit Tag-Bibliotheken

16.5 Arbeiten mit Controllern und Finder-Methoden

16.6 Ausarbeitung des Modells

16.7 Arbeiten mit der Session

16.8 Das Finish

16.8.1 Constraints validieren

16.8.2 Die Anwendung herausgeben

16.8.3 Abschied

A Installation und Dokumentation

A.1 Installation

A.2 Aktuelle Dokumentation beschaffen

A.2.1 Online-Ressourcen

A.2.2 Abonnieren von Mailinglisten

A.2.3 Verbindung mit dem Forum und Chat

B Infos zur Programmiersprache Groovy

B.1 Schlüsselwörter

C GDK-API-Kurzreferenz

C.1 Arrays und Primitives

C.2 Das Package java.lang

C.3 Das Package java.math

C.4 Die Packages java.util und java.sql

C.5 Das Package java.util.regex

C.6 Das Package java.io

C.7 Das Package java.net

D Spickzettel

D.1 Listen

D.2 Closures

D.3 Reguläre Ausdrücke

D.4 Unit Testing

D.5 Mocks und Stubs

D.6 XML-GPath-Notation

Register