0Pricing
Groovy & Gradle: JVM Automation and Build Engineering · Lekcja

Kompilacje złożone i kompozycja kompilacji

Łącz niezależne kompilacje Gradle w jedną za pomocą kompilacji złożonych (includeBuild), aby wspólnie rozwijać i testować zależne od siebie projekty bez publikowania artefaktów.

Kompilacje złożone i kompozycja kompilacji to bezpłatna lekcja Groovy & Gradle: JVM Automation and Build Engineering na CoddyKit. To lekcja 4 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Groovy & Gradle: JVM Automation and Build Engineering, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Groovy & Gradle: JVM Automation and Build Engineering zawiera 4 lekcji w sumie.

Części tej lekcji nie zostały jeszcze przetłumaczone i są wyświetlane po angielsku.

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:build

Composite 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:

  • includeBuild joins independent builds
  • Dependency substitution swaps artifacts for live source
  • Ideal for cross-repo and plugin development
  • Differs from multi-project: builds stay independently versioned

Często zadawane pytania

Czy lekcja „Kompilacje złożone i kompozycja kompilacji” jest bezpłatna?

Tak — pełny tekst „Kompilacje złożone i kompozycja kompilacji” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Groovy & Gradle: JVM Automation and Build Engineering, przejdź na CoddyKit PRO. Kurs Groovy & Gradle: JVM Automation and Build Engineering zawiera 4 lekcji w sumie.

Co nauczysz się w „Kompilacje złożone i kompozycja kompilacji”?

Łącz niezależne kompilacje Gradle w jedną za pomocą kompilacji złożonych (includeBuild), aby wspólnie rozwijać i testować zależne od siebie projekty bez publikowania artefaktów. Ćwiczysz Groovy & Gradle: JVM Automation and Build Engineering z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Groovy & Gradle: JVM Automation and Build Engineering?

Nie wymagamy żadnego doświadczenia. Groovy & Gradle: JVM Automation and Build Engineering w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 4 z 4.

Ile czasu zajmuje lekcja „Kompilacje złożone i kompozycja kompilacji”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Groovy & Gradle: JVM Automation and Build Engineering?

Tak. Każda lekcja Groovy & Gradle: JVM Automation and Build Engineering zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

  1. Struktura projektu monorepo
  2. Podprojekty i konfiguracje
  3. Zależności między projektami
  4. Kompilacje złożone i kompozycja kompilacji
← Powrót do Groovy & Gradle: JVM Automation and Build Engineering