Приведи пример применения рефлексии

Рефлексия в Java: примеры применения

Рефлексия (Reflection) — это мощный механизм, который позволяет программе в runtime (во время выполнения) инспектировать и модифицировать свою собственную структуру: классы, методы, поля, конструкторы, аннотации.

Основные возможности рефлексии

import java.lang.reflect.*;

public class ReflectionDemo {
    // Получить информацию о классе
    Class<?> clazz = User.class;
    // или
    Class<?> clazz = Class.forName("com.example.User");
    
    // Получить все методы
    Method[] methods = clazz.getDeclaredMethods();
    // Получить все поля
    Field[] fields = clazz.getDeclaredFields();
    // Получить конструкторы
    Constructor<?>[] constructors = clazz.getDeclaredConstructors();
}

Пример 1: Dependency Injection (как в Spring)

Rефлексия — основа Spring Framework. Вот упрощённый пример инъекции зависимостей:

// Сервис
public class UserService {
    public void createUser(String name) {
        System.out.println("User created: " + name);
    }
}

// Контроллер с зависимостью
public class UserController {
    @Autowired
    private UserService userService;  // Spring вольёт сюда инстанс
    
    public void register(String name) {
        userService.createUser(name);
    }
}

// Аннотация для DI
public @interface Autowired {}

// Simple DI контейнер
public class SimpleContainer {
    public <T> T createInstance(Class<T> clazz) throws Exception {
        T instance = clazz.getDeclaredConstructor().newInstance();
        
        // Инспектируем все поля
        for (Field field : clazz.getDeclaredFields()) {
            // Проверяем, есть ли аннотация @Autowired
            if (field.isAnnotationPresent(Autowired.class)) {
                // Разрешаем доступ к приватному полю
                field.setAccessible(true);
                
                // Создаём инстанс типа поля и инъектим
                Object dependency = createInstance(field.getType());
                field.set(instance, dependency);
            }
        }
        return instance;
    }
}

// Использование
public static void main(String[] args) throws Exception {
    SimpleContainer container = new SimpleContainer();
    UserController controller = container.createInstance(UserController.class);
    controller.register("John");  // Выведет: User created: John
}

Пример 2: Object-Relational Mapping (как в Hibernate)

Гибернейт использует рефлексию для маппирования объектов на таблицы БД:

// Сущность
@Entity
@Table(name = "users")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @Column(name = "email", nullable = false)
    private String email;
    
    @Column(name = "age")
    private Integer age;
}

// Упрощённая реализация ORM
public class SimpleORM {
    public String toInsertSQL(Object entity) {
        Class<?> clazz = entity.getClass();
        Table table = clazz.getAnnotation(Table.class);
        String tableName = table.name();
        
        List<String> columns = new ArrayList<>();
        List<Object> values = new ArrayList<>();
        
        // Проходим по всем полям
        for (Field field : clazz.getDeclaredFields()) {
            if (field.isAnnotationPresent(Column.class)) {
                Column col = field.getAnnotation(Column.class);
                columns.add(col.name());
                
                field.setAccessible(true);
                values.add(field.get(entity));
            }
        }
        
        String cols = String.join(", ", columns);
        String vals = values.stream()
            .map(v -> "'" + v + "'")
            .collect(Collectors.joining(", "));
        
        return String.format("INSERT INTO %s (%s) VALUES (%s)", 
            tableName, cols, vals);
    }
}

// Использование
public static void main(String[] args) throws IllegalAccessException {
    User user = new User();
    user.setEmail("john@example.com");
    user.setAge(25);
    
    SimpleORM orm = new SimpleORM();
    String sql = orm.toInsertSQL(user);
    System.out.println(sql);
    // INSERT INTO users (email, age) VALUES ('john@example.com', '25')
}

Пример 3: Сериализация JSON (как в Jackson/Gson)

Рефлексия позволяет автоматически конвертировать объекты в JSON и наоборот:

// Простой JSON сериализатор
public class SimpleJsonSerializer {
    public String toJson(Object obj) throws IllegalAccessException {
        Class<?> clazz = obj.getClass();
        StringBuilder json = new StringBuilder("{");
        
        Field[] fields = clazz.getDeclaredFields();
        for (int i = 0; i < fields.length; i++) {
            Field field = fields[i];
            field.setAccessible(true);
            
            Object value = field.get(obj);
            String fieldName = field.getName();
            String fieldValue = formatValue(value);
            
            json.append("\"").append(fieldName).append("\":").append(fieldValue);
            if (i < fields.length - 1) json.append(", ");
        }
        json.append("}");
        return json.toString();
    }
    
    private String formatValue(Object value) {
        if (value instanceof String) {
            return "\""+value+"\"";
        } else if (value instanceof Number) {
            return value.toString();
        } else if (value == null) {
            return "null";
        }
        return "\"" + value.toString() + "\"";
    }
}

// Использование
User user = new User();
user.setId(1L);
user.setEmail("john@example.com");

SimpleJsonSerializer serializer = new SimpleJsonSerializer();
String json = serializer.toJson(user);
System.out.println(json);
// {"id":1, "email":"john@example.com"}

Пример 4: Динамическое создание прокси (как в Spring AOP)

Рефлексия позволяет создавать прокси-объекты для логирования, кеширования, транзакций:

// Интерфейс сервиса
public interface Logger {
    void log(String message);
}

// Реализация
public class SimpleLogger implements Logger {
    public void log(String message) {
        System.out.println("Log: " + message);
    }
}

// Прокси с логированием методов
public class LoggingProxy {
    public static <T> T createProxy(T target, Class<T> interfaceClass) {
        return (T) Proxy.newProxyInstance(
            interfaceClass.getClassLoader(),
            new Class[]{interfaceClass},
            (proxy, method, args) -> {
                // Логирование ДО вызова метода
                System.out.println("[BEFORE] Calling: " + method.getName());
                
                // Вызов оригинального метода
                Object result = method.invoke(target, args);
                
                // Логирование ПОСЛЕ вызова метода
                System.out.println("[AFTER] Completed: " + method.getName());
                
                return result;
            }
        );
    }
}

// Использование
Logger logger = new SimpleLogger();
Logger proxiedLogger = LoggingProxy.createProxy(logger, Logger.class);
proxiedLogger.log("Hello");
// [BEFORE] Calling: log
// Log: Hello
// [AFTER] Completed: log

Пример 5: Парсинг аннотаций

// Кастомная аннотация
public @interface ValidEmail {}

public class User {
    @ValidEmail
    private String email;
}

// Валидатор на основе аннотаций
public class AnnotationValidator {
    public void validate(Object obj) throws IllegalAccessException {
        for (Field field : obj.getClass().getDeclaredFields()) {
            if (field.isAnnotationPresent(ValidEmail.class)) {
                field.setAccessible(true);
                String value = (String) field.get(obj);
                
                if (!value.contains("@")) {
                    throw new IllegalArgumentException(
                        "Field " + field.getName() + " is not a valid email"
                    );
                }
            }
        }
    }
}

// Использование
User user = new User();
user.setEmail("invalid-email");
try {
    new AnnotationValidator().validate(user);
} catch (Exception e) {
    System.out.println(e.getMessage());
}

Плюсы рефлексии

• Гибкость: динамическая работа с объектами в runtime
• Автоматизация: избегаем боилерплейта (DI, сериализация, маппинг)
• Инспекция: можно узнать о структуре класса без исходного кода
• Расширяемость: фреймворки могут работать с любыми классами

Минусы рефлексии

• Performance: рефлексия медленнее, чем прямой вызов
• Сложность отладки: ошибки в runtime, сложнее трейсировать
• Security: рефлексия может нарушить инкапсуляцию
• Хрупкость: код может сломаться при переименовании полей

Вывод

Рефлексия — это мощный инструмент, который лежит в основе большинства Java фреймворков (Spring, Hibernate, Jackson). Но используй её разумно, только когда действительно нужна динамичность. Для обычного кода предпочитай прямые вызовы.