Subprojetos e configurações
Defina e configure subprojetos, compreendendo como eles interagem em uma compilação com vários projetos.
Subprojetos e configurações é uma aula grátis de Groovy & Gradle: JVM Automation and Build Engineering no CoddyKit. Esta é a aula 2 de 4. 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 Groovy & Gradle: JVM Automation and Build Engineering, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Groovy & Gradle: JVM Automation and Build Engineering inclui 4 aulas no total.
Partes desta aula ainda não foram traduzidas e aparecem em inglês.
Welcome to Subprojects!
In large software projects, keeping everything in one giant build file can get messy. This is where subprojects come in handy!
Subprojects allow you to break down a big project into smaller, manageable modules. Think of them as mini-projects living within your main project.
- Modularity: Organize code logically.
- Reusability: Share common logic across modules.
- Faster Builds: Gradle can optimize builds by only working on changed subprojects.
Declaring Subprojects
To tell Gradle about your subprojects, you use the settings.gradle file. This file lives in your root project directory.
You use the include keyword, followed by the path to your subproject's directory. Each subproject usually resides in its own folder.
/* settings.gradle */
rootProject.name = 'my-multi-project'
include 'app'
include 'library'Subproject Directory Structure
Once declared in settings.gradle, your project structure will typically look like this:
my-multi-project/(root project)settings.gradlebuild.gradle(root build file)app/(subproject 1)build.gradle- ... (source code, resources)
library/(subproject 2)build.gradle- ... (source code, resources)
Each subproject gets its own build.gradle file.
Subproject Build Files
Just like your root project, each subproject has its own build.gradle file. This allows you to define specific configurations, dependencies, and tasks for that particular module.
For example, your app subproject might build a runnable application, while your library subproject might produce a reusable JAR.
/* library/build.gradle */
plugins {
id 'java'
}
group 'com.coddykit'
version '1.0-SNAPSHOT'
repositories {
mavenCentral()
}
dependencies {
testImplementation platform('org.junit:junit-bom:5.9.1')
testImplementation 'org.junit.jupiter:junit-jupiter'
}Defining a Subproject Task
You can define tasks within a subproject's build.gradle file. These tasks are then specific to that subproject.
Let's add a simple task to our library subproject that prints a message.
/* library/build.gradle */
plugins {
id 'java'
}
group 'com.coddykit'
version '1.0-SNAPSHOT'
repositories {
mavenCentral()
}
task helloLibrary {
doLast {
println "Hello from the Library subproject!"
}
}Executing Subproject Tasks
To run a task belonging to a specific subproject from the root directory, you use a colon : to separate the subproject name and the task name.
For example, to run the helloLibrary task from our library subproject:
public class Main {
public static void main(String[] args) {
System.out.println("To run the task: gradle :library:helloLibrary");
System.out.println("Output will be: Hello from the Library subproject!");
}
}Common Configuration: allprojects
Sometimes, you want to apply the same configuration to all projects in your multi-project build (the root project and all its subprojects).
You can do this using the allprojects { ... } block in your root build.gradle file.
/* build.gradle (root) */
allprojects {
group 'com.coddykit.common'
version '1.0.0'
repositories {
mavenCentral()
}
}Targeting Specific Subprojects
While allprojects is great for common settings, you often need to configure individual subprojects from the root build file.
You can use the project(':subprojectName') { ... } block to apply configuration specifically to one subproject.
/* build.gradle (root) */
project(':app') {
apply plugin: 'application'
mainClassName = 'com.coddykit.app.MainApp'
}
project(':library') {
apply plugin: 'java-library'
}Sharing Properties
You can also share properties or variables from your root project to all subprojects. This is useful for things like consistent version numbers or build flags.
Use the ext block (for "extra properties") in the root build.gradle and access it with rootProject.ext.propertyName in subprojects.
/* build.gradle (root) */
ext {
groovyVersion = '3.0.9'
springBootVersion = '2.7.5'
}
allprojects {
// Access properties in subprojects
println "Groovy Version: ${rootProject.ext.groovyVersion}"
}Multi-Select Check
Which of the following statements about Gradle subprojects and their configuration are TRUE?
Subprojects Recap
Great job! You've learned the basics of setting up and configuring Gradle subprojects.
- Subprojects help organize large builds.
- They are declared in
settings.gradleusinginclude. - Each subproject has its own
build.gradle. - You can configure all projects using
allprojects { ... }or specific ones usingproject(':name') { ... }. - Tasks are run with the
:subproject:tasksyntax.
Next, we'll explore how subprojects can depend on each other!
Aprenda Groovy com um tutor de IA — grátis
Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.
- Cursos
- 12
- Aulas
- 48
Perguntas Frequentes
A aula “Subprojetos e configurações” é grátis?
Sim — o texto completo de “Subprojetos e configurações” é 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 Groovy & Gradle: JVM Automation and Build Engineering, atualize para CoddyKit PRO. O curso de Groovy & Gradle: JVM Automation and Build Engineering inclui 4 aulas no total.
O que vou aprender em “Subprojetos e configurações”?
Defina e configure subprojetos, compreendendo como eles interagem em uma compilação com vários projetos. Você pratica Groovy & Gradle: JVM Automation and Build Engineering 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 Groovy & Gradle: JVM Automation and Build Engineering?
Nenhuma experiência prévia é necessária. Groovy & Gradle: JVM Automation and Build Engineering 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 4.
Quanto tempo leva a aula “Subprojetos e configurações”?
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 Groovy & Gradle: JVM Automation and Build Engineering?
Sim. Cada aula de Groovy & Gradle: JVM Automation and Build Engineering 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
- Estrutura de projetos monorepo
- Subprojetos e configurações
- Dependências entre projetos
- Compilações Compostas e Composição de Compilações