with - Exportar la aplicación Scala a JAR ejecutable

pom xml jar

Question

¿Puede decirme, si esto es posible, cómo exportar una aplicación Scala a un JAR ejecutable normal que se puede ejecutar directamente en la JVM?
Gracias

Answer 1

Como alternativa a la respuesta de Fabian, si está utilizando Maven, puede usar el plugin de ensamblaje. Algo como:

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-assembly-plugin</artifactId>
    <executions>
        <execution>
            <id>package-jar-with-dependencies</id>
            <phase>package</phase>
            <goals>
                <goal>single</goal>
            </goals>
            <configuration>
                <appendAssemblyId>true</appendAssemblyId>
                <descriptorRefs>
                    <descriptorRef>jar-with-dependencies</descriptorRef>
                </descriptorRefs>
                <archive>
                    <manifestEntries>
                        <SplashScreen-Image>splash.png</SplashScreen-Image>
                    </manifestEntries>
                    <manifest>
                        <mainClass>se.aptly.epm.main.PrognosisApp</mainClass>
                    </manifest>
                </archive>
            </configuration>
        </execution>
    </executions>
</plugin>

Eso empaquetará todos tus deps, incluyendo scala-library.jar (si está en tus deps), pero lo hará de forma aplanada con todas las clases desempaquetadas. Esto se debe a que el jar ejecutable no puede usar el código en tarros en el contenedor.

Para que funcione (lo cual es más agradable), use http://code.google.com/p/onejar-maven-plugin/ , creo que es un contenedor Maven Mojo para un solo archivo: http: // one-jar. sourceforge.net/

También hay un sbt-plugin para one-jar: https://github.com/sbt/sbt-onejar

Answer 2

Es perfectamente posible, ver por ejemplo esto: ejecutar un proyecto maven scala . Debido a que Scala compila el bytecode de Java, JVM ni siquiera es consciente del lenguaje de implementación subyacente.

scalac después de compilar las fuentes de Scala con scalac , obtendrá un grupo de archivos .class que luego puede empacar en un JAR. Entonces simplemente puede ejecutarlos usando:

$ java -cp "your.jar:scala-library.jar" com.example.Main

Tenga en cuenta que debe incluir scala-library.jar en CLASSPATH (actualmente es casi 9 MiB ...) y especificar la clase que contiene el método main .

Answer 3

La suya es mi solución, maven -> create scala runnable jar.

        <plugin>
            <groupId>org.scala-tools</groupId>
            <artifactId>maven-scala-plugin</artifactId>
            <version>2.15.2</version>
            <executions>
                <execution>
                    <id>scala-compile-first</id>
                    <goals>
                        <goal>compile</goal>
                    </goals>
                    <configuration>
                        <includes>
                            <include>**/*.scala</include>
                        </includes>
                    </configuration>
                </execution>
                <execution>
                    <id>scala-test-compile</id>
                    <goals>
                        <goal>testCompile</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-shade-plugin</artifactId>
            <executions>
                <execution>
                    <phase>package</phase>
                    <goals>
                        <goal>shade</goal>
                    </goals>
                    <configuration>
                        <transformers>
                            <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
                                <mainClass>xxx.xxx.xxx.Main</mainClass>
                            </transformer>
                            <transformer implementation="org.apache.maven.plugins.shade.resource.AppendingTransformer">
                                <resource>reference.conf</resource>
                            </transformer>
                        </transformers>
                        <filters>
                            <filter>
                                <artifact>*:*</artifact>
                                <excludes>
                                    <exclude>META-INF/*.SF</exclude>
                                    <exclude>META-INF/*.DSA</exclude>
                                    <exclude>META-INF/*.RSA</exclude>
                                </excludes>
                            </filter>
                        </filters>
                    </configuration>
                </execution>
            </executions>
        </plugin>

Answer 4

Para empaquetar una aplicación swing en un jar ejecutable, la solución que funcionó para mí fue exportar mi proyecto como un archivo jar normal (no ejecutable) y actualizar el manifiesto jar a:

1. añadir los paquetes scala-library.jar scala-swing.jar a la ruta
2. indicar la clase principal

Puede encontrar el archivo Manifest dentro del contenedor (que puede abrir con 7z, por ejemplo) en la siguiente ruta:

META-INF/MANIFEST.MF

Agregue las siguientes líneas al final del manifiesto:

Main-Class: myPackage.myMainClass
Class-Path: scala-library.jar scala-swing.jar

Ahora su jar debería ejecutarse correctamente al hacer clic en él.

NOTA: Puede encontrar más información sobre personalización de manifiesto aquí: http://docs.oracle.com/javase/tutorial/deployment/jar/manifestindex.html .

Answer 5

Si usa sbt para compilar, puede usar uno de los plugins de una jarra. Pondrán todas las dependencias en un gran archivo jar (incluidos todos los archivos scala.jar). Esto significa que solo necesita un archivo jar y no tiene que administrar todas las dependencias.

Como ejemplo con sbt-assembly (principalmente copiado de https://github.com/sbt/sbt-assembly ):

project / plugins.sbt:

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

build.sbt:

import AssemblyKeys._ // put this at the top of the file
seq(assemblySettings: _*)

entonces puedes generar el jar con:

sbt assembly