Когда мы тестируем производительность и профилируем какой‑нибудь проект Hibernate, в результатах почти наверняка появляется наша старая знакомая рефлексия.

Проекты Hibernate работают с пользовательскими объектами Java. Им нужно читать и изменять поля этих объектов, а также создавать их экземпляры. Рефлексия Java позволяет всё это делать, но всегда ли это лучший способ? Как и у большинства абстракций, у неё есть недостатки. Она может добавлять накладные расходы и выполнять проверки, которые в наших сценариях не нужны. Из‑за неё сложнее читать графики профилирования — именно там мы её и замечали. Кроме того, каждому проекту приходится самостоятельно разбираться с правилами доступа JPMS и соглашениями о доступе к членам классов. Для сборок в нативный исполняемый файл рефлексия требует дополнительной настройки.

При этом рефлексия — стандартный API JDK, с которым на первый взгляд просто работать и который давно проверен временем. Можем ли мы найти решение лучше?

Проблема не новая, и мы уже задавались этим вопросом. На протяжении многих лет каждый проект экспериментировал со своими решениями отдельно. Одни решения покрывали лишь часть задач, другие было трудно использовать повторно или заменить альтернативной реализацией. Некоторые подходили только для определённых способов доступа к данным. Это важно: самый быстрый подход зависит от задачи. Обход графа валидации и загрузка результатов запроса в сущности требуют разного доступа к состоянию объектов.

Чтобы решить эту проблему, мы начали работу над Hibernate Accessor — единым механизмом доступа к состоянию объектов. Его задача — убрать лишние накладные расходы рефлексии и предложить подходящие решения для разных способов доступа во всех проектах Hibernate.

В этой серии статей мы сначала объясним, почему существующие API JDK не закрывают наши потребности. Затем разберём неожиданные особенности генерации байт‑кода и JPMS, а также ограничения этого подхода. Покажем, что и как мы измеряли, выбирая универсальное решение по умолчанию. В завершение рассмотрим, что даёт перенос генерации кода на этап сборки и как мы планируем этим воспользоваться.

Разве эту проблему ещё не решили?

JDK постоянно развивается. Резонно спросить: разве дескрипторы методов (method handles) уже не решили проблему медленного доступа через рефлексию?

Рефлексия (java.lang.reflect): давняя знакомая на графиках профилирования

Обычная рефлексия существует очень давно. Многие фреймворки и библиотеки использовали её раньше или продолжают использовать сейчас. Работать с ней просто:

Field name = Person.class.getDeclaredField("name");
name.setAccessible(true); (1)
Object value = name.get(person); (2)
  1. Чтобы получить доступ к непубличному члену класса, нужно сделать его доступным для рефлексии. При использовании JPMS это также означает, что для глубокого рефлексивного доступа потребуются соответствующие директивы opens.

  2. Поле читается через рефлексию. setAccessible(true) отключает проверки доступа Java, но не гарантирует, что JIT‑компилятор оптимизирует такую операцию столь же эффективно, как прямое чтение поля.

Исторически рефлексия считалась медленной. Однако в JDK 18 её базовая реализация была переведена на дескрипторы методов в рамках JEP 416. Благодаря этому рефлексия может использовать оптимизации дескрипторов методов, но одновременно наследует часть их ограничений. Чтобы понять, почему проблему производительности это решает не полностью, рассмотрим сами дескрипторы.

Дескрипторы методов: решение с оговоркой

Дескриптор метода проверяет права доступа при создании, а не при каждом вызове. Рефлексия обычно проверяет доступ при каждом обращении, хотя, как мы уже говорили, эти проверки можно отключить через setAccessible(true). Когда проверки больше не выполняются при вызове, разница в производительности зависит от механизма вызова и возможностей JIT‑компилятора.

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

// The textbook way to use method handles:
private static final MethodHandle MH = MethodHandles.lookup() (1)
    .findVirtual(Person.class, "getName", MethodType.methodType(String.class));

// The actual library reality:
public class DynamicPropertyReader {
    private final MethodHandle mh; (2)

    public DynamicPropertyReader(MethodHandle mh) {
        this.mh = mh;
    }

    public Object read(Object target) throws Throwable {
        return this.mh.invoke(target); (3)
    }
}
  1. Ссылка static final обеспечивает высокую скорость: JIT может считать её константой и встроить вызываемый код.

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

  3. Такой вызов JIT практически не может встроить.

Как объясняет Jorn Vernee в руководстве по MethodHandle, для встраивания лежащей в основе вызова LambdaForm JIT‑компилятору нужно, чтобы используемый MethodHandle был точно известен как константа на этапе компиляции.

LambdaMetafactory: с методами работает, с полями — нет

LambdaMetafactory — менее известный, но мощный инструмент. Он позволяет добиться производительности, близкой к прямому вызову геттера. Во время выполнения он создаёт лёгкие реализации функциональных интерфейсов, которые хорошо поддаются оптимизации и встраиванию JIT‑компилятором.

CallSite site = LambdaMetafactory.metafactory(
    lookup, (1)
    "apply",
    MethodType.methodType(Function.class),
    MethodType.methodType(Object.class, Object.class),
    lookup.findVirtual(Person.class, "getName", MethodType.methodType(String.class)),
    MethodType.methodType(String.class, Person.class)
);
Function<Person, String> getter = (Function<Person, String>) site.getTarget().invokeExact(); (2)
  1. Объект lookup должен обладать достаточными правами для доступа к нужным членам класса.

  2. Здесь мы получаем реализацию функционального интерфейса, созданную во время выполнения.

Geoffrey De Smet подробно разбирает этот подход в статье Java Reflection, but much faster. При определённых условиях он достигает высокой производительности. Но если нужен прямой доступ к полям, а не к геттерам и сеттерам, он не подходит: фабрика работает с методами и не может непосредственно сгенерировать инструкцию GETFIELD.

По одному свойству или все сразу?

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

Но иногда за одну операцию нужно обработать несколько свойств одного объекта, после чего к ним больше не возвращаться. Например, загружая строку базы данных в сущность, Hibernate ORM записывает значения нескольких сопоставленных свойств. А при извлечении состояния сущности можно за один проход прочитать все нужные свойства в массив и больше не обращаться к исходному объекту.

Это можно сделать с помощью рефлексии, дескрипторов методов или отдельных лямбда‑функций: пройти по набору средств доступа и вызвать каждое по очереди. Но тогда для каждого свойства снова приходится выбирать и вызывать соответствующее средство доступа. Лучше было бы выполнять это переключение один раз для всей операции.

Встроенные средства JDK: близко, но недостаточно

Итак, ни одно из рассмотренных решений не удовлетворяет всем требованиям:

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

  • Ни одно из решений не даёт оптимизированного доступа к нескольким значениям сразу — чтения или записи всего набора свойств сущности за одну операцию при переносе результатов запроса из базы данных.

Остаётся ещё один вариант: генерировать байт‑код самостоятельно.

Одна фабрика для всех способов доступа

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

/**
 * Creates new instances of a type by invoking a constructor.
 */
public interface Instantiator<T> {
    T create(Object... args);
}

/**
 * Reads a value from a field or getter method on an object instance.
 */
public interface ValueReader<T> {
    T get(Object instance);
}

/**
 * Writes a value to a field or setter method on an object instance.
 */
public interface ValueWriter {
    void set(Object instance, Object value);
}

/**
 * Reads multiple values from an object instance in a single call.
 */
public interface MultiValueReader {
    Object[] get(Object instance);
}

/**
 * Writes multiple values to an object instance in a single call.
 */
public interface MultiValueWriter {
    void set(Object instance, Object[] values);
}

/**
 * Main entry point to create accessors.
 */
public interface AccessorFactory {
    <T> Instantiator<T> instantiator(Constructor<T> constructor);

    ValueReader<?> valueReader(Field field);
    ValueReader<?> valueReader(Method getter);

    ValueWriter valueWriter(Field field);
    ValueWriter valueWriter(Method setter);

    MultiValueReader multiValueReader(Class<?> declaringClass, Member... members);
    MultiValueWriter multiValueWriter(Class<?> declaringClass, Member... members);
}

Через AccessorFactory можно подключать разные реализации — например, на основе рефлексии или генерации байт‑кода. Затем полученные средства доступа используются, скажем, для чтения состояния объекта:

AccessorFactory factory = AccessorFactory.reflection(MethodHandles.lookup());
ValueReader<?> reader = factory.valueReader(Person.class.getDeclaredField("name"));
Object name = reader.get(person);

Так мы сможем менять реализацию в зависимости от среды выполнения или от того, как в будущем изменятся встроенные средства JDK.

Берём генерацию байт‑кода в свои руки

Так мы пришли к идее генерировать байт‑код для доступа к состоянию объектов. Сам по себе подход не нов: его применяли и раньше, а Hibernate ORM уже генерирует байт‑код для расширенных сущностей. Но на этот раз мы постарались создать решение для всех проектов Hibernate с учётом характерных для каждого способов доступа.

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

На бумаге сгенерировать несколько простых инструкций GETFIELD и PUTFIELD несложно. Но разработка универсальной библиотеки, которая создаёт средства доступа во время выполнения для всех проектов Hibernate, ставит перед нами новые вопросы:

  • Как генерировать и определять классы во время выполнения, не раскрывая привилегированный доступ и не обходя границы модулей?

  • Как получать доступ к непубличным свойствам?

  • Как работать с границами модулей JPMS?

  • Как не допустить утечек памяти в Metaspace из‑за классов, созданных во время выполнения?

  • И почему определение скрытого класса может завершиться ошибкой, даже если начать с объекта Lookup, обладающего всеми правами?

Эти и другие вопросы разберём во второй статье серии. Продолжение следует!

Присоединяйтесь к русскоязычному сообществу разработчиков на Spring Boot в телеграм — Spring АйО, чтобы быть в курсе последних новостей из мира разработки на Spring Boot и всего, что с ним связано.