¿Cómo construir un Uber JAR (Fat JAR) usando SBT dentro de IntelliJ IDEA?

La guía paso a paso o código que encontrarás en este artículo es la resolución más eficiente y válida que encontramos a esta inquietud o dilema.

Solución:

Finalmente, omito por completo el uso de IntelliJ IDEA para evitar generar ruido en mi comprensión global 🙂

Empecé a leer el tutorial oficial de SBT.

Creé mi proyecto con la siguiente estructura de archivos:

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

Agregué el complemento sbt-assembly en mi assembly.sbt expediente. Permitiéndome construir un JAR gordo:

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

Mi mínimo build.sbt parece :

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

val sparkVersion = "1.2.0"

libraryDependencies ++= Seq(
  "org.apache.spark" %% "spark-core" % sparkVersion % "provided",
  "org.apache.spark" %% "spark-streaming" % sparkVersion % "provided",
  "org.apache.spark" %% "spark-streaming-twitter" % sparkVersion
)

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

Nota: Los % "provided" significa no incluir la dependencia en el JAR gordo final (esas bibliotecas ya están incluidas en mis trabajadores)

Nota: Descarte de META-INF inspirado en esta respuesta.

Nota: El significado de % y %%

Ahora puedo construir mi fat JAR usando SBT (cómo instalarlo) ejecutando el siguiente comando en mi /mi proyecto carpeta raíz:

sbt assembly

Mi fat JAR ahora se encuentra en el nuevo archivo generado /objetivo carpeta:

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

Espero que ayude a alguien más.

---

Para aquellos que quieran incrustar SBT dentro de IntelliJ IDE: ¿Cómo ejecutar tareas de ensamblaje de sbt desde IntelliJ IDEA?

Proceso de 3 pasos para construir Uber JAR / Fat JAR en IntelliJ Idea:

Uber JAR / Fat JAR : Archivo JAR que tiene todas las dependencias de libraray externas.

1. Agregar el complemento SBT Assembly en IntelliJ Idea

   

   Ir a Nombre del proyecto / proyecto / objetivo / plugins.sbt archivo y agregue esta línea addSbtPlugin("com.eed3si9n" % "sbt-assembly" % "0.12.0")

2. Adición de la estrategia Fusionar, Descartar y No agregar en build.sbt

   

   Ir a Nombre del proyecto / build.sbt archivar y agregar la estrategia para empaquetar un JAR de Uber

   Fusionar estrategia: Si hay un conflicto en dos paquetes sobre una versión de la biblioteca, entonces cuál empacar en Uber JAR.
   Estrategia de descarte: Para eliminar algunos archivos de la biblioteca que no desea empaquetar en Uber JAR.
   No agregue estrategia: No agregue ningún paquete a Uber JAR.
   Por ejemplo: spark-core ya estará presente en su Spark Cluster, por lo que no deberíamos empaquetar esto en Uber JAR

   Combine la estrategia y el código básico de la estrategia de descarte:

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


   Entonces está pidiendo descartar los archivos META-INF usando este comando MergeStrategy.discard y para el resto de los archivos está tomando el primera ocurrencia del archivo de biblioteca si hay algún conflicto al usar este comando MergeStrategy.first.

   No agregue el código básico de la estrategia:

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

   Si no queremos agregar el spark-core a nuestro archivo JAR de Uber, ya que estará en nuestro clutser, entonces estamos agregando el % "provided" al final de la dependencia de la biblioteca.

3. Construyendo Uber JAR con todas sus dependencias

   

   En tipo de terminal sbt assembly para construir el paquete

Voila !!! Se construye Uber JAR. JAR estará en Nombre del proyecto / target / scala-XX

Agregue la siguiente línea a su proyecto / plugins.sbt

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

Agregue lo siguiente a su build.sbt

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

La estrategia de combinación de ensamblajes se utiliza para resolver los conflictos que se produjeron al crear fat jar.

Si te sientes incitado, puedes dejar un ensayo acerca de qué te ha parecido este post.

---

---

Utiliza Nuestro Buscador