Schreiben von benutzerdefinierten Gradle-Plugins

Dieser Artikel ist Teil einer Reihe: • Einführung in Gradle

• Ameise gegen Maven gegen Gradle

• Schreiben von benutzerdefinierten Gradle-Plugins (aktueller Artikel) • Erstellen eines Fat Jar in Gradle

1. Einleitung

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 haben einige Vor- und Nachteile.

2.1. Skript erstellen

Wir können einfach den Quellcode unseres Plugins in das Build-Skript selbst einfügen. Dies gibt uns die automatische Kompilierung und Aufnahme des Plugins.

Es ist sehr einfach, aber unser Plugin wird außerhalb des Build-Skripts nicht sichtbar sein. 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 Ordner buildSrc / src / main / java abzulegen .

Wenn Sie Gradle ausführen, wird überprüft, ob der Ordner buildSrc vorhanden ist . Wenn dies vorhanden ist, erstellt Gradle automatisch unser Plugin und fügt es hinzu.

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 - jedes Gradle-Plugin muss die Schnittstelle com.gradle.api.Plugin implementieren .

Die Schnittstelle ist generisch, daher können wir sie mit verschiedenen Parametertypen parametrisieren. Normalerweise lautet der Parametertyp org.gradle.api.Project.

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

  • mit org.gradle.api.Settings wird bei der Anwendung des Plugin auf ein Einstellungen Skript führen
  • mit org.gradle.api.Gradle wird bei der Anwendung des Plugin auf ein Initialisierungsskript führen

Das einfachste Plugin, das wir erstellen können, ist eine Hallo-Welt- Anwendung:

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

Nachdem Sie gradle Hallo angerufen haben, wird in den Protokollen die Meldung "Hallo Gradle" angezeigt .

4. Plugin-Konfiguration

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

Wir können das tun, indem wir Erweiterungsobjekte verwenden :

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

Fügen wir nun das neue Erweiterungsobjekt 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 jetzt gradle hello aufrufen, sehen wir die Standardnachricht, die in unserer GreetingPluginExtension definiert ist .

Da wir die Erweiterung erstellt haben, können wir einen Abschluss verwenden, um dies im Build-Skript 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 etwas mehr Arbeit leisten.

5.1. Konfiguration

Zunächst müssen wir die Gradle-API-Abhängigkeit importieren - was ganz einfach ist:

dependencies { compile gradleApi() }

Beachten Sie, dass für dasselbe in Maven eine Abhängigkeit von Gradle -Tooling-API erforderlich ist - aus dem Gradle-Repository:

  org.gradle gradle-tooling-api 3.0   org.gradle gradle-core 3.0 provided     repo.gradle.org //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 in den src / main / resources / META-INF / gradle - Plugins erstellen .

Die Ressourcendatei muss einen Namen haben, der mit der Plugin-ID übereinstimmt. Wenn unser Plugin die ID org.baeldung.greeting hat, lautet der genaue Pfad der Datei META-INF / gradle-plugins / org.baeldung.greeting.properties.

Next, we can define the implementation class of the plugin:

 implementation-class=org.gradle.GreetingPlugin

The implementation-class should be equal to the full package name of our plugin class.

5.3. Creating the Plugin ID

There are some rules and conventions that plugin ID must follow in Gradle. Most of them are similar to package name rules in Java:

  • They can contain only alphanumeric characters, “.” and “-“
  • The id has to have at least one “.” separating the domain name from the plugin name
  • Namespaces org.gradle and com.gradleware are restricted
  • An id cannot start or end with “.”
  • No two or more consecutive “.” characters are allowed

Finally, there's a convention that plugin Id should be a lower case name that follows reverse domain name convention.

The main difference between Java package names and Gradle plugin names is that the package name is usually more detailed than the plugin ID.

5.4. Publishing Plugin

When we want to publish our plugin to be able to reuse it in external projects, we have two ways of achieving that.

Firstly, we can publish our plugin JAR to an external repository like Maven or Ivy.

Alternatively, we can use the Gradle Plugin Portal. This will allow our plugin to be accessible by wide Gradle Community. More on publishing projects to Gradle repository can be found in Gradle Plugin Portal Documentation.

5.5. Java Gradle Development Plugin

When we're writing our plugins in Java, we can benefit from the Java Gradle Development Plugin.

This will automatically compile and add gradleApi() dependencies. It will also perform plugin metadata validation as a part of the gradle jar task.

We can add plugin by adding following block to our build script:

plugins { id 'java-gradle-plugin' }

6. Testing Plugins

To test that our plugin works properly and it's properly applied to the Project, we can use org.gradle.testfixtures.ProjectBuilder to create an instance of the Project.

We can then check if the plugin was applied and proper tasks are present in our Project instance. We can use standard JUnit tests to do that:

@Test public void greetingTest(){ Project project = ProjectBuilder.builder().build(); project.getPluginManager().apply("com.baeldung.greeting"); assertTrue(project.getPluginManager() .hasPlugin("com.baeldung.greeting")); assertNotNull(project.getTasks().getByName("hello")); }

7. Summary

In diesem Artikel haben wir die Grundlagen des Schreibens benutzerdefinierter Plugins in Gradle gezeigt. Weitere Informationen zur Plugin-Erstellung finden Sie in der Gradle-Dokumentation.

Und wie immer finden Sie alle Codebeispiele auf Github.

Weiter » Erstellen eines fetten Glases in Gradle « Vorherige Ameise gegen Maven gegen Gradle