PunchSanwo-Olu gifts Flamingos N10m, iPhones eachInquirerNLEx sees heavy traffic after road crashesBollywood HungamaAkshay Kumar starrer Samuk motion poster unveils alien threat; sci-fi thriller to release in cinemas on May 28, 2027The Jerusalem PostLiberman admits 'no universal draft law' as Knesset defense panel convenes on haredi conscriptionCNN TürkABD'nin üçüncü uçak gemisi Orta Doğu’daSky TG24Esplosione a Roma, ordigno danneggia palazzo in via Treia a S. BasilioZDF heuteAktuelle Pressemitteilungen des ZDFObservador DesportoHabitação: as autarquias lucram e culpam o mercadoABC News (Australia)Conjoined twin girls born in remote Papua New GuineaGolem.deVulcan-Rakete: Amazon verliert 40 Breitband-SatellitenNHK 社会ファッション雑誌元モデルの女性殺害か 内縁の夫逮捕 警視庁Il Fatto Quotidiano“Ha agevolato l’occultamento di capitali di soggetti indagati o condannati per riciclaggio con aggravante mafiosa”: disposta l’amministrazione giudiziaria per Revolut
The Daily Newsstand · Free, Always
Monday, November 16, 2026

Дьявол в деталях: как мы подружили One Nio с кастомной сериализацией и Java 21+

Translate

Java-сериализация — штука удобная, но медленная. Библиотека One Nio решает эту проблему: она генерирует персональные сериализаторы для каждого класса прямо из байткода, используя ASM, Unsafe и MagicAccessorImpl. Результат — сериализация в разы быстрее стандартной и других популярных библиотек.

Но есть нюанс: One Nio ничего не знает про кастомные методы writeObject(), readObject(), writeReplace() и readResolve(). А такие методы есть у многих классов в JDK (ImmutableCollections, InetAddress, DateTime API) и популярных библиотеках вроде Guava. Если попытаться сериализовать, например, List.of() с одним элементом через One Nio, то после десериализации вы получите список с лишним элементом, потому что библиотека честно записала все поля, не понимая кастомной логики.

Меня зовут Андрей, я Java-архитектор в СберТехе. В статье расскажу, как мы научили One Nio вызывать кастомные методы сериализации: реализовали собственный CustomizedSerializer, заставили его работать с defaultWriteObject() и defaultReadObject(), обошли ограничения JPMS на Java 21 и научились копировать объекты произвольных классов с помощью Unsafe. А в конце — честные числа из JMH: сколько мы потеряли в скорости и как в итоге даже выиграли.

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

Поехали!

Оглавление

Что за One Nio и чем она так крута

Библиотека One Nio предназначена для highload-обмена данными между серверами и доступна на GitHub для Open source community: https://github.com/odnoklassniki/one-nio.

Одна из основных частей библиотеки — сериализация Java-объектов в бинарный формат для передачи данных по сети. Стоит сказать, что мы форкнули данную библиотеку и параллельно развиваем её в СберТехе, используя в нашем сервисе Platform V SessionsData.

Так вот, чем же крута библиотека One Nio? В первую очередь — редким сочетанием скорости работы и гибкости. Алгоритмы One Nio сериализуют быстрее других библиотек, и в этом немалую роль играют классы MagicAccessorImpl и Unsafe. При этом One Nio не требует схемы сериализуемых данных, в отличие от многих популярных библиотек сериализации.

Про сравнение One Nio с другими Java-сериализаторами можно почитать в моих статьях на Хабре (здесь и здесь). Там и убедительные результаты из JMH benchmark, и сравнение гибкости по 20 критериям. Здесь коротко перечислю основные фишки Java-сериализации библиотекой One Nio, которые позволяют достигать таких результатов.

1. One Nio «из коробки» предоставляет около 50 сериализаторов

Они умеют отлично сериализовать стандартные типы данных: примитивы, строки, массивы, коллекции, мапы и так далее.

public abstract class Serializer<T> implements Externalizable {
    public abstract void calcSize(T obj, CalcSizeStream css) throws IOException;
    public abstract void write(T obj, DataStream out) throws IOException;
    public abstract T read(DataStream in) throws IOException, ClassNotFoundException;
    public abstract void skip(DataStream in) throws IOException, ClassNotFoundException;
    public abstract void toJson(T obj, StringBuilder builder) throws IOException;
    ...
}

2. One Nio и для каждого нестандартного класса не отступает от этого принципа

Библиотека генерирует для класса собственный, персональный GeneratedSerializer. Делается это прямо из байткода с помощью ASM framework. Другими словами, у таких сериализаторов даже нет исходников на Java, только байткод, в котором используются классы MagicAccessorImpl или Unsafe, но персонально для конкретного класса.

public class GeneratedSerializer extends Serializer<Object> {
    // все методы генерируются из байткода через ASM framework
    @Override public void calcSize(T obj, CalcSizeStream css) throws IOException;
    @Override public void write(T obj, DataStream out) throws IOException;
    @Override public T read(DataStream in) throws IOException, ClassNotFoundException;
    @Override public void skip(DataStream in) throws IOException, ClassNotFoundException;
    @Override public void toJson(T obj, StringBuilder builder) throws IOException;
    ...
}

Такой сериализатор знает о классе всё — какие у него поля, типы, что подлежит сериализации, а что нет, и так далее. При этом не важно, public это поля или private, final или нет — сериализатор умеет быстро читать их из объекта при сериализации и вставлять в объект при десериализации. Именно из-за такого индивидуального подхода к каждому классу библиотека One Nio и достигает одновременно скорости и гибкости.

Проблема с кастомными методами Java-сериализации

Да, One Nio быстро сериализует, напрямую манипулируя полями объектов. Но, в отличие от стандартной Java-сериализации, она не умеет работать с кастомными методами сериализации: writeObject(), readObject(), writeReplace() и readResolve(). Это особые методы, они не являются частью какого-либо интерфейса. Но само их наличие в классе заставляет стандартную Java-сериализацию использовать их: полностью отдавать классу логику формирования byte[] при сериализации и его чтения при десериализации.

Такими методами кастомизации пользуются многие классы в самых разных библиотеках, например, в Guava: ImmutableList, ImmutableSet и ImmutableMap.

Но такие классы есть и в самом JDK:

  • InetAddress и InetSocketAddress;

  • классы из Datе Time API, которые появились в Java 8;

  • immutable-коллекции, создаваемые фабричными методами of(), которые появились в «девятке» и которые все мы любим;

  • и многие другие.

Причём в каждой новой версии Java появляются всё новые и новые классы с кастомными методами. Давайте посмотрим на принципы их работы на примере списка, создаваемого через List.of(). Если в списке один или два элемента, то фабричный метод создаёт объект класса ImmutableCollections.List12. В этом классе определён метод writeReplace(), который возвращает экземпляр внутреннего класса CollSer как обёртку над своими данными, и уже этому объекту делегируется дальнейшая сериализация и десериализация:

Класс CollSer, в свою очередь, реализует оставшиеся кастомные методы:

  • метод writeObject(), который записывает данные в байтовый поток сериализации;

  • метод readObject(), читающий байты из потока десериализации, наполняя данными объект класса CollSer;

  • и метод readResolve(), вызываемый в конце десериализации и преобразующий наполненный объект CollSer в готовый к использованию List12.

Выглядит очень удобно, можно даже сказать — элегантно. Но проблема в том, что One Nio про всю эту кастомную логику ничего не знает и сериализует List12 просто по его полям.

Вот что получается, если в списке, создаваемом через List.of(), только один элемент:

  1. В объекте класса List12 есть два поля — e0 и e1. Первое заполнено единственным элементом списка, второе — статической константой ImmutableCollections.EMPTY, имеющей тип Object (по сути, это просто маркер того, что поле e1 не заполнено).

  2. One Nio честно записывает в поток оба поля при сериализации и восстанавливает эти поля при десериализации. Но есть нюанс: поле e1 заполняется новым экземпляром класса Object, а вовсе не ссылкой на константу EMPTY!

  3. Это приводит к тому, что список после десериализации содержит уже два элемента, а не один: у него «появляется» второй элемент с типом Object. При использовании такого «кривого» списка обязательно возникают ошибки: логические из-за неверной длины списка или ClassCastException на втором элементе.

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

И таких примеров может быть много, а каждый случай уникален. Всё это создаёт риски undefined behaviour и заставляет задуматься: можно ли «обучить» One Nio использовать кастомные методы сериализации?

Повторение логики стандартной Java-сериализации

Казалось бы, простая задача: просто повторить логику стандартной Java-сериализации. Но дьявол, как обычно, в деталях. Давайте взглянем на те, с которыми мы столкнулись на практике. Начнём с очевидного:

  • Создали в библиотеке One Nio «болванку» для нового сериализатора, который умел бы работать с кастомными методами. Назвали его тоже очевидно: CustomizedSerializer.

  • «Научили» One Nio определять, когда следует использовать этот новый сериализатор (когда в классе сериализуемого объекта есть хотя бы один кастомный метод сериализации).

  • Приступили к реализации CustomizedSerializer.

Основное, что предстояло сделать — реализовать свои варианты стримов ObjectOutputStream и ObjectInputStream, которые работали бы с One Nio «под капотом». Эти стримы нужны для вызова основных кастомных методов writeObject() и readObject().

Методы write...() и read...() для скалярных типов данных (boolean, byte, short) дались легко. А вот над методами defaultWriteObject() и defaultReadObject() пришлось поломать голову.

Как реализовали defaultWriteObject() и defaultReadObject()?

В стандартной Java-сериализации методы defaultWriteObject() и defaultReadObject() обладают особой «магией». Давайте рассмотрим её на примере того самого класса ImmutableCollections.CollSer, объект которого возвращается из List12.writeReplace():

final class CollSer implements Serializable {
    private final int tag;
    private transient Object[] array;

    private void writeObject(ObjectOutputStream stream) throws IOException {
        stream.defaultWriteObject();  // в stream попадает поле tag!
        stream.writeInt(array.length);
        for (int i = 0; i < array.length; i++) {
            stream.writeObject(array[i]);
        }
    }

    private void readObject(ObjectInputStream stream) throws IOException, ClassNotFoundException {
        stream.defaultReadObject();  // из stream—а восстанавливается поле tag!
        int len = stream.readInt();
        Object[] a = new Object[len];
        for (int i = 0; i < len; i++) {
            a[i] = stream.readObject();
        }
        array = a;
    }
    ...
}

В классе есть числовое поле tag и массив объектов — это элементы сериализуемой коллекции. Массив помечен ключевым словом transient, что «говорит» стандартной Java-сериализации игнорировать его по умолчанию. В методе writeObject(), когда мы вызываем defaultWriteObject() у стрима, каким-то чудом в поток записывается наше поле tag. А в методе readObject() при вызове метода defaultReadObject() всё тем же чудом из потока восстанавливается поле tag.

Всё это выглядит как магия, и эту магию нам в One Nio нужно было как-то повторить! Во-первых, нужен был такой же алгоритм сериализации field-by-field, учитывающий ключевое слово transient. Сразу вспомнили про основную фишку One Nio — GeneratedSerializer, который как раз так и работает:

  • сериализует объекты по их полям;

  • учитывает ключевое слово transient так же, как это делает стандартная Java-сериализация.

Сомнений не было — под капотом defaultWriteObject() и defaultReadObject() нужно использовать GeneratedSerializer. Но тут вылез ещё один нюанс: GeneratedSerializer сам умеет вызывать кастомные методы writeObject() и readObject(), но у стрима он позволяет вызвать только defaultWriteObject() и defaultReadObject(), а любой другой метод бросает Exception.

Нас это не устраивало, так как мы хотели использовать GeneratedSerializer уже находясь внутри вызова writeObject() или readObject(): он не должен был сам рекурсивно вызывать эти методы. Поэтому пришлось доработать GeneratedSerializer, добавив ему в конструктор параметры skipWriteObject и skipReadObject, при которых он бы не пытался сам вызывать соответствующие кастомные методы:

GeneratedSerializer(Class<?> cls, Boolean skipWriteObject, Boolean skipReadObject) {
    ...
}
@Override public void write(T obj, DataStream out) throws IOException {
    // если skipWriteObject, то writeObject() не вызывается
}
@Override public T read(DataStream in) throws IOException, ClassNotFoundException {
    // если skipReadObject, то readObject() не вызывается
  }

Настроенный таким образом сериализатор мы добавили в поле создаваемого нами CustomizedSerializer.

public class CustomizedSerializer extends Serializer<Object> {
    /**
     * For handle ObjectInputStream.defaultReadObject() and ObjectOutputStream.defaultWriteObject()
     */
    private GeneratedSerializer defaultSerializer;

    public CustomizedSerializer(Class<?> cls, ...) {
       ...
       this.defaultSerializer = new GeneratedSerializer(cls, true, true);
    }
    ...
}

Теперь у нас был инструмент для default-магии. Оставалось реализовать саму магию так, чтобы при обращении к методу стрима читались собственные поля.

Для этого пришлось на каждый вызов кастомного метода writeObject() или readObject() создавать отдельный экземпляр стрима, который знал бы, для какого объекта сейчас будет вызван этот кастомный метод:

@Override public void write(T obj, DataStream out) throws IOException {
    ObjectOutputStream outStream = new DataObjectOutputStream(out,
            () —> defaultSerializer.write(obj, out));  // defaultWriteObject
    customMethods.writeObject.invoke(obj, outStream);
}

Для этого в конструктор стрима передаём лямбду, которая знает про сериализуемый объект. Стрим в методе defaultWriteObject() вызывает эту лямбду — и вуаля, магия случается!

При вызове кастомного метода readObject() механика получилась аналогичная: новый экземпляр стрима на каждый вызов, и лямбда в конструктор, которая знает про десериализуемый объект:

@Override public T read(DataStream in) throws IOException, ClassNotFoundException {
    T result = /* создание пустого объекта */;
    ObjectInputStream inStream = new DataObjectInputStream(in, result.getClass(),
            () —> {  // !!!
                Object obj = defaultSerializer.read(in);
                // копирование obj в result
            }
    );
    customMethods.readObject.invoke(result, inStream);
    return result;
}

Реализовать вызовы кастомных методов writeReplace() и readResolve() труда не составило — они не принимают параметром никакой стрим, поэтому мы просто повторили логику стандартной Java-сериализации, рефлексивно вызывая эти методы.

Между прочим, стандартная Java-сериализация тоже через рефлексию вызывает у объектов их кастомные методы сериализации. Но ей в этом плане чуть проще из-за «дружбы» с JPMS — об этом мы поговорим чуть позже.

А пока кажется, что задача завершена: мы сделали в библиотеке One Nio новый CustomizedSerializer, который при необходимости вызывает кастомные методы.

Но как бы не так! При отладке и тестировании мы наткнулись на целый ряд нюансов, с которыми пришлось повозиться.

Как обеспечили десериализацию зацикленных структур данных

Я уже говорил, что One Nio — крутая библиотека для Java-сериализации? Поэтому она ещё и круто разруливает зацикленные структуры в сериализуемых данных. Допустим, мы сериализуем объект — это сотрудник Иван, который в своём поле team ссылается на другой объект — команду Программисты, к которой он относится. В поле этой команды содержится коллекция ссылок на сотрудников, которые в неё входят, а один из этих сотрудников — как раз наш сериализуемый Иван.

В идеале, нужно сериализовать эту зацикленную структуру данных так, чтобы после десериализации она так и осталась зацикленной, а в коллекции программистов не появился клон Ивана. Библиотека One Nio прекрасно справляется с этой задачей, но для этого она накладывает ограничение на алгоритм десериализации:

@Override public T read(DataStream in) throws IOException, ClassNotFoundException {
    T result = /* создание пустого объекта */;
    in.register(result);  // регистрация объекта в потоке десериализации
    // чтение данных из потока "in" внутрь объекта "result"!
    return result;
}

Метод read() каждого сериализатора обязан сначала создать пустой объект-результат и зарегистрировать его в потоке десериализации. Только после этого можно читать данные из потока, наполняя ими объект-результат.

Зачем всё это? В процессе чтения данных может понадобиться десериализовать вложенный объект из зацикленной структуры. Тогда One Nio вовремя сообразит, что структура данных замкнулась, и вместо очередного вызова read() возьмёт ранее зарегистрированный объект, который прямо сейчас сам находится в процессе десериализации где-то ниже по стеку.

Это всё, конечно, интересно, но как это относится к нашей задаче?

Проблема в том, что наш CustomizedSerializer универсальный, то есть он не знает, объекты каких именно классов десериализует:

java
@Override public T read(DataStream in) throws IOException, ClassNotFoundException {
    T result = /* создание пустого объекта, какого—то класса */;
    in.register(result);  // регистрация объекта в потоке десериализации
    if (есть методы writeReplace() или readResolve()) {
        T realResult = /* то readObject() будет вызываться не у result,
                          а readResolve() вернёт настоящий результат */
        // И как теперь данные из realResult засунуть внутрь result?
    } else
        // чтение данных вызовом result.readObject()
    return result;
}

А если у класса есть метод writeReplace(), то метод readObject() будет вызываться не у зарегистрированного result, а у промежуточного объекта, такого как рассмотренный ранее CollSer.

Но ведь этот промежуточный объект только в конце десериализации превратится в realResult методом readResolve(). Как в таком случае вынуть данные из realResult и засунуть их внутрь зарегистрированного выше result?

Нам нужна была функция memcpy(), как в C++, чтобы, не разбираясь, скопировать область памяти из под объекта realResult в объект result.

Что-то подобное мы даже нашли в классе Unsafe: там есть метод copyMemory(). Но оказалось, что метод работает только с byte[], да и размер копируемого блока памяти нам взять было неоткуда, ведь он зависит от конкретного класса. Пришлось по полям «выковыривать» данные из одного Java-объекта (realResult) и «запихивать» их в другой (result).

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

Во-первых, мы всё-таки использовали класс Unsafe, но только для чтения и записи полей объектов:

void copyObjectField(Object src, Object dst, Field field, Long fieldOffset) {
    Class<?> fieldCls = field.getType();
    Long fieldOffset = unsafe.objectFieldOffset(field);
    if (fieldCls == int.class)
        unsafe.putInt(dst, fieldOffset, unsafe.getInt(src, fieldOffset));
    else if (fieldCls == long.class)
        unsafe.putLong(dst, fieldOffset, unsafe.getLong(src, fieldOffset));
    ...
    else
        unsafe.putObject(dst, fieldOffset, unsafe.getObject(src, fieldOffset));
}

Такой способ отлично работает даже с полями private и final! Никаких проблем.

Во-вторых, мы использовали кеширование рефлексивно получаемых Field и их offset:

Map<Class<?>, Pair<Field, Long>[]> classFieldsMap = new ConcurrentHashMap<>();
void copyObjectByFields(Class<?> srcClass, BiConsumer<Field, Long> copyObjectField) {
    Pair<Field, Long>[] allFields = classFieldsMap.get(srcClass);
    if (allFields != null) {
        for (Pair<Field, Long> fieldAndOffset : allFields) {
            copyObjectField.accept(fieldAndOffset.left, fieldAndOffset.right);
        }
    } else {
        for (Class<?> cls = srcClass; cls != Object.class; cls = cls.getSuperclass()) {
            Field[] fields = cls.getDeclaredFields();
            for (Field field : fields)
                // копирование поля через copyObjectField и кэширование в classFieldsMap
        }
    }
}

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

Это то, что нужно нашему новому CustomizedSerializer, чтобы скопировать realResult в result.

@Override public T read(DataStream in) throws IOException, ClassNotFoundException {
    T result = /* создание пустого объекта, какого—то класса */;
    in.register(result);  // регистрация объекта в потоке десериализации
    if (есть методы writeReplace() или readResolve()) {
        T realResult = /* то readObject() будет вызываться не у result,
                          а readResolve() вернёт настоящий результат */
        copyObjectByFields(realResult, result);  // !!!
    } else
        // чтение данных вызовом result.readObject()
    return result;
}

Кажется, что благодаря быстрому копированию произвольных объектов мы справились с ограничением библиотеки One Nio на алгоритм десериализации. Но не тут-то было — нас ждала ещё одна проблема из серии «откуда не ждали».

Как обошли ограничения JPMS

Одновременно с доработкой One Nio мы обновляли Java 11 на Java 21 (да, вот так круто, сразу через один LTS-релиз). В процессе выяснилось, что в 21-й Java ужесточились проверки JPMS при попытках рефлексивного вызова методов, как приватных, так и публичных.

Напомню, что JPMS — модульная система платформы Java, которая появилась ещё в Java 9. Модуль — это просто набор пакетов с исходниками, по сути, jar, в дескрипторе которого написано, в какие пакеты текущего модуля есть доступы для других модулей.

И снова: как это связано с нашей задачей?

  • One Nio сериализует объекты произвольных классов не глядя на их модуль, и, конечно, у неё нет прав на все возможные модули.

  • Новому CustomizedSerializer приходится рефлексивно вызывать кастомные методы сериализации, так как они не являются частью какого-либо интерфейса: это просто методы с определённой сигнатурой.

Раньше для объекта Method мы могли просто вызвать setAccessible(true) и спокойно таким образом вызвать private-метод, либо метод класса из другого модуля:

Method method = ImmutableCollections.List12.class.getDeclaredMethod("writeReplace");
method.setAccessible(true);
method.invoke(obj);

Но теперь это перестало работать:

java.lang.reflect.InaccessibleObjectException: Unable to make private java.lang.Object java.util.ImmutableCollections$List12.writeReplace() accessible: module java.base does not "opens java.util" to unnamed module @6e4784bc
    at java.base/java.lang.reflect.AccessibleObject.throwInaccessibleObjectException(AccessibleObject.java:391)
    at java.base/java.lang.reflect.AccessibleObject.checkCanSetAccessible(AccessibleObject.java:367)
    at java.base/java.lang.reflect.AccessibleObject.checkCanSetAccessible(AccessibleObject.java:315)
    at java.base/java.lang.reflect.Method.checkCanSetAccessible(Method.java:203)
    at java.base/java.lang.reflect.Method.setAccessible(Method.java:197)
    ...

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

Нужно было как-то перехитрить JPMS. Сначала мы заглянули в реализацию метода setAccessible():

public final class Method extends Executable {
    @CallerSensitive
    public void setAccessible(boolean flag) {
        AccessibleObject.checkPermission();
        if (flag) checkCanSetAccessible(Reflection.getCallerClass());// Exception отсюда...
        setAccessible0(flag);                                        // ... если ты не внутри "java.base"
    }
    ...
public class AccessibleObject ... {  // базовый для Method
    boolean setAccessible0(boolean flag) {
        this.override = flag;
        return flag;
    }
    boolean override;  // package—private
  ...

Первым делом происходит проверка, можно ли вызвать метод, используя caller class. Результат: метод запрещено вызывать из другого модуля, кроме как из модуля «java.base». Как раз благодаря этому у стандартной Java-сериализации нет наших проблем: она спокойно вызывает метод setAccessible(), так как её код находится в том самом модуле «java.base» в отличие от кода библиотеки One Nio.

Мы решили копать дальше и увидели, что суть метода setAccessible() сводится просто к изменению поля override в базовом классе AccessibleObject. Стало понятно, что нам всего-то нужно поменять это поле, не выполняя проверки по caller class. Подумаешь, модификатор доступа package-private.

Попробовали очевидный вариант через рефлексию:

AccessibleObject.class.getDeclaredField("override");

и получили неожиданный NoSuchFieldException:

java.lang.NoSuchFieldException: override
    at java.base/java.lang.Class.getDeclaredField(Class.java:2782)
    ...

Как же так?! Ведь это откровенная ложь, мы же видели, что поле в классе есть, пусть и с доступом package-private. Оказалось, что в Java 21 и выше невозможно рефлексивно получить некоторые поля определённых классов из пакета java.lang.reflect. Не помогает даже ключик --add—opens, который, по идее, должен был бы открывать нам доступ к этому пакету:

--add—opens java.base/java.lang.reflect=ALL—UNNAMED

Ок, в лоб не получилось — пошли искать в интернете. И нашли-таки способ дотянуться до поля override через VarHandle (которые тоже появились в Java 9, как и JPMS).

VarHandle override =
        MethodHandles.privateLookupIn(AccessibleObject.class, MethodHandles.lookup())
                     .findVarHandle(AccessibleObject.class, "override", boolean.class);
override.set(method, true);
// https://www.developerload.com/get—declared—fields—of—javalangreflectfields—in—jdk12

Это, конечно, круто, но работает только с тем самым ключиком --add—opens для JVM. Нас это не устраивало, так как мы используем One Nio для взаимодействия с сотнями бизнес-сервисов, и есть жёсткие требования по обратной совместимости: нельзя заставить сотни пользователей добавить дополнительный JVM-аргумент при старте.

Вспомнили про класс Unsafe, который уже помог нам с быстрым копированием объектов. Этот класс умеет работать с полями private final, а теперь выяснилось, что он ещё и прекрасно работает с полями классов из другого модуля. И это как раз то, что нам сейчас нужно.

Но и тут незадача: чтобы поменять значение поля override, сначала нужно получить его смещение методом Unsafe.objectFieldOffset(), но этот метод принимает на вход рефлексивный Field. А ведь именно Field для поля override мы как раз и не можем получить. Пошли по второму кругу...

И тут — эврика! В Java 21 и выше мы не можем прямо в runtime получить смещение поля override в классе AccessibleObject. Но что если это смещение не изменилось с предыдущих версий Java?

Так оно и вышло! Смещение поля относительно начала объекта зависит от состава полей класса и их типов, а в классе AccessibleObject всего два поля, не считая статических:

  • это нужный нам overrideс типом boolean, у которого смещение 12;

  • и accessCheckCache с типом Object, у которого смещение 16.

Проверили все версии Java, начиная с 8 и заканчивая 25 — эти смещения одинаковые. Причём не только для HotSpot JVM, но и для Liberica, GraalVM, OpenJ9 и других.

При этом в Java 25 обнаружился ещё один нюанс: появилась возможность включить компактное представление заголовков объектов, используя ключик

-XX:+UseCompactObjectHeaders.

При включении этой оптимизации, действительно, смещение поля override уменьшается на 4 байта и становится равным 8, а не 12. Правда этого эффекта почему-то нет в OpenJ9.

Мы учли все эти нюансы и стали вычислять смещение поля override при статической инициализации библиотеки One Nio. Если включена оптимизация заголовков, и JVM не на базе OpenJ9, то смещение 8 байтов, иначе 12.

static final long overrideOffset = getOverrideOffset();
static long getOverrideOffset() {
    return useCompactObjectHeaders() && !isOpenJ9() ? 8 : 12;  // !!!
}
static boolean useCompactObjectHeaders() {
    RuntimeMXBean runtimeMxBean = ManagementFactory.getRuntimeMXBean();
    Set<String> jvmArgs = Set.copyOf(runtimeMxBean.getInputArguments());
    return jvmArgs.contains("—XX:+UseCompactObjectHeaders");
}
private boolean isOpenJ9() {
    return ManagementFactory.getRuntimeMXBean().getVmVendor().contains( "OpenJ9" );
}

Что получилось

Для вызова кастомных методов сериализации (в том числе для классов из другого модуля) на замену методу setAccessible() мы реализовали свой служебный метод setAccessibleFor(), которому передаётся объект класса Method.

void setAccessibleFor(Method method, boolean flag) {
    if (!method.isAccessible()) {
        unsafe.putBoolean(method, overrideOffset, flag);
        if (!method.isAccessible())
            throw new Error(
                    "Cannot make the method" + method.getName() + " accessible");
    }
}

Там с помощью класса Unsafe мы быстро меняем значение поля override у переданного метода, используя вычисленное один раз выше смещение.

Просто и элегантно!

Теперь наш новый CustomizedSerializer может рефлексивно вызывать кастомные методы сериализации даже на Java 21 и выше.

Method method = ImmutableCollections.List12.class.getDeclaredMethod("writeReplace");
setAccessibleFor(method, true);  // !!!
Object replaceObj = method.invoke(obj, (Object[]) null);
// аналогично для writeObject(), readObject() и readResolve()

Последний подводный камень позади, а наш CustomizedSerializer реально работает на любой версии Java!

Что ещё нужно? А осталось лишь выяснить, насколько он эффективен!

Во второй части расскажу про подробности разгона: результаты JMH benchmark до и после, почему мы при сериализации перестали считать размер заранее и как нам в этом помогла цепочка массивов для ускорения сериализации. А главное, приведу итоговые результаты, которые доказывают: наш CustomizedSerializer не только работает с кастомной логикой, но и делает это быстро.

View the original on Хабр →

KioskNews shows a cleaned-up reading view extracted from the publisher’s page — the original always lives on their site, not ours.