Как сделать свою аннотацию java

Аннотации, как создавать

— Так вот, давай-ка сейчас создадим парочку аннотаций и используем их.

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

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

Тогда можно было бы очень просто симулировать бои между различными персонажами и/или быстро просчитать баланс игры.

— Согласен – это хорошая идея.

А вот так выглядело бы описание, например, лесного эльфа-мага:

А вот так выглядело бы описание главного злодея:

— Ясно. Чем-то напоминает интерфейсы-маркеры.

— Да, только, во-первых, не приходится ничего наследовать, во вторых, в аннотациях можно хранить дополнительную информацию.

Есть еще несколько аннотаций, которыми помечаются аннотации. Вот они:

Аннотация @Retention указывает, где будет видна наша аннотация: только в исходном коде, еще и после компиляции, будет доступна даже во время исполнения программы.

Аннотация @Target указывает, что именно можно пометить этой аннотацией: класс, поле, метод, параметр метода и т.д.

Если мы хотим, чтобы наша аннотация действовала не только на отмеченный ей класс, но и на его наследников, то надо пометить ее @Inherited.

Вот как будет выглядеть наша аннотация @Person.

— Это было очень интересно, спасибо, Риша.

А как работать с этими аннотациями в программе? Как их использовать? Как прочитать их значения?

— Для этого принято использовать Reflection.

Вот как выглядело бы определение того, какой из персонажей сильнее:

Вот методы класса, которые нам нужны:

— Отлично. А я и не думал, что получить аннотацию так просто.

— Ага. Просто вызвал метод getAnnotation у объекта класса, и передал туда нужный тебе тип аннотации.

На этом на сегодня все.

— Спасибо, Риша, это была очень интересная лекция. И теперь я уже не боюсь аннотаций как воды.

Источник

Аннотации в Java

Аннотация( @Annotation ) — форма метаданных, предоставляющая данные о программе, которая не является частью самой программы. Аннотации не имеют прямого влияния на работу кода, они аннотируют его и представляют из себя лишь мета информацию.

Аннотации используются в трех случаях:

Аннотированы могут быть пакеты, классы, методы, переменные и параметры.

Как создать Аннотацию в java

Аннотации очень схожи с интерфейсами, соответственно как и интерфейсы они могут быть только public. Модификатор доступа так же как и с интерфейсами можно не писать.

Символ @ — указывает компилятору, что объявлена аннотация. Методы, объявленные в аннотации ведут себя скорее как поля.

@interface — указывает на то, что это аннотация

default — говорит про то, что метод по умолчанию будет возвращать определённое значение.

Конфигурация Аннотации

Аннотация без конфигурирования может применяться к любым элементам: классам, методам, полям, атрибутами так далее…

Аннотация @Target позволит нам ограничить Scope ее применения.
@Target (ElementType. PACKAGE ) — только для пакетов;

@Target (ElementType. TYPE ) — только для классов;

@Target (ElementType. CONSTRUCTOR ) — только для конструкторов;

@Target (ElementType. METHOD ) — только для методов;

@Target (ElementType. FIELD ) — только для атрибутов(переменных) класса;

@Target (ElementType. PARAMATER ) — только для параметров метода;

@Target (ElementType. LOCAL_VARIABLE ) — только для локальных переменных.
В случае если вы хотите, что бы ваша аннотация использовалась больше чем для одного типа параметров, то можно указать @Target следующим образом:

Источник

Аннотации в java

Для тех, кто только начал изучать язык программирования java, аннотации покажутся чем-то странным и совсем не нужным.

На первый взгляд — это так, но за аннотациями скрывается мощный инструмент, который делает программирование на JAVA еще более увлекательным.

Что такое аннотация в java?

Аннотации (annotations) — это конструкторы, которые применяются к конструкциям джава: классы, методы, поля. Они не выполняют код сами по себе, но могут использоваться компилятором или на этапе выполнения программы для выполнения определенных действий с кодом, на который они применены.

Если объяснять проще — то аннотации это вот та строка @Override, которую eclipse сам дописал, а Вы не знаете удалить ее или нет.

Вроде и когда удалил — ничего не произошло; добавил — тоже ничего. Если брать к примеру @Override, то она ничего не меняет и не выполняет. Данная аннотация является встроенной и говорит, что метод, аннотированный как Override должен переопределять метод супер класса.

Есть еще очень полезная встроенная аннотация @Deprecated. Если Вы открыли код и видите над некоторым методом данную аннотацию — это означает, что метод устарел и уже не рекомендуется к использованию. Все же выполняться код с данным методом будет, но будут показаны предупреждения компилятора. Это очень полезная и нужная аннотация. Вскоре, во время разработки больших проектов она может Вам понадобиться.

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

Как создавать собственные аннотации?

Перед тем, как начать кодить нужно еще немного теории. Создание аннотаций должно включать два типа информации: политика удержания (retention policy) и цель (target).

Политика удержания будет указывать как долго будет доступна аннотация в пределах програмного цикла. Будет ли аннотация доступна только во время выполнения или во время компиляции программы. Может быть она будет доступна и во время выполнения и компиляции.

Цель аннотации — это указатель на какою конструкцию мы будет в будущем применять аннотацию. Это могут быть поля, методы, другие аннотации, локальные переменные, конструкторы и т.д.

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

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

Для удобства создадим пакет com.javamaster.annotation_example

Далее создаем аннотацию как на гиф ниже:

Давайте назовем ее FieldCustomVal. В данной аннотации будет одна функция: если поле, на которое она будет навешана без значения — добавить значение по умолчанию. Вот ее код:

Код нашей аннотации довольно прост если Вы ознакомились с теорией выше. Мы указали Retention и Target. Также добавили value метод, который будет принимать значением строку которую мы потом присвоим полю. Если строка не задана, по умолчании будет Hello there. Далее нужно использовать аннотацию. Здесь код будет немного сложней:

Что здесь происходит? Первое: мы создали 2 поля и навешали нашу аннотацию. Как по мне — это самый очевидный и простой участок кода. Дальше в методе main мы используем рефлексию Reflection API для получения полей класса во время выполнения программы. Рефлексия — это стандартная фича языка java, которая позволяет получить доступ к классам, методам, полям программы во время выполнения.

Как Вы уже могли догадаться: результатом выполнения кода будет:

My custom val
Hello there

Аннотации достаточно удобный и мощный инструмент и Вы будете встречаться с ними постоянно во время программирования на java. Но, как показывает практика, использовать Вы будете уже готовые аннотации. Создание своих аннотаций все же полезно знать в качестве общего развития и понимания, как все это работает под капотом.

На этом пока все. Попробуйте выполнить код выше на своем компьютере. Так вникнуть намного проще.

Источник

Практическое применение аннотации в Java на примере создания Telegram-бота

Рефлексия в Java — это специальное API из стандартной библиотеки, которая позволяет получить доступ к информации о программе во время выполнения.

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

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

В этой статье мы коснемся всех этих вопросов применительно к аннотациям и на живом примере увидим как использовать, находить и писать свою.

Рефлексия

Я считаю, что ошибочно будет думать, что рефлексия в Java ограничивается лишь каким-то пакетом в стандартной библиотеке. Поэтому предлагаю рассмотреть его как термин, не привязывая конкретному пакету.

Reflection vs Introspection

Наряду с рефлексией также есть понятие интроспекции. Интроспекция — это способность программы получить данные о типе и других свойствах объекта. Например, это instanceof :

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

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

Если говорить конкретнее, то рефлексия — это возможность программы исследовать себя во время выполнения и с помощью неё изменять своё поведение.

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

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

Воспользуемся рефлексией и создадим экземпляр класса:

Давайте также через рефлексию вызовем его метод:

От теории к практике:

Вопрос #1
Почему в invoke методе в примере сверху мы должны передавать экземпляр объекта?

Далее углубляться я не буду, так как мы уйдём далеко от темы. Вместо этого я оставлю ссылку на статью старшего коллеги Тагира Валеева.

Аннотации

Задумывались ли вы, как оно работает? Если не знаете, то, прежде чем читать дальше, попробуйте догадаться.

Типы аннотаций

Рассмотрим вышеприведённую аннотацию:

@Target — указывает к чему применима аннотация. В данном случае, к методу.

@Retention — длительность жизни аннотации в коде (не в секундах, разумеется).

@interface — является синтаксисом для создания аннотаций.

Если с первым и последним все более менее понятно (подробнее см. @Target в документации), то @Retention давайте разберем сейчас, так как он поможет разделить аннотации на несколько типов, что очень важно понимать.

Эта аннотация может принимать три значения:

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

В третьем случае аннотация будет удалена компилятором (её не будет в байт-коде). Обычно это бывают аннотации, которые полезны только для компилятора.

SuperCat

Попробуем добавить свою аннотацию (это здорово нам пригодится во время разработки).

Пусть у нас в доме будет два котика: Том и Алекс. Создадим аннотацию для суперкотика:

При этом Тома мы оставим обычным котом (мир несправедлив). Теперь попробуем получить классы, которые были аннотированы данным элементом. Было бы неплохо иметь такой метод у самого класса аннотации:

Но, к сожалению, такого пока метода нет. Тогда как нам найти эти классы?

ClassPath

Это параметр, который указывает на пользовательские классы.

Надеюсь, вы с ними знакомы, а если нет, то спешите изучить это, так как это одна из фундаментальных вещей.

Итак, узнав, где хранятся наши классы, мы сможем их загрузить через ClassLoader и проверить классы на наличие данной аннотации. Сразу приступим к коду:

Не советую использовать это в вашей программе. Код приведён только для ознакомительных целей!

Этот пример показателен, но используется только для учебных целей из-за этого:

Дальше мы узнаем, почему. А пока разберём по строчкам весь код сверху:

Чтобы разобраться, откуда мы берём эти файлы, рассмотрим JAR-архив, который создаётся, когда мы запускаем приложение:

Таким образом, classes — это только наши скомпилированные файлы в виде байт-кода. Тем не менее File — это ещё не загруженный файл, мы только знаем, где они находятся, но мы пока по-прежнему не можем видеть, что находится внутри них.

Поэтому загрузим каждый файл:

Всё, что сделано ранее, было только для того, чтобы вызвать этот метод Class.forName, который загрузит необходимый нам класс. Итак, финальная часть — это получение всех аннотаций, использованных на класс repoClass, а затем проверка, являются ли они аннотацией @SuperCat :

И готово! Теперь, когда у нас есть сам класс, то мы получаем доступ ко всем методам рефлексии.

Рефлексируем

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

Итак, обработка обретает финальную форму:

И снова рубрика вопросов:

Подумайте пару минут, а затем сразу разберём ответы:

Ответ #3: Кошкам нужен дом, потому что они являются внутренними классами. Всё в рамках спецификации The Java Language Specification глава 15.9.3.

Подведём итоги и получим: Home.java

Сам он как раз-таки делает всё, что от него нужно. Тем не менее мы его используем неправильно.

Представьте себе, что вы работаете над проектов в котором 1000 и больше классов (всё-таки на Java пишем). И представьте, что вы будете загружать каждый класс, который найдёте в classPath. Сами понимаете, что память и остальные ресурсы JVM не резиновые.

Способы работы с аннотациями

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

Но всё же Spring вроде работает. Неужели из-за них моя программа такая медленная? К сожалению или к счастью, нет. Spring работает исправно (в этом плане), потому что использует несколько иной способ для работы с ними.

Прямо в байт-код

Все (надеюсь) так или иначе имеют представление, что такое байт-код. В нём хранится вся информация о наших классах и их метаданных (в том числе аннотаций).

Так почему бы нам её просто не прочитать (да, из байт-кода)? Но здесь я не буду реализовывать программу для её чтения из байт-кода, так как это заслуживает отдельной статьи. Впрочем, вы сами можете это сделать — это будет отличной практикой, которая закрепит материал статьи.

Для ознакомления с байт-кодом вы можете начать с моей статьи. Там я описываю базовые вещи байт-кода с программой Hello World! Статья будет полезна, даже если вы не собираетесь напрямую работать с байт-кодом. В нем описываются фундаментальные моменты, которые помогут ответить на вопрос: почему именно так?

После этого добро пожаловать на официальную спецификацию JVM. Если вы не хотите разбирать байт-код вручную (по байтам), то посмотрите в сторону таких библиотек, как ASM и Javassist.

Reflections

Reflections — библиотека с WTFPL лицензией, которая позволяет делать с ней всё, что вы захотите. Довольно быстрая библиотека для различной работы с classpath и метаданными. Полезным является то, что она может сохранять информацию о уже некоторых прочитанных данных, что позволяет сэкономить время. Можете покопаться внутри и найти класс Store.

spring-context

Я бы рекомендовал использовать библиотеку Reflections, так как внутри она работает через javassist, что свидетельствует о том, что используется чтение байт-кода, а не его загрузка.

Если ваши классы — это по сути managed beans, то есть находятся в контейнере Spring, то вам незачем повторно их сканировать. Вы просто можете получить доступ к этим бинам из самого контейнера.

Опять же, довольно редко вы должны будете использовать именно такой метод, но как вариант его стоит рассмотреть.
Я писал на нём бота для ВК. Вот репозиторий, с которым вы можете ознакомиться, но писал я его давно, а когда зашёл посмотреть, чтобы вставить ссылку в статью, то увидел, что через VK-Java-SDK я получаю сообщения с неинициализированными полями, хотя раньше всё работало.

Команды в нём представляют из себя вот что:

Примеры кода с аннотацией SuperCat вы можете найти в этом репозитории.

Практическое применение аннотаций в создании Телеграм-бота

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

Также здесь осознанно не будут выполнятся какие-то сложные проверки. Например, до этого в примерах не было никаких чеков на null или правильной обработки ошибок, не говоря уже об их логировании.

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

Мы будем использовать библиотеку TelegramBots с MIT лицензией для работы с API телеграма. Вы же можете использовать любую другую. Я выбрал её, потому что она могла работать как «c» (имеет версию со стартёром), так и «без» спринг-бута.

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

Reflections

Первый бот на очереди — это бот, написанный на библиотеке reflections, без Spring. Будем разбирать не всё подряд, а лишь основные моменты, в особенности нас интересует обработка аннотаций. До разбора в статье вы сами можете разобраться в его работе в моём репозитории.

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

Также добавим логгеры. Их мы будем вызвать либо до обработки запроса, либо после, а также комбинировать их:

Но также мы можем добавить параметр, чтобы логгер срабатывал при определённых сообщениях:

Или срабатывал после обработки запроса:

Мы можем делать такое, так как executionTime принимает массив значений. Принцип работы прост, поэтому приступим к обработке этих аннотаций:

По сути, мы просто создаём мапу с именем команды, которую берём из значения value в аннотации. Исходный код здесь.

То же самое делаем с Log, только логгеров с одинаковыми паттернами может быть несколько, поэтому мы чуть меняем нашу структуру данных:

На каждый паттерн приходится несколько логгеров. Остальное всё так же.
Теперь в самом боте нам нужно настроить executionTime и перенаправлять запросы на эти классы:

Лучше всего узнать код самому и посмотреть в репозитории, а ещё лучше открыть его через IDE. Этот репозиторий подходит для начала работы и ознакомления, но в качестве бота он недостаточно хорош.

Спринговый бот

Это приобретает больше смысла при работе с экосистемой спринга:

Но я думаю, что, спринг — это хорошая среда не только для энтерпрайза/веб-приложений. Просто он содержит в себе очень много как официальных, так и пользовательских библиотек для своей экосистемы (под спрингом имеется в виду Spring Boot).

И, самое главное, он позволяет реализовать очень много паттернов различными способами, предоставляемыми контейнером.

Реализация

Что ж, приступим к самому боту.

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

Более самостоятельные разработчики могут сразу приступить к чтению кода.

Здесь же я разберу именно чтение команд, хотя в самом репозитории есть ещё пара интересных моментов, которые вы можете рассмотреть самостоятельно.
Реализация очень похожа на бота через Reflections, поэтому аннотации те же.

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

Подведём итоги

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

Если вы приверженец более чистого подхода с нуля даже без JPA, то посмотрите на этого бота, который работает через JDBC через ВК и Телеграм.

Там вы увидите много записей вида:

Но код имеет двухгодичную давность, так что не советую оттуда брать все паттерны. И вообще я бы не рекомендовал таким заниматься вовсе (работу через JDBC).

Также лично мне не особо нравится работать напрямую с Hibernate. Я уже имел печальный опыт писать DAO и HibernateSessionFactoryUtil (те, кто писал, поймут, о чём я).

Что касается самой статьи, я пытался писать кратко, но достаточно, чтобы, имея в руках только эту статью, вы могли начать разработку. Всё-таки это не глава в книге, а статья на Хабре. Глубже изучить аннотации и вообще рефлексию вы сможете сами, например, создавая того же бота.

Всем удачи! И не забывайте о промокоде HABR, который дает дополнительную скидку 10% к той, что указана на баннере.

Источник

Аннотации в Java

Встроенные аннотации

В Java определено много полезных встроенных аннотаций, большинство из их являются специализированными. Аннотации, что имеют общее назначение:

Создание собственных аннотаций:

Аннотации создаются с использование механизма, основанного на интерфейсе. Ниже пример объявление аннотации:

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

Существует 3 политики удержания аннотации. Политика удержания определяет, в какой точке аннотация сбрасывается.

Такие политики инкапсулированы в перечисление java.lang.annotation.RetentionPolicy. Это SOURSE,CLASS,RUNTIME.

Аннотации с политикой SOURCE содержаться только в исходном файле и отбрасываются при компиляции.

Аннотации с политикой Class сохраняются в файле, однако они недоступны JVM во время выполнения.

Аннотации с политикой удержания RUNTIME сохраняются в файле во время компиляции и остаются доступными JVM во время выполнения.

Получение аннотации

Далее используя объект типа Class вы можете получить информацию о различных элементах, объявленных в классе включая аннотацию.

Этот пример использует рефлексию, что бы получить аннотацию MyAnno, ассоциированную с методом myMeth(). В параметры getMethod() передается название метода, который мы желаем получить.

Если Вам понравилась статья, проголосуйте за нее

Голосов: 16 Голосовать

Источник