O'Reilly logo

Stay ahead with the world's most comprehensive technology and business learning platform.

With Safari, you learn the way you learn best. Get unlimited access to videos, live online training, learning paths, books, tutorials, and more.

Start Free Trial

No credit card required

Gradle Beyond the Basics

Book Description

  • Gradle wird als Build-Tool für Java und Groovy immer populärer, vergleichbar Ant und Maven früher+ Mit einem Geleitwort von Hans Dockter, dem Erfinder von Gradle

Table of Contents

  1. Cover
  2. Titel
  3. Impressum
  4. Vorwort
    1. Zielgruppen für dieses Buch
    2. Notwendige Vorkenntnisse für das Buch
    3. Was dieses Buch nicht enthält
    4. Was dieses Buch enthält
    5. Danksagung
  5. Geleitwort
  6. Inhaltsverzeichnis
  7. 1 Einleitung
    1. make
    2. Ant
    3. Maven
    4. Gradle
    5. 1.1 Grundsätzliche Aufgaben eines Build-Management-Werkzeugs
    6. 1.2 Gradle – Kurzübersicht
    7. 1.3 Migrationspfade von anderen Build-Management-Werkzeugen
    8. 1.4 Installation
      1. 1.4.1 Kurzanleitung
      2. 1.4.2 Windows
        1. Die Umgebungsvariablen setzen
      3. 1.4.3 Unix-Varianten
        1. Setzen des Pfades
      4. 1.4.4 Mac
        1. Direkte Installation
        2. Setzen des Pfades
    9. 1.5 Gradle aufrufen
      1. Interessante und hilfreiche Tasks von Gradle
      2. Wichtige Kommandozeilenoptionen für Gradle
    10. 1.6 Erste Schritte
      1. 1.6.1 Unser erstes Skript für die Konfigurationsphase
      2. 1.6.2 Unser erstes Skript für die Ausführungsphase
      3. 1.6.3 Definition von Abhängigkeiten
    11. 1.7 Einbindung in Entwicklungsumgebungen
    12. Intellij IDEA
    13. NetBeans
    14. Eclipse
    15. 1.8 Weitergehende Informationen
  8. 2 Der Einstieg
    1. 2.1 Unser erstes Projekt
    2. 2.2 Hinzufügen von Tests
      1. 2.2.1 Abhängigkeiten und Konfigurationen in Gradle
      2. 2.2.2 Manipulation der Jar-Datei und des zugehörigen Manifests
    3. 2.3 Das Application-Plug-in
    4. 2.4 Verwendung von TestNG
    5. 2.5 Spock
    6. 2.6 Teststufen
    7. 2.7 Qualitätssicherung des Quelltextes
      1. 2.7.1 Das PMD-Plug-in
      2. 2.7.2 Einstellen des Report-Typs
      3. 2.7.3 Das Checkstyle-Plug-in
      4. 2.7.4 Verwendung von Ant zur Erzeugung des HTML-Reports
      5. 2.7.5 Das FindBugs-Plug-in
      6. 2.7.6 Das JDepend-Plug-in
    8. 2.8 Testabdeckung
      1. Einbinden externer Skripte
    9. 2.9 Sonar
      1. Ausführen von Sonar
    10. 2.10 Kopieren der Artefakte in ein Repository
      1. 2.10.1 Veröffentlichen in ein lokales Verzeichnis
      2. 2.10.2 Versionierung unserer Artefakte
      3. 2.10.3 Veröffentlichen mit Maven
        1. Versionsnamen mit und ohne Zeitstempel
      4. 2.10.4 Signieren der Ergebnisse
    11. 2.11 Groovy-Projekte mit Gradle
      1. Auswahl der qualitätssichernden Plug-ins
      2. Konfiguration von CodeNarc
    12. 2.12 Scala-Projekte mit Gradle
      1. 2.12.1 Unser erstes Scala-Programm
      2. 2.12.2 Tests für unser Scala-Programm
        1. Testen mit Java
        2. Testen mit Scala
        3. Ergebnis unserer Tests
      3. 2.12.3 Weitergehende Konfiguration
    13. 2.13 Unsere erste Webapplikation
      1. 2.13.1 Die Struktur der Webapplikation
      2. 2.13.2 Weitere Dateien für die Webapplikation
      3. 2.13.3 Die Ausführung unserer Webapplikation
      4. 2.13.4 Ein einfacher Test unserer Webapplikation
  9. 3 Weitergehende Details
    1. 3.1 Groovy für Gradle
      1. 3.1.1 Allgemeine Syntax
      2. 3.1.2 Skripte
      3. 3.1.3 Operatorüberladung
      4. 3.1.4 Benannte Parameter für Methodenaufrufe
      5. 3.1.5 Closures
      6. 3.1.6 Meta Object Protocol
      7. 3.1.7 Erbauermuster (Builder-Pattern)
        1. Die Verwendung eines Erbauers in Groovy
    2. 3.2 Das Build-Skript
      1. Die Struktur des Build-Skripts
    3. 3.3 Das Projekt
      1. 3.3.1 Deklaration von dynamischen Eigenschaften und Methoden
        1. Dynamische Methoden
      2. 3.3.2 Externe Eigenschaften
        1. Setzen über die Kommandozeile
        2. Test auf Existenz einer Eigenschaft
        3. Übergabe mittels Umgebungsvariablen
        4. Die Datei gradle.properties
        5. Das Init-Skript
    4. 3.4 Der Task
      1. Die Erzeugung und Konfiguration eines Tasks
      2. Überschreiben eines existierenden Tasks
      3. Die Konfigurations-Closure
      4. 3.4.1 Der voreingestellte Task
      5. 3.4.2 Abhängigkeiten von Tasks
      6. 3.4.3 Beeinflussung der Ausführung
        1. Die Eigenschaft enabled
        2. Verwendung einer Bedingung
        3. Werfen einer StopExecutionException
        4. Werfen einer StopActionException
        5. Ein Beispiel
        6. Werfen einer anderen Ausnahme
      7. 3.4.4 Regelbasierte Tasks
      8. 3.4.5 Aktualität der Task-Ergebnisse
        1. Setzen der Input- und Output-Dateien
    5. 3.5 Umgang mit Dateien
      1. Gradle bietet mehr Abstraktionen für Dateien als Groovy
      2. 3.5.1 Einzelne Dateien
      3. 3.5.2 Mengen von Dateien
        1. Filtern einer FileCollection
      4. 3.5.3 Hierarchien von Dateien
        1. Lesen von Archiven
      5. 3.5.4 Operationen auf Dateien
        1. Kopieren von Dateien
    6. 3.6 Ausführung externer Kommandos
      1. Ausführung von Java-Klassen
    7. 3.7 Häufig benutzte Task-Typen
      1. 3.7.1 Umgang mit Dateien
        1. Die Verwendung des Sync-Tasks
      2. 3.7.2 Archivierung von Dateien
      3. 3.7.3 Benennung von Ergebnissen
      4. 3.7.4 Ausführung externer Programme
      5. 3.7.5 Erzeugung initialer Installationsskripte
        1. Kontrollierte Aktualisierung von Gradle in Build-Umgebungen
    8. 3.8 Logging mit Gradle
    9. 3.9 Umgang mit Quellen
      1. 3.9.1 Hinzufügen von Quellen
      2. 3.9.2 Integration von SourceSets in den Build
        1. Übernehmen der Daten von existierenden Konfigurationen
        2. Referenzieren von Ergebnisdateien
        3. Einfügen in den Build-Prozess
        4. Verwendung in eigenen Tasks
    10. 3.10 Testen im Detail
      1. Setzen von Systemeigenschaften für den Test
      2. Beeinflussung der Java Virtual Machine
      3. Angabe von Quellen und Orte für Ergebnisse
    11. 3.11 Verwendung von Plug-ins
      1. Domänenobjekte von Plug-ins
      2. Plug-ins für Gradle
    12. 3.12 Externe Abhängigkeiten
      1. Transitive Abhängigkeiten
      2. Übersicht über alle Abhängigkeiten
      3. Versionskonflikte
      4. Allgemeine Festlegung der Version von Abhängigkeiten
      5. Ausschluss transitiver Abhängigkeiten
      6. Anbindung von Repositories
    13. 3.13 Gradle GUI
    14. 3.14 Konfiguration des Build-Environments
      1. 3.14.1 Grundsätzliche Konfigurationseigenschaften
      2. 3.14.2 Verwendung eines Web-Proxys
        1. Setzen der Werte in einer Windows-Domäne
    15. 3.15 Gradle-Daemon
      1. Kommandozeilenoptionen
      2. Identifikation von Problemen
      3. Details
    16. 3.16 Laufzeiten des Builds
    17. 3.17 Online-Dokumentation
  10. 4 Migration zu Gradle
    1. 4.1 Ant
      1. 4.1.1 Gradle und Ant
      2. 4.1.2 Verwendung von Ant-Tasks
      3. 4.1.3 Verwendung zusätzlicher Bibliotheken
        1. Ausführung eines Skripts als Ant-Task
      4. 4.1.4 Verwendung eigener Ant-Tasks
      5. 4.1.5 Verwendung vollständiger Ant-Build-Dateien
    2. 4.2 Maven
      1. 4.2.1 Vergleich der Build-Skripte
      2. 4.2.2 Konvertierung eines Maven-Build-Skripts
        1. Das maven2gradle-Plug-in
        2. Verwendung des maven2gradle-Plug-ins
        3. Notwendige Nacharbeiten
  11. 5 Multiprojekt-Builds
    1. 5.1 Die Ausgangsbasis
      1. 5.1.1 Das Teilprojekt service
        1. Die Testklasse
        2. Das klassische Build-Skript
      2. 5.1.2 Das Teilprojekt client
    2. 5.2 Der Umbau in einen Multiprojekt-Build
      1. 5.2.1 Die Datei settings.gradle
      2. 5.2.2 Hinzufügen des ersten Teilprojekts
        1. Aufruf von Tasks im Multiprojekt-Build
      3. 5.2.3 Konfiguration durch das Elternprojekt
      4. 5.2.4 Der vernünftige Mittelweg
      5. 5.2.5 Hinzufügen des zweiten Teilprojekts
    3. 5.3 Weitere Funktionalität für Multiprojekte
      1. 5.3.1 Abhängigkeit von Tasks anderer Teilprojekte
      2. 5.3.2 Abhängigkeit in der Konfigurationsphase
      3. 5.3.3 Projektübergreifende Definition von Tasks
    4. 5.4 Verwendung eines Initialisierungsskripts
  12. 6 Integration mit dem Build-Server
    1. 6.1 Integration mit Jenkins
      1. Installation des Gradle-Plug-ins
      2. Konfiguration der Gradle-Installation in Jenkins
      3. Einrichten eines Gradle-Jobs
      4. Unser erster Build
      5. Die Build-Ergebnisse
    2. 6.2 Integration mit JetBrains TeamCity
      1. Einrichten eines TeamCity-Projekts
      2. Unser erster Build
  13. 7 Erweiterung von Gradle
    1. 7.1 Arten von Erweiterungen
    2. 7.2 Orte für Erweiterungen
      1. 7.2.1 Das Build-Skript
      2. 7.2.2 Externe Skripte
      3. 7.2.3 Das Verzeichnis buildSrc
      4. 7.2.4 Eigene Projekte
      5. 7.2.5 Wahl der Variante
    3. 7.3 Eigene Tasks
      1. 7.3.1 Annotationen für unsere eigenen Task-Klassen
      2. 7.3.2 Ein einfaches Beispiel
      3. 7.3.3 Ein komplettes Beispiel
      4. 7.3.4 Unser Task im Verzeichnis buildSrc
        1. Die Task-Klasse
        2. Das Build-Skript
      5. 7.3.5 Unser Task im eigenen Projekt
      6. 7.3.6 Verwendung von Tasks aus Bibliotheken
        1. Angabe eines Archivs in einem lokalen Verzeichnis
        2. Angabe eines Archivs in einem Repository
        3. Die Verwendung
    4. 7.4 Eigene Plug-ins
      1. 7.4.1 Ein einfaches Beispiel
      2. 7.4.2 Ein komplexeres Beispiel
      3. 7.4.3 Integration mit dem Build-Skript
        1. Direkter Zugriff auf das Plug-in
        2. Integration mit der Project-Instanz
        3. Verwendung von Konventionsobjekten
        4. Verwendung von Erweiterungsobjekten
        5. Erzeugung von Mengen gleichartiger Objekte
      4. 7.4.4 Ein komplettes Beispiel mit Konventionsobjekten
        1. Einführung eines Proxy-Objekts
      5. 7.4.5 Das komplette Beispiel mit Erweiterungsobjekten
        1. Einführung eines Proxy-Objekts
      6. 7.4.6 Unser Plug-in im Verzeichnis buildSrc
        1. Die Klasse TestTypePlugin mit Konventionsobjekt
        2. Die Klasse TestTypePlugin mit Erweiterungsobjekt
        3. Die anderen Klassen
        4. Das Build-Skript
      7. 7.4.7 Unser Plug-in im eigenen Projekt
        1. Definition eines logischen Namens
        2. Die Verwendung von Plug-ins aus Bibliotheken
  14. 8 Praktische Vorgehensweisen
    1. 8.1 Explizite Vorgaben
      1. Projektabhängigkeiten
      2. Build-Abhängigkeiten
    2. 8.2 Multiprojektumgebungen
      1. Explizite Vorgaben
      2. Einfachheit des Skripts
    3. 8.3 Einsatz von Ant-Tasks
    4. 8.4 Quelltext im Gradle-Skript
    5. 8.5 Konfiguration der Tests
    6. 8.6 Ausgaben Ihrer Skripte
  15. 9 Weitere Plug-ins
    1. 9.1 Verwendung des Tomcat als Webcontainer
    2. 9.2 Integration mit Git
      1. 9.2.1 Die Verwendung von GitClone
      2. 9.2.2 Erzeugen eines Entwicklungs-Branch
      3. 9.2.3 Verwendung von Feature-Branches
      4. 9.2.4 Übernahme von Daten
      5. 9.2.5 Zusammenführen von Änderungen
      6. 9.2.6 Setzen von Tags
      7. 9.2.7 Weitergehende Funktionalität
    3. 9.3 Erzeugung von Versionsnummern
      1. 9.3.1 Verwendung des Quelltextverwaltungssystems
    4. 9.4 Weitere Plug-ins
  16. 10 Zusammenfassung
  17. 11 Literatur
  18. Index
  19. Fußnote
    1. Kapitel 1