SBT: Guia Prático para Build, Teste e Empacotamento em Scala

SBT: Guia Prático para Build, Teste e Empacotamento em Scala

Por

SBT: Guia Prático para Build, Teste e Empacotamento em Scala

SBT (Simple Build Tool) é a ferramenta de construção padrão para projetos Scala. Ele oferece uma maneira consistente e poderosa de gerenciar dependências, compilar código, executar testes e empacotar sua aplicação. Este guia fornece um passo a passo prático sobre como usar o SBT de forma eficaz.

Pré-requisitos

Antes de começar, certifique-se de ter o seguinte instalado:

  • Java Development Kit (JDK) 8 ou superior

  • SBT (geralmente instalado via gerenciador de pacotes do sistema, como `brew install sbt` no macOS ou `apt-get install sbt` no Linux)

  • Um editor de texto ou IDE (IntelliJ IDEA, VS Code com Scala Metals, etc.)

Criando um Novo Projeto SBT

A maneira mais fácil de começar é criar um diretório para o seu projeto e usar o comando `sbt new` para gerar um projeto esqueleto. Existem vários templates disponíveis; usaremos o template básico `scala/hello-world.g8` neste exemplo.

mkdir meu-projeto-scala

cd meu-projeto-scala

sbt new scala/hello-world.g8

O SBT irá solicitar o nome da sua organização (organization) e o nome do projeto (name). Preencha-os de acordo com as suas necessidades. Por exemplo:

name [My Hello World App]: MeuProjeto

organization [com.example]: com.minhaorganizacao

Após a conclusão, você terá uma estrutura de diretório semelhante a esta:

meu-projeto-scala/

├── build.sbt

├── project/

│   └── plugins.sbt

└── src/

    └── main/

        └── scala/

            └── Main.scala

Entendendo os Arquivos Principais

  • build.sbt: Este é o arquivo de construção principal do seu projeto. Ele define as configurações do projeto, dependências e tarefas.

  • project/plugins.sbt: Este arquivo é usado para adicionar plugins ao SBT que estendem sua funcionalidade.

  • src/main/scala/: Este diretório contém o código fonte da sua aplicação.

Configurando o build.sbt

O arquivo `build.sbt` contém as definições do seu projeto. Aqui está um exemplo básico:

name := "MeuProjeto"
organization := "com.minhaorganizacao"
version := "1.0-SNAPSHOT"
scalaVersion := "2.13.8"
libraryDependencies += "org.scalatest" %% "scalatest" % "3.2.12" % "test"

Vamos analisar as principais configurações:

  • name: Define o nome do seu projeto.

  • organization: Define o identificador da sua organização.

  • version: Define a versão do seu projeto. “1.0-SNAPSHOT” indica uma versão em desenvolvimento.

  • scalaVersion: Define a versão do Scala que você está usando.

  • libraryDependencies: Define as dependências do seu projeto. Neste caso, estamos adicionando ScalaTest para testes. O `%%` garante que a versão do Scala seja adicionada ao nome da dependência (artefato). `% “test”` indica que esta dependência é usada apenas durante os testes.

Adicionando Dependências

Para adicionar mais dependências, use a sintaxe `libraryDependencies +=` seguido pela string de dependência no formato “groupId” %% “artifactId” % “version”. Por exemplo, para adicionar a biblioteca Akka HTTP:

libraryDependencies += "com.typesafe.akka" %% "akka-http" % "10.2.9"

Não se esqueça de recarregar o SBT após modificar o `build.sbt`. Abra um terminal na raiz do seu projeto e execute o comando `sbt reload`.

Compilando e Executando

Para compilar seu projeto, execute o comando `sbt compile` no terminal.

sbt compile

Para executar sua aplicação (assumindo que você tenha um ponto de entrada `main` definido), use o comando `sbt run`.

sbt run

Se você tiver várias classes `main`, o SBT perguntará qual você deseja executar.

Testando sua Aplicação

Para executar os testes, use o comando `sbt test`.

sbt test

Certifique-se de ter as dependências de teste adequadas configuradas no `build.sbt`. O exemplo acima já inclui ScalaTest. Crie seus arquivos de teste no diretório `src/test/scala/`.

Um exemplo de teste usando ScalaTest poderia ser:

import org.scalatest.flatspec.AnyFlatSpec

import org.scalatest.matchers.should.Matchers
class MeuTesteSpec extends AnyFlatSpec with Matchers {

  "Uma soma" should "retornar o resultado correto" in {

    1 + 1 should be (2)

  }

}

Empacotando sua Aplicação

Existem várias maneiras de empacotar sua aplicação com o SBT. Uma das mais comuns é criar um JAR executável (uberjar) que contém todas as dependências.

Para fazer isso, você pode usar o plugin sbt-assembly. Adicione a seguinte linha ao `project/plugins.sbt`:

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

Recarregue o SBT com `sbt reload`. Em seguida, execute o comando `sbt assembly`.

sbt assembly

Isso irá criar um JAR executável no diretório `target/scala-2.13/`. Você pode executar o JAR usando o comando `java -jar nome-do-jar.jar`.

Outra opção é empacotar sua aplicação como um container Docker. Para isso, você pode usar o plugin sbt-native-packager. Ele oferece suporte para vários formatos de pacote, incluindo Docker.

Primeiro, adicione o plugin ao `project/plugins.sbt`:

addSbtPlugin("com.github.sbt" % "sbt-native-packager" % "1.9.14")

Recarregue o SBT (`sbt reload`). Em seguida, no seu `build.sbt`, adicione:

import NativePackagerHelper._
enablePlugins(JavaAppPackaging)
maintainer := "[email protected]"
dockerBaseImage := "openjdk:11-jre-slim"

Execute o comando `sbt docker:publishLocal` para construir e publicar a imagem Docker localmente.

sbt docker:publishLocal

Você pode então executar o container Docker usando o comando `docker run nome-da-imagem`.

Dicas e Truques

  • Use `~compile` para compilação automática: O SBT pode monitorar as alterações no seu código e recompilar automaticamente.

  • `sbt console` para o REPL: Inicia o REPL Scala com as dependências do seu projeto já carregadas.

  • `sbt dependencyTree` para visualizar dependências: Mostra a árvore de dependências completa do seu projeto, útil para identificar conflitos.

  • Organize seu `build.sbt` com `settings`: Para projetos maiores, use `settings` para organizar as configurações e evitar repetição.

Conclusão

SBT é uma ferramenta essencial para o desenvolvimento de projetos Scala. Este guia forneceu uma visão geral prática de como usar o SBT para build, teste e empacotamento. Ao dominar os conceitos básicos, você poderá criar e gerenciar projetos Scala complexos de forma eficiente.

Perguntas Frequentes (FAQs)

Como resolvo conflitos de dependência no SBT?

Use o comando `sbt dependencyTree` para visualizar a árvore de dependências e identificar os conflitos. Você pode então excluir explicitamente versões conflitantes ou usar estratégias de resolução de conflitos no seu `build.sbt`.

Como defino variáveis de ambiente para minha aplicação no SBT?

Você pode definir variáveis de ambiente no seu `build.sbt` ou passá-las como argumentos ao executar o SBT. Por exemplo, use `javaOptions += “-Dmy.property=value”` no `build.sbt` ou `sbt -Dmy.property=value run` na linha de comando.

Como faço para adicionar um repositório Maven personalizado ao SBT?

Adicione `resolvers += “Meu Repositório” at “http://meu-repositorio.com/maven”` ao seu `build.sbt`. Substitua o URL pelo endereço correto do seu repositório Maven.

O que significa o erro “unresolved dependency” no SBT?

Este erro indica que o SBT não conseguiu encontrar uma dependência especificada no seu `build.sbt`. Verifique se a dependência está escrita corretamente, se o repositório correto está configurado e se você tem acesso à rede.

Como faço para atualizar a versão do SBT do meu projeto?

A versão do SBT usada para construir seu projeto é especificada em `project/build.properties`. Altere o valor da propriedade `sbt.version` para a versão desejada e recarregue o projeto (`sbt reload`).

Como executar um subprojeto específico em um projeto multi-módulo?

Use o comando `sbt projeto/run`, substituindo “projeto” pelo nome do subprojeto que você deseja executar.

Deixe um comentário