Scala Language
Mit Gradle arbeiten

Grundeinstellung

1. Erstellen Sie eine Datei mit dem Namen SCALA_PROJECT/build.gradle mit folgendem Inhalt:

   group 'scala_gradle'
   version '1.0-SNAPSHOT'
   
   apply plugin: 'scala'
   
   repositories {
       jcenter()
       mavenCentral()
       maven {
           url "https://repo.typesafe.com/typesafe/maven-releases"
       }
   }
   
   dependencies {
       compile group: 'org.scala-lang', name: 'scala-library', version: '2.10.6'
   }
   
   
   task  "create-dirs" << {
       sourceSets*.scala.srcDirs*.each { it.mkdirs() }
       sourceSets*.resources.srcDirs*.each { it.mkdirs() }
   }
   
   

2. Führen Sie gradle tasks , um die verfügbaren Tasks gradle tasks .

3. Führen Sie gradle create-dirs , um ein Verzeichnis src/scala, src/resources zu erstellen.

4. Führen Sie gradle build , um das Projekt zu erstellen und Abhängigkeiten herunterzuladen.

Erstellen Sie Ihr eigenes Gradle Scala-Plugin

Nachdem Sie das grundlegende Setup- Beispiel durchgearbeitet haben , wiederholen Sie möglicherweise den größten Teil davon in jedem einzelnen Scala Gradle-Projekt. Riecht nach Boilerplate-Code ...

Was wäre, wenn Sie statt des von Gradle angebotenen Scala-Plugins Ihr eigenes Scala-Plugin anwenden könnten, das für die Handhabung Ihrer gesamten Build-Logik verantwortlich ist und gleichzeitig das bereits vorhandene Plugin erweitert.

In diesem Beispiel wird die vorherige Build-Logik in ein wiederverwendbares Gradle-Plugin umgewandelt.

Glücklicherweise können Sie in Gradle problemlos benutzerdefinierte Plugins mithilfe der Gradle-API schreiben, wie in der Dokumentation beschrieben . Als Implementierungssprache können Sie Scala selbst oder sogar Java verwenden. Die meisten Beispiele, die Sie in allen Dokumenten finden, sind jedoch in Groovy geschrieben. Wenn Sie mehr Code-Beispiele benötigen oder wissen möchten, was sich hinter dem Scala-Plugin verbirgt, können Sie das Gradle Github-Repo überprüfen.

Das Plugin schreiben

Das benutzerdefinierte Plugin fügt die folgenden Funktionen hinzu, wenn es auf ein Projekt angewendet wird:

• ein scalaVersion Eigenschaftsobjekt, das zwei überschreibbare Standardeigenschaften haben wird
  • major = "2.12"
  • minor = "0"
• Eine withScalaVersion Funktion, die auf einen Abhängigkeitsnamen angewendet wird, fügt die Scala-Hauptversion hinzu, um die Binärkompatibilität zu gewährleisten (sbt %% Operator %% möglicherweise, sonst gehen Sie hier vor dem %% )
• Eine createDirs Task zum Erstellen der erforderlichen Verzeichnisstruktur, genau wie im vorherigen Beispiel

1. Erstellen Sie ein neues Gradle-Projekt und fügen Sie Folgendes zu build.gradle

apply plugin: 'scala'
apply plugin: 'maven'

repositories {
    mavenLocal()
    mavenCentral()
}

dependencies {
    compile gradleApi()
    compile "org.scala-lang:scala-library:2.12.0"
}

Anmerkungen :

• Die Implementierung des Plugins ist in Scala geschrieben, daher benötigen wir das Gradle Scala Plugin
• Um das Plugin aus anderen Projekten zu verwenden, wird das Gradle Maven Plugin verwendet. Dadurch wird die install zum Speichern des Projektbehälters zum lokalen Repository von Maven hinzugefügt
• compile gradleApi() fügt dem gradle-api-<gradle_version>.jar die gradle-api-<gradle_version>.jar

2. Erstellen Sie eine neue Scala-Klasse für die Plugin-Implementierung

package com.btesila.gradle.plugins 
 
import org.gradle.api.{Plugin, Project}  
 
class ScalaCustomPlugin extends Plugin[Project] {
    override def apply(project: Project): Unit = {
        project.getPlugins.apply("scala")
    }
}

Anmerkungen :

• Um ein Plugin zu implementieren, erweitern Sie einfach die Plugin Eigenschaft des Typs Project und überschreiben die apply Methode
• Innerhalb der Apply-Methode haben Sie Zugriff auf die Project Instanz, auf die das Plugin angewendet wird, und Sie können es zum Hinzufügen von Build-Logik verwenden
• Dieses Plugin übernimmt nichts anderes als das bereits vorhandene Gradle Scala Plugin

3. scalaVersion Sie die scalaVersion Objekteigenschaft hinzu

Zunächst erstellen wir eine ScalaVersion Klasse, die die beiden Versionseigenschaften enthält

class ScalaVersion {
  var major: String = "2.12"
  var minor: String = "0"
}

Eine coole Sache an Gradle-Plugins ist die Tatsache, dass Sie immer bestimmte Eigenschaften hinzufügen oder überschreiben können. Ein Plugin empfängt diese Art von Benutzereingaben über den ExtensionContainer , der an eine Gradle- Project Instanz angehängt ist. Für weitere Informationen, lesen Sie diese aus.
Indem wir der apply Methode Folgendes hinzufügen, tun wir im Wesentlichen Folgendes:

• Wenn im Projekt keine scalaVersion Eigenschaft definiert ist, fügen Sie eine mit den Standardwerten hinzu
• Andernfalls erhalten wir die vorhandene als Instanz von ScalaVersion , um sie weiter zu verwenden

var scalaVersion = new ScalaVersion
if (!project.getExtensions.getExtraProperties.has("scalaVersion"))
   project.getExtensions.getExtraProperties.set("scalaVersion", scalaVersion)
else
   scalaVersion = project.getExtensions.getExtraProperties.get("scalaVersion").asInstanceOf[ScalaVersion]

Dies entspricht dem Schreiben der folgenden Datei in die Erstellungsdatei des Projekts, in dem das Plugin angewendet wird:

ext {
    scalaVersion.major = "2.12"
    scalaVersion.minor = "0"

}

4. scalaVersion Sie die scala-lang Bibliothek mithilfe der scalaVersion zu den Projektabhängigkeiten scalaVersion

project.getDependencies.add("compile", s"org.scala-lang:scala-library:${scalaVersion.major}.${scalaVersion.minor}")

Dies entspricht dem Schreiben der folgenden Datei in die Erstellungsdatei des Projekts, in dem das Plugin angewendet wird:

compile "org.scala-lang:scala-library:2.12.0"

5. withScalaVersion Sie die withScalaVersion Funktion hinzu

val withScalaVersion = (lib: String) => {
    val libComp = lib.split(":")
    libComp.update(1, s"${libComp(1)}_${scalaVersion.major}")
    libComp.mkString(":")
}
project.getExtensions.getExtraProperties.set("withScalaVersion", withScalaVersion)

6. Erstellen createDirs schließlich die createDirs Task und fügen Sie sie dem Projekt hinzu
   Implementieren Sie eine Gradle-Aufgabe, indem Sie DefaultTask :

class CreateDirs extends DefaultTask {
  @TaskAction
  def createDirs(): Unit = {
    val sourceSetContainer = this.getProject.getConvention.getPlugin(classOf[JavaPluginConvention]).getSourceSets

    sourceSetContainer forEach { sourceSet =>
      sourceSet.getAllSource.getSrcDirs.forEach(file => if (!file.getName.contains("java")) file.mkdirs())
    }
  }
}

Hinweis : Der SourceSetContainer enthält Informationen zu allen im Projekt vorhandenen Quellverzeichnissen. Was das Gradle Scala Plugin macht, ist das Hinzufügen der zusätzlichen Quellensätze zu den Java-Quelldateien, wie Sie in den Plugin-Dokumenten sehen können .

Fügen Sie die createDir Aufgabe für das Projekt durch das an den Anhängen apply Methode:

project.getTasks.create("createDirs", classOf[CreateDirs])

Am Ende sollte Ihre ScalaCustomPlugin Klasse so aussehen:

class ScalaCustomPlugin extends Plugin[Project] {
  override def apply(project: Project): Unit = {
    project.getPlugins.apply("scala")

    var scalaVersion = new ScalaVersion
    if (!project.getExtensions.getExtraProperties.has("scalaVersion"))
      project.getExtensions.getExtraProperties.set("scalaVersion", scalaVersion)
    else
      scalaVersion = project.getExtensions.getExtraProperties.get("scalaVersion").asInstanceOf[ScalaVersion]

    project.getDependencies.add("compile", s"org.scala-lang:scala-library:${scalaVersion.major}.${scalaVersion.minor}")

    val withScalaVersion = (lib: String) => {
      val libComp = lib.split(":")
      libComp.update(1, s"${libComp(1)}_${scalaVersion.major}")
      libComp.mkString(":")
    }
    project.getExtensions.getExtraProperties.set("withScalaVersion", withScalaVersion)

    project.getTasks.create("createDirs", classOf[CreateDirs])
  }
}

Dies ist sehr einfach durch Ausführen der gradle install
Sie können die Installation überprüfen, indem Sie in das lokale Repository-Verzeichnis ~/.m2/repository , das sich normalerweise unter ~/.m2/repository

Jedes Gradle-Plugin hat eine id die in der apply Anweisung verwendet wird. Wenn Sie zum Beispiel Folgendes in die Build-Datei schreiben, wird dies in einen Trigger für Gradle übersetzt, um das Plugin mit der ID- scala zu finden und anzuwenden.

apply plugin: 'scala'

Genauso möchten wir unser neues Plugin folgendermaßen einsetzen:

apply plugin: "com.btesila.scala.plugin"

com.btesila.scala.plugin bedeutet, dass unser Plugin die ID com.btesila.scala.plugin .

Um diese ID festzulegen, fügen Sie die folgende Datei hinzu:
src / main / resources / META-INF / gradle-plugin / com.btesil.scala.plugin.properties

implementation-class=com.btesila.gradle.plugins.ScalaCustomPlugin

Führen Sie danach gradle install erneut gradle install .

Verwendung des Plugins

1. Erstellen Sie ein neues leeres Gradle-Projekt und fügen Sie der Build-Datei Folgendes hinzu

buildscript {
    repositories {
        mavenLocal()
        mavenCentral()
    }

    dependencies {
        //modify this path to match the installed plugin project in your local repository
        classpath 'com.btesila:working-with-gradle:1.0-SNAPSHOT'
    }
}

repositories {
    mavenLocal()
    mavenCentral()
}


apply plugin: "com.btesila.scala.plugin"

2. Führen Sie gradle createDirs - Sie sollten jetzt alle Quellverzeichnisse erstellt haben
3. Überschreiben Sie die Scala-Version, indem Sie dies der Build-Datei hinzufügen:

ext {
    scalaVersion.major = "2.11"
    scalaVersion.minor = "8"

}
println(project.ext.scalaVersion.major)
println(project.ext.scalaVersion.minor)

4. Fügen Sie eine Abhängigkeitsbibliothek hinzu, die mit der Scala-Version binär kompatibel ist

dependencies {
    compile withScalaVersion("com.typesafe.scala-logging:scala-logging:3.5.0")
}

Das ist es! Sie können dieses Plugin jetzt für alle Ihre Projekte verwenden, ohne dieselbe alte Boilerplate zu wiederholen.