VBO Wiki

2.01. Reflection API

6 min read

RU | EN | DE

Определение и назначение

Reflection — это механизм выполнения, позволяющий программе исследовать и изменять свою структуру и поведение во время исполнения: классы, поля, методы, конструкторы, аннотации, модификаторы доступа и т.д.
Базовые пакеты и классы: java.lang.Class, java.lang.reflect.Field/Method/Constructor, java.lang.reflect.Modifier, java.lang.reflect.Proxy, java.lang.invoke.MethodHandles/VarHandle.

Когда нужен:

  • фреймворки / контейнеры (Spring, JPA/Hibernate, Jackson) — инъекции, сериализация, прокси;
  • универсальные библиотеки (мапперы, валидаторы, DI/AOP);
  • тестирование/моки (JUnit, Mockito);
  • инспекция метаданных (аннотации), плагинные системы.

Как это работает под капотом (короткая карта)

  1. Класс загружен ClassLoader’ом → его метаданные доступны через объект Class<?>.
  2. Через Class<?> берём Fields/Methods/Constructors, аннотации, модификаторы.
  3. Через AccessibleObject#setAccessible(true) (Java 8) или canAccess/модульные “opens” (Java 9+) можем получить доступ к непубличным членам (с ограничениями модульной системы).
  4. Вызываем Method.invoke, читаем/пишем Field.get/set, создаём объект через Constructor.newInstance.
  5. Для динамической подмены поведения — динамические прокси (Proxy.newProxyInstance) или CGLIB (в Spring), для быстрого вызова — MethodHandles/VarHandle.

Где применяется (особенно в Spring)

Spring Framework

  • IoC/DI: поиск конструкторов/сеттеров/полей, помеченных аннотациями (@Autowired, @Value), и внедрение зависимостей через рефлексию.
  • AOP/Протоколы: создание динамических прокси:
    • JDK Proxy для интерфейсов;
    • CGLIB для классов (создаёт subclass во время выполнения).
  • Обработка аннотаций: @Transactional, @Cacheable, @RequestMapping и др. — считывание метаданных и построение цепочек advice/interceptor’ов.
  • Data Binding/Validation: привязка полей из HTTP-запросов к бинам (WebDataBinder), чтение ограничений @NotNull, @Size.

Другие примеры:

  • Hibernate/JPA — доступ к приватным полям/методам, маппинг сущностей.
  • Jackson/Gson — сериализация/десериализация по полям/геттерам.
  • Bean Validation (Jakarta Validation) — поиск аннотаций ограничений.
  • JUnit/Mockito — поиск тестовых методов, создание моков/спаев.

Базовые операции — примеры кода

1. Получить Class<?>

Class<?> c1 = String.class;
Class<?> c2 = Class.forName("com.example.User");
Object obj = new User();
Class<?> c3 = obj.getClass();

2. Поля (Fields)

class User {
    private String name;
    public int age;
}
 
// Чтение/запись поля
User u = new User();
Field f = User.class.getDeclaredField("name");
f.setAccessible(true);            // Java 8; в Java 9+ могут быть модульные ограничения
f.set(u, "Alice");                // записать приватное поле
String name = (String) f.get(u);  // прочитать

3. Методы (Methods)

class Calculator {
    private int add(int a, int b) { return a + b; }
}
 
Calculator calc = new Calculator();
Method m = Calculator.class.getDeclaredMethod("add", int.class, int.class);
m.setAccessible(true);
int sum = (int) m.invoke(calc, 2, 3); // 5

4. Конструкторы (Constructors)

class Person {
    private final String name;
    private Person(String name) { this.name = name; }
}
 
Constructor<Person> ctor = Person.class.getDeclaredConstructor(String.class);
ctor.setAccessible(true);
Person p = ctor.newInstance("Bob");

5. Аннотации

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
@interface Column { String name(); }
 
class Entity {
    @Column(name = "user_name")
    private String username;
}
 
Field f = Entity.class.getDeclaredField("username");
Column col = f.getAnnotation(Column.class);
if (col != null) {
    System.out.println(col.name()); // "user_name"
}

6. Работа с типами и generic-метаданными

class Repo<T> {
    List<T> items;
}
 
Field items = Repo.class.getDeclaredField("items");
Type gType = items.getGenericType();           // java.util.List<T>
if (gType instanceof ParameterizedType pt) {
    Type arg = pt.getActualTypeArguments()[0]; // T (стерто в runtime, но видно как TypeVariable)
}

7. Массивы через java.lang.reflect.Array

Object arr = Array.newInstance(String.class, 3);
Array.set(arr, 0, "a");
String first = (String) Array.get(arr, 0);

8. Динамический прокси (JDK Proxy)

interface Greeting {
    String hello(String name);
}
 
class LoggingHandler implements InvocationHandler {
    private final Object target;
    LoggingHandler(Object target) { this.target = target; }
 
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println(">>> " + method.getName());
        return method.invoke(target, args);
    }
}
 
Greeting original = name -> "Hi " + name;
Greeting proxy = (Greeting) Proxy.newProxyInstance(
        Greeting.class.getClassLoader(),
        new Class[]{Greeting.class},
        new LoggingHandler(original)
);
 
System.out.println(proxy.hello("Alice")); // лог + "Hi Alice"

9. Быстрый вызов через MethodHandles/VarHandle

class A { private int x = 42; }
A a = new A();
 
MethodHandles.Lookup lookup = MethodHandles.lookup();
VarHandle vh = MethodHandles.privateLookupIn(A.class, lookup)
    .findVarHandle(A.class, "x", int.class);
 
int v = (int) vh.get(a);     // 42
vh.set(a, 100);              // быстрее, чем Field.set в горячем коде

Модульная система (Java 9+) и доступность

  • В эпоху --add-exports/--add-opens доступ к непубличным членам может быть запрещён, если модуль не открыл пакет.
  • В Spring Boot часто используется JVM-опция:
    --add-opens java.base/java.lang=ALL-UNNAMED (или конкретным модулям), чтобы позволить рефлексии работать с приватными членами.
  • В продакшене лучше минимизировать “opens” и рефлексию к приватному.

Почему нужно осторожно использовать

1. Нарушение инкапсуляции

setAccessible(true)/privateLookupIn позволяют менять приватные поля/методы.
Это ломает контракт класса, усложняет сопровождение и может привести к хрупкому коду.

2. Безопасность

  • Доступ к приватным данным, обход инвариантов, возможные утечки.
  • В рантайме (особенно в плагинных системах) можно подхватить код со злонамеренным поведением.

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

  • Рефлексия дороже прямого вызова; частые Method.invoke/Field.get в горячих циклах → деградация производительности.
  • Динамические прокси/генерация классов (CGLIB) → время и память, прогрев JIT.

4. Совместимость и хрупкость

  • Переименование/рефакторинг полей/методов ломает код, который обращается к ним по строковым именам.
  • Модульные ограничения Java 9+ (и разные JDK) могут внезапно блокировать доступ.

5. Type Erasure

  • Дженерик-типы стираются → рефлексия не знает конкретный тип-параметр в рантайме (видит List вместо List<String>), нужны хитрости с Type/ParameterizedType.

Типичные ошибки и как их решать

ОшибкаПричинаРешение
NoSuchFieldException / NoSuchMethodExceptionНеправильные имена, сигнатуры, модификаторыПроверяй точные типы параметров, используй getDeclared* для непубличных
IllegalAccessExceptionНет доступа (модификатор/модуль)setAccessible(true) (Java 8) или privateLookupIn + --add-opens (Java 9+)
InvocationTargetExceptionИсключение изнутри вызываемого методаЛогируй getCause(), оборачивай в доменное исключение
ClassNotFoundExceptionНе найден класс указанным ClassLoaderПроверь имя/CL, в веб-контейнерах используй TCCL (Thread Context ClassLoader)
Утечки памятиДолговечные ссылки на ClassLoader/проксиЧисти кэши, не удерживай CL в статике, закрывай плагины корректно
Просадка производительностиЧастые рефлексивные вызовыКэшируй дескрипторы, используй MethodHandle/VarHandle или прямой вызов
Ломкий код при рефакторингеСтроковые именаЦентрализуй константы имён, минимизируй точки рефлексии

Best practices (краткий чек-лист)

  1. Сначала — обычный код. Рефлексия — когда других путей нет (универсальные фреймворки, кросс-типовые инструменты).
  2. Минимизируй область применения. Оборачивай в небольшие утилиты/адаптеры, не размазывай по коду.
  3. Кэшируй Field/Method/Constructor. Не ищи их заново в каждом вызове.
  4. Предпочитай MethodHandles/VarHandle в горячих местах — они быстрее после прогрева.
  5. Учитывай модули. В Java 9+ заранее планируй --add-opens или архитектуру без доступа к приватному.
  6. Не ломай инварианты. Если уж меняешь приватное поле — документируй и тестируй инварианты.
  7. Безопасность. Проверяй источник классов/плагинов, не давай рефлексии гулять по всему ClassLoader’у.
  8. Логируй и оборачивай. Все рефлексивные исключения — с контекстом (какой класс/поле/метод), оборачивай в доменные ошибки.
  9. Для аннотаций — делай слой метаданных, не читай аннотации везде подряд.
  10. В Spring — по возможности опирайся на стандартные механизмы (DI, конвертеры, бин-постпроцессоры), а собственную рефлексию — только в точках расширения.

Мини-FAQ для собеседования

  • Чем рефлексия опасна? Нарушает инкапсуляцию, может ломать контракт, ухудшает производительность и безопасность; плюс проблемы с модулями.
  • Когда использовать? Фреймворки/универсальные библиотеки, динамические плагины, сериализация/маппинг, DI/AOP.
  • JDK Proxy vs CGLIB? JDK Proxy — только для интерфейсов; CGLIB — проксирует классы (через наследование), нужен final-осторожно. Spring сам выбирает.
  • MethodHandles/VarHandle? Современнее и быстрее, чем отражение через Method/Field, особенно в горячем коде; но сложнее API.
  • Как дружить с Java 9+ модулями? Использовать --add-opens/--add-exports, по возможности не лезть в приватное; проектировать API так, чтобы не требовалось.

Backlinks