Introdução ao SBT (Simple Build Tool)
O SBT (Simple Build Tool) é uma ferramenta de construção poderosa e flexível, fundamental para o desenvolvimento de projetos em Scala. Ele automatiza tarefas como compilação, testes, empacotamento e publicação, facilitando o gerenciamento de dependências e a organização do fluxo de trabalho. Dominar o SBT é crucial para qualquer desenvolvedor Scala, pois ele permite focar na lógica do negócio, em vez de se preocupar com detalhes de configuração e infraestrutura.
Este guia tem como objetivo fornecer um entendimento abrangente do SBT, desde os conceitos básicos até a utilização de recursos avançados. Através de exemplos práticos e explicações detalhadas, você aprenderá a configurar, personalizar e otimizar o SBT para atender às necessidades específicas de seus projetos.
Instalação e Configuração
Antes de começar, você precisa ter o SBT instalado em sua máquina. A instalação varia dependendo do sistema operacional:
* **Linux:** Geralmente, você pode instalar o SBT através do gerenciador de pacotes da sua distribuição (por exemplo, `apt-get install sbt` no Debian/Ubuntu).
* **macOS:** Use o Homebrew (`brew install sbt`) ou o SDKMAN! (que também funciona bem em Linux).
* **Windows:** O SDKMAN! é uma boa opção. Outra alternativa é baixar o instalador do site oficial do SBT.
Após a instalação, verifique se o SBT está corretamente instalado executando o comando `sbt sbtVersion` no terminal. Este comando deve retornar a versão instalada do SBT.
Estrutura de um Projeto SBT
Um projeto SBT segue uma estrutura de diretórios padrão:
* **`project/`:** Contém arquivos de configuração do SBT, plugins e definições adicionais de build. O arquivo `build.properties` define a versão do SBT a ser utilizada.
* **`src/`:** Contém o código fonte do projeto, dividido em `main` (código principal) e `test` (testes unitários/integração).
* **`src/main/scala/`:** Código fonte Scala principal.
* **`src/main/java/`:** Código fonte Java principal (se necessário).
* **`src/main/resources/`:** Recursos estáticos (arquivos de configuração, templates, etc.).
* **`src/test/scala/`:** Testes unitários/integração em Scala.
* **`src/test/java/`:** Testes unitários/integração em Java (se necessário).
* **`src/test/resources/`:** Recursos para testes.
* **`build.sbt`:** O arquivo principal de configuração do build, onde você define as dependências, as configurações de compilação e outras opções.
O Arquivo `build.sbt`
O `build.sbt` é o coração da configuração do seu projeto. Ele é um arquivo Scala que permite definir as configurações do build de forma declarativa. Aqui estão alguns exemplos comuns:
scala
name := “meu-projeto-scala”
version := “1.0”
scalaVersion := “2.13.8”
libraryDependencies ++= Seq(
“org.scalatest” %% “scalatest” % “3.2.12” % Test,
“com.typesafe.akka” %% “akka-actor” % “2.6.20”
)
* **`name := “meu-projeto-scala”`:** Define o nome do projeto.
* **`version := “1.0”`:** Define a versão do projeto.
* **`scalaVersion := “2.13.8”`:** Define a versão do Scala a ser utilizada. É importante escolher uma versão compatível com as dependências do seu projeto.
* **`libraryDependencies ++= Seq(…)`:** Define as dependências do projeto. A sintaxe `”org.scalatest” %% “scalatest” % “3.2.12” % Test` adiciona o ScalaTest como uma dependência de teste. O `%%` indica que o SBT deve adicionar o sufixo com a versão do Scala automaticamente. O `% Test` indica que esta dependência só é necessária para os testes.
**Escopos de Dependência:**
As dependências podem ter diferentes escopos, que definem quando elas são necessárias:
* **`Compile`:** Dependências necessárias para compilar e executar o código principal.
* **`Test`:** Dependências necessárias apenas para compilar e executar os testes.
* **`Runtime`:** Dependências necessárias apenas para executar o código (não para compilar).
* **`Provided`:** Dependências que são fornecidas pelo ambiente de execução (por exemplo, um servidor web).
Tarefas Comuns do SBT
O SBT oferece uma série de tarefas (ou *tasks*) que automatizam diferentes aspectos do processo de build. Aqui estão algumas das tarefas mais comuns:
* **`compile`:** Compila o código fonte Scala e Java.
* **`test`:** Executa os testes unitários e de integração.
* **`package`:** Cria um arquivo JAR contendo o código compilado do projeto.
* **`run`:** Executa a classe principal do projeto.
* **`clean`:** Remove os arquivos gerados pelo build (arquivos compilados, JARs, etc.).
* **`console`:** Inicia um REPL (Read-Eval-Print Loop) com o classpath do projeto.
* **`publishLocal`:** Publica o projeto no repositório Maven local.
Para executar uma tarefa, basta digitar o nome da tarefa no prompt do SBT e pressionar Enter. Por exemplo:
> compile
**Entrando no modo interativo do SBT:**
Para entrar no modo interativo do SBT, execute o comando `sbt` no diretório raiz do seu projeto. Dentro do modo interativo, você pode executar as tarefas diretamente, sem precisar reiniciar o SBT a cada vez.
Personalizando o SBT
O SBT pode ser altamente personalizado para atender às necessidades específicas do seu projeto. Você pode definir novas tarefas, modificar as configurações de compilação, adicionar plugins e muito mais.
**Plugins do SBT:**
Os plugins do SBT são extensões que adicionam novas funcionalidades à ferramenta. Existem plugins para diversas finalidades, como geração de documentação, análise de código, integração com ferramentas de DevOps e muito mais.
Para adicionar um plugin, adicione a dependência do plugin no arquivo `plugins.sbt` dentro do diretório `project/`. Por exemplo, para adicionar o plugin `sbt-assembly` (que cria um JAR “fat” contendo todas as dependências):
scala
// project/plugins.sbt
addSbtPlugin(“com.eed3si9n” % “sbt-assembly” % “0.15.0”)
Depois de adicionar o plugin, reinicie o SBT para que ele seja carregado. Os plugins geralmente adicionam novas tarefas que você pode executar no prompt do SBT.
**Definindo Novas Tarefas:**
Você pode definir suas próprias tarefas personalizadas no arquivo `build.sbt`. Por exemplo:
scala
lazy val helloTask = taskKey[Unit](“Prints a greeting message”)
helloTask := {
println(“Hello, SBT!”)
}
Este código define uma nova tarefa chamada `helloTask` que imprime a mensagem “Hello, SBT!”. Para executar esta tarefa, digite `helloTask` no prompt do SBT.
**Configurações de Compilação:**
Você pode personalizar as configurações de compilação do SBT, como as opções do compilador Scala, o diretório de destino dos arquivos compilados e muito mais. Por exemplo:
scala
scalacOptions ++= Seq(“-deprecation”, “-unchecked”, “-feature”)
Este código adiciona as opções `-deprecation`, `-unchecked` e `-feature` ao compilador Scala, que ativam avisos para código obsoleto, verificações mais rigorosas e recursos experimentais, respectivamente.
Gerenciamento de Dependências Avançado
O SBT oferece recursos avançados para o gerenciamento de dependências, como a resolução de conflitos, a utilização de repositórios privados e a publicação de seus próprios artefatos.
**Resolução de Conflitos:**
Quando um projeto tem várias dependências que dependem de versões diferentes da mesma biblioteca, o SBT precisa resolver esses conflitos. Por padrão, o SBT usa a estratégia “latest wins”, que seleciona a versão mais recente da biblioteca. Você pode personalizar essa estratégia, se necessário.
**Repositórios Privados:**
Se você precisa usar dependências que não estão disponíveis nos repositórios públicos (como Maven Central), você pode configurar o SBT para usar repositórios privados. Para fazer isso, adicione a URL do repositório ao arquivo `build.sbt`:
scala
resolvers += “Meu Repositório Privado” at “http://meu-repositorio.com/maven”
**Publicando Artefatos:**
Se você deseja publicar seus próprios artefatos (bibliotecas, aplicativos, etc.) em um repositório Maven, o SBT oferece suporte para isso. Você precisa configurar as credenciais do repositório e as informações do artefato (groupId, artifactId, version, etc.).
Exemplo Completo de `build.sbt`
Aqui está um exemplo mais completo de um arquivo `build.sbt` que demonstra algumas das funcionalidades discutidas:
scala
name := “meu-projeto-scala-completo”
version := “1.0-SNAPSHOT”
scalaVersion := “2.13.8”
organization := “com.example”
resolvers += “Typesafe Releases” at “https://repo.typesafe.com/typesafe/releases/”
libraryDependencies ++= Seq(
“org.scalatest” %% “scalatest” % “3.2.12” % Test,
“com.typesafe.akka” %% “akka-actor” % “2.6.20”,
“com.typesafe.akka” %% “akka-stream” % “2.6.20”
)
scalacOptions ++= Seq(“-deprecation”, “-unchecked”, “-feature”)
// Configuração do sbt-assembly para criar um JAR “fat”
assemblyMergeStrategy in assembly := {
case PathList(“META-INF”, xs @ _*) => MergeStrategy.discard
case _ => MergeStrategy.first
}
Este exemplo define o nome, a versão, a organização do projeto, adiciona o repositório Typesafe Releases, define as dependências (ScalaTest, Akka Actor, Akka Stream), configura as opções do compilador Scala e define uma estratégia de merge para o plugin `sbt-assembly`.
Conclusão
O SBT é uma ferramenta essencial para o desenvolvimento de projetos Scala. Dominar o SBT permite que você gerencie as dependências do seu projeto, automatize tarefas de build, personalize o processo de compilação e muito mais. Com este guia, você tem uma base sólida para começar a usar o SBT em seus projetos Scala e explorar seus recursos avançados. A prática contínua e a exploração da documentação oficial do SBT são fundamentais para se tornar um especialista. Lembre-se de consultar a documentação do SBT e explorar os plugins disponíveis para descobrir novas formas de otimizar o seu fluxo de trabalho. O SBT é constantemente atualizado, então manter-se informado sobre as últimas versões e recursos é sempre uma boa prática.
Perguntas Frequentes (FAQs)
**O que é SBT e por que eu deveria usá-lo?**
O SBT (Simple Build Tool) é uma ferramenta de construção para projetos Scala (e Java). Ele automatiza tarefas como compilação, testes, empacotamento e gerenciamento de dependências, simplificando o processo de desenvolvimento e garantindo a consistência do build.
**Como instalar o SBT?**
A instalação do SBT depende do seu sistema operacional. No Linux, você pode usar o gerenciador de pacotes (apt-get, yum, etc.). No macOS, você pode usar o Homebrew ou SDKMAN!. No Windows, o SDKMAN! é recomendado, mas também há instaladores disponíveis no site oficial.
**Qual a estrutura de diretórios padrão de um projeto SBT?**
A estrutura padrão inclui os diretórios `project/` (para configurações do SBT), `src/main/scala/` (código fonte principal), `src/test/scala/` (testes unitários) e o arquivo `build.sbt` (configuração do build).
**O que é o arquivo `build.sbt` e qual sua função?**
O `build.sbt` é o principal arquivo de configuração do seu projeto SBT. Nele, você define o nome do projeto, a versão, a versão do Scala, as dependências e outras opções de build.
**Como adicionar dependências ao meu projeto SBT?**
Você adiciona dependências ao seu projeto SBT usando a configuração `libraryDependencies` no arquivo `build.sbt`. Por exemplo: `libraryDependencies += “org.scalatest” %% “scalatest” % “3.2.12” % Test`.
**Como executar os testes no SBT?**
Para executar os testes, digite `test` no prompt do SBT.
**Como criar um arquivo JAR do meu projeto SBT?**
Para criar um arquivo JAR, digite `package` no prompt do SBT.
**O que são plugins do SBT e como usá-los?**
Plugins do SBT são extensões que adicionam novas funcionalidades à ferramenta. Você os adiciona no arquivo `project/plugins.sbt` e, em seguida, reinicia o SBT.
**Como resolver conflitos de dependência no SBT?**
O SBT usa a estratégia “latest wins” por padrão. Você pode personalizar a estratégia de resolução de conflitos, se necessário, mas geralmente a estratégia padrão é suficiente.
**Como publicar meu projeto SBT em um repositório Maven?**
Você precisa configurar as credenciais do repositório e as informações do artefato no arquivo `build.sbt` e, em seguida, executar a tarefa `publish`. Geralmente, é necessário configurar o plugin `sbt-sonatype` para publicar em repositórios como Maven Central.