Groovy: Grundlagen und fortgeschrittene Techniken

Groovy: Grundlagen und fortgeschrittene Techniken

by Joachim Baumann
Released March 2008
Publisher(s): dpunkt
ISBN: 9783898644457

Read it now on the O’Reilly learning platform with a 10-day free trial.

O’Reilly members get unlimited access to books, live events, courses curated by job role, and more from O’Reilly and nearly 200 top publishers.

Start your free trial

Book description

Grundlagen und fortgeschrittene Techniken

Groovy ist eine neue, auf Java aufbauende Sprache, die die Vorteile klassischer Programmier- und Skriptsprachen elegant vereint. Zusätzliche Sprachkonstrukte erlauben eine in Java nicht gekannte Produktivität. Durch Verzicht auf überflüssigen syntaktischen Ballast von Java und gleichzeitige vollständige Kompatibilität zu existierenden Java-Bibliotheken ist der Umstieg zudem sehr einfach.

Groovy eignet sich u.a. hervorragend zur XML-Bearbeitung, für grafische Benutzeroberflächen oder für das Testen von Groovy- und Java-Applikationen, aber auch Webserver lassen sich in 25 Zeilen implementieren.

Fundiert und leicht lesbar bietet Groovy-Committer Joachim Baumann anhand zahlreicher Beispiele zunächst eine umfassende Einführung in Groovy in der Version 1.5. Aufbauend darauf widmet er sich fortgeschrittenen Themen wie dem Meta Object Protocol, der Groovy-eigenen Erbauer/Builder-Infrastruktur sowie Möglichkeiten der funktionalen Programmierung oder der Integration mit Java-Applikationen, z.B. mit dem Spring Framework.

Nach der Lektüre werden Sie in der Lage sein, komplexe Groovy-Applikationen eigenständig und in Kombination mit Java zu entwickeln. Vorausgesetzt werden mittlere Java-Kenntnisse.

These links have been provided by the publisher.

Table of contents

  2. Copyright
  3. 1. Einleitung
    1. 1.1. Kleine Nabelschau
    2. 1.2. Unterteilung des Buches
    3. 1.3. Vollständige Beispiele
    4. 1.4. Detailinformationen
    5. 1.5. Zielgruppen und ihre Lesepfade
    6. 1.6. Website zum Buch
    7. 1.7. Zum Schluss eine Warnung
  4. I. Einführung
    1. 2. Was ist Groovy?
      1. 2.1. Einführung
      2. 2.2. Entstehungsgeschichte
      3. 2.3. Vorteile einer Skriptsprache
      4. 2.4. Die Sprache Groovy
      5. 2.5. Interaktion mit Java
      6. 2.6. Erweiterungen gegenüber Java
        1. 2.6.1. Erweiterte Spracheigenschaften
        2. 2.6.2. Erweiterte Java-Klassen
        3. 2.6.3. Bibliotheken (Beispiel Umgang mit XML)
    2. 3. Installation und Benutzung
      1. 3.1. Systeminstallation und -integration
        1. 3.1.1. Unix-Varianten
        2. 3.1.2. Windows
        3. 3.1.3. Cygwin
        4. 3.1.4. Fehlerbehebung
        5. 3.1.5. Inhalt des Installationsverzeichnisses
        6. 3.1.6. Das Konfigurationsverzeichnis
        7. 3.1.7. Automatische Ausführung von Groovy-Programmen
      2. 3.2. Der Groovy-Interpreter
      3. 3.3. Der Compiler von Groovy
        1. 3.3.1. Gemeinsame Übersetzung von Groovy und Java
      4. 3.4. GroovyShell
      5. 3.5. GroovyConsole
      6. 3.6. Einbindung in Entwicklungsumgebungen
        1. 3.6.1. Eclipse
        2. 3.6.2. NetBeans
        3. 3.6.3. IDEA
        4. 3.6.4. Fehlerbehebung
        5. 3.6.5. Editoren
        6. 3.6.6. Verfügbarkeit der IDE-Plugins
  5. II. Grundlagen
    1. 4. Sprachgrundlagen
      1. 4.1. Java: Wichtige Gemeinsamkeiten und Unterschiede
        1. 4.1.1. Kommentare
        2. 4.1.2. Namensraumunterstützung
        3. 4.1.3. Closures (Methoden erster und höherer Ordnung)
        4. 4.1.4. Anweisungen
        5. 4.1.5. Operatoren und Zuweisungen
        6. 4.1.6. Primitive Datentypen
        7. 4.1.7. Auswertung von Bedingungen
        8. 4.1.8. Kontrollstrukturen
        9. 4.1.9. Der ternäre Operator und der Elvis-Operator
        10. 4.1.10. Die Assert-Anweisung
        11. 4.1.11. Klassen und Methoden
        12. 4.1.12. Späte Typbindung
        13. 4.1.13. Implizite Annahmen
        14. 4.1.14. Notation
      2. 4.2. Skripte
        1. 4.2.1. Umbau eines Skriptes in eine Java-Klasse
        2. 4.2.2. Deklaration von Variablen
        3. 4.2.3. Argumente auf der Kommandozeile
      3. 4.3. Deklaration von Methoden
        1. 4.3.1. Getter und Setter – Bean-Eigenschaften in Groovy
      4. 4.4. Vordefinierte Imports
      5. 4.5. Sichere Navigation in Groovy
      6. 4.6. Elegante Typumwandlung in Groovy
      7. 4.7. Zeichenketten
        1. 4.7.1. Zusätzliche Methoden für Zeichenketten
        2. 4.7.2. Weitere Methoden ab Groovy 1.5
        3. 4.7.3. Überladene Operatoren
        4. 4.7.4. Formatierung von Zeichenketten
        5. 4.7.5. Der Typ GString
      8. 4.8. Operatoren
      9. 4.9. Operationen auf Zahlen
        1. 4.9.1. Automatische Typanpassung bei Zahlen
        2. 4.9.2. Groovy-spezifische Methoden für Zahlen
      10. 4.10. Collection-Typen
        1. 4.10.1. Der Typ Range
        2. 4.10.2. Der Typ List
        3. 4.10.3. Der Typ Map
        4. 4.10.4. Der Spread-Operator
      11. 4.11. Klassische Felder
      12. 4.12. Unterstützung für den Typ BitSet
      13. 4.13. Groovy und Iteratoren
      14. 4.14. Iteratoren und Closures
      15. 4.15. Dynamische Objekte (Expandos)
      16. 4.16. Neue Kontrollstrukturen in Groovy
        1. 4.16.1. Die For-Schleife
        2. 4.16.2. Das Switch-Konstrukt
      17. 4.17. Das Schlüsselwort in
      18. 4.18. Reguläre Ausdrücke
        1. 4.18.1. Kurzeinführung in reguläre Ausdrücke
        2. 4.18.2. Reguläre Ausdrücke in der Praxis
        3. 4.18.3. Reguläre Ausdrücke und isCase()
        4. 4.18.4. Matcher-Funktionalität
      19. 4.19. Zusammenfassung
    2. 5. Klassen in Groovy
      1. 5.1. Physikalische Organisation
        1. 5.1.1. Zuordnung von Datei und Klasse in Groovy
      2. 5.2. Sichtbarkeiten
      3. 5.3. Klassen
        1. 5.3.1. Attribute
        2. 5.3.2. Lokale Variablen
        3. 5.3.3. Methoden
        4. 5.3.4. Konstruktor
        5. 5.3.5. Vererbung
        6. 5.3.6. Enum-Typen
      4. 5.4. Interfaces
      5. 5.5. Das Schlüsselwort as
      6. 5.6. Annotationen
      7. 5.7. Generische Datentypen
      8. 5.8. Groovy-Beans
        1. 5.8.1. Deklaration
        2. 5.8.2. Der direkte Zugriff auf die Attribute
        3. 5.8.3. Event-Handling
      9. 5.9. GPath
        1. 5.9.1. Der Spread-Dot-Operator
      10. 5.10. Zusammenfassung
    3. 6. Closures
      1. 6.1. Einführung
      2. 6.2. Erzeugung einer Closure
      3. 6.3. Aufruf von Closures
      4. 6.4. Die Parameter
      5. 6.5. Rückkehr aus einer Closure
        1. 6.5.1. Verwendung von Break und Continue
        2. 6.5.2. Beeinflussung des umgebenden Kontrollflusses
      6. 6.6. Closures und GStrings
      7. 6.7. Der Typ Closure
        1. 6.7.1. Interessante Methoden des Typs Closure
      8. 6.8. Methodenreferenzen
      9. 6.9. Kontext und Sichtbarkeit
        1. 6.9.1. Lokale Variablen
        2. 6.9.2. Methoden und Attribute
      10. 6.10. Currying
      11. 6.11. Closures für Fortgeschrittene
        1. 6.11.1. Generatorfunktionen
        2. 6.11.2. Verkettung von Closures
        3. 6.11.3. Generatorfunktionen und Verkettung
      12. 6.12. Zusammenfassung
  6. III. Fortgeschrittene Themen
    1. 7. Das Meta Object Protocol
      1. 7.1. Einführung
        1. 7.1.1. Was ist das Meta Object Protocol?
        2. 7.1.2. Die nächsten Schritte
      2. 7.2. Categories
        1. 7.2.1. Iterator für Closures
      3. 7.3. Modifikation des Zugriffsoperators
        1. 7.3.1. Künstliche Eigenschaften
        2. 7.3.2. Eingriff in den Methodenaufruf
        3. 7.3.3. Dynamischer Aufruf von Methoden
        4. 7.3.4. Nicht existierende Methoden und Properties
      4. 7.4. Die Implementierung des MOP
        1. 7.4.1. Die Schnittstellen
        2. 7.4.2. Das Zusammenspiel
      5. 7.5. Eigene Metaklassen
        1. 7.5.1. Statische Registrierung von Metaklassen
        2. 7.5.2. Die Basisklasse MetaClassImpl
        3. 7.5.3. Die Basisklasse DelegatingMetaClass
        4. 7.5.4. Die Klasse ProxyMetaClass
      6. 7.6. Die Metaklasse ExpandoMetaClass
        1. 7.6.1. Methoden
        2. 7.6.2. Eigenschaften
        3. 7.6.3. Nicht existierende Methoden und Properties
        4. 7.6.4. Weitere interessante Methoden
        5. 7.6.5. Beeinflussung entlang des Ableitungsbaums
        6. 7.6.6. Schnittstellen
      7. 7.7. Zusammenfassung
    2. 8. Erweiterungen der Java-Bibliotheken
      1. 8.1. Einführung
      2. 8.2. Erweiterungen für alle Objekte
        1. 8.2.1. Ausgabe von Texten
        2. 8.2.2. Ausgabe von Objektinformation
        3. 8.2.3. Mehrere Operationen auf einem Objekt
        4. 8.2.4. Thread-Steuerung für alle Objekte
      3. 8.3. Dateioperationen
        1. 8.3.1. Dateisystem
        2. 8.3.2. Lesen von Daten
        3. 8.3.3. Schreiben von Daten
        4. 8.3.4. Umgang mit Objekten
        5. 8.3.5. Konvertieren von Daten
        6. 8.3.6. Kopieren von Daten
      4. 8.4. Nebenläufige Programmierung
      5. 8.5. Prozesse
        1. 8.5.1. Kontrolle über die Ein- und Ausgabeströme
        2. 8.5.2. Weitere interessante Methoden
      6. 8.6. Netzwerkkommunikation
        1. 8.6.1. URL
        2. 8.6.2. Base64-Kodierung
        3. 8.6.3. ServerSocket
        4. 8.6.4. Socket
        5. 8.6.5. Beispiel Webserver
      7. 8.7. Zusammenfassung
    3. 9. Die Groovy-Bibliotheken
      1. 9.1. Einführung
      2. 9.2. Erbauer
        1. 9.2.1. Konzept
        2. 9.2.2. Vom Konzept zur Implementierung
        3. 9.2.3. NodeBuilder
        4. 9.2.4. MarkupBuilder
        5. 9.2.5. StreamingMarkupBuilder
        6. 9.2.6. DOMBuilder
        7. 9.2.7. StreamingDOMBuilder
        8. 9.2.8. SAXBuilder
        9. 9.2.9. StreamingSAXBuilder
        10. 9.2.10. CLIBuilder
        11. 9.2.11. Eigene Erbauer
      3. 9.3. Grafik mit Groovy
        1. 9.3.1. SwingBuilder
        2. 9.3.2. SwingXBuilder
        3. 9.3.3. GraphicsBuilder
      4. 9.4. Einlesen und Bearbeiten von XML
        1. 9.4.1. Einlesen von XML-Inhalten
        2. 9.4.2. Node-Objekte und GPathResult-Objekte
        3. 9.4.3. Unterstützung für Document Object Models
      5. 9.5. Ant-Unterstützung
        1. 9.5.1. Verwendung von Groovy in Ant
        2. 9.5.2. Übersetzung von Groovy-Quellen
        3. 9.5.3. AntBuilder
        4. 9.5.4. Gant
      6. 9.6. Datenbankunterstützung
        1. 9.6.1. Die Datenbankverbindung
        2. 9.6.2. Normale und vorbereitete SQL-Anweisungen
        3. 9.6.3. Erzeugen von Daten
        4. 9.6.4. Lesen der Daten
        5. 9.6.5. Modifizieren und Löschen von Daten
        6. 9.6.6. Metadaten
        7. 9.6.7. Stored Procedures
        8. 9.6.8. Der Typ DataSet
      7. 9.7. Testunterstützung
        1. 9.7.1. Tests in Groovy
        2. 9.7.2. Organisation der Tests
        3. 9.7.3. Testen für Fortgeschrittene
        4. 9.7.4. TestNG
      8. 9.8. Zusammenfassung
    4. 10. Groovy und Java – Interaktionsmöglichkeiten
      1. 10.1. Einführung
      2. 10.2. Grundsätzliche Zusammenhänge
        1. 10.2.1. Explizite Übersetzung
        2. 10.2.2. Implizite Übersetzung
        3. 10.2.3. Vor- und Nachteile
      3. 10.3. Einbinden von Groovy
      4. 10.4. Groovy-eigene Möglichkeiten der Integration
        1. 10.4.1. Einfache Ausführung einer Folge von Anweisungen
        2. 10.4.2. Die Klasse GroovyShell
        3. 10.4.3. GroovyScriptEngine
        4. 10.4.4. Der Groovy-eigene Klassenlader
        5. 10.4.5. Integration mit dem Java-Sicherheitsmodell
      5. 10.5. Java 6 Scripting API
        1. 10.5.1. Erste Schritte
        2. 10.5.2. Programmatische Verwendung
        3. 10.5.3. Fortgeschrittene Verwendung
      6. 10.6. Integration mit Spring
        1. 10.6.1. Erzeugen einer Applikation
        2. 10.6.2. Verwendung von Groovy-Klassen
        3. 10.6.3. Eingebettete Skripte
        4. 10.6.4. Vor- und Nachteile
      7. 10.7. Zusammenfassung
    5. 11. Was fehlt?
      1. 11.1. Groovy-Klassen
      2. 11.2. Module für Groovy
      3. 11.3. Zum Schluss
  7. IV. Anhang
    1. A. Das GDK – Groovy Development Kit
      1. A.1. GDK-Methoden (496 Methoden)
        1. A.1.1. Normale Klassen
        2. A.1.2. Primitive Datentypen
      2. A.2. DOMCategory
        1. A.2.1. Element
        2. A.2.2. NodeList
        3. A.2.3. NamedNodeMap
    2. B. Erbauermethoden
      1. B.1. SwingBuilder
        1. B.1.1. Eigenständige Komponenten
        2. B.1.2. Optional eigenständige Komponenten
        3. B.1.3. Komponenten
        4. B.1.4. Container
        5. B.1.5. Layout-Manager
        6. B.1.6. GridBagLayout – Constraints
        7. B.1.7. BoxLayout – Angebotene Methoden
        8. B.1.8. TableLayout – Methoden
        9. B.1.9. TableLayout – Attribute für Zellen
        10. B.1.10. Menu-Funktionalität
        11. B.1.11. Modelle
        12. B.1.12. Action-Objekte
        13. B.1.13. Attribute für Action-Objekte
        14. B.1.14. Erweiterung
      2. B.2. SwingXBuilder
        1. B.2.1. Komponenten
        2. B.2.2. MultiSplitLayout – Methoden
        3. B.2.3. Painter
        4. B.2.4. Effekte
        5. B.2.5. Filter
        6. B.2.6. Highlighter
      3. B.3. GraphicsBuilder
        1. B.3.1. Methoden zum Erzeugen von Objekten
        2. B.3.2. Operationen auf Gebieten
        3. B.3.3. Transformationen
        4. B.3.4. Erweiterungen für Java 1.6
        5. B.3.5. Erweiterungen für SwingX
        6. B.3.6. Farben
    3. Literatur

Product information

  • Title: Groovy: Grundlagen und fortgeschrittene Techniken
  • Author(s): Joachim Baumann
  • Release date: March 2008
  • Publisher(s): dpunkt
  • ISBN: 9783898644457