Benutzerdefinierte Gradle-Plugins schreiben

1. Einführung

Gradle ist ein sehr beliebtes Build-Tool, das häufig für den hochgradig anpassbaren Build-Prozess geschätzt wird.

Heute werden wir zeigen, wie benutzerdefinierte Gradle-Plugins erstellt werden, mit denen wir den Erstellungsprozess über das hinaus ändern können, was wir mit der Standardkonfiguration erreichen können.

2. Speicherort der Plugin-Quelle

Wir können unseren Code an verschiedenen Orten platzieren. Alle von ihnen haben einige Vor- und Nachteile.

2.1. Skript erstellen

Wir können den Quellcode unseres Plugins einfach in das Build-Skript selbst einfügen. Dies gibt uns die Möglichkeit, das Plugin automatisch zu kompilieren und einzubinden.

It’s very simple, however, our plugin won’t be visible outside of the build script. Aus diesem Grund können wir es nicht in anderen Build-Skripten wiederverwenden.

**2.2. BuildSrc Ordner**

Eine andere Möglichkeit, die wir nutzen können, besteht darin, den Quellcode unseres Plugins im OrdnerbuildSrc/src/main/javaabzulegen.

Wenn Sie Gradle ausführen, wird überprüft, ob der OrdnerbuildSrcvorhanden ist. Wenn dies der Fall ist, wird Gradle unser Plugin automatisch erstellen und einbinden.

Dies gibt uns die Möglichkeit, unser Plugin zwischen verschiedenen Build-Skripten zu teilen, aber wir können es trotzdem nicht in anderen Projekten verwenden.

2.3. Standalone-Projekt

Schließlich können wir unser Plugin als separates Projekt erstellen, wodurch das Plugin in verschiedenen Projekten vollständig wiederverwendbar ist.

Um es jedoch in einem externen Projekt zu verwenden, müssen wir es in einer JAR-Datei bündeln und einem Projekt hinzufügen.

3. Unser erstes Plugin

Beginnen wir mit den Grundlagen -every Gradle Plugin must implement the com.gradle.api.Plugin interface.

Die Schnittstelle ist generisch, sodass wir sie mit verschiedenen Parametertypen parametrieren können. Normalerweise ist der Parametertyporg.gradle.api.Project.

Wir können jedoch verschiedene Typparameter verwenden, so dass das Plugin in verschiedenen Lebensphasen angewendet wird:

Die Verwendung vonorg.gradle.api.Settings führt dazu, dass das Plugin auf ein Einstellungsskript angewendet wird
Die Verwendung vonorg.gradle.api.Gradle führt dazu, dass das Plugin auf ein Initialisierungsskript angewendet wird

Das einfachste Plugin, das wir erstellen können, ist die Anwendung vonhello world:

public class GreetingPlugin implements Plugin {
    @Override
    public void apply(Project project) {
        project.task("hello")
          .doLast(task -> System.out.println("Hello Gradle!"));
    }
}

Wir können es jetzt anwenden, indem wir eine Zeile in unser Build-Skript einfügen:

apply plugin: GreetingPlugin

Nach dem Aufruf vongradle hello, wird die Nachricht“Hello Gradle”in den Protokollen angezeigt.

4. Plugin-Konfiguration

Die meisten Plugins benötigen Zugriff auf eine externe Konfiguration über das Build-Skript.

Wir können das tun, indem wirextension objects verwenden:

public class GreetingPluginExtension {
    private String greeter = "example";
    private String message = "Message from the plugin!"
    // standard getters and setters
}

Fügen wir nun die neuenextension object zu unserer Plugin-Klasse hinzu:

@Override
public void apply(Project project) {
    GreetingPluginExtension extension = project.getExtensions()
      .create("greeting", GreetingPluginExtension.class);

    project.task("hello")
      .doLast(task -> {
          System.out.println(
            "Hello, " + extension.getGreeter());
          System.out.println(
            "I have a message for You: " + extension.getMessage());
      });
}

Wenn wir jetztgradle hello, aufrufen, wird die in unserenGreetingPluginExtension. definierte Standardnachricht angezeigt

Aber da wir die Erweiterung erstellt haben, können wir einen Abschluss verwenden, um dies innerhalb des Build-Skripts zu tun:

greeting {
    greeter = "Stranger"
    message = "Message from the build script"
}

5. Standalone-Plugin-Projekt

Um ein eigenständiges Gradle-Plugin zu erstellen, müssen wir noch ein wenig arbeiten.

5.1. Konfiguration

Erstens müssen wir die Gradle-API-Abhängigkeit importieren - was ziemlich einfach ist:

dependencies {
    compile gradleApi()
}

Beachten Sie, dass für dasselbe in Maven die Abhängigkeit vongradle-tooling-apierforderlich ist - aus dem Gradle-Repository:


    
        org.gradle
        gradle-tooling-api
        3.0
    
    
        org.gradle
        gradle-core
        3.0
        provided
    


    
        repo.gradle.org
        https://repo.gradle.org/gradle/libs-releases-local/

5.2. Plugin verkabeln

Damit Gradle die Implementierung unseres eigenständigen Plugins finden kann, müssen wir die Eigenschaftendatei insrc/main/resources/META-INF/gradle_-plugins_ erstellen.

Die Ressourcendatei muss einen Namen haben, der mit der Plugin-ID übereinstimmt. So if our plugin has an id of org.example.greeting, the exact path of the file would be META-INF/gradle-plugins/org.example.greeting.properties.

Als nächstes können wir die Implementierungsklasse des Plugins definieren:

    implementation-class=org.gradle.GreetingPlugin

Dieimplementation-class sollten dem vollständigen Paketnamen unserer Plugin-Klasse entsprechen.

5.3. Erstellen der Plugin-ID

Es gibt einige Regeln und Konventionen, denen die Plugin-ID in Gradle folgen muss. Die meisten von ihnen ähneln den Regeln für Paketnamen in Java:

Sie dürfen nur alphanumerische Zeichen ("." Und "-") enthalten.
Die ID muss mindestens ein "." Enthalten, das den Domain-Namen vom Plugin-Namen trennt
Die Namespacesorg.gradle undcom.gradleware sind eingeschränkt
Eine ID kann nicht mit "." Beginnen oder enden.
Es sind nicht zwei oder mehr aufeinanderfolgende "." - Zeichen zulässig

Schließlich gibt es eine Konvention, dass die Plugin-ID ein Kleinbuchstabe sein sollte, der der Konvention für umgekehrte Domänennamen folgt.

Der Hauptunterschied zwischen Java-Paketnamen und Gradle-Plug-In-Namen besteht darin, dass der Paketname in der Regel detaillierter ist als die Plug-In-ID.

5.4. Plugin veröffentlichen

Wenn wir unser Plugin veröffentlichen möchten, um es in externen Projekten wiederverwenden zu können, haben wir zwei Möglichkeiten, dies zu erreichen.

Erstenswe can publish our plugin JAR to an external repository like Maven or Ivy.

Alternativ können wir das Gradle Plugin Portal verwenden. Dies ermöglicht es unserer Plug-in für die breite Gradle Community zugänglich zu sein. Weitere Informationen zum Veröffentlichen von Projekten im Gradle-Repository finden Sie inGradle Plugin Portal Documentation.

5.5. Java Gradle Development Plugin

Wenn wir unsere Plugins in Java schreiben, können wir vonJava Gradle Development Plugin. profitieren

Dadurch werden die Abhängigkeiten vongradleApi()automatisch kompiliert und hinzugefügt. Außerdem wird die Überprüfung der Plugin-Metadaten als Teil der Aufgabegradle jardurchgeführt.

Wir können das Plugin hinzufügen, indem wir folgenden Block zu unserem Build-Skript hinzufügen:

plugins {
    id 'java-gradle-plugin'
}

6. Plugins testen

Um zu testen, ob unser Plugin ordnungsgemäß funktioniert und ordnungsgemäß auf dieProject,angewendet wird, können wirorg.gradle.testfixtures.ProjectBuilderverwenden, um eine Instanz derProjectzu erstellen.

Wir können dann überprüfen, ob das Plugin angewendet wurde und ob in unsererProject-Instanz die richtigen Aufgaben vorhanden sind. Dazu können wir Standardtests vonJUnitverwenden:

@Test
public void greetingTest(){
    Project project = ProjectBuilder.builder().build();
    project.getPluginManager().apply("com.example.greeting");

    assertTrue(project.getPluginManager()
      .hasPlugin("com.example.greeting"));

    assertNotNull(project.getTasks().getByName("hello"));
}

7. Zusammenfassung

In diesem Artikel haben wir die Grundlagen zum Schreiben benutzerdefinierter Plugins in Gradle gezeigt. Schauen Sie sich dieGradle Documentationan, um mehr über die Erstellung von Plugins zu erfahren.

Und wie immer finden Sie alle Codebeispiele inover on Github.

TOC

Benutzerdefinierte Gradle-Plugins schreiben