⌨️Метапрограммирование: Использование Reflection для динамического изменения кода

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

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

✔️ Создавать экземпляры классов: Вы можете создавать объекты, не зная их тип на этапе компиляции.

✔️ Вызывать методы динамически: Это дает возможность запускать методы объектов, основываясь на их именах, переданных в виде строк.

✔️ Изменять значения полей: Вы можете динамически изменять значения полей объектов, что может быть особенно полезно в контексте тестирования или сериализации.

Преимущества использования рефлексии:

✔️ Потенциал для создания более абстрактного кода: Вы можете реализовать паттерны проектирования, такие как Dependency Injection.

✔️ Упрощение работы с библиотеками и фреймворками: Многие популярные библиотеки, такие как Spring и Hibernate, активно используют рефлексию для создания и управления объектами.

В следующем посте мы рассмотрим конкретные примеры использования рефлексии на практике. Оставайтесь с нами! 🚀

#Java #Метапрограммирование #Reflection

⌨️ Пример реализации Dependency Injection с использованием Reflection

Продолжаем тему метапрограммирования и поговорим о том, как реализовать паттерн проектирования Dependency Injection (DI) с использованием рефлексии. DI позволяет нам разделить зависимости и упростить управление ими, что делает код более чистым и тестируемым.

Пример: Простой контейнер для Dependency Injection

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

1. Аннотация @Inject для пометки полей, которые мы хотим внедрить.
2. Контейнер для обработки аннотаций и создания объектов.

Шаг 1: Создаем аннотацию

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;

@Retention(RetentionPolicy.RUNTIME)
@interface Inject {}

Шаг 2: Создаем классы с зависимостями

class Service {
    public void serve() {
        System.out.println("Service is working!");
    }
}

class Client {
    @Inject
    private Service service;

    public void doSomething() {
        service.serve();
    }
}

Шаг 3: Реализуем контейнер для Dependency Injection

import java.lang.reflect.Field;

class DIContainer {
    public static void inject(Object obj) {
        Class<?> clazz = obj.getClass();
        
        for (Field field : clazz.getDeclaredFields()) {
            if (field.isAnnotationPresent(Inject.class)) {
                try {
                    field.setAccessible(true); // Делаем поле доступным
                    Object dependency = field.getType().getDeclaredConstructor().newInstance(); // Создаем экземпляр зависимости
                    field.set(obj, dependency); // Внедряем зависимость
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

Шаг 4: Используем наш контейнер

public class Main {
    public static void main(String[] args) {
        Client client = new Client();
        DIContainer.inject(client); // Внедряем зависимости

        client.doSomething(); // Вывод: Service is working!
    }
}

Как это работает?

1️⃣ Мы создаем аннотацию @Inject, чтобы пометить поля, которые должны быть внедрены.

2️⃣ В классе Client поле service помечено этой аннотацией.

3️⃣ Контейнер DIContainer проходит по полям класса, ищет аннотацию @Inject, и, если находит, создает объект зависимости и устанавливает его в поле.

4️⃣ Когда мы вызываем метод doSomething, объект Service успешно внедрен, и мы можем использовать его методы.

#Java #Метапрограммирование #DependencyInjection

⌨️ Метод Stream.distinct()

Если у вас есть поток, который может содержать повторяющиеся элементы, используйте операцию distinct(), чтобы удалить их.

var list = Arrays.asList(1, 2, 3, 3, 4, 5, 5);
var distinctList = list.stream()
                       .distinct()
                       .collect(Collectors.toList());
// distinctList: [1, 2, 3, 4, 5]

⌨️ Простой пример использования Project Reactor, который демонстрирует основы работы с Mono и Flux.

import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;

public class ProjectReactorExample {
    public static void main(String[] args) {
        // Пример с Mono
        Mono<String> monoExample = Mono.just("Hello, Reactor!");
        monoExample
            .map(String::toUpperCase) // Преобразуем строку в верхний регистр
            .subscribe(System.out::println); // Подписываемся и выводим результат

        // Пример с Flux
        Flux<Integer> fluxExample = Flux.just(1, 2, 3, 4, 5);
        fluxExample
            .filter(num -> num % 2 == 0) // Фильтруем четные числа
            .map(num -> num * num) // Возводим в квадрат
            .subscribe(System.out::println); // Подписываемся и выводим результат
    }
}

🔍 Что происходит в коде?

1. Mono:
- Создаем экземпляр Mono с помощью Mono.just(), передавая строку.
- Используем метод map(), чтобы преобразовать строку в верхний регистр.
- Подписываемся на Mono с помощью subscribe, который выводит результат.

2. Flux:
- Создаем экземпляр Flux с числовыми значениями от 1 до 5.
- Фильтруем четные числа с помощью filter().
- Применяем map(), чтобы возвести каждое четное число в квадрат.
- Подписываемся на Flux и выводим результат.

🌱 Spring SpEL (Spring Expression Language) — это мощный язык выражений, предоставляемый фреймворком Spring. Он используется для динамической обработки данных, управления конфигурацией и вычисления значений в runtime. SpEL позволяет обращаться к свойствам объектов, вызывать методы, работать с коллекциями, выполнять арифметические и логические операции, а также взаимодействовать с бинами Spring.

Основные возможности SpEL:

✔️ Обращение к свойствам: person.name

✔️Вызов методов: person.getName()

✔️ Работа с коллекциями: фильтрация и проекция (list.?[property > 10]).

✔️ Логические и арифметические операции: age > 18 && hasLicense

✔️ Доступ к бинам Spring: @beanName.method()

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

import org.springframework.expression.ExpressionParser;
import org.springframework.expression.spel.standard.SpelExpressionParser;

public class SpELExample {
    public static void main(String[] args) {
        ExpressionParser parser = new SpelExpressionParser();

        // Пример вычисления простого выражения
        String expression = "'Hello, Spring SpEL!'.toUpperCase()";
        String result = parser.parseExpression(expression).getValue(String.class);

        System.out.println(result); // Вывод: HELLO, SPRING SPEL!
    }
}

Использование в аннотациях:

@Component
public class MyBean {
    @Value("#{T(java.lang.Math).random() * 100}")
    private double randomValue;

    @Value("#{systemProperties['user.name']}")
    private String userName;

    public void printValues() {
        System.out.println("Random Value: " + randomValue);
        System.out.println("User Name: " + userName);
    }
}

✔️ T(java.lang.Math).random() — вызов статического метода Math.random().

✔️ systemProperties['user.name'] — доступ к системным свойствам.

Использование с коллекциями:

import org.springframework.expression.ExpressionParser;
import org.springframework.expression.spel.standard.SpelExpressionParser;

import java.util.Arrays;
import java.util.List;

public class CollectionExample {
    public static void main(String[] args) {
        ExpressionParser parser = new SpelExpressionParser();

        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

        // Фильтрация списка
        List<Integer> filteredNumbers = (List<Integer>) parser.parseExpression(
                "#numbers.?[#this > 2]").getValue(new StandardEvaluationContext(), numbers);

        System.out.println(filteredNumbers); // Вывод: [3, 4, 5]
    }
}

SpEL является удобным инструментом для внедрения динамического поведения и вычислений в приложениях Spring.

⌨️ EnumMap — это реализация Map, которая использует в качестве ключей исключительно Enum.

Внутренне EnumMap использует массив для хранения значений, где индекс массива соответствует порядковому номеру (ordinal()) элемента перечисления. Это делает его быстрее, чем хэш-таблицы (HashMap) и более экономным по памяти.

EnumMap хранит ключи в порядке их объявления в перечислении, что отличает его от большинства других Map (кроме LinkedHashMap).

Так как ключи строго ограничены перечислением, это снижает вероятность ошибок при разработке.

🔍 Пример:

import java.util.EnumMap;

enum Action {
    START, STOP, PAUSE
}

public class EnumMapExample {
    public static void main(String[] args) {
        EnumMap<Action, Runnable> actionMap = new EnumMap<>(Action.class);

        // Определяем поведение для каждого значения Enum
        actionMap.put(Action.START, () -> System.out.println("Starting the process..."));
        actionMap.put(Action.STOP, () -> System.out.println("Stopping the process..."));
        actionMap.put(Action.PAUSE, () -> System.out.println("Pausing the process..."));

        // Пример вызова
        Action currentAction = Action.START;
        actionMap.get(currentAction).run();
    }
}

#Java #EnumMap

⌨️ Как работает IdentityHashMap

IdentityHashMap — это необычная реализация Map, которая использует сравнение по ссылкам (==) вместо стандартного метода equals().

В IdentityHashMap два ключа считаются равными только если это один и тот же объект (сравнение по ссылкам).

📌 Пример:

 java
import java.util.IdentityHashMap;
import java.util.Map;

public class IdentityHashMapExample {
    public static void main(String[] args) {
        Map<String, String> map = new IdentityHashMap<>();

        String key1 = new String("key");
        String key2 = new String("key");

        map.put(key1, "Value 1");
        map.put(key2, "Value 2");

        System.out.println(map); // Выведет обе пары: {key=Value 1, key=Value 2}
    }
}

key1 и key2 — это разные объекты, даже если их строки одинаковы.

✨ Когда использовать?

1️⃣ Кэширование: если нужно различать объекты с одинаковыми данными.

2️⃣ Оптимизация: для низкоуровневой работы с объектами, где важна ссылка, а не значение.

3️⃣ Специфические задачи: при разработке компиляторов, интерпретаторов или для отслеживания уникальных объектов.

💡 Ограничение:
IdentityHashMap не гарантирует порядок элементов и редко используется в стандартных задачах. Это инструмент для узкоспециализированных случаев!

#Java #IdentityHashMap

⌨️ WeakHashMap: когда удаление происходит само собой

WeakHashMap — это коллекция, которая позволяет ключам удаляться из неё автоматически, если на них больше нет сильных ссылок.

Если ключ в WeakHashMap становится недостижимым (нет сильных ссылок), он удаляется сборщиком мусора.

Это делает WeakHashMap полезной для реализации кэшей и других структур, где нужно избегать утечек памяти.

📌 Пример:

 java
import java.util.WeakHashMap;

public class WeakHashMapExample {
    public static void main(String[] args) {
        WeakHashMap<Object, String> map = new WeakHashMap<>();

        Object key = new Object();
        map.put(key, "Value");

        System.out.println("Before GC: " + map); // Ключ и значение есть

        key = null; // Убираем сильную ссылку на объект
        System.gc(); // Вызываем сборку мусора

        System.out.println("After GC: " + map); // Ключ и значение исчезли
    }
}

Пока объект-ключ доступен, пара ключ-значение остаётся в WeakHashMap.
Как только ключ становится недоступным, он автоматически удаляется сборщиком мусора.

✨ Когда использовать?

1️⃣ Кэширование: для хранения данных, которые можно восстановить, если они удалены.

2️⃣ Маппинг вспомогательных данных: например, привязка метаданных к объектам, где их удаление важно.

💡 Совет:
Не используйте WeakHashMap для данных, которые критически важны — сборщик мусора может удалить их в любой момент!

#Java #WeakHashMap