📌 Magic numbers в Java - мелкая привычка, которая потом превращает поддержку кода в археологию.

Когда в коде встречается 86400, 7, 1.21 или 5000, компилятору всё равно. Человеку - нет. Через месяц уже приходится вспоминать, что это было: секунд в дне, дней сессии, НДС или задержка перед повторной попыткой.

Плохой вариант выглядит так:

if (sessionAgeSeconds > 86400 * 7)

Формально код работает. Но смысл спрятан внутри чисел.

Нормальный вариант:

SECONDS_PER_DAY
SESSION_DAYS
VAT_RATE
RETRY_DELAY_MS

Теперь намерение видно прямо в месте вызова. Не нужно угадывать, почему именно 7, что означает 5000 и можно ли безопасно поменять значение.

Это особенно важно в бизнес-логике, где числа редко бывают случайными. Лимиты, комиссии, таймауты, скидки, сроки жизни сессии, количество попыток - всё это правила продукта, а не просто цифры в коде.

Хорошее правило простое: если число несёт смысл, дай ему имя. Исключения вроде 0, 1, индексов и простых счётчиков можно не трогать.

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

#java #cleancode

N+1 в Spring Boot выглядит безобидно, пока прод не начинает молиться на базу данных.

Классический сценарий:

Вы грузите список заказов:

orderRepository.findAll()

А потом в цикле обращаетесь к order.getItems().

Hibernate сначала делает один запрос за заказами, а потом ещё по одному запросу на каждый заказ, чтобы достать items.

100 заказов = 101 SQL-запрос.

И вот здесь спасает @EntityGraph.

Он позволяет явно сказать репозиторию, какие связи нужно подтянуть сразу:

@EntityGraph(attributePaths = {"items"})

В итоге Hibernate может сгенерировать один запрос с JOIN, вместо десятков лишних походов в базу.

Что получаем:

- меньше SQL-запросов
- меньше нагрузки на БД
- чище код репозитория
- без ручного JPQL
- fetch-стратегия управляется точечно под конкретный кейс

LAZY сам по себе не зло. Зло - когда вы не контролируете, где и как он срабатывает.

@EntityGraph - один из самых простых способов держать N+1 под контролем в Spring Boot.

💡 Java: делегирование часто безопаснее наследования

Наследование кажется удобным, пока суперкласс не начинает жить своей жизнью.

Если класс наследуется от родителя, он получает весь его API. Любое изменение сверху может внезапно сломать поведение дочернего класса.

С делегированием проще: объект хранит внутри helper/service и передаёт ему нужные вызовы.

Плюсы:

* меньше жёсткой связности
* проще тестировать и мокать
* легче менять реализацию
* меньше риска сломаться из-за изменений в родителе

Правило простое: наследуйтесь только когда связь is-a действительно железная. В остальных случаях чаще лучше композиция и делегирование.

Кто-то разобрал Claude Code почти до винтика

learn-coding-agent - репозиторий для тех, кто хочет понять, как устроены современные coding agents не на уровне промо-страниц, а на уровне архитектуры.

Автор собрал разбор Claude Code по публичным источникам: цикл агента, систему инструментов, разрешения, работу с контекстом, сессии, подпроцессы, MCP, удалённые настройки, телеметрию и скрытые флаги.

Получился не “гайд по использованию”, а карта внутренней логики CLI-агента: как он принимает решение, когда просит разрешение, как вызывает инструменты, как хранит историю и как расширяется через внешние интеграции.

https://github.com/justxor/Claudecourse/

🔥 Хочешь быстрее расти в IT? Хватит учиться в одиночку

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

Окружение решает больше, чем кажется.

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

AI: t.me/ai_machinelearning_big_data
Python: t.me/pythonl
Linux: t.me/linuxacademiya
Хакинг: t.me/linuxkalii
DevOps: t.me/DevOPSitsec
Docker: t.me/DevopsDocker
Golang: t.me/Golang_google
Rust: t.me/rust_code
C++: t.me/cpluspluc
C#: t.me/csharp_1001_notes
Java: t.me/java_library
JavaScript: t.me/javascriptv
React: t.me/react_tg
Frontend: t.me/front
PHP: t.me/phpshka
Android: t.me/android_its
Мобильная разработка: t.me/mobdevelop
Базы данных: t.me/sqlhub
Data Science: t.me/data_analysis_ml
Big Data: t.me/bigdatai
Математика: t.me/data_math
Физика: t.me/fizmat
Kubernetes: t.me/kubernetc
GameDev: https://t.me/gamedev
Haskell: t.me/haskell_tg

Собеседования и карьера:

DS собеседования: t.me/machinelearning_interview
Python собеседования: t.me/python_job_interview

Папка с вакансиями: t.me/addlist/_zyy_jQ_QUsyM2Vi
Папка Go разработчика: t.me/addlist/MUtJEeJSxeY2YTFi
Папка Python разработчика: t.me/addlist/eEPya-HF6mkxMGIy
Папка ML: https://t.me/addlist/2Ls-snqEeytkMDgy
Папка Frontend: https://t.me/addlist/mzMMG3RPZhY2M2Iy

Полезное сверху:

ИТ-мемы: t.me/memes_prog
Английский для программистов: t.me/english_forprogrammers
ИИ и технологии: t.me/vistehno
954 ГБ open-source курсов: @courses
ИТ-книги бесплатно: https://t.me/addlist/BkskQciUW_FhNjEy

Max Ai: https://max.ru/ai_machinelearning_big_data
Max python: https://max.ru/pythonl
ТЕХНО: https://max.ru/vistehno
Max Go: https://max.ru/Golang_google
Max Linux: https://max.ru/linuxkalii
Devops: https://max.ru/DevOPSitsec
C#: https://max.ru/csharp_ci
C++: https://max.ru/cpluspluc
SQL: https://max.ru/sqlhub
Java: https://max.ru/javatg

Подписывайся на нужные направления и собирай себе ленту, которая реально двигает вперёд.

Пока кто-то листает шум, ты будешь видеть инструменты, задачи и идеи, которые помогают расти в профессии.

❓Что из вариантов лучше всего описывается определением: Операция, которая содержит серию задач, которые должны быть выполнены либо все, либо не выполнена ни одн

#spring

Java-совет: два разных пути могут вести к одному файлу

Сравнение через Path.equals() проверяет только сами пути. Поэтому эти значения считаются разными:

Path path1 = Path.of("data/report.txt");
Path path2 = Path.of("data/../data/report.txt");

Чтобы проверить, указывают ли они на один и тот же реальный файл, используйте:

boolean same = Files.isSameFile(path1, path2);

Метод учитывает:

- относительные и абсолютные пути;
- символические ссылки;
- особенности файловой системы;
- разные способы записи одного расположения.

Пример:

Path original = Path.of("/app/config.json");
Path symlink = Path.of("/app/current-config");

if (Files.isSameFile(original, symlink)) {
    System.out.println("Это один файл");
}

Важно: метод обращается к файловой системе и может выбросить IOException.

Files.isSameFile() полезен перед копированием, перемещением или удалением файлов — особенно когда в проекте используются символические ссылки и нестандартные пути.

💡 Редкий совет Java: используйте `ClassValue` для кэша, привязанного к классу

Обычно метаданные кэшируют так:

Map<Class<?>, Metadata> cache = new ConcurrentHashMap<>();

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

Для подобных случаев в Java есть ClassValue:

private static final ClassValue<Metadata> CACHE =
new ClassValue<>() {
@Override
protected Metadata computeValue(Class<?> type) {
return inspect(type);
}
};

Metadata metadata = CACHE.get(User.class);

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

ClassValue особенно полезен для reflection-кэшей, сериализаторов, ORM, прокси и плагинных архитектур.

Редкий инструмент JVM, который часто безопаснее, чем ConcurrentHashMap<Class<?>, ...>.

#Java #JVM #Backend #Performance

💡 Java cj: unmodifiableList() не делает настоящую копию

Эти два варианта выглядят похоже, но работают по-разному:

List<String> source = new ArrayList<>();
source.add("Java");

List<String> view = Collections.unmodifiableList(source);
List<String> copy = List.copyOf(source);

source.add("Spring");

System.out.println(view); // [Java, Spring]
System.out.println(copy); // [Java]

Collections.unmodifiableList() создаёт только неизменяемое представление исходного списка. Если source изменится, изменения появятся и в view.

List.copyOf() создаёт отдельный неизменяемый снимок данных.

Используйте:

- unmodifiableList() — когда нужен read-only view актуального списка;
- List.copyOf() — когда нужно зафиксировать состояние и безопасно вернуть его наружу.

public List<String> getUsers() {
    return List.copyOf(users);
}

Так внешний код не сможет изменить внутреннюю коллекцию, а последующие изменения users не повлияют на уже возвращённый результат.

List.copyOf() доступен начиная с Java 10.

#Java #JavaTips #Backend

💡 Java совет: два пути могут указывать на один и тот же файл

Path.equals() сравнивает только представление пути:

Path a = Path.of("data.txt");
Path b = Path.of("./data.txt");

System.out.println(a.equals(b)); // false

Хотя оба пути могут вести к одному файлу.

Для проверки используйте:

boolean same = Files.isSameFile(a, b);

Files.isSameFile() обращается к файловой системе и учитывает:

- относительные пути;
- символические ссылки;
- реальное расположение файла.

Path file = Path.of("data.txt");
Path link = Path.of("data-link.txt");

Files.isSameFile(file, link); // true, если link ведёт к data.txt

Полезно при поиске дубликатов, проверке пользовательских путей и защите от повторной обработки одного файла.

Учтите: метод может обращаться к диску и выбрасывать IOException, поэтому это не просто строковое сравнение.

Доступно начиная с Java 7.

#Java #JavaTips #Files

☕️ Java-совет: не запускайте блокирующий I/O через `CompletableFuture` без собственного пула

Такой код выглядит асинхронным:

CompletableFuture<User> future =
        CompletableFuture.supplyAsync(() -> userClient.loadUser(id));

Но без явного Executor задача обычно попадёт в общий ForkJoinPool.commonPool().

Если loadUser() ждёт HTTP, базу данных или файловую систему, поток блокируется. Несколько медленных вызовов могут занять весь общий пул и затормозить совершенно несвязанные операции приложения.

Лучше выделить отдельный пул для блокирующего I/O:

private static final ExecutorService IO_POOL =
        Executors.newFixedThreadPool(32);

CompletableFuture<User> future =
        CompletableFuture.supplyAsync(
                () -> userClient.loadUser(id),
                IO_POOL
        );

И не забыть корректно его закрыть:

IO_POOL.shutdown();

Для цепочки тоже важно явно выбирать executor:

future.thenApplyAsync(
        user -> enrichUser(user),
        IO_POOL
);

Почему это полезно:

- медленный внешний сервис не блокирует общий пул;
- нагрузку можно ограничить размером executor;
- проще наблюдать очередь и время выполнения;
- разные типы задач не мешают друг другу.

CompletableFuture не делает блокирующий код неблокирующим. Он лишь переносит ожидание в другой поток.

Асинхронность без контроля executor - это просто блокировка в менее заметном месте.

⚡️ Java-приём: не храни метаданные классов в `static Map<Class<?>, ...>` — используй `ClassValue`.

Допустим, библиотека кеширует информацию о каждом классе:

private static final Map<Class<?>, Metadata> CACHE =
        new ConcurrentHashMap<>();

На первый взгляд всё нормально.

Но в приложениях с динамической загрузкой классов — plugins, application servers, hot reload — такой кеш может удерживать Class, а вместе с ним и его ClassLoader.

И получить неприятную утечку памяти.

В Java для этого есть малоизвестный ClassValue<T>:

private static final ClassValue<Metadata> CACHE =
        new ClassValue<>() {
            @Override
            protected Metadata computeValue(Class<?> type) {
                return buildMetadata(type);
            }
        };

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

Metadata metadata = CACHE.get(MyClass.class);

Что даёт ClassValue:

- ленивое вычисление значения для каждого класса;
- thread-safe доступ;
- не нужен собственный ConcurrentHashMap;
- кеш лучше согласован с жизненным циклом загруженных классов.

Особенно полезно для reflection, serializers, ORM, DI-контейнеров и framework-кода, где постоянно кешируются данные по Class<?>.

🔥 Если видишь в библиотеке:

static ConcurrentHashMap<Class<?>, ...>

стоит хотя бы задать вопрос:

а почему здесь не `ClassValue`?

#Java #JVM #Backend #Programming

Полезный Java-совет:

Не вызывай parallelStream() просто потому, что данных много.

Для коротких операций он легко оказывается медленнее обычного stream(), потому что платишь за разбиение задачи, синхронизацию и работу ForkJoinPool.

Особенно неприятно то, что по умолчанию parallelStream() использует общий ForkJoinPool.commonPool(). Если приложение уже нагружает его другими задачами, производительность может внезапно просесть вообще в другом месте.

Если параллелизм реально нужен, лучше контролировать executor явно, а не прятать его внутри parallelStream().

Java-ловушка: почему `parallelStream()` может замедлить приложение

Многие думают:

«Есть stream(), добавлю parallelStream() — станет быстрее».

Но не всегда.

parallelStream() использует общий ForkJoinPool Java:

users.parallelStream()
     .map(this::callExternalApi)
     .toList();

Если внутри идут HTTP-запросы, SQL или ожидание внешнего сервиса, можно получить обратный эффект:

забить общий пул потоков
увеличить задержки
замедлить другие части приложения

parallelStream() хорошо подходит для:

✅ сложных CPU-вычислений
✅ обработки больших коллекций
✅ математических операций

Но плохо подходит для:

❌ HTTP
❌ базы данных
❌ файлового I/O
❌ ожидания внешних сервисов

Для таких задач лучше использовать отдельный пул:

ExecutorService executor =
    Executors.newFixedThreadPool(20);

и контролировать количество параллельных операций.

Главное правило:

parallelStream() — для вычислений.
ExecutorService — для бизнес-логики и внешних вызовов.

Код может идеально работать на тестах, но в production внезапно получить проблемы из-за одного parallelStream().

🔥 Java: subList() может неожиданно удерживать огромный список в памяти

Кажется, что:

List<Item> small = hugeList.subList(0, 10);
hugeList = null;

оставит только 10 элементов.

Но subList() обычно создаёт представление исходного списка, а не независимую копию. Пока жив small, исходный ArrayList и его внутренний массив тоже могут оставаться в памяти.

Если нужна отдельная маленькая коллекция:

List<Item> small = new ArrayList<>(hugeList.subList(0, 10));

Особенно неприятный баг в кэшах и долгоживущих объектах: сохраняешь 10 элементов — а в памяти остаются сотни тысяч.

Autobase

Это инструмент, разработанный для автоматизации развёртывания и управления PostgreSQL-кластерами с использованием Ansible. Он поддерживает широкий набор функций, включая настройку репликации, автоматизацию резервного копирования с помощью инструментов, таких как pgBackRest и WAL-G, мониторинг состояния кластеров, а также настройку высокодоступной инфраструктуры (HA).

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

https://github.com/autobase-tech/autobase