Хабрахабр

[Перевод] Эмуляция литералов свойств с Java 8 Method Reference

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

В этом посте я покажу, как можно креативно воспользоваться Method Reference из Java 8 для эмуляции литералов свойств с помощью генерации байт-кода. Одна из вещей, которой часто не хватает разработчикам библиотек в Java, — литералы свойств.

Это было бы полезно для дизайна API, где есть необходимость выполнять действия над свойствами или каким-то образом конфигурировать их. Сродни литералам классов (например, Customer.class), литералы свойств позволили бы ссылаться на свойства классов-бинов типобезопасно.

От переводчика: Под катом разбираем как из подручных средств это реализовать.
Например, рассмотрим API конфигурации маппинга индекса в Hibernate Search:

new SearchMapping().entity(Address.class) .indexed() .property("city", ElementType.METHOD) .field();

Или же метод validateValue() из Bean Validation API, позволяющий проверить значение по ограничениям на свойстве:

Set<ConstraintViolation<Address>> violations = validator.validateValue(Address.class, "city", "Purbeck" );

В обоих случаях чтобы сослаться на свойство city объекта Address используется тип String.

Это может приводить к ошибкам:

  • класс Address может вообще не иметь свойства city. Или кто-то может забыть обновить строковое имя свойства после переименования get/set методов при рефакторинге.
  • в случае validateValue() у нас нет возможности убедиться, что тип передаваемого значения соответствует типу свойства.

Пользователи этого API могут узнать об этих проблемах только запустив приложение. Разве не круто было бы, если бы компилятор и система типов предотвращали такое использование с самого начала? Если бы в Java были литералы свойств, то мы бы могли делать так (этот код не компилируется):

mapping.entity(Address.class) .indexed() .property(Address::city, ElementType.METHOD ) .field();

И:

validator.validateValue(Address.class, Address::city, "Purbeck");

Мы бы могли избежать проблем, упомянутых выше: любая описка в имени свойства привела бы к ошибке компиляции, которую можно заметить прямо в вашей IDE. Это позволило бы разработать API конфигурации Hibernate Search так, чтобы он принимал только свойства класса Address, когда мы конфигурируем сущность Address. И в случае c Bean Validation validateValue() литералы свойств помогли бы убедиться, что мы передаём значение верного типа.

Java 8 Method Reference

Java 8 не поддерживает литералы свойств (и их не планируется поддержать в Java 11), но в то же время она предоставляет интересный способ для их эмуляции: Method Reference (ссылка на метод). Изначально, Method Reference были добавлены для упрощения работы с лямбда-выражениями, но их можно использовать как литералы свойств для бедных.

Рассмотрим идею использования ссылки на геттер метод в качестве литерала свойства:

validator.validateValue(Address.class, Address::getCity, "Purbeck");

Очевидно, это будет работать, только если у вас есть геттер. Но если ваши классы уже следуют конвенции JavaBeans, что чаще всего так, — это нормально.

Ключевой момент — использование нового типа Function: Как выглядело бы объявление метода validateValue()?

public <T, P> Set<ConstraintViolation<T>> validateValue( Class<T> type, Function<? super T, P> property, P value);

Используя два параметра типизации мы можем убедиться, что тип бина, свойства и переданного значения корректны. С точки зрения API мы получили то, что нужно: его безопасно использовать и IDE будет даже автоматически дополнять имена методов начинающиеся с Address::. Но как же вывести имя свойства из объекта Function в реализации метода validateValue()?

Это похоже не то, что нам было нужно. И тут то начинается веселье, поскольку функциональный интерфейс Function всего лишь объявляет один метод — apply(), который исполняет код функции для переданного экземпляра T.

ByteBuddy во спасение

Как выясняется, в применении функции и состоит трюк! Создавая прокси-экземпляр типа T, мы имеем цель для вызова метода и получения его имени в обработчике вызовов Proxy. (От переводчика: здесь и далее идёт речь о динамических прокси Java — java.lang.reflect.Proxy).

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

Давайте начнём с определения интерфейса, который бы позволил хранить и получать имя свойства, извлечённое из Method Reference.

public interface PropertyNameCapturer { String getPropertyName(); void setPropertyName(String propertyName);
}

Теперь задействуем ByteBuddy для программного создания прокси-классов, которые совместимы с интересующими нас типами (например: Address) и реализуют PropertyNameCapturer:

public <T> T /* & PropertyNameCapturer */ getPropertyNameCapturer(Class<T> type) Class<?> proxyType = builder .implement(PropertyNameCapturer.class) (3) .defineField("propertyName", String.class, Visibility.PRIVATE) .method( ElementMatchers.any()) (4) .intercept(MethodDelegation.to( PropertyNameCapturingInterceptor.class )) .method(named("setPropertyName").or(named("getPropertyName"))) (5) .intercept(FieldAccessor.ofBeanProperty()) .make() .load( (6) PropertyNameCapturer.class.getClassLoader(), ClassLoadingStrategy.Default.WRAPPER ) .getLoaded(); try { @SuppressWarnings("unchecked") Class<T> typed = (Class<T>) proxyType; return typed.newInstance(); (7) } catch (InstantiationException | IllegalAccessException e) { throw new HibernateException( "Couldn't instantiate proxy for method name retrieval", e ); }
}

Код может показаться слегка запутанным, так что позвольте мне его пояснить. Сначала мы получаем экземпляр ByteBuddy (1), который является входной точкой DSL. Он используется для создания динамических типов, которые либо расширяют нужный тип (если это класс) или наследуют Object и реализуют нужный тип (если это интерфейс) (2).

Затем мы говорим, что вызовы всех методов должны перехватываться PropertyNameCapturingInterceptor (4). Затем, мы указываем, что тип реализует интерфейс PropertyNameCapturer и добавляем поле для хранения имени нужного свойства (3). Наконец, класс создаётся, загружается (6) и инстанциируется (7). Только setPropertyName() и getPropertyName() (из интерфейса PropertyNameCapturer) должны получать доступ к реальному свойству, созданному ранее (5).

Теперь давайте посмотрим на перехватчик вызовов: Это всё, что нам нужно для создания прокси-типов, спасибо ByteBuddy, это можно сделать в несколько строк кода.

public class PropertyNameCapturingInterceptor { @RuntimeType public static Object intercept(@This PropertyNameCapturer capturer, @Origin Method method) { (1) capturer.setPropertyName(getPropertyName(method)); (2) if (method.getReturnType() == byte.class) { (3) return (byte) 0; } else if ( ... ) { } // ... handle all primitve types // ... } else { return null; } } private static String getPropertyName(Method method) { (4) final boolean hasGetterSignature = method.getParameterTypes().length == 0 && method.getReturnType() != null; String name = method.getName(); String propName = null; if (hasGetterSignature) { if (name.startsWith("get") && hasGetterSignature) { propName = name.substring(3, 4).toLowerCase() + name.substring(4); } else if (name.startsWith("is") && hasGetterSignature) { propName = name.substring(2, 3).toLowerCase() + name.substring(3); } } else { throw new HibernateException( "Only property getter methods are expected to be passed"); (5) } return propName; }
}

Метод intercept() принимает вызываемый Method и цель для вызова (1). Аннотации @Origin и @This используются для указания соответствующих параметров, чтобы ByteBuddy мог сгенерировать корректные вызовы intercept() в динамическом прокси.

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

Если метод не является геттером, то код выбрасывает исключение (5). Вызывая getPropertyName() (4) мы можем получить имя свойства, соответствующее переданному Method Reference, и сохранить его в PropertyNameCapturer (2). Возвращаемый тип геттера не имеет значения, так что мы возвращаем null с учётом типа свойства (3).

Теперь у нас всё готово для того, чтобы получить имя свойства в методе validateValue():

public <T, P> Set<ConstraintViolation<T>> validateValue( Class<T> type, Function<? super T, P> property, P value) { T capturer = getPropertyNameCapturer(type); property.apply(capturer); String propertyName = ((PropertyLiteralCapturer) capturer).getPropertyName(); // здесь запускам саму валидацию значения
}

После применения функции к созданному прокси, мы приводим тип к PropertyNameCapturer и получаем имя из Method.

Вот так используя немного магии генерации байт-кода, мы применили Method Reference из Java 8 для эмуляции литералов свойств.

Я бы разрешил даже работать с приватными свойствами и, наверное, на свойства можно было бы ссылаться из аннотаций. Конечно же, будь у нас реальные литералы свойств в языке, нам всем было бы лучше. Реальные литералы свойств были бы более аккуратными (без префикса «get») и не выглядели бы как хак.

От переводчика

Тут стоит отметить, что другие хорошие языки уже поддерживают (или почти) подобный механизм:
Если вы вдруг используете c Java проект Lombok, то для него написан байткод генератор времени компиляции.

Вдохновившись описанным в статье подходом, ваш покорный слуга собрал небольшую библиотеку, которая реализует nameOfProperty() для Java 8:

Исходники
Бинарники

Показать больше

Похожие публикации

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *

Кнопка «Наверх»