Veröffentlicht am 11-03-2019

Gradle Plugin Quick Bootstrap

Einführung

Erforderlich:

  • IntelliJ IDEA
    • Java 1.8
    • Maven Repository
    • Vor nicht allzu langer Zeit musste ich ein Gradle-Plugin für den internen Gebrauch in unserem Unternehmen schreiben. Bei der Suche nach Informationen zu diesem Thema bin ich auf viele verschiedene Quellen gestoßen, und nicht alle waren konsistent. Aus diesem Grund habe ich beschlossen, ein einfaches "Hallo Welt" -Plugin zu entwickeln, um herauszufinden, welche Quelle die beste ist.

      Was mich anfangs verwirrt hat, war, wo ich anfangen soll. Ich wollte nicht alles in eine groovige Datei schreiben, wie es in den Tutorials vorgeschlagen wurde. Ich wollte einen einfachen Proof of Concept erstellen, jedoch mit ordnungsgemäß organisiertem Code.

      Die Ergebnisse werden in Form von Anweisungen zum schnellen Bootstrap eines funktionierenden Plugins dargestellt.

      Das Arbeitsbeispiel können Sie hier herunterladen.

      Lasst uns beginnen

      Beginnen wir mit der Erstellung eines einfachen Gradle-Java-Projekts. Ich habe einen gradle Wrapper verwendet, also habe ich diese Option aktiviert.

      Kopieren Sie den folgenden Code in Ihr build.gradle.

      Plugins {
          id 'java-gradle-plugin'
      }
      project.description = 'Hallo Welt Plugin'
      project.group = 'com.virtuslab'
      project.version = '1.0-SNAPSHOT'
      sourceCompatibility = 1.8
      Repositories {
          mavenCentral ()
      }
      gradlePlugin {
          Plugins {
             HalloWorldPlugin {
                 id = 'HelloWorldPlugin'
                 ImplementationClass = 'com.virtuslab.HelloWorldPlugin' // Hauptklasse des Plugins
             }
         }
      }

      In diesem Verfahren verwenden wir Java-Gradle-Plugin. Ich wollte die Dinge einfach halten, und dieses Plugin bot mir diese Gelegenheit.

      Java Gradle Plugin

      „Um ein Gradle-Plugin-Projekt einzurichten, sollte möglichst wenig Code für die Boilerplate erforderlich sein.“ - https://guides.gradle.org/implementing-gradle-plugins/

      Das Java-Gradle-Plugin wendet das Java-Plugin für uns an, fügt die Abhängigkeit von gradleApi () hinzu und erstellt eine * .properties-Datei. All dies ist erforderlich, daher weiß gradle, was diese importiert und weiß, dass es sich um ein Plugin handelt. Die Konfiguration erfolgt im gradlePlugin-Block.

      gradlePlugin {
          Plugins {
              HalloWorldPlugin {
                  id = 'HelloWorldPlugin'
                  conversionClass = 'com.virtuslab.HelloWorldPlugin'
              }
          }
      }

      Das ID-Feld wird zur Benennung der Eigenschaftendatei verwendet. In diesem Fall handelt es sich um META-INF / HelloWorldPlugin.properties

      ImplementationClass teilt gradle mit, welche Klasse der Startpunkt für das Plugin ist.

      Weitere Informationen zum Java-Gradle-Plugin finden Sie hier.

      Hauptplugin-Klasse

      Erstellen Sie die Klasse com.virtuslab.HelloWorldPlugin und geben Sie den folgenden Code ein.

      Paket com.virtuslab;
      import org.gradle.api.Plugin;
      import org.gradle.api.Project;
      public class HelloWorldPlugin implementiert das Plugin  {
          @Überfahren
          öffentlich ungültig gelten (Projektprojekt) {
               project.task ("Hallo"). doLast (Task -> System.out.println ("Hallo Welt vom Plugin!"));
          }
      }

      Plugin ist eine Schnittstelle, die von der Gradle-Abhängigkeit bereitgestellt wird. Es wendet die neue Konfiguration auf das Projekt an.

      Veröffentlichung

      Der Einfachheit halber veröffentlichen wir das Plugin im lokalen Repository.

      Dafür sollte build.gradle so aussehen. Für die Veröffentlichung sind fettgedruckte Teile im folgenden Snippet verantwortlich.

      Plugins {
          id 'java-gradle-plugin'
          id 'maven-publish'
      }
      project.description = 'Hallo Welt Plugin'
      project.group = 'com.virtuslab'
      project.version = '1.0-SNAPSHOT'
      sourceCompatibility = 1.8
      Repositories {
          mavenCentral ()
      }
      gradlePlugin {
          Plugins {
             HalloWorldPlugin {
                 id = 'HelloWorldPlugin'
                 ImplementationClass = 'com.virtuslab.HelloWorldPlugin' // Hauptklasse des Plugins
             }
         }
      }
      veröffentlichen {
          Veröffentlichungen {
              pluginPublikation (MavenPublikation) {
                 von components.java
                 groupId Projektgruppe
                 Artefakt-ID "Hallo-Welt-Plugin"
                 Version Projektversion
              }
          }
      }

      Nach dem Ausführen von ./gradlew publishToMavenLocal sollte eine Erfolgsmeldung angezeigt werden, und das Plugin sollte in Ihrem lokalen Maven-Repository platziert werden. Normalerweise kann es unter $ HOME / .m2 gefunden werden.

      Unit-Tests

      In vielen Büchern und Artikeln wurde geschrieben, wie wichtig es ist, unsere Software zu testen. Das 2. Kapitel in der Gradle-Dokumentation (hier) ist lesenswert, wenn Sie Grundkenntnisse zum Testen von Plugins erwerben möchten.

      Um unser Plugin zu testen, verwenden wir Groovy und Spock. Spock ist extrem flexibel und kann verwendet werden, um sehr gut lesbare Testspezifikationen zu schreiben. Groovy ist die Sprache, die Spock als Testimplementierungssprache verwendet.

      Aktualisieren Sie Ihr build.gradle mit einem Abhängigkeitsblock.

      Plugins {
          id 'groovy'
          id 'java-gradle-plugin'
          id 'maven-publish'
      }
      project.description = 'Hallo Welt Plugin'
      project.group = 'com.virtuslab'
      project.version = '1.0-SNAPSHOT'
      sourceCompatibility = 1.8
      Repositories {
          mavenCentral ()
      }
      Abhängigkeiten
          testCompile gradleTestKit ()
          Gruppe testCompile: 'junit', Name: 'junit', Version: '4.12'
          Gruppe testCompile: 'org.spockframework', Name: 'Spock-Core', Version: '1.2-groovy-2.4'
      }
      gradlePlugin {
          Plugins {
             HalloWorldPlugin {
                 id = 'HelloWorldPlugin'
                 Implementierungsklasse = com.virtuslab.HelloWorldPlugin '// Hauptklasse für Plugins
             }
         }
      }
      veröffentlichen {
          Veröffentlichungen {
              pluginPublikation (MavenPublikation) {
                 von components.java
                 groupId Projektgruppe
                 Artefakt-ID "Hallo-Welt-Plugin"
                 Version Projektversion
              }
          }
      }

      Erstellen Sie in Ihrem Testverzeichnis in IntelliJ einen groovigen Ordner und markieren Sie ihn als Stamm der Testquellen (https://www.jetbrains.com/help/idea/creating-and-managing-modules.html). Erstellen Sie als Nächstes eine com.virtuslab.HelloWorldPluginSpec.groovy-Datei und fügen Sie den folgenden Code ein:

      Paket com.virtuslab
      import org.gradle.testkit.runner.GradleRunner
      import org.gradle.testkit.runner.TaskOutcome
      import org.junit.Rule
      import org.junit.rules.TemporaryFolder
      spock.lang.Spezifikation importieren
      Die Klasse HelloWorldPluginSpec erweitert die Spezifikation {
          @Regel
          final TemporaryFolder testProjectDir = neuer TemporaryFolder ()
          private Datei buildFile
          privater statischer abschließender String BASIC_PLUGIN_IMPORT = '' '
              Buildscript {
                  Repositories {
                      mavenLocal ()
                  }
                  Abhängigkeiten
                      Klassenpfad 'com.virtuslab: Hallo-Welt-Plugin: 1.0-SNAPSHOT'
                  }
              }
              Plugin anwenden: 'HelloWorldPlugin'
          '' '
          def setup () {
              prepareBuildGradle ()
          }
          def "Hallo Aufgabe sollte Hallo Nachricht drucken" () {
              wann:
              def result = GradleRunner.create ()
                 .withProjectDir (testProjectDir.root)
                 .withArgumente ("Hallo")
                 .bauen()
              dann:
              result.output.contains ("Hallo Welt vom Plugin!")
              Ergebnis.Task (": Hallo"). Ergebnis == TaskOutcome.SUCCESS
          }
          privates Def prepareBuildGradle () {
              buildFile = testProjectDir.newFile ('build.gradle')
              buildFile << BASIC_PLUGIN_IMPORT
          }
      }

      Unser Grundtest ist fett gedruckt. Das Ganze verwendet Gradle Runner von TestKit, um das Testen so weit wie möglich zu vereinfachen. Im Grunde müssen wir in einem temporären Ordner eine build.gradle -Datei erstellen, die unser Plugin importiert. Anschließend testen wir bei gegebener Implementierung unsere Aufgabe und erhalten ein Ergebnis, optionale Fehlermeldungen usw., die später mit den erwarteten Werten verglichen werden können.

      TIPP: Während der Testausführung erhalten Sie möglicherweise einen java.lang.ExceptionInInialialError (keine Fehlermeldung)

      : compileTestGroovy FAILED
      FEHLER: Die Erstellung ist mit einer Ausnahme fehlgeschlagen.
      * Was schief gelaufen ist:
      Ausführung fehlgeschlagen für Task "compileTestGroovy"
      > java.lang.ExceptionInInitializerError (keine Fehlermeldung)

      Dies ist das Ergebnis eines Konflikts zwischen der vorhandenen Groovy-Version und der Version, die das Plugin herunterladen und verwenden soll. Es gibt viele Möglichkeiten, dieses Problem zu beheben. Die, die ich gewählt habe, beinhaltet eine Änderung in der build.gradle-Zeile:

      Gruppe testCompile: 'org.spockframework', Name: 'Spock-Core', Version: '1.2-groovy-2.4'

      zu

      testCompile ("org.spockframework: spock-core: 1.0-groovy-2.4") {
          Gruppe ausschließen: "org.codehaus.groovy", Modul: "groovy-all"
      }

      Fazit

      In wenigen Minuten haben wir ein einfaches Plugin erstellt, das sich leicht zu etwas nützlicherem erweitern lässt.

Siehe auch

Samsungs neue Galaxy-Knospen machen AirPods fast zu einem RennenDie Rolle des Markeninhalts beim Aufbau von MarkenSamsung C7 ProIPTV / OTT-Set-Top-Boxen: Wie zahlen Sie nicht zweimal?Wie haben sie es getan? Tanas Übergang vom Lab Tech zum Software EngineerPlanen Sie Einstieg in Tech (´Esecape From Plan A ’Ep. 71)