Abhängigkeitsverwaltung und Plugins

When building Scala projects, you often need functionality that isn't part of the core language. Things like logging, database access, or web frameworks are common examples.

Instead of writing all this code yourself, you can use external libraries (also called dependencies). These are pre-written code packages that other developers have created and shared.

SBT makes it easy to add these external libraries. You declare them in your build.sbt file using the libraryDependencies setting.

Here's the basic syntax:

• "org.group": The organization or group ID.
• % "artifact": The artifact ID (library name). Use %% for Scala libraries to automatically match your Scala version.
• % "version": The specific version of the library you want.

Example:

libraryDependencies += "org.slf4j" % "slf4j-simple" % "1.7.32"

Libraries might only be needed for specific parts of your project. SBT uses scopes to manage this.

• compile (default): Needed for compiling and running your main code.
• test: Only needed for compiling and running your test code (e.g., a testing framework like ScalaTest).
• runtime: Not needed for compilation, but required when the application runs.

You specify the scope like this:

libraryDependencies += "org.scalatest" %% "scalatest" % "3.2.16" % "test"

Imagine a library you use, like a web framework, also uses other libraries itself. These are called transitive dependencies.

SBT automatically handles fetching all these indirect dependencies for you. When you add a library, SBT looks up its own dependencies and downloads them too, ensuring your project has everything it needs.

This saves you from manually tracking dozens of libraries!

Let's use a common logging library, SLF4J (Simple Logging Facade for Java), with its simple implementation. First, add it to your build.sbt:

libraryDependencies += "org.slf4j" % "slf4j-simple" % "1.7.32"

Now, run the Scala code below to see it in action. Notice how we import org.slf4j.LoggerFactory, which comes from our new dependency.

Beyond managing libraries, SBT itself can be extended using plugins. Plugins are special JAR files that add new commands or settings to SBT.

For example, there are plugins for packaging applications, deploying to servers, or even for integrating with specific tools like code formatters.

They help automate common tasks and streamline your development workflow.

Unlike regular dependencies that go into build.sbt, SBT plugins are declared in a special file: project/plugins.sbt. This file lives inside the project directory at the root of your SBT project.

The syntax is similar to dependencies, but you use addSbtPlugin:

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

This tells SBT to download and enable the specified plugin for your project.

One popular plugin is sbt-assembly. It creates a single, executable "fat JAR" containing your application's code and all its dependencies.

First, add the plugin to project/plugins.sbt:

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

After adding it, you can run sbt assembly from your terminal to create the JAR. The Scala code below is what sbt-assembly would package.

As your project grows, managing many dependencies can be tricky. Here are some tips:

• Consistent Versions: Use the same version for a library across all modules to avoid conflicts.
• Resolvers: SBT fetches libraries from repositories (like Maven Central). You can add custom resolvers if a library isn't in the default ones.

By default, SBT uses standard public repositories. For private libraries, you'd specify a custom resolver in build.sbt.

You want to add a new external library to your Scala project and use it. Put the following steps in the correct order.

Great job! You've learned how to manage external code in your Scala projects.

• Dependencies (libraries) are added to build.sbt using libraryDependencies.
• SBT handles transitive dependencies and supports different scopes (like compile and test).
• Plugins extend SBT's functionality and are declared in project/plugins.sbt using addSbtPlugin.

Mastering dependency and plugin management is key to building complex and robust Scala applications efficiently!