Programação sbt: Guia para iniciantes e dicas avançadas

Programação sbt: Guia para iniciantes e dicas avançadas

Por

O sbt (Simple Build Tool) é uma ferramenta de construção amplamente utilizada no ecossistema Scala e Java. Ele automatiza tarefas como compilação, teste, empacotamento e publicação de projetos. Este guia abrangente fornecerá uma introdução ao sbt, cobrindo desde o básico até técnicas mais avançadas, com exemplos práticos em português brasileiro.

Introdução ao sbt

O sbt utiliza uma abordagem declarativa para definir as configurações do projeto. Ao invés de escrever scripts complexos, você define o que precisa ser feito, e o sbt se encarrega de determinar como fazê-lo. A configuração principal do sbt reside no arquivo build.sbt, localizado na raiz do projeto.

Instalação e Configuração

Para começar a usar o sbt, você precisa ter o Java Development Kit (JDK) instalado em sua máquina. O sbt é distribuído como um script que gerencia o download e a execução da versão correta do sbt. Geralmente, você pode baixar o script de instalação do site oficial do sbt e executá-lo.

Após a instalação, crie um novo diretório para o seu projeto Scala ou Java e, dentro desse diretório, crie um arquivo chamado build.sbt. Este arquivo conterá as configurações do seu projeto.

Estrutura de Diretórios

A estrutura de diretórios padrão para um projeto sbt é a seguinte:



  meu-projeto/

  ├── build.sbt

  ├── src/

  │   ├── main/

  │   │   ├── scala/

  │   │   │   └── MeuPrograma.scala

  │   │   └── java/  (opcional)

  │   │       └── MeuProgramaJava.java (opcional)

  │   └── test/

  │       ├── scala/

  │       │   └── MeuProgramaSpec.scala

  │       └── java/  (opcional)

  │           └── MeuProgramaJavaTest.java (opcional)

  └── project/

      └── plugins.sbt (opcional)

  • build.sbt: Arquivo de configuração principal do sbt.

  • src/main/scala: Código fonte Scala da aplicação principal.

  • src/main/java: Código fonte Java da aplicação principal (opcional).

  • src/test/scala: Código fonte Scala dos testes.

  • src/test/java: Código fonte Java dos testes (opcional).

  • project/plugins.sbt: Arquivo para adicionar plugins ao sbt.

Configurando o build.sbt

O arquivo build.sbt é o coração da configuração do seu projeto sbt. Ele usa uma sintaxe Scala para definir as propriedades do projeto, dependências e tarefas.

Configurações Básicas

Um arquivo build.sbt básico pode se parecer com isto:



  

  name := "meu-projeto"
version := "1.0"
scalaVersion := "2.13.8"
libraryDependencies += "org.scalatest" %% "scalatest" % "3.2.12" % Test

  • name := "meu-projeto": Define o nome do projeto.

  • version := "1.0": Define a versão do projeto.

  • scalaVersion := "2.13.8": Define a versão do Scala utilizada.

  • libraryDependencies += "org.scalatest" %% "scalatest" % "3.2.12" % Test: Adiciona a dependência ScalaTest para testes. O operador %% garante que a dependência seja compatível com a versão do Scala especificada em scalaVersion. % Test indica que essa dependência é utilizada apenas em testes.

Adicionando Dependências

Para adicionar dependências ao seu projeto, utilize a chave libraryDependencies. Você pode adicionar múltiplas dependências utilizando += para cada dependência ou ++= para uma lista de dependências.



  

  libraryDependencies ++= Seq(

    "org.apache.spark" %% "spark-core" % "3.3.0",

    "org.apache.spark" %% "spark-sql" % "3.3.0"

  )

Neste exemplo, adicionamos as dependências spark-core e spark-sql do Apache Spark.

Escopos de Dependência

O sbt permite definir o escopo de cada dependência, determinando quando ela estará disponível. Os escopos mais comuns são:

  • Compile: Dependências necessárias para compilar o código principal.

  • Test: Dependências necessárias apenas para executar os testes.

  • Runtime: Dependências necessárias para executar a aplicação em tempo de execução.

  • Provided: Dependências fornecidas pelo ambiente de execução (por exemplo, um servidor de aplicações).

Você pode especificar o escopo de uma dependência como mostrado no exemplo anterior com % Test.

Tarefas Comuns do sbt

O sbt oferece uma variedade de tarefas para gerenciar seu projeto. Aqui estão algumas das tarefas mais comuns:

  • compile: Compila o código fonte.

  • test: Executa os testes.

  • run: Executa a aplicação.

  • package: Cria um arquivo JAR contendo a aplicação.

  • publishLocal: Publica o projeto no repositório Maven local.

  • clean: Limpa os arquivos gerados pelo sbt (classes compiladas, arquivos JAR, etc.).

  • update: Resolve e baixa as dependências do projeto.

  • console: Abre um console Scala interativo com as dependências do projeto no classpath.

  • consoleProject: Similar ao `console`, mas com as dependências *não gerenciadas* do projeto no classpath. Isso é útil para testar configurações complexas do sbt.

Para executar uma tarefa, abra um terminal no diretório do projeto e digite sbt <tarefa>. Por exemplo, para compilar o projeto, execute sbt compile.

Plugins do sbt

Os plugins do sbt estendem a funcionalidade da ferramenta, permitindo realizar tarefas específicas como geração de documentação, análise de código, integração com ferramentas de DevOps e muito mais.

Adicionando Plugins

Para adicionar um plugin, crie o arquivo project/plugins.sbt (caso não exista) e adicione a dependência do plugin.



  

  addSbtPlugin("com.typesafe.sbt" % "sbt-native-packager" % "1.9.11")

Este exemplo adiciona o plugin sbt-native-packager, que permite criar pacotes nativos para diferentes plataformas (Linux, Windows, macOS).

Após adicionar um plugin, reinicie o sbt para que ele seja carregado.

Plugins Populares

  • sbt-native-packager: Para criar pacotes nativos.

  • sbt-assembly: Para criar um único arquivo JAR executável (uber jar).

  • sbt-scalafmt: Para formatar o código Scala automaticamente.

  • sbt-jacoco: Para gerar relatórios de cobertura de código com JaCoCo.

  • sbt-docker: Para criar imagens Docker da sua aplicação.

Dicas Avançadas

Para usuários mais experientes, aqui estão algumas dicas avançadas para otimizar o uso do sbt:

  • Definindo tarefas personalizadas: Você pode definir suas próprias tarefas no build.sbt para automatizar processos específicos do seu projeto. Utilize a sintaxe Scala para definir a lógica da tarefa.

  • Configurações condicionais: Utilize condicionais no build.sbt para alterar as configurações do projeto dependendo de diferentes fatores (por exemplo, ambiente de desenvolvimento ou produção).

  • Gerenciamento de segredos: Evite incluir informações confidenciais (senhas, chaves de API) diretamente no build.sbt. Utilize variáveis de ambiente ou arquivos de configuração externos para gerenciar esses segredos.

  • Otimização da resolução de dependências: O sbt pode levar um tempo considerável para resolver as dependências do projeto. Utilize o cache de dependências e configure a resolução paralela para otimizar esse processo.

  • Utilização de múltiplos projetos: Para projetos grandes e complexos, considere dividir o projeto em múltiplos subprojetos, cada um com seu próprio build.sbt. Isso facilita a organização e o gerenciamento do código.

Conclusão

O sbt é uma ferramenta poderosa e flexível para gerenciar projetos Scala e Java. Este guia forneceu uma introdução abrangente ao sbt, cobrindo desde o básico até técnicas mais avançadas. Ao dominar o sbt, você poderá automatizar tarefas complexas, gerenciar dependências de forma eficiente e otimizar o processo de desenvolvimento da sua aplicação.

Perguntas Frequentes (FAQs)

Como posso resolver problemas de dependência no sbt?

Verifique se as versões das dependências são compatíveis entre si. Utilize o comando sbt update para forçar a atualização das dependências. Se o problema persistir, tente limpar o cache do sbt com o comando sbt clean e execute sbt update novamente.

Como posso acelerar o tempo de compilação do sbt?

Utilize um SSD para armazenar o projeto e as dependências. Aumente a memória alocada para o sbt através da variável de ambiente SBT_OPTS (por exemplo, export SBT_OPTS="-Xmx4G"). Utilize a compilação incremental do sbt, que recompila apenas os arquivos que foram modificados. Considere também o uso de ferramentas de “hot reload” se o seu projeto se beneficia disso (como o sbt-revolver).

Como posso usar diferentes versões do Scala com o sbt?

Defina a chave scalaVersion no build.sbt para a versão desejada do Scala. Se você precisar de suporte para múltiplas versões do Scala, considere o uso de projetos múltiplos com configurações diferentes.

Como posso executar testes específicos no sbt?

Utilize o comando sbt "testOnly <nome do teste>" para executar um teste específico. Você também pode usar curingas para executar múltiplos testes que correspondam a um padrão (por exemplo, sbt "testOnly *Spec").

Onde posso encontrar mais informações sobre o sbt?

A documentação oficial do sbt (disponível em https://www.scala-sbt.org/) é a melhor fonte de informações. Além disso, existem diversos tutoriais e artigos online sobre o sbt.

Deixe um comentário