Java Custom Annotations
Аннотация Java - это некоторая мета -информация, прикрепленная к коду, которая используется для анализа и использования некоторых инструментов во время компиляции и времени выполнения, и служат функциями объяснения и конфигурации.
Аннотация не будут и не могут влиять на фактическую логику кода и играть только вспомогательную роль. Включено в пакет java.lang.annotation.
1. Мета
Метанотация относится к аннотации аннотации. В том числе четыре типа: @retention @Target @Document @Inhyted.
1.1. @Retention: Определите стратегию удержания аннотаций
@Retention (hardententpolicy.source) // Аннотация существует только в исходном коде и не содержит @retention (artententypolicy.class) // Политика удержания по умолчанию используется. Аннотация будет существовать в файле байт -кодов класса, но ее нельзя получить во время выполнения. @Retention (hardententpolicy.runtime) // Аннотация будет существовать в файле байт -кода класса и может быть получена посредством отражения во время выполнения.
Класс аннотаций:
@Retention (hestentionpolicy.runtime) // Аннотация будет существовать в файле класса Bytecode. @Target ({elementType.field, elementType.method} может быть получено посредством отражения при выполнении // определить цель аннотации ** Диапазон поля и константы перечисления/метод @документирован // указывать, что аннотация будет включена в javadoc public @Interface fieldme {/***. false;/*** Имя поля* @return*/string name () default "";/**** 0;} Класс сущности:
открытый класс anno {@fieldmeta (id = true, name = "serial number", order = 1) private int id; @fieldmeta (name = "name", order = 3) private string name; @fieldmeta (name = "Age", order = 2) private int age; @fieldmeta (description = "description", order = 4) public string desc () ebute return inte test test of return in everse retember in efort in efort int in in in in in in efet uptation id;} public void setId (int id) {this.id = id;} public string getName () {return name;} public void setName (string name) {this.name = name;} public int getage () {return Age;} public void setage (int age) {this.age = ege;}}}}}}}} Получите класс помощи для аннотации:
Public Class Sortablefield {public ortablefield () {} public sortablefield (fieldmeta meta, field field) {super (); this.meta = meta; this.field = field; this.name = field.getname (); this.type = field.gettype ();} public sortablefield (fieldmet meta, string name, class <?> type); meta; this.name = name; this.type = type;} private fieldmeta meta; поля частного поле; getName () {return name;} public void setName (string name) {this.name = name;} public class <?> getType () {return type;} public void settype (class <?> type) {this.Type = type;}} Чтобы получить аннотации во время выполнения, сначала создайте базовый класс:
Public Class Parent <t> {private class <t> entity; public parent () {init ();}@spistresswarnings ("unchecked") public list <sortablefield> init () {list <sortablefield> list = new Arraylist <sortablefield> ();/** getClass (). GetGenericSuperClass (). (класс, интерфейс, примитивный тип или void) *, а затем преобразует его в параметризованный тип. Полем * GetActualtyPearguments () Возвращает массив объектов типа, представляющие фактические параметры типа этого типа. * [0] - первый в этом массиве. Полем * Короче говоря, это получить фактический тип общих параметров суперкласса. Полем */entity = (class <t>) (((параметризованнаятипе) this.getClass (). getGenericSuperClass ()). getActualtyPearguments () [0]; // FieldMeta filed = entity.getAnnotation (FieldMet.Class); if (this.Entity! Поля, но не включайте унаследованные поля* entity.getFields (); Возвращает только все доступные общедоступные поля класса или интерфейса, представленные объектом*в классе GetDeclared ** () Метод возвращает поля, методы и т. Д. Со всеми разрешениями доступа; * См. API * */field [] fields = entity.getDeclaredFields (); // for (Field F: Fields) {// Получить аннотацию, содержащую Fieldmeta FieldMetta Meta = F.Getannotation (FieldMeta.Class); if (meta! Все доступные публичные методы класса или интерфейса, представленные методом объекта [] methods = entity.getMethods (); Для (Метод M: Методы) {FieldMeta meta = m.getannotation (fieldmeta.class); if (meta! = null) {SortableField SF = new SortableField (meta, m.getName (), m.getReturnType ()); list.add (sf);}} // этот метод создать новый интерфейс для реализации для реализации Comportor Compare. Для реализации Comportor -Compare Compraor Compartor -Comprast Comprator. Сортировка // collections.sort (list, new Fieldsortcom ()); collections.sort (список, новый компаратор <sortablefield> () {@overridepublic int compare (sortablefield s1, sortablefield s2) {return s1.getmeta (). order ()-s2.getmeta (). order (); // return (). s1.getName (). Compareto (s2.getName ()); // Вы также можете использовать сравнение для сравнения}});} return List;}} Создайте подкласс, чтобы наследовать базовый класс:
Public Class Child расширяет родитель <anno> {} Тестовый класс:
Общедоступный класс Testannotation {@suppresswarnings ({"unchecked", "ravtypes"}) public void main (string [] args) {родитель c = new Child (); list <sortablefield> list = c.init (); // get the Annotation в классе в Generics // Выходной "+l.getName ()+"/t Тип поля: "+l.getType ()+"/t Имя аннотации: "+l.getMeta (). name ()+"/t Аннотация Описание: "+l.getMeta (). description ());}}}//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1. Принцип работы аннотации:
JDK5.0 предоставляет функциональность аннотации, позволяя разработчикам определять и использовать свои собственные типы аннотаций. Эта функция состоит из синтаксиса, который определяет тип аннотации и синтаксис, который описывает объявление аннотации, API, который считывает аннотацию, файл класса, который использует аннотацию для изменения и инструмент обработки аннотаций.
Аннотация напрямую не влияет на семантику кода, но ее можно рассматривать как инструмент или библиотека классов программы. Это, в свою очередь, окажет некоторое влияние на семантику программы бега.
Аннотация может быть прочитана различными способами с помощью механизма отражения во время выполнения.
2. Аннотация @override:
Java.lang
Переопределение типа комментария
@Target (значение = метод)
@Retention (значение = источник)
public @Interface переопределение означает, что объявление метода намеревается переопределить другое объявление метода в суперклассе. Если метод аннотирует этот тип аннотации, но не переопределяет метод Superclass, компилятор генерирует сообщение об ошибке.
Аннотация @Override означает, что подкласс должен переопределить соответствующий метод родительского класса.
Переопределение - это маркерная аннотация, используемая для идентификации аннотации. Само имя аннотации представляет информацию, которая будет предоставлена для программы инструментов.
Вот пример с использованием аннотации @Override:
класс A {Private String Id; A (String id) {this.id = id; } @Override public String toString () {return id; }}3. @deprecated Annotation:
Java.lang
Тип комментариев устарел
@Documented
@Retention (значение = время выполнения)
Общественные элементы программы Public @Interface, аннотированные с @Deprecated, программисты не поощряют использование таких элементов, как правило, потому что это опасно или есть лучшие варианты. Компилятор предупреждает при использовании неутвержденных элементов программы или выполнения переписываний в неутвержденном коде.
@Deprecated Метод представления аннотаций не рекомендуется.
Умеренное маркерное аннотация.
Вот пример с использованием аннотации @Deprecated:
класс A {Private String Id; A (String id) {this.id = id; } @Deprecated public void execute () {System.out.println (id); } public static void main (string [] args) {a a = new a ("a123"); A.Execute (); }}4. @suppresswarnings аннотация:
Java.lang
Комментарии Типов Пресс -Парнингс
@Target (value = {type, поле, метод, параметр, конструктор, local_variable})
@Retention (значение = источник)
Public @Interface SuppressWarnings указывает, что указанное предупреждение компилятора должно быть незамечено в элементе комментария (и все элементы программы, содержащиеся в этом элементе комментария). Обратите внимание, что набор предупреждений, которые не используются в данном элементе, является суперсетом всех предупреждений, которые не обезглавлены в элементе. Например, если вы прокомментируете класс, чтобы снять предупреждение и аннотировать метод, чтобы не схватить другое предупреждение, оба предупреждения будут нераспределены в этом методе.
В зависимости от стиля, программисты всегда должны использовать эту аннотацию на внутренних вложенных элементах, и это будет работать только в случае использования там. Если вы хотите снять предупреждение в определенном методе, вы должны прокомментировать метод вместо его класса.
@Suppresswarnings аннотация указывает на предупреждение о подавлении.
Вот пример с использованием аннотации @suppresswarnings:
@Suppresswarnings ("unchecked") public static void main (string [] args) {list list = new ArrayList (); list.add ("abc");}5. Пользовательские аннотации:
При использовании @Interface для пользовательских аннотаций, интерфейс java.lang.annotation.annotation автоматически унаследован, а другие детали автоматически завершаются компилятором. При определении аннотаций другие аннотации или интерфейсы не могут быть унаследованы.
Настройте самый простой комментарий:
public @Interface myannotation {} Используйте пользовательскую аннотацию: открытый класс AnnotationTest2 {@myannotation public void execute () {System.out.println ("method"); }} 5.1. Добавить переменные:
public @Interface myannotation {string value1 ();} Использовать пользовательские аннотации: открытый класс AnnotationTest2 {@myannotation (value1 = "abc") public void execute () {system.out.println ("method"); }}Когда имя атрибута, используемое в аннотации, является значением, интерфейс значения атрибута может быть записан непосредственно без указания имени атрибута при его назначении; За исключением неожиданных имен переменных значений, все имена переменных должны быть назначены с помощью name = value.
5.2. Добавить значения по умолчанию:
public @Interface myannotation {string value1 () default "abc";}5.3. Многомерное перечисление использования:
public @Interface myannotation {string value1 () default "abc"; Myenum value2 () default myenum.sunny;} enum myenum {Sunny, дождливый} Используйте пользовательские аннотации:
открытый класс AnnotationTest2 {@myannotation (value1 = "a", value2 = myenum.sunny) public void execute () {system.out.println ("method"); }} 5.4. Переменные массива:
public @Interface myannotation {string [] value1 () default "abc";} Используйте пользовательские аннотации:
открытый класс AnnotationTest2 {@myannotation (value1 = {"a", "b"}) public void execute () {system.out.println ("method"); }}6. Установите сферу применения аннотации:
@Documented
@Retention (значение = время выполнения)
@Target (value = annotation_type)
Общественное удержание @Interface указывает, как долго следует сохранить аннотация типа аннотации. Если аннотация удержания не существует в объявлении типа комментариев, политика удержания по умолчанию по умолчанию hareverypolicy.class.
Целевые мета -комментарии действительны только тогда, когда тип комментирования метада используется напрямую для комментариев. Если тип комментариев мета используется в качестве члена другого типа комментариев, он недействителен.
Public Enum arsentpolicy
Распространяет Enum <serententpolicy> Политику удержания комментариев. Константы для этого типа перечисления описывают различные стратегии для хранения комментариев. Они используются с типами мета -комментариев, чтобы указать, как долго сохраняются аннотации.
СОРТ
Компилятор будет регистрировать комментарии в файле класса, но виртуальная машина не должна хранить комментарии во время выполнения.
Время выполнения
Компилятор будет записывать комментарии в файле класса, а виртуальная машина сохранит комментарии во время выполнения, поэтому его можно отразить.
ИСТОЧНИК
Комментарии, чтобы отказаться от компилятора. Аннотация @retention может обеспечить политику удержания аннотаций для компиляторов при определении аннотаций.
Аннотация, принадлежащая к политике удержания класса, - это @suppresswarnings, которая не будет храниться в файле .class.
6.1. Примеры использования в пользовательских аннотациях:
@Retention (hardententpolicy.class) public @interface myannotation {string [] value1 () default "abc";}7. Пример использования отражения для чтения информации о аннотации политики сохранения времени:
java.lang.reflect
Интерфейс аннотации
Все известные классы реализации:
Доступный объем, класс, конструктор, поле, метод, пакет представляет собой закомментированный элемент программы, которая в настоящее время работает в этой виртуальной машине. Этот интерфейс позволяет рефлексивно прочитать комментарии. Все комментарии, возвращаемые методами на этом интерфейсе, являются неизменными и сериализуемыми. Вызывающий абонент может изменить массив, возвращаемый аксессуаром назначенного перечисленного массива; Это не повлияет на массив, возвращенный другими абонентами.
Если метод в этом интерфейсе возвращает комментарий (прямо или косвенно), содержащий назначенного члена класса, который ссылается на класс, который не доступен в этой виртуальной машине, пытаясь прочитать класс, вызывая метод, возвращенный соответствующим классом в возвращенном комментарии, приведет к типенотпрессантиксации.
IsannotationPresent
Boolean Isannotationpresent (Class <? Extends Annotation> AnnotationClass) возвращает true, если комментарий указанного типа существует в этом элементе, в противном случае возвращает False. Этот метод в основном разработан для облегчения доступа к комментариям тегов.
Параметр:
AnnotationClass - объект класса, соответствующий типу аннотации
возвращаться:
Верните True, если в этом объекте существует комментарий указанного типа комментария, в противном случае неверно
Бросать:
NullPointerException - если данный класс аннотации является нулевым
Начните со следующей версии:
1.5
заталкивание
<T Extends Annotation> T Getannotation (класс <t> AnnotationClass) возвращает эти комментарии, если есть комментарии указанного типа этого элемента, в противном случае возвращается NULL.
Параметр:
AnnotationClass - объект класса, соответствующий типу аннотации
возвращаться:
Если в этом объекте существуют комментарии указанного типа комментариев элемента, эти комментарии возвращаются, в противном случае NULL
Бросать:
NullPointerException - если данный класс аннотации является нулевым
Начните со следующей версии:
1.5
Getnanotations
Аннотация [] getAnnotations () возвращает все комментарии, которые существуют в этом элементе. (Если этот элемент не будет прокомментирован, возвращается массив нуля длины.) Вызывающий абонент метода может изменить возвращенный массив по желанию; Это не повлияет на массив, возвращенный другими абонентами.
возвращаться:
Все комментарии, которые существуют в этом элементе
Начните со следующей версии:
1.5
GetDeclaredAnnations
Аннотация [] getDeclaredAnnotations () Возвращает все комментарии, которые существуют непосредственно на этом элементе. В отличие от других методов в этом интерфейсе, этот метод игнорирует унаследованные аннотации. (Если не существует комментариев непосредственно в этом элементе, возвращается массив нуля длины.) Вызывающий абонент метода может изменить возвращенный массив по желанию; Это не повлияет на массив, возвращенный другими абонентами.
возвращаться:
Все комментарии, которые существуют непосредственно на этом элементе
Начните со следующей версии:
1.5
Вот пример использования отражения для чтения информации о аннотации политики сохранения времени:
Пользовательские аннотации:
@Retention (hestententpolicy.runtime) public @interface myannotation {string [] value1 () default "abc";} Используйте пользовательские аннотации:
открытый класс AnnotationTest2 {@myannotation (value1 = {"a", "b"}) @deprecated public void execute () {system.out.println ("method"); }} Прочитайте информацию в аннотации:
Public Static void Main (String [] args) выбрасывает SecurityException, nosuchmethodexception, allodalargumentException, allogalaccessexception, vococationTargetException {annotationTest2 AnnotationTest2 = new AnnotationTest2 (); // getClass экземпляр AnnotationTest2Class <AnnotationTest2> c = AnnotationTest2.class; // getMethoDinStance Метод метода = c.getMethod ("execute", новый класс [] {}); // Определите, содержит ли метод аннотацию myannotation if (method.isannotationpresent (myannotation.class)) {// Получить экземпляр аннотации Myannotation этого метода myannotation myannotation = method.getannotation (myannotation.class); // Выполнить метод метода.invoke (annotationTest2, new Object [] {}); // Получить myannotation string [] value1 = myannotation.value1 (); System.out.println (value1 [0]); } // Получить все аннотации на аннотации метода [] аннотации = method.getannotations (); Для (аннотация аннотации: аннотации) {System.out.println (аннотация); }}8. Использование ограниченных аннотаций:
Ограниченные аннотации используют @Target.
@Documented
@Retention (значение = время выполнения)
@Target (value = annotation_type)
Public @Interface Target указывает тип элементов программы, к которым применяется тип аннотации. Если в объявлении типа комментариев не существует целевой мета -комментария, объявленный тип может использоваться в любом элементе программы. Если существует такой комментарий мета, компилятор обеспечивает указанный предел использования. Например, этот метал -комментарий указывает на то, что тип объявления сам по себе, то есть тип комментирования мета. Его можно использовать только в объявлениях типа комментариев:
@Target (elementtype.annotation_type) public @Interface MetaAnanotationType {...} Этот метал -комментарий указывает на то, что тип объявления может использоваться только в качестве типов членов в объявлениях типа сложных аннотаций. Его нельзя использовать напрямую для комментариев:
@Target ({}) public @Interface membertype {...} Это ошибка времени компиляции, которая указывает на то, что константа elementtype появляется более одного раза в целевом комментарии. Например, следующие мета -комментарии являются незаконными:
@Target ({elementtype.field, elementtype.method, elementtype.field}) public @Interface Bogus {...} public enum ementtypeExtends enum <lementtype> Тип элемента программы. Константы этого типа перечисления обеспечивают простую классификацию элементов, объявленных в программе Java.
Эти константы используются с типом целевого мета -комментария, чтобы указать, при каких обстоятельствах законно использовать тип комментариев.
Annotation_type
Объявление типа комментариев
КОНСТРУКТОР
Оператор метода конструктора
ПОЛЕ
Полевой объявление (включая константы перечисления)
Local_variable
Локальная переменная объявление
Метод
Метод оператор
УПАКОВКА
Заявление пакета
Параметр
Объявление параметров
ТИП
Класс, интерфейс (включая типы комментариев) или объявление об перечислении
Примеры ограничений на использование аннотаций:
@Target (elementType.method) public @Interface myannotation {string [] value1 () default "abc";}9. Добавьте примечания в справочный документ:
Чтобы добавить информацию о аннотации в файл API при создании файла Javadoc, вы можете использовать java.lang.annotation.documented.
Объявить документ аннотации сборки в пользовательской аннотации:
@DocumentedPublic @Interface myannotation {string [] value1 () default "abc";} Используйте пользовательские аннотации:
открытый класс AnnotationTest2 {@myannotation (value1 = {"a", "b"}) public void execute () {system.out.println ("method"); }}10. Используйте наследование в аннотациях:
По умолчанию аннотации не унаследованы в подклассы. Вы можете добавить Java.lang.annotation.inhydated Annotation Declaration при использовании пользовательских аннотаций.
@Documented
@Retention (значение = время выполнения)
@Target (value = annotation_type)
Public @Interface Унаследован указывает на то, что тип аннотации автоматически унаследован. Если в объявлении типа комментариев существует унаследованная мета -аннотация, и пользователь запрашивает тип комментариев в объявлении класса, и нет комментариев этого типа в объявлении класса, тип комментариев будет автоматически запросить в суперклассе класса. Этот процесс повторяется до тех пор, пока этот тип комментариев не будет найден или достигнут верхний уровень иерархии классов. Если ни у Superclass не есть аннотация такого типа, запрос будет указывать на то, что текущий класс не имеет такой аннотации.
Обратите внимание, что если вы используете тип аннотации для комментариев, кроме класса, этот тип мета -комментария является недействительным. Также обратите внимание, что этот Meta Comment только облегчает наследство комментариев от SuperClasses; Это неверно для комментариев к реализованным интерфейсам.
В приведенной выше статье кратко рассказывается об индивидуальных аннотациях Java и об использовании размышлений для получения аннотаций во время выполнения - это все контент, которым я делюсь с вами. Я надеюсь, что это может дать вам ссылку, и я надеюсь, что вы сможете поддержать Wulin.com больше.