Java for Beginner
685 subscribers
585 photos
161 videos
12 files
898 links
Канал от новичков для новичков!
Изучайте Java вместе с нами!
Здесь мы обмениваемся опытом и постоянно изучаем что-то новое!

Наш YouTube канал - https://www.youtube.com/@Java_Beginner-Dev

Наш канал на RUTube - https://rutube.ru/channel/37896292/
Download Telegram
Переменные

Maven поддерживает несколько типов переменных, которые используются для динамической настройки конфигурации.

User-defined ${} переменные
Пользовательские переменные определяются в <properties> в POM.xml или settings.xml.
<properties>
<java.version>11</java.version>
</properties>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<configuration>
<source>${java.version}</source>
<target>${java.version}</target>
</configuration>
</plugin>

Переменные загружаются в память как часть POM-модели или объекта Settings. Maven заменяет ${} на значения во время парсинга, что требует минимальных ресурсов, так как это операция на уровне строк.


Environment variables

Переменные окружения (например, JAVA_HOME, PATH) доступны через ${env.VARIABLE_NAME}.
<properties>
<java.home>${env.JAVA_HOME}</java.home>
</properties>

Maven получает переменные окружения через System.getenv(), что не нагружает память, так как данные уже доступны JVM.


System properties (-D)

Системные свойства задаются через флаг -D в командной строке:

mvn package -Denv=production


Они доступны в POM.xml через ${propertyName}.
<properties>
<env>${env}</env>
</properties>

Системные свойства загружаются в память через System.getProperties(). Они имеют приоритет над переменными из POM.xml или settings.xml.


Переменные из settings.xml и POM
settings.xml: Переменные задаются в <properties> внутри профилей или глобально. Они применяются ко всем проектам.
POM.xml: Переменные в <properties> применяются только к текущему проекту или наследуются дочерними модулями.


Maven объединяет все переменные в единую модель свойств в памяти. Порядок приоритета: системные свойства (-D) > переменные окружения > свойства из POM.xml > свойства из settings.xml. Это требует дополнительных вычислений для разрешения конфликтов имен переменных.


#Java #middle #Maven #Profiles #Settings #m2
👍2
Secure settings: хранение credentials

Для безопасного хранения учетных данных (например, паролей для репозиториев) Maven поддерживает шифрование в settings.xml.

Процесс:

Создание мастер-пароля:

mvn --encrypt-master-password


Создает зашифрованный мастер-пароль, который сохраняется в ~/.m2/settings-security.xml:

<settingsSecurity>
<master>{encryptedMasterPassword}</master>
</settingsSecurity>


Шифрование пароля сервера:

mvn --encrypt-password


Создает зашифрованный пароль для <server> в settings.xml:
<server>
<id>nexus</id>
<username>user</username>
<password>{encryptedPassword}</password>
</server>


Maven использует библиотеку Plexus Cipher для шифрования и дешифрования. Зашифрованные данные загружаются в память как строки, а дешифрование происходит во время обращения к репозиториям. Это минимально влияет на память, но требует правильной настройки settings-security.xml.



.m2 директория

Директория ~/.m2 — это локальный репозиторий и хранилище пользовательских настроек Maven.

Основные компоненты:
repository/: Хранит кэшированные зависимости, плагины и их POM-файлы. Структура: groupId/artifactId/version/. Это снижает потребность в сетевых запросах, но увеличивает использование диска.
settings.xml: Локальный файл настроек пользователя.
settings-security.xml: Хранит зашифрованный мастер-пароль.
toolchains.xml: Определяет альтернативные JDK для сборки (например, для кросс-компиляции).


Maven загружает содержимое ~/.m2/settings.xml и settings-security.xml в память при старте. Локальный репозиторий не загружается полностью, но Maven читает метаданные (POM-файлы) по мере необходимости, что оптимизирует использование памяти. Однако при большом количестве зависимостей или устаревших артефактов в ~/.m2/repository может потребоваться очистка для освобождения места на диске.
Нюансы и внутренние механизмы


Управление памятью:
Maven загружает POM.xml, settings.xml и профили в память как объектные модели (POM model и Settings). Это увеличивает потребление памяти в многомодульных проектах или при большом количестве профилей.
Активация профилей требует проверки условий, что создает временные объекты в памяти для хранения результатов.
Для оптимизации используйте минимальное количество профилей и избегайте сложных условий активации.


Конфликты переменных:

Переменные с одинаковыми именами из разных источников (системные, окружения, POM, settings.xml) могут конфликтовать. Maven разрешает их по приоритету, но это требует дополнительных вычислений.
Используйте уникальные имена для пользовательских переменных, чтобы избежать путаницы.


Безопасность:

Хранение паролей в открытом виде в settings.xml небезопасно. Всегда используйте шифрование с --encrypt-password.
Убедитесь, что settings-security.xml имеет ограниченные права доступа (например, chmod 600).


Многомодульные проекты:

Профили из родительского POM.xml наследуются дочерними модулями, но могут быть переопределены. Это увеличивает сложность объединения конфигураций в памяти.
Используйте <pluginManagement> и <dependencyManagement> для централизованного управления.


Параллельное выполнение:

При использовании флага -T Maven загружает конфигурации для каждого модуля параллельно, что увеличивает пиковое потребление памяти из-за одновременной обработки нескольких POM-моделей и профилей.


Кэширование:

Локальный репозиторий (~/.m2/repository) кэширует зависимости, что снижает сетевые запросы, но требует периодической очистки для удаления устаревших SNAPSHOT-версий.
Maven кэширует результаты проверки условий активации профилей в рамках одной сессии, что ускоряет повторные сборки.


Отладка:

Используйте флаг -X для вывода подробной информации о загрузке профилей, переменных и настроек.
Плагин help:effective-settings показывает итоговую конфигурацию settings.xml:mvn help:effective-settings

Плагин help:effective-pom показывает объединенную модель POM с учетом активных профилей:mvn help:effective-pom


#Java #middle #Maven #Profiles #Settings #m2
👍2
Что выведет код?

public class Task070725 {
public static void main(String[] args) {
String[] arr1 = {"A", "B", "C"};
String[] arr2 = arr1;
arr2[1] = "X";

System.out.println(arr1[1]);
}
}


#Tasks
👍1
Варианты ответа:
Anonymous Quiz
7%
"A"
33%
"B"
56%
"X"
4%
Ошибка компиляции
👍1
Что такое Deque и в чем его особенности? 🤓

Ответ:

Deque (Double-Ended Queue) — интерфейс, представляющий очередь, в которую можно добавлять и удалять элементы с обоих концов.

Реализации: ArrayDeque, LinkedList.

Пример:
Deque<String> deque = new ArrayDeque<>();
deque.addFirst("A"); // Добавление в начало
deque.addLast("B"); // Добавление в конец
System.out.println(deque.removeFirst()); // A

Подходит для стеков, очередей и других структур с двусторонним доступом.

#собеседование
Please open Telegram to view this post
VIEW IN TELEGRAM
👍2
📌 Факт дня:

А вы знали, что термин "домен" в интернете был введён в 1983 году?

Пол Мокапетрис, создавая DNS (Domain Name System), предложил термин "domain" для обозначения адресов, таких как .com или .org. Это упростило навигацию в интернете, заменив числовые IP.

Proof

#facts
Please open Telegram to view this post
VIEW IN TELEGRAM
👍1
📌 Цитата дня: Андрей Терехов

"Хороший программист пишет код, который живет дольше его самого."


Андрей Терехов, разработчик российских компиляторов, сказал это в 2005 году на конференции по программированию в Санкт-Петербурге.


Биография

#Citation #Biography
Please open Telegram to view this post
VIEW IN TELEGRAM
👍2
Конвенции именования в Java

1. Что такое конвенции именования в Java?

Конвенции именования — это стандартизированные правила, определяющие стиль и формат имен для идентификаторов в Java-программах. Идентификаторы — это имена классов, методов, полей, переменных, пакетов и других элементов программы. Java следует строгим соглашениям, описанным в официальной документации (например, Oracle’s Java Code Conventions), чтобы обеспечить единообразие и упростить понимание кода.

Зачем нужны конвенции именования?
Читаемость: Понятные имена делают код более интуитивным для разработчиков.
Поддерживаемость: Единый стиль упрощает работу в команде и поддержку кода.
Предсказуемость: Конвенции позволяют быстро понять назначение элемента (например, метод или константа) по его имени.
Интеграция с инструментами: Многие инструменты (например, IDE, линтеры) используют конвенции для анализа и автодополнения кода.
Упрощение рефакторинга: Стандартизированные имена облегчают поиск и замену идентификаторов.



2. Синтаксис конвенций именования

Конвенции именования в Java используют несколько стилей оформления, таких как camelCase, PascalCase и UPPER_SNAKE_CASE, в зависимости от типа идентификатора.

2.1. Основные стили именования
camelCase: Слова соединяются, первое слово начинается с маленькой буквы, каждое последующее — с заглавной (например, calculateTotalPrice).
PascalCase: Слова соединяются, каждое слово начинается с заглавной буквы (например, CustomerService).
UPPER_SNAKE_CASE: Все буквы заглавные, слова разделяются подчеркиваниями (например, MAX_VALUE).
kebab-case: Не используется в Java, но упомянем для полноты — слова разделяются дефисами (например, my-variable). В Java предпочтение отдается подчеркиваниям для констант.


2.2. Правила для идентификаторов
Идентификаторы могут содержать буквы, цифры, подчеркивания (_) и знак доллара ($).
Идентификаторы не могут начинаться с цифры.
Идентификаторы не могут быть ключевыми словами Java (например, class, int).
Идентификаторы чувствительны к регистру (myVariable и MyVariable — разные идентификаторы).


2.3. Примеры для различных элементов
// Классы и интерфейсы (PascalCase)
public class CustomerService {
// Поля и переменные (camelCase)
private String customerName;
private int orderCount;

// Константы (UPPER_SNAKE_CASE)
public static final int MAX_ORDERS = 100;

// Методы (camelCase)
public void calculateTotalPrice() {
// Локальные переменные (camelCase)
int totalPrice = 0;
}

// Пакеты (все строчные, слова разделяются точками)
package com.example.myapp;
}



3. Конвенции для различных элементов программы

3.1. Классы и интерфейсы

Стиль: PascalCase.
Описание: Имена начинаются с заглавной буквы, каждое слово в имени также начинается с заглавной.
Примеры: CustomerService, OrderProcessor, Serializable.
Примечание: Интерфейсы следуют тому же стилю, но их имена часто отражают их назначение (например, Comparable, Runnable).


3.2. Методы
Стиль: camelCase.
Описание: Имена начинаются с маленькой буквы, каждое последующее слово — с заглавной. Имя должно начинаться с глагола, описывающего действие.
Примеры: calculateTotal, getCustomerName, isOrderValid.
Примечание: Для булевых методов часто используют префиксы is или has (например, isActive, hasPermission).


3.3. Поля и переменные
Стиль: camelCase.
Описание: Имена начинаются с маленькой буквы, каждое последующее слово — с заглавной. Имена должны быть описательными.
Примеры: customerId, orderDate, totalAmount.
Примечание: Избегайте однобуквенных имен (например, x, y), кроме случаев, когда они очевидны (например, i в циклах).

3.4. Константы
Стиль: UPPER_SNAKE_CASE.
Описание: Все буквы заглавные, слова разделяются подчеркиваниями. Используется для static final полей.
Примеры: MAX_VALUE, DEFAULT_TIMEOUT, PI.
Примечание: Константы должны быть неизменяемыми и описывать фиксированные значения.


#Java #для_новичков #beginner #java_syntax #Conventions
👍2
3.5. Пакеты
Стиль: Все строчные буквы, слова разделяются точками.
Описание: Имена пакетов обычно используют обратную доменную нотацию для уникальности.
Примеры: com.example.myapp, org.apache.commons.
Примечание: Избегайте подчеркиваний и дефисов в именах пакетов.


3.6. Локальные переменные и параметры

Стиль: camelCase.
Описание: Аналогично полям, имена должны быть описательными, но могут быть короче, если контекст ясен.
Примеры: index, userInput, result.


4. Правильное применение конвенций именования

Правильное использование конвенций именования критически важно для создания качественного кода.

4.1. Описательность
Имена должны четко отражать назначение элемента. Например, вместо data используйте customerData или orderDetails.
Для методов используйте глаголы, описывающие действие: calculateTotal вместо total, validateInput вместо check.


Пример:
// Хорошо
int calculateOrderTotal(Order order) {
return order.getItems().stream().mapToInt(Item::getPrice).sum();
}

// Плохо
int calc(Order o) {
return o.getItems().stream().mapToInt(Item::getPrice).sum();
}


4.2. Согласованность
Следуйте одному стилю именования во всем проекте. Например, если вы используете getName для геттеров, не используйте fetchName в других местах.
Согласованность упрощает поиск и понимание кода в больших проектах.

4.3. Избегайте сокращений
Используйте полные слова вместо сокращений, чтобы избежать двусмысленности. Например, computeAverage лучше, чем compAvg.
Исключение: общепринятые сокращения, такие как max, min, id.
Геттеры и сеттеры: Следуйте конвенции get и set для методов доступа (например, getName, setName).
Булевы методы: Используйте префиксы is или has для методов, возвращающих boolean (например, isEmpty, hasAccess).

4.4. Контекстная ясность
Имена должны быть понятны в контексте класса. Например, в классе Order метод calculateTotal не нуждается в уточнении Order (в отличие от calculateOrderTotal).

4.5. Избегайте избыточности
Не добавляйте лишние слова, если они не уточняют смысл. Например, calculateTotal лучше, чем doCalculateTotal.


Пример:
class Order {
// Хорошо
public double calculateTotal() {
return items.stream().mapToDouble(Item::getPrice).sum();
}

// Плохо
public double doCalculateTotalOfOrder() {
return items.stream().mapToDouble(Item::getPrice).sum();
}
}



5. Назначение конвенций именования

Конвенции именования выполняют несколько важных функций:

5.1. Улучшение читаемости
Хорошо названные идентификаторы позволяют разработчикам мгновенно понять назначение класса, метода или переменной.
Например, имя CustomerService сразу указывает на класс, связанный с обслуживанием клиентов.


5.2. Упрощение командной работы
Единые правила именования позволяют разработчикам из разных команд понимать код друг друга.
Это особенно важно в больших проектах или open-source сообществах.


5.3. Поддержка инструментов

Современные IDE (например, IntelliJ IDEA, Eclipse) используют конвенции для автодополнения, рефакторинга и анализа кода. Например, метод getName автоматически распознается как геттер.
Линтеры и статические анализаторы (например, Checkstyle) проверяют соблюдение конвенций.


5.4. Предотвращение ошибок
Правильные имена уменьшают вероятность ошибок. Например, имя MAX_RETRIES для константы ясно указывает на ее неизменяемость, а calculateTotal для метода — на его назначение.

5.5. Документация и самодокументирующийся код
Хорошо названные идентификаторы делают код самодокументирующимся, уменьшая необходимость в избыточных комментариях.
Например, вместо комментария // Вычисляет сумму цен можно просто использовать имя calculateTotalPrice.


#Java #для_новичков #beginner #java_syntax #Conventions
👍2
6. Конвенции именования и работа под капотом

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

6.1. Хранение идентификаторов в памяти

Идентификаторы (имена классов, методов, полей) хранятся в Metaspace как часть метаданных класса. Они представляют собой строки, которые компилируются в байт-код и загружаются в JVM при загрузке класса.
Длина имени идентификатора не влияет на размер объекта в куче (Heap), так как имена хранятся отдельно в Metaspace. Однако длинные имена могут незначительно увеличить объем метаданных.


6.2. Влияние на байт-код
В байт-коде идентификаторы преобразуются в ссылки на строки в пуле констант (constant pool) класса. Это позволяет JVM эффективно работать с именами, минимизируя их влияние на производительность.
JVM не различает стили именования (camelCase, PascalCase и т.д.), так как они являются лишь соглашениями для разработчиков. Однако несоблюдение конвенций может запутать инструменты анализа кода.


6.3. Рефлексия и имена
Рефлексия в Java (например, через Class.getMethod) использует имена методов и полей. Правильные имена (например, getName) позволяют рефлексии точно находить нужные элементы.
Неправильные имена (например, name вместо getName для геттера) могут привести к ошибкам при использовании рефлексии в фреймворках, таких как Spring или Hibernate.

Пример:
import java.lang.reflect.Method;

class Example {
public String getName() {
return "Test";
}
}

class ReflectionTest {
public static void main(String[] args) throws Exception {
Method method = Example.class.getMethod("getName"); // Работает
// Method method = Example.class.getMethod("name"); // Ошибка, если метод не существует
}
}


6.4. Оптимизация и производительность
Длина имени: Хотя длинные имена увеличивают объем метаданных в Metaspace, их влияние на производительность минимально благодаря оптимизациям JVM, таким как интернирование строк.
Читаемость vs. производительность: Длинные, но описательные имена (например, calculateTotalOrderPrice) предпочтительнее коротких и неясных (например, calc), так как читаемость важнее незначительных затрат памяти.
Инструменты минимизации: При использовании инструментов, таких как ProGuard, имена могут быть обфусцированы (сокращены) для уменьшения размера байт-кода, но это не влияет на исходный код.


6.5. Утечки памяти и имена
Неправильные имена не напрямую вызывают утечки памяти, но они могут привести к ошибкам, которые косвенно влияют на память. Например, если метод с именем clear не очищает ресурсы, а разработчик предполагает обратное, это может привести к удержанию объектов в куче.
Четкие имена, такие как releaseResources, помогают избежать таких недоразумений.



7. Лучшие практики

Следуйте официальным конвенциям: Используйте рекомендации Oracle’s Java Code Conventions для обеспечения совместимости с другими проектами.
Будьте описательны, но лаконичны: Имена должны быть понятными, но не избыточно длинными (например, getCustomerName лучше, чем getTheNameOfTheCustomer).
Используйте глаголы для методов: Методы должны начинаться с глагола, описывающего действие (например, calculate, get, set).
Избегайте неоднозначности: Не используйте имена, которые могут быть поняты неправильно (например, process может означать слишком многое).
Документируйте через имена: Делайте код самодокументирующимся, используя понятные имена вместо избыточных комментариев.
Проверяйте с помощью линтеров: Используйте инструменты, такие как Checkstyle, для автоматической проверки соблюдения конвенций.


Пример самодокументирующегося кода:

class OrderProcessor {
// Хорошо: имя метода понятно без комментариев
public double calculateTotalPrice(List<Item> items) {
return items.stream().mapToDouble(Item::getPrice).sum();
}
}


#Java #для_новичков #beginner #java_syntax #Conventions
👍2
Что выведет код?

public class Task080725 {
public static void main(String[] args) {
int String = 10;
System.out.println(String);
}
}


#Tasks
👍1
Варианты ответа:
Anonymous Quiz
65%
Ошибка компиляции
10%
"String"
15%
10
10%
null
😱1
Чем отличается forEach от forEachOrdered в Stream API? 🤓

Ответ:

forEach() выполняет действие для каждого элемента потока в произвольном порядке (особенно в параллельных потоках).

forEachOrdered() гарантирует обработку в порядке следования элементов, но может быть медленнее.

Пример:
List<String> list = Arrays.asList("a", "b", "c");
list.parallelStream().forEach(System.out::println); // Порядок не гарантирован

list.parallelStream().forEachOrdered(System.out::println); // a, b, c

#собеседование
Please open Telegram to view this post
VIEW IN TELEGRAM
👍3
📌 Факт дня:

А вы знали, что первый "цифровой текстовый редактор" был создан в 1967 году?

Программа QED, разработанная для компьютеров SDS 940, позволяла редактировать текст в реальном времени. Она вдохновила современные редакторы, такие как Vim и Notepad.

Proof

#facts
Please open Telegram to view this post
VIEW IN TELEGRAM
👍1
📌 Цитата дня: Исаак Брук

"ЭВМ должна быть не только умной, но и доступной."


Исаак Брук, разработчик первой в мире ЭВМ М-1 на полупроводниках, сказал это в 1950 году на заседании АН СССР, обсуждая важность технологий.


Биография

#Citation #Biography
Please open Telegram to view this post
VIEW IN TELEGRAM
👍1
Модульность и многомодульные проекты в Maven

Многомодульный проект в Maven — это проект, состоящий из нескольких подмодулей (submodules), каждый из которых является самостоятельным Maven-проектом со своим POM.xml. Все модули объединяются под общим родительским (parent) или агрегирующим (aggregator) POM.xml, который определяет общую конфигурацию и координирует сборку.

Основные характеристики:
Каждый модуль имеет собственный жизненный цикл, артефакты (JAR, WAR и т.д.) и зависимости.
Родительский POM задает общие настройки, такие как версии плагинов, зависимости и свойства.
Модули могут зависеть друг от друга, образуя граф зависимостей.
Сборка выполняется централизованно через родительский POM или выборочно для отдельных модулей.


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


Структура: Aggregator (Parent POM) vs Parent Project

Многомодульный проект может использовать два подхода к организации: aggregator POM и parent POM. Хотя термины часто пересекаются, их роли различаются.

Aggregator POM

Агрегирующий POM — это файл, который перечисляет модули проекта в секции <modules> и координирует их сборку. Он не обязательно содержит конфигурацию, а служит для запуска сборки всех модулей.

Пример:
<project>
<groupId>com.example</groupId>
<artifactId>aggregator</artifactId>
<version>1.0.0</version>
<packaging>pom</packaging>
<modules>
<module>module-api</module>
<module>module-core</module>
<module>module-web</module>
</modules>
</project>


Упаковка: <packaging>pom</packaging> указывает, что проект не создает артефакт (JAR/WAR), а только управляет модулями.
Сборка: Команда mvn package в директории aggregator вызывает сборку всех модулей в порядке, определенном реактором (см. ниже).


Parent POM

Родительский POM определяет общую конфигурацию, которая наследуется модулями. Он может быть одновременно агрегирующим POM.

Пример:
<project>
<groupId>com.example</groupId>
<artifactId>parent</artifactId>
<version>1.0.0</version>
<packaging>pom</packaging>
<properties>
<java.version>11</java.version>
</properties>
<dependencyManagement>
<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<version>5.3.20</version>
</dependency>
</dependencies>
</dependencyManagement>
<modules>
<module>module-api</module>
<module>module-core</module>
</modules>
</project>


Модуль наследует настройки из родительского POM:
<project>
<parent>
<groupId>com.example</groupId>
<artifactId>parent</artifactId>
<version>1.0.0</version>
</parent>
<artifactId>module-api</artifactId>
</project>


Наследование: Модули наследуют <groupId>, <version>, <properties>, <dependencyManagement>, <pluginManagement> и другие настройки.
Отличие: Родительский POM может существовать отдельно от агрегирующего, например, в другом проекте. Модули ссылаются на него через <parent>, но могут не быть перечислены в <modules>.


В памяти Maven загружает родительский POM первым, создавая базовую модель, которая затем дополняется конфигурацией каждого модуля. Если родительский POM находится в удаленном репозитории, Maven загружает его из ~/.m2/repository или скачивает, что добавляет сетевые операции и временное использование памяти.

Aggregator vs Parent

Aggregator: Управляет сборкой модулей через <modules>. Не обязательно является родительским.
Parent: Определяет наследуемую конфигурацию через <parent>. Может не быть агрегирующим.
Комбинация: Часто один POM выполняет обе роли, что упрощает структуру.


#Java #middle #Maven #Profiles #Parent_POM #MultiModule #Module_Inheritance
👍2
Module Inheritance

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

Модули наследуют от родительского POM:

Метаданные: <groupId>, <version> (если не переопределены в модуле).
Свойства: <properties> для общих настроек, таких как версии Java или библиотек.
Управление зависимостями: <dependencyManagement> задает версии зависимостей, которые модули могут использовать без указания версии.
Управление плагинами: <pluginManagement> определяет версии и конфигурации плагинов.
Репозитории: <repositories> и <pluginRepositories> для загрузки артефактов.


Пример наследования зависимостей:
<!-- parent POM -->
<dependencyManagement>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.13.2</version>
<scope>test</scope>
</dependency>
</dependencies>
</dependencyManagement>

<!-- module POM -->
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
</dependency>
</dependencies>


В памяти Maven объединяет родительскую и модульную модели POM, создавая эффективную модель (effective POM) для каждого модуля. Это требует дополнительных ресурсов, так как каждый модуль хранит свою копию модели, частично дублируя родительские данные.


Нюансы наследования

Переопределение: Модуль может переопределить унаследованные настройки, например, указав собственный <version> или <properties>.
Глубокое наследование: Если родительский POM сам наследуется от другого POM, Maven рекурсивно загружает все родительские модели, что увеличивает потребление памяти.
Конфликты: Неправильное переопределение (например, дублирование плагинов) может вызвать ошибки. Используйте mvn help:effective-pom для анализа итоговой конфигурации.



Разделение по слоям: API, Core, Impl, Web


Многомодульные проекты часто структурируются по слоям для разделения ответственности.


Типичная структура:
API: Содержит интерфейсы, DTO и публичные контракты. Упаковка — JAR. Пример: module-api.
Core: Реализует бизнес-логику, зависящую от API. Упаковка — JAR. Пример: module-core.
Impl: Конкретные реализации, например, интеграция с базами данных. Упаковка — JAR. Пример: module-impl.
Web: Веб-приложение, зависящее от Core или Impl. Упаковка — WAR. Пример: module-web.


Пример структуры:
project-root/
├── pom.xml (parent/aggregator)
├── module-api/
│ └── pom.xml
├── module-core/
│ └── pom.xml
├── module-impl/
│ └── pom.xml
├── module-web/
│ └── pom.xml


Зависимости между модулями:
<!-- module-core POM -->
<dependencies>
<dependency>
<groupId>com.example</groupId>
<artifactId>module-api</artifactId>
<version>${project.version}</version>
</dependency>
</dependencies>

<!-- module-web POM -->
<dependencies>
<dependency>
<groupId>com.example</groupId>
<artifactId>module-core</artifactId>
<version>${project.version}</version>
</dependency>
</dependencies>


В памяти Maven строит граф зависимостей, где модули являются узлами. Реактор (см. ниже) определяет порядок сборки, чтобы гарантировать, что module-api собирается до module-core, а module-core — до module-web. Это увеличивает объем памяти, так как Maven хранит метаданные всех модулей и их взаимосвязи.


Преимущества разделения

Модульность: Упрощает тестирование и повторное использование.
Четкие границы: Снижает связанность между компонентами.
Параллельная разработка: Команды могут работать над разными модулями независимо.


Нюансы

Циклические зависимости: Maven не допускает циклических зависимостей между модулями (например, module-api зависит от module-core, а module-core — от module-api). Это проверяется реактором, и при обнаружении цикла сборка завершается с ошибкой.
Размер графа: Большое количество модулей увеличивает сложность графа зависимостей, что требует больше памяти для хранения и обработки.



#Java #middle #Maven #Profiles #Parent_POM #MultiModule #Module_Inheritance
👍2
Best Practices

Versioning и dependencyManagement

Единая версия: Используйте одинаковую версию для всех модулей, унаследованную от родительского POM (${project.version}). Это упрощает управление и предотвращает несовместимость.
dependencyManagement: Централизуйте версии зависимостей в родительском POM:<dependencyManagement>
<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<version>5.3.20</version>
</dependency>
</dependencies>
</dependencyManagement>


Это снижает дублирование и обеспечивает согласованность версий.
pluginManagement: Аналогично управляйте версиями плагинов:<pluginManagement>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.10.1</version>
<configuration>
<source>${java.version}</source>
<target>${java.version}</target>
</configuration>
</plugin>
</plugins>
</pluginManagement>


В памяти dependencyManagement и pluginManagement хранятся как часть родительской POM-модели, минимизируя дублирование данных в модулях.


CI/CD подходы с модулями

Полная сборка: Настройте CI/CD (например, Jenkins, GitHub Actions) для выполнения полной сборки через mvn clean install в корне проекта. Это гарантирует, что все модули совместимы.
Инкрементальная сборка: Для ускорения используйте флаг --also-make (-am) или --projects (-pl) для сборки только измененных модулей (см. ниже).


Публикация артефактов: Используйте mvn deploy для загрузки артефактов в репозиторий (например, Nexus).
Настройте <distributionManagement> в родительском POM:<distributionManagement>
<repository>
<id>nexus</id>
<url>https://nexus.example.com/repository/maven-releases/</url>
</repository>
</distributionManagement>


Параллельная сборка: Используйте флаг -T (например, -T 4) для параллельного выполнения модулей. Это ускоряет сборку, но увеличивает пиковое потребление памяти из-за одновременной обработки нескольких POM-моделей.


Сборка части дерева

Maven позволяет собирать отдельные модули или их поддерево с помощью опций реактора:
Выбор модуля: Собрать только указанный модуль:mvn package -pl module-web
Включение зависимостей: Собрать модуль и все его зависимости:mvn package -pl module-web -am
Исключение модулей: Пропустить модуль:mvn package -pl !module-api


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


Работа с реактором

Реактор (Reactor) — это внутренний механизм Maven, который управляет порядком сборки модулей в многомодульном проекте.


Реактор:
Строит граф модулей: Анализирует <modules> в агрегирующем POM и зависимости между модулями (через <dependencies>).
Определяет порядок: Выполняет топологическую сортировку графа, чтобы модули, от которых зависят другие, собирались первыми.
Координирует сборку: Запускает жизненный цикл для каждого модуля в рассчитанном порядке.


В памяти реактор хранит граф модулей как направленный ациклический граф (DAG), где узлы — модули, а ребра — зависимости. Размер графа пропорционален количеству модулей, что увеличивает потребление памяти в крупных проектах. Реактор также кэширует промежуточные артефакты в ~/.m2/repository, чтобы избежать повторной сборки неизмененных модулей.

Нюансы реактора

Циклические зависимости: Реактор обнаруживает циклы и завершает сборку с ошибкой. Используйте mvn dependency:tree для анализа.
Пропуск модулей: Флаг -pl или -am изменяет граф, который обрабатывает реактор, уменьшая объем памяти.
Ошибки: Если модуль завершает сборку с ошибкой, реактор останавливает процесс, но промежуточные артефакты сохраняются в target.


#Java #middle #Maven #Profiles #Parent_POM #MultiModule #Module_Inheritance
👍2
Жизненный цикл в многомодульных проектах

Жизненный цикл в многомодульных проектах аналогичен одномодульному, но применяется к каждому модулю индивидуально. Основные фазы (Clean, Default, Site) выполняются в порядке, определенном реактором.

Последовательность: Реактор вызывает фазы жизненного цикла (например, validate, compile, package) для каждого модуля по очереди. Например, mvn package сначала выполнит package для module-api, затем для module-core и так далее.
Параллельность: С флагом -T Maven выполняет фазы для независимых модулей параллельно, что ускоряет сборку, но увеличивает потребление памяти из-за одновременной загрузки нескольких POM-моделей и плагинов.
Общие ресурсы: Родительский POM задает общие плагины и зависимости, которые загружаются в память один раз и используются всеми модулями, оптимизируя ресурсы.
Пропуск фаз: Флаги, такие как -DskipTests, применяются ко всем модулям, что снижает нагрузку на память.


В памяти Maven хранит модель жизненного цикла для каждого модуля, включая привязки плагинов к фазам. Для крупных проектов это может привести к значительному потреблению памяти, особенно на фазах, таких как compile или test, где загружаются исходные файлы, зависимости и результаты тестов.

Нюансы

Инкрементальная сборка: Maven использует временные метки файлов в target, чтобы пропускать неизмененные модули. Это снижает нагрузку на память и процессор.
Ошибки в модуле: Если одна фаза завершается с ошибкой в модуле, Maven останавливает сборку, но уже созданные артефакты сохраняются.
Кэширование артефактов: Модули, установленные в ~/.m2/repository (через mvn install), не пересобираются при повторных запусках, что оптимизирует производительность.



Нюансы и внутренние механизмы

Управление памятью:
Maven загружает модель POM для каждого модуля, создавая объединенную модель проекта. Это увеличивает потребление памяти пропорционально количеству модулей.
Реактор строит граф модулей в памяти, что требует дополнительных ресурсов для хранения и сортировки.
Параллельная сборка (-T) увеличивает пиковое потребление памяти из-за одновременной обработки нескольких модулей.
Для оптимизации используйте -pl для выборочной сборки и настройте JVM с помощью -Xmx.


Кэширование:
Локальный репозиторий (~/.m2/repository) кэширует артефакты модулей, что снижает необходимость повторной сборки.
Maven использует файлы _remote.repositories для отслеживания происхождения артефактов, минимизируя сетевые запросы.


Конфликты зависимостей:
Модули могут использовать разные версии одной библиотеки, что приводит к конфликтам. Используйте <dependencyManagement> для согласованности.
Плагин maven-enforcer-plugin с правилом dependencyConvergence помогает выявить конфликты.


Производительность:
Инкрементальная сборка и кэширование ускоряют процесс, но первый запуск или полная сборка (mvn clean) могут быть медленными.
Параллельная сборка сокращает время, но требует мощного оборудования из-за высокой нагрузки на память и процессор.


Отладка:
Используйте mvn -X для вывода подробной информации о порядке сборки и загрузке модулей.
Команда mvn dependency:tree -pl module-name помогает анализировать зависимости конкретного модуля.
Плагин help:effective-pom показывает итоговую конфигурацию модуля с учетом наследования.


CI/CD интеграция:
Настройте CI/CD для выполнения mvn clean install на каждое изменение, чтобы гарантировать целостность всех модулей.
Используйте матричные сборки для тестирования модулей в разных окружениях (например, разные версии Java).
Храните SNAPSHOT-версии в репозитории (например, Nexus) для промежуточных сборок, а релизные версии — в отдельном репозитории.


#Java #middle #Maven #Profiles #Parent_POM #MultiModule #Module_Inheritance
👍2
Что выведет код?

import java.util.function.Function;

public class Task090725 {
public static void main(String[] args) {
Function<Integer, Integer> f = x -> x * 2;
Function<Integer, Integer> g = x -> x + 3;

System.out.println(f.compose(g).apply(5));
System.out.println(f.andThen(g).apply(5));
}
}


#Tasks
👍2
Варианты ответа:
Anonymous Quiz
20%
13 16
30%
10 13
20%
16 10
30%
16 13
👍2