Модульность и многомодульные проекты в Gradle

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

Преимущества:
Разделение функциональности на независимые модули (например, API, ядро, реализация).
Упрощение тестирования и поддержки.
Параллельная сборка модулей для повышения производительности.
Повторное использование конфигураций и зависимостей.

В памяти: Каждый модуль создает собственный объект Project в модели Gradle, увеличивая потребление памяти пропорционально количеству модулей (обычно 50-100 МБ на модуль). Граф задач (DAG) для всех модулей хранится в памяти, что может достигать 1-2 ГБ для крупных проектов.

settings.gradle(.kts) — управление include-проектами
Файл settings.gradle (или settings.gradle.kts) определяет структуру многомодульного проекта, включая корневое имя и подмодули.

Основные функции:
Указание имени корневого проекта: rootProject.name.
Включение подмодулей через include.
Настройка репозиториев и плагинов через pluginManagement.

Пример (Groovy DSL):

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

Kotlin DSL:

rootProject.name = "my-project"
include("module-api", "module-core", "module-web")

Нюансы:

Каждый подмодуль должен иметь собственный build.gradle в папке с таким же именем (например, module-api/build.gradle).
Подмодули могут быть вложенными:include 'module-core:submodule'

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

Структура multi-module проекта: Parent + Children

Многомодульный проект состоит из корневого (parent) проекта и подмодулей (children), каждый из которых имеет собственный build.gradle.

Пример структуры:

my-project/
├── build.gradle
├── settings.gradle
├── module-api/
│   └── build.gradle
├── module-core/
│   └── build.gradle
├── module-web/
│   └── build.gradle

Parent проект:
Корневой build.gradle задает общие настройки, плагины и зависимости для всех подмодулей.

Пример:

allprojects {
    repositories {
        mavenCentral()
    }
}
subprojects {
    apply plugin: 'java'
    dependencies {
        testImplementation 'junit:junit:4.13.2'
    }
}

Children проекты:
Каждый подмодуль имеет собственный build.gradle, определяющий специфические задачи, зависимости и конфигурации.

Пример (module-api/build.gradle):

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

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

Для оптимизации используйте --configure-on-demand:

./gradlew build --configure-on-demand

Project Access: project(":module")

Подмодули доступны через объект project с использованием их пути, определенного в settings.gradle.

Пример:

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

Это добавляет module-core как зависимость для текущего модуля.

Нюансы:
Путь начинается с : для корневого проекта (например, :module-core:submodule для вложенных модулей).
Доступ к свойствам другого модуля:println project(':module-core').version

В памяти: Gradle хранит все объекты Project в памяти, обеспечивая доступ через project(). Это увеличивает модель проекта, особенно для больших иерархий модулей.

#Java #middle #Gradle #Task #include_projects

Sharing Logic между проектами

Совместное использование логики между модулями повышает повторное использование кода и упрощает поддержку.

Common Logic

В корневом build.gradle:
Используйте блоки allprojects и subprojects для общих настроек:

subprojects {
    apply plugin: 'java'
    version = '1.0.0'
    repositories {
        mavenCentral()
    }
}

Скриптовые плагины:

Создайте файл common.gradle:

apply plugin: 'java'
dependencies {
    testImplementation 'junit:junit:4.13.2'
}

Подключите в подмодулях:

apply from: "$rootDir/gradle/common.gradle"

Кастомные плагины:
Создайте плагин для общей логики (см. раздел "Создание собственных плагинов" в предыдущей статье).

Пример применения:

subprojects {
    apply plugin: 'com.example.common-plugin'
}

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

Version Catalogs (libs.versions.toml)

Version Catalogs — это централизованный способ управления версиями зависимостей и плагинов, введенный в Gradle 7.0.

Настройка (gradle/libs.versions.toml):

[versions]
spring-boot = "2.7.18"
junit = "4.13.2"

[libraries]
spring-core = { group = "org.springframework", name = "spring-core", version.ref = "spring-boot" }
junit = { group = "junit", name = "junit", version.ref = "junit" }

[plugins]
spring-boot = { id = "org.springframework.boot", version.ref = "spring-boot" }

Использование:

plugins {
    alias(libs.plugins.spring.boot)
}
dependencies {
    implementation libs.spring.core
    testImplementation libs.junit
}

Kotlin DSL:

plugins {
    alias(libs.plugins.spring.boot)
}
dependencies {
    implementation(libs.spring.core)
    testImplementation(libs.junit)
}

Преимущества:
Централизованное управление версиями.
Улучшенная читаемость и автодополнение в IDE.
Упрощение обновления версий.

В памяти: Version Catalog загружается как часть модели проекта, добавляя минимальный overhead (10-20 МБ), но упрощает управление зависимостями, снижая вероятность конфликтов.

#Java #middle #Gradle #Task #include_projects

Сценарии и практики разделения: Core/Api/Impl

Разделение проекта на модули (Core, Api, Impl) — распространенная практика в корпоративной разработке для обеспечения модульности и повторного использования.

Core:
Содержит общую бизнес-логику, утилиты, модели данных.

Пример:

module-core/build.gradle:plugins {
    id 'java-library'
}
dependencies {
    implementation 'org.apache.commons:commons-lang3:3.12.0'
}

Api:
Определяет публичные интерфейсы, DTO или контракты.

Пример:

module-api/build.gradle:plugins {
    id 'java-library'
}
dependencies {
    api project(':module-core')
}

Impl:
Реализует интерфейсы из Api, добавляя конкретную функциональность.

Пример: module-impl/build.gradle:

plugins {
    id 'java'
}
dependencies {
    implementation project(':module-api')
}

Структура:

my-project/
├── module-core/
│   └── build.gradle
├── module-api/
│   └── build.gradle
├── module-impl/
│   └── build.gradle
├── build.gradle
├── settings.gradle

Практики:
Используйте api в модуле module-api для экспорта публичных интерфейсов.
Минимизируйте зависимости между модулями, чтобы избежать циклических зависимостей.
Централизуйте версии через Version Catalog или dependencyManagement в корневом build.gradle.

В памяти: Каждый модуль добавляет объект Project, задачи и зависимости в модель Gradle, увеличивая потребление памяти. Разделение на Core/Api/Impl уменьшает размер каждого модуля, но увеличивает общее количество объектов в памяти.

Gradle Composite Builds

Composite Builds позволяют включать другие Gradle-проекты как зависимости, без необходимости публикации в репозиторий.

Настройка:
В settings.gradle корневого проекта:

includeBuild '../other-project'

В build.gradle используйте проект как зависимость:

dependencies {
    implementation project(':other-project:module-x')
}

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

В памяти: Composite Builds загружают модели всех включенных проектов в память, значительно увеличивая overhead (100-500 МБ на проект). Используйте с осторожностью для крупных систем.

Процесс сборки с помощью task-graph (Task Avoidance, Parallel Build)

Gradle строит граф задач (Directed Acyclic Graph, DAG) для определения порядка выполнения задач в многомодульных проектах.

Task Avoidance:
Gradle использует инкрементальную сборку, пропуская задачи, чьи входные/выходные данные не изменились (up-to-date checks).

Пример:

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

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

Parallel Build:
Gradle поддерживает параллельное выполнение задач с флагом --parallel:

./gradlew build --parallel

#Java #middle #Gradle #Task #include_projects

Раздел 4: Управляющие конструкции

Условные операторы. if / else в Java

Условные операторы if и else в Java позволяют выполнять разные части кода в зависимости от определенных условий. Они являются основой для управления потоком программы, позволяя принимать решения на основе значений переменных или выражений.

1. Что такое if и else в Java?

if и else — это ключевые слова в Java, которые используются для выполнения кода, если определенное условие истинно (true) или ложно (false). Они помогают программе выбирать, какой код запускать в зависимости от ситуации.

Зачем нужны if и else?
Принятие решений: Например, проверять, достаточно ли у пользователя денег для покупки.
Управление потоком: Позволяют программе выполнять разные действия в разных случаях.
Читаемость: Делают код понятным, показывая, какие действия зависят от условий.
Гибкость: Позволяют писать программы, которые реагируют на разные входные данные.


2. Синтаксис if и else

if проверяет условие, и если оно истинно (true), выполняется блок кода. else указывает, что делать, если условие ложно (false). Условие — это выражение, которое возвращает boolean (true или false).

Общий синтаксис:

if (условие) {
    // Код, который выполняется, если условие истинно
} else {
    // Код, который выполняется, если условие ложно
}

Простой пример:

int age = 18;
if (age >= 18) {
    System.out.println("Вы взрослый!");
} else {
    System.out.println("Вы несовершеннолетний!");
}

Вывод: Вы взрослый!

Вариации синтаксиса:
Простой if (без else):

if (age >= 18) {
    System.out.println("Вы можете голосовать!");
}

Многоуровневый if-else (else if):

int score = 85;
if (score >= 90) {
    System.out.println("Отлично!");
} else if (score >= 70) {
    System.out.println("Хорошо!");
} else {
    System.out.println("Попробуйте еще раз!");
}

Вывод: Хорошо!

Однострочный if (без фигурных скобок, если только одна команда):

if (age >= 18) System.out.println("Вы взрослый!");

Примечания к синтаксису:
Условие в скобках должно возвращать boolean (true или false).
Фигурные скобки {} обязательны, если блок кода содержит больше одной строки.
else и else if необязательны.


3. Типы конструкций if / else

3.1. Простой if
Используется, когда нужно выполнить код только при истинном условии.

Пример:

int temperature = 25;
if (temperature > 20) {
    System.out.println("На улице тепло!");
}

Вывод: На улице тепло!

3.2. if с else
Выполняет один блок кода, если условие истинно, и другой — если ложно.

Пример:

int number = 10;
if (number % 2 == 0) {
    System.out.println("Число четное!");
} else {
    System.out.println("Число нечетное!");
}

Вывод: Число четное!

3.3. if с else if
Позволяет проверять несколько условий последовательно.

Пример:

int grade = 75;
if (grade >= 90) {
    System.out.println("Оценка: A");
} else if (grade >= 80) {
    System.out.println("Оценка: B");
} else if (grade >= 70) {
    System.out.println("Оценка: C");
} else {
    System.out.println("Оценка: D");
}

Вывод: Оценка: C

3.4. Вложенные if
if внутри другого if для более сложных проверок.

Пример:

int age = 20;
boolean hasID = true;
if (age >= 18) {
    if (hasID) {
        System.out.println("Можно войти!");
    } else {
        System.out.println("Нужен документ!");
    }
} else {
    System.out.println("Слишком молод!");
}

Вывод: Можно войти!

4. Правильное применение if / else

Чтобы писать понятный и эффективный код с if и else, следуйте этим рекомендациям:

4.1. Простота условий
Пишите простые и понятные условия. Разбивайте сложные выражения на переменные.

Пример:

// Плохо: сложное условие
if (score >= 70 && score <= 100 && isExamPassed) {
    System.out.println("Экзамен сдан!");
}

// Хорошо: разбиваем на части
boolean isValidScore = score >= 70 && score <= 100;
if (isValidScore && isExamPassed) {
    System.out.println("Экзамен сдан!");
}

#Java #для_новичков #beginner #if #else

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

Пример:

// Плохо: избыточное условие
if (isActive == true) {
    System.out.println("Активен!");
}

// Хорошо: упрощение
if (isActive) {
    System.out.println("Активен!");
}

4.3. Используйте else if для взаимоисключающих условий
Если условия взаимосвязаны, используйте else if, чтобы не проверять лишние условия.

Пример:

int x = 5;
if (x > 0) {
    System.out.println("Положительное");
} else if (x < 0) {
    System.out.println("Отрицательное");
} else {
    System.out.println("Ноль");
}

4.4. Избегайте глубоких вложений
Слишком много вложенных if делают код сложным для чтения. Используйте переменные или методы для упрощения.

Пример:

// Плохо: глубокая вложенность
if (age >= 18) {
    if (hasTicket) {
        if (isVenueOpen) {
            System.out.println("Вход разрешен!");
        }
    }
}

// Хорошо: упрощение
boolean canEnter = age >= 18 && hasTicket && isVenueOpen;
if (canEnter) {
    System.out.println("Вход разрешен!");
}

4.5. Проверяйте на null
При работе с объектами всегда проверяйте на null, чтобы избежать NullPointerException.

Пример:

String name = null;
if (name != null) {
    System.out.println("Имя: " + name);
} else {
    System.out.println("Имя не задано!");
}

5. Назначение if / else

if и else выполняют важные функции в программировании:

5.1. Управление потоком
Позволяют программе выбирать, какой код выполнять, в зависимости от условий.

5.2. Обработка разных случаев
Помогают обрабатывать разные сценарии, например, успех или ошибку.

5.3. Улучшение читаемости
Делают логику программы понятной, показывая, как данные влияют на поведение.

5.4. Гибкость
Позволяют писать код, который адаптируется к разным входным данным.


6. Работа if / else под капотом

Понимание, как if и else работают в JVM, поможет писать более эффективный код.

6.1. Компиляция в байт-код
Компилятор Java (javac) переводит if и else в инструкции условного перехода в байт-коде.
Условие в if преобразуется в сравнение (например, if_icmpgt для сравнения чисел), а затем JVM решает, какой блок кода выполнить.

Пример:

int x = 5;
if (x > 0) {
    System.out.println("Положительное");
}

Байт-код (упрощенно):

iload x        // Загружаем x в стек
ifgt label     // Если x > 0, перейти к метке
return         // Иначе выйти
label:
invokevirtual  // Вызов System.out.println
return

6.2. Память и стек
Стек операндов: Условие if вычисляется в стеке операндов JVM. Например, для x > 0 JVM загружает x и 0, сравнивает их и сохраняет результат (true или false).
Локальные переменные: Переменные, используемые в условии (например, x), хранятся в стеке вызовов.
Куча: Если в условии используются объекты (например, name != null), они находятся в куче, а их ссылки — в стеке.

6.3. Оптимизация в JVM
JIT-компиляция: JIT-компилятор может оптимизировать if/else, встраивая часто используемые условия в машинный код.
Короткое замыкание: Если условие в if использует логические операторы (&&, ||), JVM пропускает ненужные вычисления.
Константные условия: Если условие всегда true или false (например, if (true)), компилятор может убрать ненужный код.

Пример оптимизации:

if (false) {
    System.out.println("Никогда не выполнится");
}

Компилятор полностью удалит этот блок из байт-кода.

6.4. Ошибки в памяти
Глубокие вложенности: Слишком много вложенных if увеличивают глубину стека вызовов, но это редко вызывает проблемы.
NullPointerException: Работа с объектами без проверки на null в условии может привести к ошибке.
Неэффективные условия: Сложные условия, такие как a > b && b > c && c > d, могут замедлить выполнение, если не оптимизированы.

Пример ошибки:

String text = null;
if (text.equals("Hello")) { // Ошибка: NullPointerException
    System.out.println("Совпадение!");
}

Исправление:
if (text != null && text.equals("Hello")) {
    System.out.println("Совпадение!");
}

#Java #для_новичков #beginner #if #else