Create standalone jar using SBT

Question

I was a heavy Maven user and now I'm gradually using SBT for some of my projects.

I'd like to know how could I use SBT to create a standalone Java project? This project should be packaged as a JAR file and this JAR file would be used as a dependency in another SBT project.

In Maven, I could tell in my pom.xml what type of artifact it should produce when I build it. Is there something similar that I can do in SBT?

Canea

Take a look at sbt-onejar: github.com/sbt/sbt-onejar. See also Aggregation and Classpath dependencies – Debutant

How do I create a new sbt project using sbt-onejar? For example., with Maven, there is a command line that would generate the project structure for me. Any ideas on how I could do this with sbt and sbt-onejar? – Canea

If u have lots of dependencies you can also use github.com/sbt/sbt-assembly after making some instructions just call sbt assembly as for me I use it. – Narvik

Would sbt assembly create a project skeleton for me that I can later build as a standalone jar? – Canea

possible duplicate of Why doesn't sbt create project files? – Tunny

After the comments of the OP I believe it's a potential duplicate of https://mcmap.net/q/353802/-why-doesn-39-t-sbt-create-project-files/1305344 – Tunny

Answer 1

There is a difference between standalone and making a project useable as a dependency or another project. In the first case, you would use a plugin such as sbt-assembly. What it will do is create one jar file containing the project class files along with all of its dependencies. If you write an application, what you get is a double-clickable jar that you can execute from anywhere.

If you want to use your project A as a dependency for another project B, you have different options. You could just package the class files of A, using sbt package (answer of @Channing Walton). Then you could drop the resulting .jar file in the lib directory of project B. However, if A also requires libraries, you must make sure that they also end up in project B's libraries.

A better approach is to publish your project. You can do that purely on your local machine, using sbt publish-local. That will store the jar as produced by package in a special local directory which can be accessed from sbt in another project, along with a POM file that contains the dependencies of A. It will use a group-ID (organization) and artifact-ID (name) and a version of your project A. For example, in build.sbt:

name              := "projecta"

version           := "0.1.0-SNAPSHOT"

organization      := "com.github.myname"

scalaVersion      := "2.10.3"

publishMavenStyle := true

After publishing with sbt publish-local, you can add the following dependency to your project B:

libraryDependencies += "com.github.myname" %% "projecta" % "0.1.0-SNAPSHOT"

If you have a pure Java project, you can omit the Scala version suffix, i.e. in Project A:

crossPaths       := false

autoScalaLibrary := false

And then in Project B:

libraryDependencies += "com.github.myname" % "projecta" % "0.1.0-SNAPSHOT"

(using only one % character between group and artifact ID).

More on publishing in the sbt documentation.

Kissiah

Answer 2

'sbt package' will produce a jar file.

If you want it to be executable you need to add the following to your .sbt config:

mainClass in Compile := Some("your.main.Class")

Cobbler

Where does the JAR file end up? – Harebell

its written to target/scala-2.xx/ – Cobbler

Any idea how to create an executable jar file using that? The last time I checked the jar file created by package command is not executable. – Gragg

I added what you need to make the jar executable – Cobbler

old topic but I recommend this plugin for SBT - github.com/sbt/sbt-assembly it is excellent, I also recommend you follow up with java service wrapper - wrapper.tanukisoftware.com/doc/english/integrate-jar-nix.html, you can reliably restart, run, monitor you jar executable and integrate this into your CI process. – Hutton

Answer 3

Sure, you can use 'sbt package' command, it creates a jar file but this jar will be without any dependencies. To run it necessary to specify 'classpath' arg to the libraries.

In your case you wish a standalone runnable file. And you need to add the dependencies. To do this you can use 'assembly' plugin for SBT, see https://github.com/sbt/sbt-assembly/

Afterward you can just run 'sbt assembly' command, it provides a fat jar file with all dependencies that you can deploy and run anywhere and at any time.

For details see this article

Burnham

Article link is dead. – Manful

Answer 4

publishLocal

builds the artifact and publish in the local Ivy repository making it available for your local project dependencies.

publishM2

same as above, but the artifact is published in local Maven repo instead of Ivy repo.

Rohrer

Answer 5

I think the easiest way to produce a stand-alone jar with your project in it, is sadly not lying inside sbt.

I personally use my IDE: Intellij to make the jar (through the 'build artifact' feature).

Thanks to Intellij I can easily choose which library I want to include in the jar or not, (for instance the scala stl).

IMHO, this is by far the simplest method to get an executable jar for your project.

If you put the scala stl you can run your jar with the "java -jar" command, if you don't you have to run it somewhere with the correct version of scala installed with "scala".

Buddybuderus

That is an option, however, most projects of significant build their artefacts with continuous integration tools like TeamCity, for which you will need something like SBT. – Cobbler

Agreed. My use case was a small utility, that I wanted to deploy on remote machine without installing scala – Buddybuderus