Build composite e composizione delle build
Combini build Gradle indipendenti in una sola usando le build composite (includeBuild), così da sviluppare e testare insieme progetti interdipendenti senza pubblicare artefatti.
Build composite e composizione delle build è una lezione Groovy & Gradle: JVM Automation and Build Engineering gratuita su CoddyKit. Questa è la lezione 4 di 4. 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 Groovy & Gradle: JVM Automation and Build Engineering, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Groovy & Gradle: JVM Automation and Build Engineering include 4 lezioni in totale.
Parti di questa lezione non sono ancora state tradotte e vengono mostrate in inglese.
What is a Composite Build?
A composite build stitches multiple otherwise-independent Gradle builds together. Unlike subprojects, each included build keeps its own settings.gradle and lifecycle.
- Subprojects: one build, many modules
- Composite: many builds, joined on demand
Why Use Composites?
Composite builds shine when you work across repository boundaries:
- Develop a library and its consumer side by side
- Avoid publishing SNAPSHOTs just to test a change
- Debug a plugin in the context of a real project
includeBuild Basics
You join another build with includeBuild in settings.gradle. The path points at a directory containing its own settings file.
includeBuild("../shared-library")Dependency Substitution
The magic is automatic dependency substitution. When your project declares a dependency on a module that an included build produces, Gradle wires the in-source build in place of the published artifact.
dependencies {
implementation("com.acme:shared-library:1.0")
}Explicit Substitution
If group/name do not match, declare the mapping manually so Gradle knows which project replaces the coordinate.
includeBuild("../shared-library") {
dependencySubstitution {
substitute(module("com.acme:shared")).using(project(":"))
}
}Running Tasks Across Builds
You can invoke tasks from an included build using the :buildName:task syntax from the root.
gradle :shared-library:buildComposite vs Multi-Project
Use a multi-project build when modules always ship together. Use a composite when builds are independently versioned and released but you occasionally need them linked.
Plugin Development Workflow
Composite builds are the recommended way to test a custom plugin. Include the plugin build, and consuming projects pick up your local changes instantly.
includeBuild("../my-gradle-plugin")IDE Behavior
IntelliJ IDEA and Android Studio import composite builds as a single workspace, so navigation, refactoring, and debugging span all included builds seamlessly.
Limitations to Know
A few constraints apply:
- Included builds cannot themselves define the same root build
- A build cannot include itself (no cycles)
- Publishing tasks are not substituted, only consumable artifacts
Best Practices
Keep composites ergonomic:
- Use relative paths so teammates can clone side by side
- Keep coordinates consistent to rely on automatic substitution
- Document which builds are expected to be included
Quick Check
Test your understanding of composite builds.
Recap
You learned composite builds:
includeBuildjoins independent builds- Dependency substitution swaps artifacts for live source
- Ideal for cross-repo and plugin development
- Differs from multi-project: builds stay independently versioned
Impara Groovy con un tutor IA — gratis
Scrivi ed esegui vero codice nel tuo browser, ricevi aiuto istantaneo da un tutor IA disponibile 24/7, e riprendi da dove hai lasciato sul web o nell'app.
- Corsi
- 12
- Lezioni
- 48
Domande Frequenti
La lezione «Build composite e composizione delle build» è gratuita?
Sì — il testo completo di «Build composite e composizione delle build» è 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 Groovy & Gradle: JVM Automation and Build Engineering, passa a CoddyKit PRO. Il corso Groovy & Gradle: JVM Automation and Build Engineering include 4 lezioni in totale.
Cosa imparerò in «Build composite e composizione delle build»?
Combini build Gradle indipendenti in una sola usando le build composite (includeBuild), così da sviluppare e testare insieme progetti interdipendenti senza pubblicare artefatti. Eserciti Groovy & Gradle: JVM Automation and Build Engineering 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 Groovy & Gradle: JVM Automation and Build Engineering?
Non è richiesta alcuna esperienza precedente. Groovy & Gradle: JVM Automation and Build Engineering su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 4.
Quanto tempo richiede la lezione «Build composite e composizione delle build»?
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 Groovy & Gradle: JVM Automation and Build Engineering?
Sì. Ogni lezione Groovy & Gradle: JVM Automation and Build Engineering 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
- Struttura di progetto monorepo
- Sottoprogetti e configurazioni
- Dipendenze tra progetti
- Build composite e composizione delle build