Compilações e implantação de vários projetos
Configure e gerencie compilações SBT com vários projetos para aplicações maiores e prepare-se para a implantação.
Compilações e implantação de vários projetos é uma aula grátis de Scala for Backend Engineering & Functional Programming no CoddyKit. Esta é a aula 3 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 criar projetos múltiplos?
À medida que as aplicações Scala crescem, gerenciar todo o código em um único projeto pode se tornar difícil. Compilações com vários projetos ajudam a organizar sua base de código.
Elas permitem:
- Separar diferentes módulos (por exemplo, lógica principal, API e utilitários).
- Gerenciar claramente as dependências entre esses módulos.
- Aplicar configurações específicas a partes individuais da sua aplicação.
Essa abordagem melhora a modularidade e a facilidade de manutenção.
Definindo vários projetos
No SBT, você define vários projetos dentro do seu arquivo principal build.sbt. Cada projeto normalmente é um lazy val.
O projeto raiz geralmente agrega ou depende desses subprojetos.
Veja uma configuração básica para um projeto raiz e dois subprojetos:
lazy val root = project
.in(file("."))
.aggregate(core, api)
lazy val core = project
.in(file("core"))
lazy val api = project
.in(file("api"))Estrutura de diretórios dos subprojetos
Em uma compilação com vários projetos, cada subprojeto normalmente fica em seu próprio diretório, no nível raiz do projeto.
A estrutura padrão é semelhante a esta:
my-app/(diretório do projeto raiz)build.sbt(arquivo principal de compilação)project/(arquivos de definição da compilação do SBT)core/(diretório do subprojeto 'core')src/(código-fonte de 'core')
api/(diretório do subprojeto 'api')src/(código-fonte de 'api')
Exemplo de código de subprojeto
Cada subprojeto pode conter seus próprios arquivos de código-fonte Scala. Por exemplo, nosso projeto core pode ter um utilitário simples.
Tente executar este exemplo dentro do projeto core:
package com.coddykit.core
object Greeter {
def greet(name: String): String = s"Hello, $name!"
}
object CoreApp {
def main(args: Array[String]): Unit = {
println(Greeter.greet("CoddyKit"))
}
}Dependências entre projetos
Muitas vezes, um subprojeto precisa usar código de outro. Por exemplo, seu projeto api pode precisar do Greeter do projeto core.
Você declara essas dependências usando .dependsOn() no seu build.sbt.
lazy val root = project
.in(file("."))
.aggregate(core, api)
lazy val core = project
.in(file("core"))
lazy val api = project
.in(file("api"))
.dependsOn(core)Compartilhando configurações comuns
Muitas configurações (como a versão do Scala ou dependências comuns) podem ser iguais em todos os seus subprojetos.
Para evitar repetição, você pode definir um bloco commonSettings e aplicá-lo a cada projeto.
lazy val commonSettings = Seq(
scalaVersion := "2.13.8",
organization := "com.coddykit"
)
lazy val root = project
.in(file("."))
.aggregate(core, api)
.settings(commonSettings)
lazy val core = project
.in(file("core"))
.settings(commonSettings)
lazy val api = project
.in(file("api"))
.dependsOn(core)
.settings(commonSettings)Agregando tarefas
Quando você tem um projeto raiz que agrega subprojetos, executar uma tarefa como compile no projeto raiz a executará automaticamente em todos os subprojetos agregados.
Por exemplo, digitar sbt compile no diretório raiz compilará core e api.
O método .aggregate() é fundamental para esse comportamento.
Empacotando para implantação
Depois que sua aplicação for compilada, você precisará empacotá-la para implantação. Isso geralmente significa criar um arquivo JAR (Java Archive) executável.
Em compilações com vários projetos, muitas vezes você quer um único JAR que inclua todo o código do projeto e suas dependências. Isso é chamado de 'fat JAR' ou 'uber JAR'.
O SBT não cria fat JARs por padrão, mas plugins podem ajudar.
Plugin SBT Assembly para fat JARs
O plugin sbt-assembly é amplamente usado para criar fat JARs. Ele reúne todas as classes compiladas e dependências em um único JAR executável.
Primeiro, adicione o plugin a project/plugins.sbt:
addSbtPlugin("com.eed3si9n" % "sbt-assembly" % "2.0.0")Empacotamento de vários projetos
Qual das afirmações a seguir sobre empacotar uma aplicação Scala com vários projetos para implantação é TRUE?
Recapitulação e próximos passos
Você aprendeu a estruturar e gerenciar compilações com vários projetos no SBT!
- Vimos como definir subprojetos em
build.sbt. - Você viu como organizar diretórios e gerenciar dependências entre projetos com
.dependsOn(). - Discutimos o compartilhamento de configurações comuns e a agregação de tarefas.
- Por fim, exploramos o empacotamento para implantação, especificamente usando o plugin
sbt-assemblypara criar fat JARs.
Dominar compilações com vários projetos é essencial para aplicações Scala maiores e mais complexas, garantindo modularidade e fluxos de desenvolvimento eficientes.
Perguntas Frequentes
A aula “Compilações e implantação de vários projetos” é grátis?
Sim — o texto completo de “Compilações e implantação de vários projetos” é 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 “Compilações e implantação de vários projetos”?
Configure e gerencie compilações SBT com vários projetos para aplicações maiores e prepare-se para a implantaçã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 3 de 3.
Quanto tempo leva a aula “Compilações e implantação de vários projetos”?
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
- Configuração e fundamentos de projetos SBT
- Gerenciamento de dependências e plugins
- Compilações e implantação de vários projetos