it-swarm.com.de

Wie erstelle ich eine Uber JAR (Fat JAR) mit SBT mit IntelliJ IDEA?

Ich verwende SBT (innerhalb von IntelliJ IDEA), um ein einfaches Scala Projekt zu erstellen.

Ich würde gerne wissen, wie am einfachsten ein Uber JAR Datei (aka Fat JAR, Super JAR).

Ich verwende momentan SBT, aber wenn ich meine JAR-Datei an Apache Spark sende, wird der folgende Fehler angezeigt:

Ausnahme im Thread "main" Java.lang.SecurityException: Ungültiger Signaturdatei-Digest für Manifest-Hauptattribute

Oder dieser Fehler während der Kompilierungszeit:

Java.lang.RuntimeException: deduplicate: Unterschiedliche Dateiinhalte im Folgenden:
PATH\DEPENDENCY.jar: META-INF/DEPENDENCIES
PATH\DEPENDENCY.jar: META-INF/MANIFEST.MF

Es sieht aus wie weil einige meiner Abhängigkeiten Signaturdateien (META-INF) enthalten, die in der endgültigen Uber JAR-Datei entfernt werden müssen.

Ich habe versucht, das sbt-Assembly Plugin so zu benutzen:

/project/Assembly.sbt

addSbtPlugin("com.eed3si9n" % "sbt-Assembly" % "0.12.0")

/project/plugins.sbt

logLevel := Level.Warn

/build.sbt

lazy val commonSettings = Seq(
  name := "Spark-Test"
  version := "1.0"
  scalaVersion := "2.11.4"
)

lazy val app = (project in file("app")).
  settings(commonSettings: _*).
  settings(
    libraryDependencies ++= Seq(
      "org.Apache.spark" %% "spark-core" % "1.2.0",
      "org.Apache.spark" %% "spark-streaming" % "1.2.0",
      "org.Apache.spark" % "spark-streaming-Twitter_2.10" % "1.2.0"
    )
  )

Wenn ich in IntelliJ auf " Build Artifact ..." klicke IDEA Ich erhalte eine JAR-Datei. Am Ende erhalte ich jedoch denselben Fehler ...

Ich bin neu bei SBT und habe wenig Erfahrung mit IntelliJ IDE.

Vielen Dank.

83
Yves M.

Schließlich überspringe ich die Verwendung von IntelliJ IDEA), um das Erzeugen von Rauschen in meinem globalen Verständnis zu vermeiden :)

Ich fing an, das offizielle SBT-Tutorial zu lesen.

Ich habe mein Projekt mit folgender Dateistruktur angelegt:

my-project/project/Assembly.sbt
my-project/src/main/scala/myPackage/MyMainObject.scala
my-project/build.sbt

Die sbt-AssemblyPlugin wurde in meine Assembly.sbt Datei eingefügt. Gestatten Sie mir, eine fette JAR zu bauen:

addSbtPlugin("com.eed3si9n" % "sbt-Assembly" % "0.12.0")

Meine minimale build.sbt sieht so aus:

lazy val root = (project in file(".")).
  settings(
    name := "my-project",
    version := "1.0",
    scalaVersion := "2.11.4",
    mainClass in Compile := Some("myPackage.MyMainObject")        
  )

libraryDependencies ++= Seq(
  "org.Apache.spark" %% "spark-core" % "1.2.0" % "provided",
  "org.Apache.spark" %% "spark-streaming" % "1.2.0" % "provided",
  "org.Apache.spark" % "spark-streaming-Twitter_2.10" % "1.2.0"
)

// META-INF discarding
mergeStrategy in Assembly <<= (mergeStrategy in Assembly) { (old) =>
   {
    case PathList("META-INF", xs @ _*) => MergeStrategy.discard
    case x => MergeStrategy.first
   }
}

Hinweis: Das % "provided" bedeutet, die Abhängigkeit nicht in die endgültige Fett-JAR aufzunehmen (diese Bibliotheken sind bereits in meinen Workern enthalten)

Hinweis: META-INF verwirft inspiriert von diesem Beantworter .

Hinweis: Bedeutung von % und %%

Jetzt kann ich mein fettes JAR mit SBT erstellen ( wie man es installiert ), indem ich den folgenden Befehl in meinem /my-project root-Verzeichnis:

sbt Assembly

Meine fette JAR befindet sich jetzt im neu generierten Ordner /target :

/my-project/target/scala-2.11/my-project-Assembly-1.0.jar

Hoffe das hilft jemand anderem.


Für diejenigen, die SBT in IntelliJ IDE einbinden möchten: Ausführen von sbt-Assembly-Tasks in IntelliJ IDEA?

133
Yves M.

3-Schritt-Prozess zum Erstellen von Uber JAR/Fat JAR in IntelliJ Idea:

Uber JAR/Fat JAR : JAR-Datei mit allen externen Bibliotheksabhängigkeiten.

  1. Hinzufügen des SBT Assembly Plugins in IntelliJ Idea

    Plugin sbt Path

    Gehen Sie zu ProjectName/project/target/plugins.sbt und fügen Sie diese Zeile hinzu addSbtPlugin("com.eed3si9n" % "sbt-Assembly" % "0.12.0")

  2. Hinzufügen einer Strategie zum Zusammenführen, Verwerfen und Nicht-Hinzufügen in build.sbt

    Build sbt Path

    Gehen Sie zur Datei ProjectName/build.sbt und fügen Sie die Strategie für das Packen einer Uber-JAR hinzu

    Merge-Strategie: Wenn in zwei Paketen ein Konflikt über eine Version der Bibliothek besteht, dann welches, um es in Uber JAR zu packen.
    Strategie verwerfen: Zum Entfernen einiger Dateien aus der Bibliothek, die nicht in Uber JAR gepackt werden sollen.
    Strategie nicht hinzufügen: Fügen Sie Uber JAR kein Paket hinzu.
    Zum Beispiel: spark-core Ist bereits in Ihrem Spark Cluster vorhanden. Daher sollten wir dies nicht in Uber JAR packen

    Strategie zusammenführen und Strategie verwerfen Basiscode:

    assemblyMergeStrategy in Assembly := { case PathList("META-INF", xs @ _*) => MergeStrategy.discard case x => MergeStrategy.first }

    Sie möchten also META-INF-Dateien mit diesem Befehl verwerfen MergeStrategy.discard Und für die übrigen Dateien das erste Vorkommen der Bibliotheksdatei verwenden, wenn ein Konflikt vorliegt dieser Befehl MergeStrategy.first.

    Strategie-Basiscode nicht hinzufügen:

    libraryDependencies += "org.Apache.spark" %% "spark-core" % "1.4.1" %"provided"

    Wenn wir den Spark-Core nicht zu unserer Uber JAR-Datei hinzufügen möchten, da er sich bereits auf unserem Clutser befindet, fügen wir am Ende der Bibliotheksabhängigkeit den % "provided" Hinzu.

  3. Erstellen von Uber JAR mit all seinen Abhängigkeiten

    sbtassembly

    Geben Sie im Terminal sbt Assembly Ein, um das Paket aufzubauen


Voila !!! Uber JAR wird gebaut. JAR befindet sich in ProjectName/target/scala-XX

JarBuilt

38
Ajay Gupta

Fügen Sie Ihrem Projekt/plugins.sbt die folgende Zeile hinzu

addSbtPlugin("com.eed3si9n" % "sbt-Assembly" % "0.12.0")

Fügen Sie Ihrem build.sbt Folgendes hinzu

mainClass in Assembly := some("package.MainClass")
assemblyJarName := "desired_jar_name_after_Assembly.jar"

val meta = """META.INF(.)*""".r
assemblyMergeStrategy in Assembly := {
  case PathList("javax", "servlet", xs @ _*) => MergeStrategy.first
  case PathList(ps @ _*) if ps.last endsWith ".html" => MergeStrategy.first
  case n if n.startsWith("reference.conf") => MergeStrategy.concat
  case n if n.endsWith(".conf") => MergeStrategy.concat
  case meta(_) => MergeStrategy.discard
  case x => MergeStrategy.first
}

Die Strategie zum Zusammenführen von Assemblys wird verwendet, um Konflikte zu lösen, die beim Erstellen von Fat Jars aufgetreten sind.

16
ARMV