Advertisement
  1. Code
  2. Android Studio

Die Vor- und Nachteile von Gradle

Scroll to top
Read Time: 12 min

German (Deutsch) translation by Alex Grigorovich (you can also view the original English article)

Als erste IDE (Integrated Development Environment), die sich ausschließlich Android widmet, ist das von Google unterstützte Android Studio eine aufregende Perspektive für Android-Entwickler. Es bedeutet aber auch, sich mit einer neuen Technologie vertraut zu machen, insbesondere mit dem Gradle-Build-System.

In diesem Artikel lernen Sie das neue Build-System von Android kennen, von den Grundlagen dessen, was Gradle ist und was es tut, über einen detaillierten Blick auf einige der wichtigsten Gradle-Dateien bis hin zum Erlernen der Ausführung und Überwachung von Gradle-Aufgaben.

Sie werden sich auch die verschiedenen Gradle-Werkzeug-Fenster in Android Studio genauer ansehen und lernen, wie Sie einem Projekt Abhängigkeiten hinzufügen, ohne dass zuvor Gradle-Kenntnisse erforderlich sind.

Der erste Schritt, um das neue Build-System von Android in den Griff zu bekommen, besteht darin, genau zu verstehen, was Gradle ist und warum seine Aufnahme in Android Studio für Android-Entwickler eine so gute Nachricht ist.

1. Was ist Gradle?

Gradle ist ein automatisiertes Build-Werkzeugkit, das über Plugins in viele verschiedene Umgebungen integriert werden kann. In Android Studio wird die Gradle-Integration über das treffend benannte Android Gradle-Plugin erreicht.

Wenn Sie Gradle noch nie zuvor verwendet haben, scheint dies eine frustrierende Eintrittsbarriere zu sein, wenn Sie über einen Wechsel zu Android Studio nachdenken. Gradle hat Android-Entwicklern jedoch viel zu bieten. Es lohnt sich also, etwas Zeit in das Erlernen der Vor- und Nachteile von Gradle zu investieren. Hier sind nur einige der Dinge, die Sie mit Gradle tun können.

Minimieren Sie die für neue Projekte erforderliche Konfiguration

Gradle hat Standardkonfigurationseinstellungen, die automatisch auf jedes Projekt angewendet werden, das Sie in Android Studio erstellen. Wenn Sie ein Projekt entwickeln, das diese Standardkonfigurationsregeln nicht einhält, lässt sich Gradle einfach anpassen.

Projektabhängigkeiten deklarieren

Abhängigkeiten können Module, JAR-Dateien oder Bibliotheken sein und sich entweder im lokalen Dateisystem oder auf einem Remote-Server befinden.

Testen Sie Ihr Projekt

Gradle generiert automatisch ein Testverzeichnis und eine Test-APK aus den Testquellen Ihres Projekts und kann Ihre Tests während des Erstellungsprozesses ausführen.

Generieren Sie signierte APKs

Wenn Sie Ihrer Gradle-Builddatei alle erforderlichen Informationen wie keyPassword und keyAlias hinzufügen, können Sie mit Gradle signierte APKs generieren.

Generieren Sie mehrere APKs aus einem einzigen Modul

Gradle kann mehrere APKs mit unterschiedlichen Paket- und Build-Konfigurationen aus einem einzigen Modul generieren. Diese Funktion ist aus mehreren Gründen besonders praktisch für Android-Entwickler:

1. Unterstützen Sie eine breite Palette von Geräten

Ein großer Teil der Entwicklung für die Android-Plattform besteht darin, möglichst viele verschiedene Android-Geräte und -Versionen des Android-Betriebssystems zu unterstützen. Der Google Play Store bietet sogar Unterstützung für mehrere APKs, sodass Sie mehrere Versionen Ihrer App erstellen können, wobei jede Version auf eine andere Gerätekonfiguration abzielt und diese als einzelne Play Store-Liste anbietet.

Hier kommt Gradle ins Spiel. Sie können das neue Build-System von Android verwenden, um mehrere APK-Varianten aus demselben Modul zu generieren. Geben Sie diesen Varianten einfach denselben Paketnamen und Sie können sie in dieselbe Google Play-Liste hochladen.

2. Bieten Sie verschiedene Versionen einer App an

Manchmal möchten Sie mehrere Versionen Ihrer App im Play Store auflisten, beispielsweise wenn Sie eine kostenlose und eine "Pro"-Version Ihrer App anbieten. Auch hier können Sie Gradle verwenden, um mehrere APKs aus demselben Modul zu generieren und jedem APK einen anderen Paketnamen zu geben. Sie können dann jede APK separat in den Play Store hochladen.

2. Durchsuchung der Gradle-Dateien

Wenn Sie ein Projekt in Android Studio erstellen, generiert das Build-System automatisch alle erforderlichen Gradle-Build-Dateien.

Da bei jedem Erstellen eines Android Studio-Projekts die gleichen Gradle-Dateien angezeigt werden, erstellen wir ein grundlegendes Beispielprojekt und sehen uns diese automatisch generierten Dateien genauer an.

Der erste Schritt ist das Erstellen Ihres Beispielprojekts:

  1. Starten Sie Android Studio.
  2. Klicken Sie auf Neues Android Studio-Projekt starten.
  3. Geben Sie Ihrem Projekt einen Namen, geben Sie eine Domain ein und wählen Sie aus, wo Ihr Beispielprojekt gespeichert werden soll. Weiter klicken.
  4. Stellen Sie sicher, dass nur Telefon und Tablet ausgewählt sind, und akzeptieren Sie die Standardeinstellungen für das minimale SDK. Weiter klicken.
  5. Wählen Sie Leere Aktivität und klicken Sie auf Weiter.
  6. Halten Sie sich an die Standardeinstellungen und klicken Sie auf Fertig stellen.

Gradle Build-Dateien

Gradle-Build-Dateien verwenden eine domänenspezifische Sprache oder DSL, um eine benutzerdefinierte Build-Logik zu definieren und mit den Android-spezifischen Elementen des Android-Plugins für Gradle zu interagieren.

Android Studio-Projekte bestehen aus einem oder mehreren Modulen. Dies sind Komponenten, die Sie unabhängig voneinander erstellen, testen und debuggen können. Jedes Modul verfügt über eine eigene Build-Datei, sodass jedes Android Studio-Projekt zwei Arten von Gradle-Build-Dateien enthält:

  • Build-Datei der obersten Ebene: Hier finden Sie die Konfigurationsoptionen, die allen Modulen Ihres Projekts gemeinsam sind.
  • Build-Datei auf Modulebene: Jedes Modul verfügt über eine eigene Gradle-Build-Datei, die modulspezifische Build-Einstellungen enthält. Sie verbringen die meiste Zeit damit, Build-Dateien auf Modulebene und nicht die Build-Datei Ihres Projekts auf oberster Ebene zu bearbeiten.

Um einen Blick auf diese build.gradle-Dateien zu werfen, öffnen Sie das Projektfenster von Android Studio (indem Sie die Registerkarte Projekt auswählen) und erweitern Sie den Ordner Gradle Scripts. In unserem Beispielprojekt sind die ersten beiden Elemente in der Liste die Build-Dateien Ihres Projekts auf oberster und Modulebene.

The first two items in the Gradle Scripts folder are the project-level and module-level Gradle build filesThe first two items in the Gradle Scripts folder are the project-level and module-level Gradle build filesThe first two items in the Gradle Scripts folder are the project-level and module-level Gradle build files

Unser Beispielprojekt enthält nur eine Build-Datei auf Modulebene. Der folgende Screenshot gibt Ihnen jedoch eine Vorstellung davon, wie der Ordner "Gradle Scripts" für ein Projekt mit mehreren Modulen aussehen könnte.

Example of how the Gradle Scripts folder looks for a multiple module projectExample of how the Gradle Scripts folder looks for a multiple module projectExample of how the Gradle Scripts folder looks for a multiple module project

Gradle-Build-Datei der obersten Ebene

Jedes Android Studio-Projekt enthält eine einzelne Gradle-Build-Datei der obersten Ebene. Diese build.gradle-Datei ist das erste Element, das im Gradle Scripts-Ordner angezeigt wird und deutlich als Projekt gekennzeichnet ist.

Meistens müssen Sie keine Änderungen an dieser Datei vornehmen, aber es ist immer noch nützlich, den Inhalt und die Rolle zu verstehen, die sie in Ihrem Projekt spielt. Unten finden Sie eine kommentierte Version einer typischen Build-Datei der obersten Ebene.

1
buildscript {
2
3
//Project-level Gradle build files use buildscript to define dependencies.//

4
5
    repositories {
6
7
        jcenter()
8
    }
9
10
//This file relies on the jJCenter repository.//

11
12
    dependencies {
13
14
   classpath 'com.android.tools.build:gradle:1.0.0'
15
16
//Project is dependent on version 1.0.0 of the Android plugin for Gradle.// 

17
18
    }
19
}
20
21
allprojects {
22
23
//Defines the dependencies required by your application.//

24
25
    repositories {
26
        jcenter()
27
    }
28
}
29
30
//Application depends on the jCenter repository.// 

Gradle-Build-Dateien auf Modulebene

Zusätzlich zur Gradle-Build-Datei auf Projektebene verfügt jedes Modul über eine eigene Gradle-Build-Datei. Unten finden Sie eine kommentierte Version einer einfachen Gradle-Build-Datei auf Modulebene.

1
apply plugin: 'com.android.application'
2
3
//Since this project is an Android app, the build.gradle file utilises the Android plugin.//

4
5
android {
6
7
//The following section configures all your project’s Android-specific parameters, and tells Gradle which version of Android it should build your project with. If you’ve developed Android applications before, the following should all be familiar.//

8
9
    compileSdkVersion 21
10
11
//The API your project is targeting.// 

12
13
    buildToolsVersion "21.1.1"
14
15
////The version of the build tools you want to use.//

16
17
    defaultConfig {
18
19
        applicationId "com.example.jessica.myapplication"
20
21
//Defines your application’s ID. Note, earlier versions of the Android plugin used ‘packageName’ instead of ‘applicationID.’//

22
23
        minSdkVersion 16
24
25
//The minimum API required by your project.//

26
27
        targetSdkVersion 21
28
29
//The version of Android you’re developing your application for.//

30
        
31
versionCode 1
32
33
        versionName "1.0"
34
    }
35
36
    buildTypes {
37
        release {
38
39
//‘BuildTypes’ controls how your app is built and packaged. If you want to create your own build variants, you’ll need to add them to this section.//

40
41
            minifyEnabled true
42
43
//Gradle runs ProGuard during the build process.//

44
45
            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
46
47
//Applies the default ProGuard settings from the Android SDK.// 

48
49
        }
50
    }
51
}
52
53
dependencies {
54
55
//Declares the dependencies for the current module.//

56
57
   compile fileTree(dir: 'libs', include: ['*.jar'])
58
59
//Although you can add JAR files by compiling them individually, this can be time-consuming if you have lots of JARs. In this example, we’re telling Gradle to add all the JAR files in the app/libs folder.// 

60
61
  compile 'com.android.support:appcompat-v7:21.0.3'
62
63
//To create more dependencies, add them to the depencies closure.//

64
65
}

Andere Gradle-Dateien

Zusätzlich zu den build.gradle-Dateien enthält Ihr Gradle Scripts-Ordner einige andere Gradle-Dateien. Meistens müssen Sie diese Dateien nicht manuell bearbeiten, da sie automatisch aktualisiert werden, wenn Sie relevante Änderungen an Ihrem Projekt vornehmen. Es ist jedoch eine gute Idee, die Rolle dieser Dateien in Ihrem Projekt zu verstehen.

gradle-wrapper.properties (Gradle-Version)

Mit dieser Datei können andere Personen Ihren Code erstellen, auch wenn Gradle nicht auf ihrem Computer installiert ist. Diese Datei prüft, ob die richtige Version von Gradle installiert ist, und lädt bei Bedarf die erforderliche Version herunter. In unserer Beispiel-App enthält gradle-wrapper.properties Folgendes:

1
distributionBase=GRADLE_USER_HOME
2
3
//Determines whether the unpacked wrapper distribution should be stored in the project, or in the Gradle user home directory.//

4
5
distributionPath=wrapper/dists
6
7
//The path where the Gradle distributions required by the wrapper are unzipped.//

8
9
zipStoreBase=GRADLE_USER_HOME
10
11
zipStorePath=wrapper/dists
12
13
distributionUrl=https\://services.gradle.org/distributions/gradle-2.2.1-all.zip

14
15
//The URL where the correct version of Gradle should be downloaded from.//

settings.gradle

Diese Datei verweist auf alle Module, aus denen Ihr Projekt besteht. Da unser Beispielprojekt ein einzelnes Modul enthält, ist diese Datei sehr einfach, wie Sie unten sehen können.

1
include ':app'

gradle.properties (Projekteigenschaften)

Diese Datei enthält Konfigurationsinformationen für Ihr gesamtes Projekt. Es ist standardmäßig leer, aber Sie können Ihrem Projekt eine Vielzahl von Eigenschaften zuweisen, indem Sie sie dieser Datei hinzufügen.

local.properties (SDK-Speicherort)

Diese Datei teilt dem Android Gradle-Plugin mit, wo sich Ihre Android SDK-Installation befindet. Beispielsweise:

1
sdk.dir=/Users/jessica/Library/Android/sdk

Beachten Sie, dass local.properties Informationen enthält, die für die lokale Installation des Android SDK spezifisch sind. Dies bedeutet, dass Sie diese Datei nicht unter Quellcodeverwaltung halten sollten.

3. Android Studio-Benutzeroberfläche

Nachdem Sie mit allen automatisch generierten Gradle-Dateien vertraut sind, ist es an der Zeit, mit dem Gradle-Build-System zu interagieren. Die gute Nachricht ist, dass Sie direkt über die Android Studio-Benutzeroberfläche mit Gradle interagieren können.

An den vertikalen und horizontalen Rändern von Andorid Studio befinden sich Registerkarten, die verschiedene Werkzeugfenster öffnen. In den nächsten Abschnitten werde ich Ihnen einige Gradle-spezifische Werkzeug-Fenster von Android Studio vorstellen und zeigen, wie Sie über diese Fenster mit dem Gradle-Build-System interagieren.

Gradle-Aufgabenfenster

Sie können das Gradle-Aufgabenfenster verwenden, um die verschiedenen Aufgaben zu durchsuchen und auszuführen, die beim Kompilieren Ihres Projekts in eine ausführbare Anwendung erforderlich sind.

Klicken Sie zum Öffnen des Gradle-Aufgabenfensters auf die Registerkarte Gradle auf der rechten Seite Ihrer Android Studio-Installation. Wenn Sie Ihre Android Studio-Benutzeroberfläche angepasst haben und die Registerkarte Gradle nicht mehr finden, können Sie stattdessen Ansicht > Werkzeugfenster > Gradle auswählen.

Doppelklicken Sie auf der Registerkarte Gradle-Aufgaben auf Ihr Projekt, gefolgt von Ihrem Modul. Sie sehen eine Liste aller Gradle-Aufgaben, die sich auf dieses Modul beziehen.

Select the Gradle tab to reveal the Gradle tasks windowSelect the Gradle tab to reveal the Gradle tasks windowSelect the Gradle tab to reveal the Gradle tasks window

Wenn Sie im Gradle-Aufgabenfenster auf eine Aufgabe doppelklicken, wird sie ausgeführt und die Ausgabe wird in einem anderen Gradle-spezifischen Fenster, der Gradle-Konsole, angezeigt.

Gradle-Konsole

Die Gradle-Konsole zeigt die Ausgabe von Gradle-Aufgaben während ihrer Ausführung zusammen mit Fehlermeldungen oder Warnungen an.

Um die Gradle-Konsole zu öffnen, wählen Sie die Registerkarte Gradle-Konsole unten rechts in Ihrer IDE. Wenn Sie die Benutzeroberfläche von Android Studio angepasst haben und diese Registerkarte nicht mehr finden, können Sie stattdessen immer Ansicht > Werkzeugfenster > Gradle-Konsole auswählen.

Lassen Sie uns die Gradle-Konsole ausprobieren. Suchen Sie im Gradle-Aufgabenfenster die assemble-Aufgabe, die eine Release-Version Ihrer Anwendung erstellt, die zur Verteilung bereit ist, und doppelklicken Sie darauf. Während die assembler-Aufgabe ausgeführt wird, wird die Ausgabe der Aufgabe in der Gradle-Konsole angezeigt.

Die Gradle-Konsole benachrichtigt Sie dann entweder darüber, dass Ihr Projekt erfolgreich erstellt wurde, oder es wird eine Meldung "Build fehlgeschlagen" zusammen mit Informationen darüber angezeigt, warum Ihr Build fehlgeschlagen ist.

Example of the assemble task output in the Gradle ConsoleExample of the assemble task output in the Gradle ConsoleExample of the assemble task output in the Gradle Console

Terminal

Sie können Gradle-Aufgaben auch über das integrierte Terminal von Android Studio ausführen. Wenn Sie genau wissen, welche Gradle-Aufgabe Sie ausführen möchten, ist das Terminal normalerweise viel schneller und bequemer als das Durchsuchen der Aufgabenlisten in der Gradle-Konsole.

Klicken Sie zum Öffnen des Terminals auf die Registerkarte Terminal unten links in Android Studio oder wählen Sie Ansicht > Werkzeug Windows > Gradle Console. Das Terminal wird dann mit dem bereits ausgewählten aktuellen Verzeichnis geöffnet. Sie können dann Gradle-Aufgaben ausführen, indem Sie sie in das Terminal eingeben und entweder der Return oder die Eingabetaste auf Ihrer Tastatur drücken.

4. Abhängigkeiten hinzufügen

In diesem Abschnitt erfahren Sie, wie Sie mit Gradle die Modulabhängigkeiten, lokalen Binärabhängigkeiten und Remote-Binärabhängigkeiten Ihres Projekts verwalten können.

Wenn Sie Ihrem Projekt Abhängigkeiten hinzufügen möchten, bietet Gradle verschiedene Optionen.

Option 1: Dateien in das libs/ Verzeichnis von Project ablegen

Die entsprechende build.gradle-Datei wird dann automatisch aktualisiert.

Option 2: Ändern Sie die Datei build.gradle manuell

Öffnen Sie Ihre Datei build.gradle und fügen Sie dem Abschluss der Abhängigkeiten eine neue Erstellungsregel hinzu. Wenn Sie beispielsweise Google Play Services hinzufügen möchten, sieht der Abschnitt "Abhängigkeiten" Ihres Projekts ungefähr so aus:

1
dependencies {
2
3
       compile fileTree(dir: 'libs', include: ['*.jar'])
4
5
     compile 'com.google.android.gms:play-services:6.5.+'
6
7
   }

Option 3: Verwenden Sie die Benutzeroberfläche von Android Studio

Klicken Sie im Projektfenster bei gedrückter Ctrl-Taste auf das Modul, zu dem Sie die Abhängigkeit hinzufügen möchten, und wählen Sie Moduleinstellungen öffnen aus.

Add a dependency via the Android Studio UI Add a dependency via the Android Studio UI Add a dependency via the Android Studio UI

Wählen Sie die Registerkarte Abhängigkeiten, gefolgt von der Schaltfläche + in der unteren linken Ecke. Sie können aus der folgenden Liste von Optionen auswählen:

  • Bibliotheksabhängigkeit
  • Dateiabhängigkeit
  • Modulabhängigkeit

Anschließend können Sie weitere Informationen zu der Abhängigkeit eingeben, die Sie Ihrem Projekt hinzufügen möchten. Wenn Sie beispielsweise Bibliotheksabhängigkeit auswählen, zeigt Android Studio eine Liste von Bibliotheken an, aus denen Sie auswählen können.

Überprüfen Sie nach dem Hinzufügen Ihrer Abhängigkeit die Datei build.gradle auf Modulebene. Es sollte automatisch aktualisiert worden sein, um die neue Abhängigkeit aufzunehmen.

Abschluss

In diesem Artikel werden Ihnen alle automatisch generierten Gradle-Build-Dateien vorgestellt, die Sie in einem typischen Android Studio-Projekt finden, insbesondere die Gradle-Build-Dateien der obersten Ebene und der Modulebene. Sie haben auch gelernt, wie Sie über die Android Studio-Benutzeroberfläche direkt mit dem Gradle-Build-System interagieren können.

Wenn Sie mehr über Gradle erfahren möchten, finden Sie viele zusätzliche Informationen auf der Android-Entwickler-Website und auf der Gradle-Website.

Advertisement
Did you find this post useful?
Want a weekly email summary?
Subscribe below and we’ll send you a weekly email summary of all new Code tutorials. Never miss out on learning about the next big thing.
Advertisement
Looking for something to help kick start your next project?
Envato Market has a range of items for sale to help get you started.