Build multi-progetto e deployment
Configuri e gestisca build SBT multi-progetto per applicazioni di grandi dimensioni e si prepari al deployment.
Build multi-progetto e deployment è una lezione Scala for Backend Engineering & Functional Programming gratuita su CoddyKit. Questa è la lezione 3 di 3. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Scala for Backend Engineering & Functional Programming, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Scala for Backend Engineering & Functional Programming include 3 lezioni in totale.
Perché utilizzare build multiprogetto?
Man mano che le applicazioni Scala crescono, gestire tutto il codice in un singolo progetto può diventare difficile. Le build multiprogetto aiutano a organizzare la base di codice.
Consentono di:
- Separare moduli diversi (ad esempio logica principale, API e utilità).
- Gestire in modo chiaro le dipendenze tra questi moduli.
- Applicare impostazioni specifiche alle singole parti dell'applicazione.
Questo approccio migliora la modularità e la manutenibilità.
Definizione di più progetti
In SBT, si definiscono più progetti all'interno del file principale build.sbt. Ogni progetto è in genere un lazy val.
Il progetto root generalmente aggrega o utilizza questi sottoprogetti come dipendenze.
Ecco una configurazione di base per un progetto root e due sottoprogetti:
lazy val root = project
.in(file("."))
.aggregate(core, api)
lazy val core = project
.in(file("core"))
lazy val api = project
.in(file("api"))Struttura delle directory dei sottoprogetti
In una build multiprogetto, ogni sottoprogetto si trova in genere in una propria directory al livello root del progetto.
La struttura standard è la seguente:
my-app/(directory del progetto root)build.sbt(file principale della build)project/(file di definizione della build di SBT)core/(directory del sottoprogetto 'core')src/(codice sorgente di 'core')
api/(directory del sottoprogetto 'api')src/(codice sorgente di 'api')
Esempio di codice di un sottoprogetto
Ogni sottoprogetto può contenere i propri file sorgente Scala. Ad esempio, il progetto core potrebbe avere una semplice utilità.
Provi a eseguire questo esempio dall'interno del progetto 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"))
}
}Dipendenze tra progetti
Spesso un sottoprogetto deve utilizzare il codice di un altro. Ad esempio, il progetto api potrebbe aver bisogno di Greeter del progetto core.
Queste dipendenze vengono dichiarate utilizzando .dependsOn() nel file 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)Condivisione delle impostazioni comuni
Molte impostazioni, come la versione di Scala o le dipendenze comuni, potrebbero essere uguali in tutti i sottoprogetti.
Per evitare ripetizioni, è possibile definire un blocco commonSettings e applicarlo a ogni progetto.
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)Aggregazione dei task
Quando un progetto root aggrega più sottoprogetti, l'esecuzione di un task come compile sul root lo esegue automaticamente in tutti i sottoprogetti aggregati.
Ad esempio, digitando sbt compile nella directory root, verranno compilati sia core sia api.
Il metodo .aggregate() è fondamentale per questo comportamento.
Creazione del pacchetto per il deployment
Una volta compilata l'applicazione, è necessario creare il pacchetto per il deployment. Di solito questo significa creare un file JAR eseguibile (Java Archive).
Nelle build multiprogetto, spesso si desidera un unico JAR che includa tutto il codice del progetto e le relative dipendenze. Questo viene chiamato 'fat JAR' o 'uber JAR'.
SBT non crea fat JAR per impostazione predefinita, ma i plugin possono essere d'aiuto.
Plugin SBT Assembly per i fat JAR
Il plugin sbt-assembly è ampiamente utilizzato per creare fat JAR. Raggruppa tutte le classi compilate e le dipendenze in un unico JAR eseguibile.
Per prima cosa, aggiunga il plugin a project/plugins.sbt:
addSbtPlugin("com.eed3si9n" % "sbt-assembly" % "2.0.0")Creazione del pacchetto di un progetto multiprogetto
Quale delle seguenti affermazioni sulla creazione del pacchetto per il deployment di un'applicazione Scala multiprogetto è VERA?
Riepilogo e prossimi passi
Ha imparato a strutturare e gestire build multiprogetto in SBT!
- Abbiamo visto come definire i sottoprogetti in
build.sbt. - Ha imparato a organizzare le directory e a gestire le dipendenze tra progetti con
.dependsOn(). - Abbiamo analizzato la condivisione delle impostazioni comuni e l'aggregazione dei task.
- Infine, abbiamo esplorato la creazione del pacchetto per il deployment, in particolare utilizzando il plugin
sbt-assemblyper creare fat JAR.
Imparare a gestire le build multiprogetto è fondamentale per applicazioni Scala più grandi e complesse, poiché garantisce modularità e flussi di sviluppo efficienti.
Domande Frequenti
La lezione «Build multi-progetto e deployment» è gratuita?
Sì — il testo completo di «Build multi-progetto e deployment» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Scala for Backend Engineering & Functional Programming, passa a CoddyKit PRO. Il corso Scala for Backend Engineering & Functional Programming include 3 lezioni in totale.
Cosa imparerò in «Build multi-progetto e deployment»?
Configuri e gestisca build SBT multi-progetto per applicazioni di grandi dimensioni e si prepari al deployment. Eserciti Scala for Backend Engineering & Functional Programming con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare Scala for Backend Engineering & Functional Programming?
Non è richiesta alcuna esperienza precedente. Scala for Backend Engineering & Functional Programming su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 3 di 3.
Quanto tempo richiede la lezione «Build multi-progetto e deployment»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione Scala for Backend Engineering & Functional Programming?
Sì. Ogni lezione Scala for Backend Engineering & Functional Programming include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.
Tutte le lezioni di questo corso
- Configurazione e fondamenti dei progetti SBT
- Gestione delle dipendenze e plugin
- Build multi-progetto e deployment