plugins {
    id 'java'
    id 'org.springframework.boot' version '2.7.18'
}
repositories {
    mavenCentral()
}
dependencies {
    implementation 'org.springframework.boot:spring-boot-starter'
    testImplementation 'junit:junit:4.13.2'
}

В памяти: Парсится в объектную модель Gradle, включая задачи и зависимости. Динамическая компиляция Groovy/Kotlin увеличивает overhead.

rootProject.name = 'my-project'
include 'module-api', 'module-core', 'module-web'

В памяти: Формирует модель проекта, включая граф модулей. Меньше по объему, чем build.gradle, но влияет на DAG.

org.gradle.jvmargs=-Xmx2048m
org.gradle.parallel=true
myVersion=1.0.0

В памяти: Свойства загружаются как часть конфигурации Gradle, минимально влияя на память.

plugins {
    id 'java'
    id 'org.springframework.boot' version '2.7.18'
}

plugins {
    java
    id("org.springframework.boot") version "2.7.18"
}

В памяти: Плагины загружаются как Java-классы в JVM, увеличивая потребление памяти пропорционально их зависимостям и сложности.

repositories {
    mavenCentral()
    maven { url 'https://repo.example.com' }
}

В памяти: Gradle загружает метаданные репозиториев (POM-файлы, индексы) в память для разрешения зависимостей, что требует временного увеличения ресурсов.

dependencies {
    implementation 'org.springframework:spring-core:5.3.20'
    testImplementation 'junit:junit:4.13.2'
}

В памяти: Gradle строит граф зависимостей (Directed Acyclic Graph, DAG), хранящий метаданные каждой зависимости. Это увеличивает потребление памяти, особенно для крупных проектов.

task hello {
    doLast {
        println 'Hello, Gradle!'
    }
}

['test', 'jar']) {
    doLast { println 'Building project' }
}

В памяти: Каждая задача представлена как объект в JVM, содержащий конфигурацию, зависимости и действия. Gradle хранит DAG задач в памяти, что увеличивает overhead для сложных проектов.

configurations {
    customConfig
}
dependencies {
    customConfig 'com.example:library:1.0'
}

В памяти: Конфигурации хранятся как часть графа зависимостей, добавляя метаданные для каждой группы. Это увеличивает объем памяти, особенно при использовании кастомных конфигураций.

plugins {
    id 'java'
    id 'org.springframework.boot' version '2.7.18'
}
repositories {
    mavenCentral()
}
dependencies {
    implementation 'org.springframework.boot:spring-boot-starter'
    testImplementation 'junit:junit:4.13.2'
}
tasks.register('customTask') {
    doLast {
        println 'Custom task executed'
    }
}

В памяти: Файл build.gradle парсится в объектную модель, включающую плагины, зависимости и задачи. Groovy DSL требует загрузки Groovy-библиотек, а Kotlin DSL — Kotlin-библиотек, что увеличивает потребление памяти.

dependencies {
    implementation 'org.springframework:spring-core:5.3.20'
}

dependencies {
    implementation("org.springframework:spring-core:5.3.20")
}

В памяти: Groovy DSL компилируется динамически, загружая Groovy-библиотеки (например, groovy-all) в JVM, что увеличивает потребление памяти (около 50-100 МБ дополнительно). Kotlin DSL требует загрузки Kotlin-библиотек (kotlin-stdlib, kotlin-scripting), что добавляет аналогичный overhead, но статическая типизация снижает вероятность ошибок. Gradle кэширует результаты парсинга в ~/.gradle/caches для ускорения повторных сборок.

println project.name
println project.version

В памяти: Gradle загружает модель проекта в JVM во время фазы конфигурации (см. ниже). Для многомодульных проектов каждый подпроект создает отдельную модель, увеличивая потребление памяти пропорционально количеству модулей. Кэширование метаданных в ~/.gradle/caches снижает повторные вычисления

В памяти: Загружаются settings.gradle и плагины, необходимые для инициализации. Это минимальная фаза по потреблению памяти.

В памяти: Самая ресурсоемкая фаза, так как Gradle загружает и компилирует все скрипты, плагины и зависимости. Для крупных проектов может потребоваться несколько сотен МБ.

В памяти: Зависит от сложности задач. Например, compileJava загружает исходные файлы и зависимости, а test — тестовые классы и фреймворки.

version = '1.0.0'
ext.myProperty = 'value'

project.version, project.myProperty.

В памяти: Свойства загружаются как часть модели проекта или JVM, требуя минимальных ресурсов. Однако большое количество свойств в gradle.properties увеличивает время парсинга.

implementation 'org.example:lib:1.0'
implementation("org.example:lib:1.0")

В памяти: Kotlin DSL требует загрузки Kotlin-библиотек, что увеличивает потребление памяти на 50-100 МБ по сравнению с Groovy. Однако статическая типизация снижает вероятность ошибок, что может уменьшить затраты на отладку.

В памяти: Парсится в модель проекта, включая DAG задач и граф зависимостей.

rootProject.name = 'my-project'
include 'module-api', 'module-core'

В памяти: Загружается первым, формируя модель проекта и граф модулей. Меньше по объему, чем build.gradle.

org.gradle.parallel=true
myVersion=1.0.0

В памяти: Загружается как часть конфигурации Gradle, минимально влияя на память.

allprojects {
    repositories {
        mavenCentral()
    }
}

В памяти: Конфигурационные файлы загружаются последовательно: gradle.properties → settings.gradle → build.gradle. Gradle кэширует результаты парсинга в ~/.gradle/caches, снижая overhead при повторных сборках.
Нюансы и внутренние механизмы

dependencies {
    implementation 'org.springframework:spring-core:5.3.20'
}

Использование: Для внутренних зависимостей, которые не должны быть видны внешним модулям.

plugins {
    id 'java-library'
}
dependencies {
    api 'org.apache.commons:commons-lang3:3.12.0'
}

Использование: Для библиотек, которые должны быть доступны в classpath потребителей (например, интерфейсы или DTO).

dependencies {
    compileOnly 'javax.servlet:javax.servlet-api:4.0.1'
}

Использование: Для API, предоставляемых контейнером (например, Servlet API в веб-приложениях).

dependencies {
    runtimeOnly 'mysql:mysql-connector-java:8.0.28'
}

Использование: Для драйверов баз данных или библиотек, используемых только во время выполнения.

dependencies {
    testImplementation 'junit:junit:4.13.2'
}

Использование: Для тестовых фреймворков и библиотек.

В памяти: Каждая конфигурация представлена как объект в модели Gradle, содержащий список зависимостей и их метаданные. Gradle хранит граф зависимостей в памяти как Directed Acyclic Graph (DAG), что увеличивает потребление памяти пропорционально количеству зависимостей и конфигураций.

configurations {
    customConfig
}
dependencies {
    customConfig 'com.example:library:1.0'
}
tasks.register('useCustomConfig') {
    doLast {
        configurations.customConfig.each { file ->
            println "Using ${file.name}"
        }
    }
}

Назначение: Кастомные конфигурации позволяют группировать зависимости для нестандартных задач, таких как интеграционные тесты или обработка ресурсов.

configurations {
    customConfig.extendsFrom implementation
}

Это добавляет все зависимости implementation в customConfig.

В памяти: Кастомные конфигурации увеличивают объем графа зависимостей, так как Gradle создает дополнительные объекты для каждой конфигурации. Это требует больше памяти, особенно если конфигурации содержат много транзитивных зависимостей.

dependencies {
    implementation 'org.springframework:spring-core:5.+'
}

В памяти: Gradle строит граф зависимостей и разрешает конфликты во время фазы конфигурации, храня временные структуры для сравнения версий.

configurations.all {
    resolutionStrategy {
        force 'org.springframework:spring-core:5.3.20'
    }
}

В памяти: Форсинг добавляет правила в граф зависимостей, что минимально влияет на память, но требует дополнительных вычислений.

dependencies {
    implementation('org.springframework:spring-core:5.3.20') {
        exclude group: 'commons-logging'
    }
}

В памяти: Исключения уменьшают размер графа зависимостей, снижая потребление памяти и вероятность конфликтов.

dependencies {
    implementation platform('org.springframework.boot:spring-boot-dependencies:2.7.18')
    implementation 'org.springframework.boot:spring-boot-starter'
}

В памяти: BOM увеличивает объем графа зависимостей, так как Gradle загружает и парсит дополнительный POM-файл. Однако это упрощает управление версиями, снижая вероятность конфликтов.

dependencies {
    implementation project(':module-core')
}

В памяти: Зависимости от модулей добавляются в граф как узлы, увеличивая его размер. Gradle кэширует артефакты модулей в ~/.gradle/caches, снижая сетевые запросы, но требуя места на диске

В памяти: Кэширование снижает потребность в сетевых операциях, но увеличивает использование диска. Gradle загружает метаданные зависимостей в память только для активных конфигураций, оптимизируя ресурсы.

dependencyLocking {
    lockAllConfigurations()
}

./gradlew dependencies --write-locks

org.springframework:spring-core:5.3.20
org.junit:junit:4.13.2

Использование: Gradle использует версии из lockfile, игнорируя динамические версии или новейшие доступные.

В памяти: Lockfiles загружаются как часть модели зависимостей, добавляя минимальный overhead. Они уменьшают время разрешения зависимостей, так как Gradle не проверяет удаленные репозитории.

./gradlew dependencies

implementation - Implementation dependencies for the main source set.
\--- org.springframework:spring-core:5.3.20
     \--- commons-logging:commons-logging:1.2
testImplementation - Implementation dependencies for the test source set.
\--- junit:junit:4.13.2

В памяти: Gradle загружает полный граф зависимостей в память для генерации отчета, что может быть ресурсоемким для крупных проектов. Кэширование метаданных в ~/.gradle/caches ускоряет повторные вызовы.

dependencies {
    implementation 'org.example:library:1.0' {
        attributes {
            attribute(TargetJvmVersion.TARGET_JVM_VERSION_ATTRIBUTE, 11)
        }
    }
}

В памяти: Gradle хранит атрибуты и варианты в графе зависимостей, что увеличивает сложность и потребление памяти, особенно для библиотек с множеством вариантов.

import org.gradle.api.DefaultTask
import org.gradle.api.tasks.TaskAction

class CustomTask extends DefaultTask {
    @TaskAction
    void executeTask() {
        println 'Executing custom task'
    }
}

tasks.register('customTask', CustomTask)

import org.gradle.api.DefaultTask
import org.gradle.api.tasks.TaskAction

open class CustomTask : DefaultTask() {
    @TaskAction
    fun executeTask() {
        println("Executing custom task")
    }
}

tasks.register<CustomTask>("customTask")

В памяти: Каждая задача представлена как объект в JVM, содержащий метаданные (имя, зависимости, действия). Gradle загружает все задачи в память во время фазы конфигурации, что увеличивает потребление памяти пропорционально их количеству. Плагины, такие как java, добавляют множество задач (например, compileJava, test), увеличивая overhead.

В памяти: Минимальная фаза по потреблению ресурсов, так как загружается только settings.gradle и связанные плагины. Объем памяти зависит от количества модулей (обычно 50-100 МБ).

В памяти: Самая ресурсоемкая фаза, так как Gradle загружает и компилирует все скрипты, плагины и зависимости. Для крупных проектов может потребоваться 500-1000 МБ памяти.

./gradlew build --configure-on-demand

В памяти: Зависит от сложности задач. Например, compileJava загружает исходные файлы и зависимости, а test — тестовые классы и фреймворки. Параллельное выполнение (--parallel) увеличивает пиковое потребление памяти.

./gradlew build --no-daemon

task compileJava {
    doLast { println 'Compiling Java' }
}
task test(dependsOn: compileJava) {
    doLast { println 'Running tests' }
}

Gradle выполнит compileJava перед test.

task taskA {
    doLast { println 'Task A' }
}
task taskB {
    mustRunAfter 'taskA'
    doLast { println 'Task B' }
}

Если обе задачи выполняются, taskB будет после taskA, но taskB может выполняться отдельно.

task build {
    doLast { println 'Building' }
}
task cleanUp {
    doLast { println 'Cleaning up' }
}
build.finalizedBy cleanUp

В памяти: DAG задач хранится как структура данных в JVM, где каждая задача — объект с метаданными (зависимости, действия). Размер графа пропорционален количеству задач, что может увеличить потребление памяти до нескольких сотен МБ в крупных проектах.

> Task :compileJava UP-TO-DATE

tasks.named('compileJava') {
    inputs.files('src/main/java')
    outputs.dir('build/classes/java/main')
}

В памяти: Gradle хранит хэши входов/выходов в памяти и в ~/.gradle/caches для сравнения. Это добавляет небольшой overhead (около 10-50 МБ), но значительно ускоряет сборку.

./gradlew build --info

task processFiles {
    inputs.files fileTree('src/main/resources')
    doLast {
        println 'Processing files'
    }
}

task generateReport {
    outputs.file file('build/report.txt')
    doLast {
        file('build/report.txt').text = 'Report content'
    }
}

В памяти: Gradle хранит метаданные входов/выходов в памяти и кэширует хэши в ~/.gradle/caches. Для задач с большим количеством файлов (например, compileJava) это увеличивает потребление памяти, так как Gradle сканирует файловую систему.

task customTask {
    inputs.property 'version', project.version
    doLast { println "Version: ${project.version}" }
}