0Pricing
Scala for Backend Engineering & Functional Programming · Aula

Gerenciamento de dependências e plugins

Gerencie bibliotecas externas, declare dependências e utilize plugins SBT para ampliar as funcionalidades de compilação.

Gerenciamento de dependências e plugins é uma aula grátis de Scala for Backend Engineering & Functional Programming no CoddyKit. Esta é a aula 2 de 3. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Scala for Backend Engineering & Functional Programming, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Scala for Backend Engineering & Functional Programming inclui 3 aulas no total.

Por que usar bibliotecas externas?

Ao criar projetos Scala, você frequentemente precisa de funcionalidades que não fazem parte da linguagem principal. Elementos como registro de eventos, acesso a bancos de dados ou estruturas para a web são exemplos comuns.

Em vez de escrever todo esse código por conta própria, você pode usar bibliotecas externas (também chamadas de dependências). Elas são pacotes de código previamente escritos, criados e compartilhados por outras pessoas desenvolvedoras.

Adicionando bibliotecas ao build.sbt

O SBT facilita a adição dessas bibliotecas externas. Você as declara no arquivo build.sbt usando a configuração libraryDependencies.

Veja a sintaxe básica:

  • "org.group": o identificador da organização ou do grupo.
  • % "artifact": o identificador do artefato (nome da biblioteca). Use %% para bibliotecas Scala, a fim de corresponder automaticamente à sua versão do Scala.
  • % "version": a versão específica da biblioteca que você deseja.

Exemplo:

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

Escopos de dependências: compilação e teste

As bibliotecas podem ser necessárias apenas para partes específicas do seu projeto. O SBT usa escopos para gerenciar isso.

  • compile (padrão): necessário para compilar e executar seu código principal.
  • test: necessário apenas para compilar e executar seu código de teste (por exemplo, uma estrutura de testes como ScalaTest).
  • runtime: não é necessário para a compilação, mas é exigido quando a aplicação é executada.

Você especifica o escopo desta forma:

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

Busca automática de dependências

Imagine que uma biblioteca usada por você, como uma estrutura para a web, também use outras bibliotecas. Essas são chamadas de dependências transitivas.

O SBT gerencia automaticamente a busca de todas essas dependências indiretas. Quando você adiciona uma biblioteca, o SBT consulta as dependências dela e também as baixa, garantindo que seu projeto tenha tudo de que precisa.

Isso evita que você precise acompanhar manualmente dezenas de bibliotecas!

Registro de eventos com SLF4J

Vamos usar uma biblioteca comum de registro de eventos, o SLF4J (Simple Logging Facade for Java), com sua implementação simples. Primeiro, adicione-a ao seu build.sbt:

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

Agora, execute o código Scala abaixo para ver seu funcionamento. Observe como importamos org.slf4j.LoggerFactory, que vem da nossa nova dependência.

import org.slf4j.LoggerFactory

object Main {
  private val logger = LoggerFactory.getLogger(getClass.getName)

  def main(args: Array[String]): Unit = {
    logger.info("Hello from a logged message!")
    println("This is a standard print output.")
  }
}

Estendendo o SBT com plug-ins

Além de gerenciar bibliotecas, o próprio SBT pode ser estendido usando plug-ins. Plug-ins são arquivos JAR especiais que adicionam novos comandos ou configurações ao SBT.

Por exemplo, existem plug-ins para empacotar aplicações, implantá-las em servidores ou até integrá-las a ferramentas específicas, como formatadores de código.

Eles ajudam a automatizar tarefas comuns e simplificar seu fluxo de trabalho de desenvolvimento.

Declarando plug-ins em plugins.sbt

Ao contrário das dependências comuns, que ficam em build.sbt, os plug-ins do SBT são declarados em um arquivo especial: project/plugins.sbt. Esse arquivo fica dentro do diretório project, na raiz do seu projeto SBT.

A sintaxe é semelhante à das dependências, mas você usa addSbtPlugin:

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

Isso informa ao SBT que deve baixar e ativar o plug-in especificado para o seu projeto.

Criando um JAR completo com sbt-assembly

Um plug-in popular é o sbt-assembly. Ele cria um único “JAR completo” executável, contendo o código da sua aplicação e todas as suas dependências.

Primeiro, adicione o plug-in a project/plugins.sbt:

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

Depois de adicioná-lo, você pode executar sbt assembly no terminal para criar o JAR. O código Scala abaixo é o que sbt-assembly empacotaria.

object Main {
  def main(args: Array[String]): Unit = {
    println("This is a simple application.")
    println("sbt-assembly would package this along with its dependencies into a single JAR.")
  }
}

Gerenciamento de versões e resolvedores

À medida que seu projeto cresce, gerenciar muitas dependências pode ser complicado. Aqui estão algumas dicas:

  • Versões consistentes: use a mesma versão de uma biblioteca em todos os módulos para evitar conflitos.
  • Resolvedores: o SBT busca bibliotecas em repositórios (como o Maven Central). Você pode adicionar resolvedores personalizados se uma biblioteca não estiver nos padrões.

Por padrão, o SBT usa repositórios públicos padrão. Para bibliotecas privadas, você especificaria um resolvedor personalizado em build.sbt.

Ordenar as etapas

Você quer adicionar uma nova biblioteca externa ao seu projeto Scala e usá-la. Coloque as etapas a seguir na ordem correta.

Resumo da lição

Excelente trabalho! Você aprendeu a gerenciar código externo em seus projetos Scala.

  • Dependências (bibliotecas) são adicionadas ao build.sbt usando libraryDependencies.
  • O SBT gerencia dependências transitivas e oferece diferentes escopos (como compile e test).
  • Plugins ampliam a funcionalidade do SBT e são declarados em project/plugins.sbt usando addSbtPlugin.

Dominar o gerenciamento de dependências e plugins é fundamental para criar aplicações Scala complexas e robustas com eficiência!

Perguntas Frequentes

A aula “Gerenciamento de dependências e plugins” é grátis?

Sim — o texto completo de “Gerenciamento de dependências e plugins” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Scala for Backend Engineering & Functional Programming, atualize para CoddyKit PRO. O curso de Scala for Backend Engineering & Functional Programming inclui 3 aulas no total.

O que vou aprender em “Gerenciamento de dependências e plugins”?

Gerencie bibliotecas externas, declare dependências e utilize plugins SBT para ampliar as funcionalidades de compilação. Você pratica Scala for Backend Engineering & Functional Programming com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Scala for Backend Engineering & Functional Programming?

Nenhuma experiência prévia é necessária. Scala for Backend Engineering & Functional Programming no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 3.

Quanto tempo leva a aula “Gerenciamento de dependências e plugins”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Scala for Backend Engineering & Functional Programming?

Sim. Cada aula de Scala for Backend Engineering & Functional Programming inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Configuração e fundamentos de projetos SBT
  2. Gerenciamento de dependências e plugins
  3. Compilações e implantação de vários projetos
← Voltar para Scala for Backend Engineering & Functional Programming