⌛ Как отслеживать изменения в файловой системе в реальном времени

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

🔹 Возможные сценарии использования:
- Отслеживание действий пользователя.
- Мониторинг изменений в конфигурационных файлах для их динамической перезагрузки.
- Автоматическая обработка данных, как только они поступают в систему (например, новые изображения или документы).
- Логирование и анализ активности в системных директориях.

import java.nio.file.*;
import java.io.IOException;

public class DirectoryWatcher {
    public static void main(String[] args) throws IOException, InterruptedException {
        WatchService watchService = FileSystems.getDefault().newWatchService();
        Path path = Paths.get("/path/to/watch");
        path.register(watchService, StandardWatchEventKinds.ENTRY_CREATE, 
                                    StandardWatchEventKinds.ENTRY_DELETE, 
                                    StandardWatchEventKinds.ENTRY_MODIFY);

        System.out.println("Monitoring directory: " + path);
        
        while (true) {
            WatchKey key = watchService.take();
            key.pollEvents().forEach(event -> {
                WatchEvent.Kind<?> kind = event.kind();
                System.out.println(kind.name() + ": " + event.context());
            });
            if (!key.reset()) break;
        }
    }
}

WatchService — это механизм мониторинга событий файловой системы. Для его работы регистрируем путь для отслеживания событий с помощью path.register() и указываем тип событий: создание, удаление или модификация.
В бесконечном цикле программа ожидает события с помощью watchService.take(), после чего события обрабатываются через лямбду.
Метод reset() проверяет, можно ли продолжить отслеживание, если нет — цикл завершится.

🔹 Преимущества использования:
- Моментальное реагирование на изменения файлов, что упрощает автоматизацию.
- Легкая настройка — всего несколько строк кода для полного мониторинга директории.
- Минимальные ресурсы — WatchService не требует постоянного опроса файловой системы.

ℹ️ Как устроен под капотом TreeSet?

TreeSet — это коллекция, которая хранит уникальные элементы и автоматически сортирует их в натуральном порядке или по заданному Comparator. Под капотом используется самобалансирующееся красно-черное дерево, которое гарантирует, что добавление, удаление и поиск элементов будут происходить за логарифмическое время. В отличие от HashSet, TreeSet не только предотвращает дублирование элементов, но и поддерживает их упорядоченность.

🔹 Структура TreeSet

В основе TreeSet лежит красно-черное дерево — структура данных, которая поддерживает балансировку после каждой операции вставки или удаления. Т.е. дерево автоматически регулирует свою форму при каждом добавлении или удалении элемента, чтобы предотвратить чрезмерное «перерастание» дерева в одну сторону.
Элементы в TreeSet хранятся в виде узлов дерева:

▪️ Каждый узел содержит ключ и ссылки на дочерние узлы
▪️ Дерево автоматически сбалансировано — максимальная глубина любого пути от корня к листу в два раза меньше самой длинной возможной
▪️ Элементы располагаются в отсортированном порядке по мере добавления, что гарантирует логарифмическую сложность поиска и вставки

🔹 Производительность

▪️ Добавление: При добавлении элемента дерево балансируется, чтобы соблюсти свойства красно-черного дерева. Это обеспечивает сложность добавления O(log n).
▪️ Удаление: Работает схожим образом — дерево ребалансируется, а ссылки между узлами корректируются. Удаление также выполняется за O(log n).
▪️ Поиск: Благодаря сбалансированной структуре, поиск элемента в TreeSet занимает O(log n), что делает его быстрее, чем линейный поиск в несбалансированных структурах.

🔹 Использование памяти

Каждый узел в TreeSet хранит не только ключ, но и ссылки на дочерние узлы (левый и правый). Это создает определенные накладные расходы по памяти, ведь для каждого элемента требуется больше памяти, чем, например, в HashSet, где хранятся лишь сами элементы.

🔹 Преимущества и недостатки

▪️ Преимущества:
- Гарантированный порядок элементов: В отличие от HashSet, TreeSet хранит элементы в отсортированном виде. Это важно, если нужно быстро получать минимальные, максимальные или средние значения без дополнительной сортировки. Также можно извлекать диапазоны значений с помощью методов вроде subSet().
- Навигационные методы: TreeSet предоставляет мощные инструменты для навигации по набору, такие как методы для поиска ближайших элементов (floor(), ceiling()), что делает его удобным для задач с диапазонами данных.
▪️ Недостатки:
- Производительность: Операции в TreeSet медленнее, чем в HashSet.
- Большие накладные расходы по памяти: Для каждого элемента TreeSet требуется хранить дополнительные ссылки на дочерние узлы, что увеличивает потребление памяти.

💡 ReentrantLock vs. Lock

Lock — это интерфейс, предоставляющий базовые методы для управления синхронизацией потоков. Одной из наиболее популярных реализаций этого интерфейса является ReentrantLock, которая предлагает более широкие возможности по сравнению с базовыми реализациями. Разбираемся, в чём различие:

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

🔵 Больше контроля
ReentrantLock даёт больше возможностей управления блокировкой: можно настраивать справедливость (потоки захватывают блокировку по очереди) и использовать неблокирующие методы, такие как tryLock(), чтобы избежать ожидания.

🔵 Управление состоянием
С ReentrantLock блокировку можно вручную освобождать, что полезно при более сложной логике.

🔵 Дополнительные методы
ReentrantLock предоставляет такие полезные методы, как getHoldCount(), чтобы узнать, сколько раз текущий поток захватил блокировку, и isHeldByCurrentThread() для проверки, удерживается ли она этим потоком.

Используйте ReentrantLock, если вам требуется гибкость и контроль над блокировками. Lock подходит для простых случаев синхронизации.

🔥 Свежие обновления GraalVM

Недавно вышли новые демо и руководства для GraalPy и GraalJS, которые помогут легче внедрять многоязычную работу в проектах. Эти улучшения делают работу с Python и JavaScript внутри Java-приложения ещё удобнее и быстрее.

📌 Подробности и примеры можно найти на GitHub и GraalVM.

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

🔗 Шпаргалка: Основы тестирования с JUnit

1️⃣ Добавляем зависимость JUnit

Для Maven:

<dependency>
    <groupId>org.junit.jupiter</groupId>
    <artifactId>junit-jupiter-api</artifactId>
    <version>5.9.3</version>
    <scope>test</scope>
</dependency>

Для Gradle:

testImplementation 'org.junit.jupiter:junit-jupiter-api:5.9.3'

2️⃣ Создаем тестовый класс

Начнем с создания класса для тестирования и метода с аннотацией @Test:

import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;

public class MyTest {
    @Test
    public void testAddition() {
        int result = 2 + 2;
        assertEquals(4, result); // Проверка, что результат 4
    }
}

3️⃣ Основные аннотации JUnit

- @Test — указывает, что метод является тестом.
- @BeforeEach — выполняется перед каждым тестом (настройка окружения).
- @AfterEach — выполняется после каждого теста (очистка).
- @BeforeAll — выполняется один раз перед всеми тестами (должен быть статическим).
- @AfterAll — выполняется один раз после всех тестов (тоже статический).

Пример использования:

@BeforeEach
public void setUp() {
    // Код инициализации перед каждым тестом
}

@AfterEach
public void tearDown() {
    // Код очистки после каждого теста
}

4️⃣ Основные ассерты (проверки)

- assertEquals(expected, actual) — проверяет равенство значений.
- assertNotEquals(expected, actual) — проверяет неравенство.
- assertTrue(condition) — проверяет, что условие истинно.
- assertFalse(condition) — проверяет, что условие ложно.
- assertNull(object) — проверяет, что объект равен null.
- assertThrows(exception.class, () -> { ... }) — проверяет, что выбрасывается исключение.

5️⃣ Параметризованные тесты

Если нужно протестировать несколько вариантов входных данных, используйте параметризованные тесты:

@ParameterizedTest
@ValueSource(strings = {"abc", "123", "xyz"})
public void testWithParameters(String input) {
    assertNotNull(input);
}

6️⃣ Используйте assertAll() для группировки нескольких проверок в одном тесте

@Test
public void testMultipleAsserts() {
    assertAll(
        () -> assertEquals(4, 2 + 2),
        () -> assertTrue(3 > 1),
        () -> assertNotNull(new Object())
    );
}

7️⃣ Мокирование зависимостей

Для изоляции кода можно использовать библиотеки для мокирования, такие как Mockito:

@Mock
private MyService myService;

@BeforeEach
public void setUp() {
    MockitoAnnotations.initMocks(this);
}

@Test
public void testWithMock() {
    when(myService.getData()).thenReturn("Mock Data");
    assertEquals("Mock Data", myService.getData());
}

8️⃣ Запуск тестов

В IDE тесты можно запускать прямо из тестового класса.
Maven: mvn test.
Gradle: gradle test.

🤔 Основы математики в Machine Learning / Deep Learning

🗓 16 октября мы разберем ряд Тейлора, собственные векторы и другие ключевые понятия в ML – https://proglib.io/w/d2948d01

Спикер: Иван Потапов – Staff Machine Learning Engineer at ShareChat. Руководит командой, отвечающей за качество рекомендаций, и имеет 8-летний опыт в сфере машинного обучения.

😮 Что будем обсуждать:

– Теорию вероятностей: случайные величины, математическое ожидание и дисперсию.

– Линейную алгебру: векторы, матрицы, собственные векторы и собственные значения.

– Математический анализ: производные и разложение функций в ряд Тейлора.

👨‍💻 А еще после каждого блока вас ждет практика в применении полученных знаний.

🎯 Почему это важно?
Понимание математических основ помогает глубже разобраться в работающих под капотом алгоритмах ML/DL и эффективно применять их на практике.

Присоединяйтесь к нам и совершенствуйте свои навыки в машинном обучении!

📌 Регистрация по ссылке: https://proglib.io/w/d2948d01

🕯 Паттерн Factory (Фабрика)

Factory — это порождающий паттерн, который предоставляет интерфейс для создания объектов в суперклассе, но позволяет подклассам изменять тип создаваемых объектов.

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

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

Преимущества:

1️⃣ Снижает связанность кода с конкретными классами, делая систему более гибкой.
2️⃣ Улучшает структуру кода за счёт выделения логики создания объектов в отдельные классы.
3️⃣ Упрощает добавление новых типов объектов, не изменяя существующий код.

Недостатки:

1️⃣ Увеличивает количество классов в проекте, что усложняет его поддержку.
2️⃣ Требует понимания принципов абстракции и иерархий, что может усложнить первоначальное восприятие.

📌 Factory широко применяется для создания объектов в системах, где тип создаваемого объекта зависит от условий, например, в логике обработки различных пользовательских запросов или для генерации разных типов документов.

ℹ️ Что такое @Transactional в Spring?

@Transactional — это аннотация, которая управляет транзакциями в Spring. Она позволяет автоматически начать, зафиксировать или откатить транзакцию при выполнении бизнес-логики. Применяется к методам или классам, где важно обеспечить целостность данных.

🔹 Как работает:

Когда метод помечен @Transactional, Spring создает прокси-объект, который начинает транзакцию до выполнения метода и завершает её после. В случае исключения транзакция откатывается, если оно не является проверяемым (checked exception).

🔹 Конфигурации @Transactional:

▪️ Propagation (распространение):

- REQUIRED (по умолчанию): метод должен выполняться в существующей транзакции, если она есть, иначе создается новая.
- REQUIRES_NEW: всегда создает новую транзакцию, приостанавливая текущую.
- SUPPORTS: метод может выполняться в транзакции, но не требует её обязательного наличия.
- MANDATORY: требует существования транзакции, иначе будет выброшено исключение.
- NOT_SUPPORTED: метод выполняется без транзакции, даже если она существует.
- NEVER: запрещает выполнение метода в транзакции, иначе выбрасывается исключение.
- NESTED: позволяет создавать вложенные транзакции, которые могут быть откатаны отдельно от внешней.

▪️ Isolation (изолированность):

- DEFAULT: уровень изоляции БД по умолчанию.
- READ_UNCOMMITTED: минимальная изоляция, позволяет читать незавершенные изменения.
- READ_COMMITTED: запрещает чтение незавершенных транзакций.
- REPEATABLE_READ: гарантирует, что данные не изменятся во время транзакции.
- SERIALIZABLE: максимальная изоляция, исключает фантомные записи.

▪️ Timeout и Rollback:

timeout: ограничивает время выполнения транзакции (по умолчанию бесконечно).
rollbackFor/noRollbackFor: настраивают, какие исключения должны вызвать откат или нет.

🔹 Когда @Transactional не сработает?

- @Transactional не срабатывает, если метод с этой аннотацией вызывается внутри другого метода того же класса. Это связано с тем, что Spring использует прокси для управления транзакциями, и он активируется только при внешних вызовах. Когда метод вызывается из другого метода того же класса, прокси не задействуется, и транзакция не будет создана.
- Также нужно помнить, что аннотация не работает с private методами.

💥 Волшебные методы в Spring Data JPA: скрытые возможности работы с данными

В Spring Data JPA можно создавать "волшебные" методы в репозиториях, которые автоматически генерируют SQL-запросы на основе имени метода. Это очень мощный инструмент, который ускоряет разработку и упрощает работу с базой данных. Вместо написания SQL-запросов вручную, достаточно правильно написать название метода, и фреймворк создаст нужный SQL запрос.

🔵 Примеры возможностей:

1️⃣ Поиск по полю:

Метод:

findByEmail(String email)

Генерируемый запрос:

SELECT * FROM users WHERE email = ?;

2️⃣ Комбинирование условий (с помощью AND и OR):

Метод:

findByFirstNameAndLastName(String firstName, String lastName)

Генерируемый запрос:

SELECT * FROM users WHERE first_name = ? AND last_name = ?;

Метод:

findByAgeOrSalary(int age, int salary)

Генерируемый запрос:

SELECT * FROM users WHERE age = ? OR salary = ?;

3️⃣ Диапазоны значений:

Метод:

findByAgeBetween(int startAge, int endAge)

Генерируемый запрос:

SELECT * FROM users WHERE age BETWEEN ? AND ?;

4️⃣ Сравнение значений:

Метод:

findBySalaryGreaterThan(int salary)

Генерируемый запрос:

SELECT * FROM users WHERE salary > ?;

5️⃣Сортировка результатов:

Метод:

findByLastNameOrderByFirstNameAsc(String lastName)

Генерируемый запрос:

SELECT * FROM users WHERE last_name = ? ORDER BY first_name ASC;

6️⃣ Частичное совпадение:

Метод:

findByNameContaining(String keyword)

Генерируемый запрос:

SELECT * FROM users WHERE name LIKE '%?%';

7️⃣ Работа с NULL:

Метод:

findByMiddleNameIsNull()

Генерируемый запрос:

SELECT * FROM users WHERE middle_name IS NULL;

8️⃣ Ограничение количества записей:

Метод:

findTop3BySalaryGreaterThan(int salary)

Генерируемый запрос:

SELECT * FROM users WHERE salary > ? LIMIT 3;

9️⃣ Поиск по коллекции значений:

Метод:

findByRoleIn(List<String> roles)

Генерируемый запрос:

SELECT * FROM users WHERE role IN (?);

⚠️ Недостатки использования волшебных методов:

- Ограниченная гибкость: Когда запросы становятся сложными, волшебные методы перестают быть удобными. Например, сложно создать метод для многоступенчатых операций, объединений или работы с подзапросами.
- Трудности с оптимизацией: Автоматически сгенерированные SQL-запросы могут быть не такими оптимальными, как вручную написанные. Это может негативно влиять на производительность приложения, особенно при работе с большими объёмами данных.
- Неочевидность логики: В сложных проектах имя метода может становиться длинным и трудночитаемым. Это усложняет понимание логики запроса, что может запутать других разработчиков, работающих с кодом.
- Отсутствие контроля: Разработчик не всегда контролирует точную структуру генерируемого запроса, что может привести к неожиданным результатам, особенно если в базе данных есть индексы или другие особенности структуры.

🔼Полезные советы:

- Используйте волшебные методы для простых запросов и CRUD-операций.
- Для более сложных случаев лучше использовать @Query и писать запросы вручную.

🔍 Обработка исключений с помощью Try-With-Resources в Java

В Java 7 была представлена мощная конструкция Try-With-Resources, которая значительно упрощает управление ресурсами, такими как файлы, соединения с БД или сокеты. Это улучшение позволяет автоматически закрывать ресурсы, предотвращая утечки памяти. Любые объекты, реализующие интерфейс AutoCloseable, можно безопасно использовать в блоке try. Java сама вызовет метод close() в конце блока, даже если произошло исключение.

📌 Преимущества:

- Нет необходимости в блоках finally для ручного закрытия ресурсов.
- Можно использовать несколько ресурсов в одном блоке try.
- Исключает риск утечек, особенно при работе с внешними ресурсами.

try (BufferedReader reader = new BufferedReader(new FileReader("file.txt"))) {
    String line = reader.readLine();
    System.out.println(line);
} catch (IOException e) {
    e.printStackTrace();
}

Этот подход не только уменьшает количество шаблонного кода, но и делает обработку исключений более предсказуемой. Для более сложных систем, где важно управление ресурсами, Try-With-Resources становится незаменимым инструментом.

💡 Try-With-Resources может комбинироваться с собственными классами, реализующими AutoCloseable, чтобы управлять закрытием любых типов ресурсов.