По поводу аннотаций Java я посоветовался с некоторыми людьми вокруг меня, и многие люди сказали:

Я знаю, как им пользоваться, но я не знаком с ним

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

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

Что такое аннотации?

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

Аннотации и отражения очень легко игнорировать в Java, но они очень важны. В мейнстриме Spring их полно аннотаций. Аннотации и аннотации очень похожи. об этом в следующей статье)

Надеюсь, вы обратите внимание на следующие два момента:

1. Комментарии и комментарии очень похожи 2. Комментарии для наших программистов, а комментарии собственно для программ.

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

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

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

Комментарии для программистов, а как насчет комментариев? Разница в одном слове, аннотация для просмотра программой, только сначала запомните.

Дальнейшее понимание аннотаций

Как мы сказали выше, аннотации и аннотации очень похожи Аннотации для нас, а аннотации для программ Предыдущая аннотация проста для понимания Эта аннотация для программ Возможно, вы еще немного запутались Я пойду дальше. пожалуйста, объясни.

Во-первых, интуитивно понятно, что такое аннотация, вроде такой, которую мы написали в коде:

/** * @Description 用户类 * @Author ithuangqing * @Date 2020-07-31 15:33 **/@Repositorypublic class UserBean {    private String name;    private int age;}12345678910

@Repository здесь является аннотацией. Глядя на этот код, на нем есть аннотации. Мы видим аннотации и обнаруживаем, что можем ясно их понять, но, увидев @Repository, мы не так хорошо понимаем. Что это такое и какая польза?

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

Однако, хотя нам это и не ясно, ясно одно, что это такое? Это конкретная программа, то есть специальная программа.Когда она видит, что в UserBean есть @Repository, программа знает, что UserBean нужно загрузить в контейнер Spring, поэтому программист начинает для выполнения ряда операций для загрузки этого UserBean в контейнер Spring.

Итак, вы уже должны понимать:

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

Давайте подытожим, что такое аннотация:

В программе аннотации можно рассматривать как особый вид меток, обычно используемых для обозначения классов, методов или интерфейсов и т. д. Эти метки имеют некоторые характеристики, например, при компиляции (команда javac компилирует исходные файлы java в файл байтового кода класс), когда класс загружается и запускается (при использовании java-команды для выполнения файла байткода начинается жизненный цикл класса, от загрузки до выгрузки) читается (обычно для чтения этих аннотаций есть специальная программа), использовать технологию отражения для разбора аннотаций, а затем выполнять соответствующую обработку в соответствии с полученной информацией)

Да, про аннотации, надо знать такой пункт знаний:

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

Что касается этой программы, это зависит от конкретной сцены, то есть программа отличается, так как же программа узнает, какую аннотацию читать и что делать? Это зависит от определения самой аннотации. Например, Аннотация @Repository определяется как аннотация загружается в контейнер Spring, затем уникальная программа получает аннотацию и знает, что делать.

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

Простая классификация аннотаций

Эта точка знания очень расслабляет и доставляет удовольствие, и вам не нужно терять много клеток мозга.

Аннотации классифицируются, обычно существует три типа аннотаций:

1. Пользовательские аннотации (на самом деле очень мало)
2. Встроенные аннотации JDK (@Override check method override)
3. Аннотации в кадре

Не знаю, можно ли это понять.То есть есть несколько разных категорий для аннотаций.Во-первых, мы можем сами написать аннотацию (о ней будет рассказано ниже), а в самом JDK есть своя аннотация.Возьмем взгляните на код, и вы узнаете:

Например это переписать метод toString.На нем есть встроенная JDK аннотация @Override.Эта аннотация играет роль в проверке,потому что это метод Object.Если вы хотите переписать его сейчас,то имя и параметры.Если вы хотите, чтобы было как раньше, но не так, я выдам вам ошибку.Если вы мне не верите, попробуйте:

Это про встроенную аннотацию JDK, потом последняя аннотация про фреймворк, я думаю вы ее знаете, пока изучили Spring, типа @Controller, знакомы с ним, это аннотация в фреймворке.

Характер аннотаций

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

Позвольте мне сказать вам, суть аннотации - это интерфейс, почему, давайте сначала посмотрим, как определить аннотацию (подробно будет объяснено ниже)

public @interface Main {}12

На этом все, я определяю аннотацию. Не знаю, нашли ли вы ее. Это очень похоже на интерфейс. В чем разница? Там лишний @, иначе это интерфейс. Далее используем XJad для декомпиляции эту аннотацию и см. Смотри:

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

Давайте поговорим об этом сейчас, просто помните!

Как определить аннотации

Далее давайте поговорим о том, как настроить аннотацию. Как мы уже говорили выше, суть аннотации на самом деле представляет собой интерфейс. Вышеприведенное также кратко демонстрирует определение аннотации следующим образом:

public @interface Main {}12

Подумайте об этом, как мы обычно определяем интерфейс, используем ли мы интерфейс ключевого слова, тогда как насчет класса? Используете ли вы ключевое слово класса? То есть для их определения обычно требуется объявление ключевого слова. Очевидно, что ключевое слово для определения аннотации — это @interface, а определение его и интерфейса — это дополнительный @, но аннотация Определение не только это!

метааннотация

Здесь нам нужно ввести понятие мета-аннотаций. Давайте сначала подумаем об этом. Как мы сказали выше, аннотации вообще можно использовать для обозначения классов, интерфейсов или методов и т. д. Тогда здесь возникает проблема. Например, я определил такая основная аннотация:

public @interface Main {}12

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

Итак, как это сделать, ответ — мета-аннотация, так что же такое мета-аннотация?

Мета-аннотации — это аннотации аннотаций разметки.

Что это значит? Давайте посмотрим. Например, аннотацию Main, которую мы определили, мы оговариваем, что она может использоваться только для обозначения методов, поэтому мы можем сделать это:

Мы добавили к нему аннотацию @Target, за которой следуют параметры (описано ниже), этот параметр ElementType.METHOD означает, что наша аннотация используется для аннотирования методов, приходите и пробуйте:

Видите ли, его можно использовать в нашем основном методе, но нельзя ли его использовать в классах? Давай попробуем:

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

Что касается метааннотаций, то обычно выделяют следующие основные:

1. @Documented для документирования
2. @Target указывает место, где используется аннотация. Если он не указан, его можно использовать где угодно.
3. @Retention (политика хранения аннотаций)

Вот отдельное упоминание о последней политике хранения @Retention, объявляющей аннотации, что это значит?

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

Я нарисовал это очень четко, вообще говоря, наши аннотации зарезервированы до времени выполнения, поэтому в целом это выглядит так:

Конечно, это будет решаться в индивидуальном порядке.

На данный момент вы можете обнаружить, что в этой аннотации могут быть параметры? Конечно, это возможно, я кратко продемонстрирую это здесь, вы узнаете это, когда я буду говорить о синтаксисе аннотаций:

Затем посмотрите на использование:

Это на самом деле очень просто!

Базовый синтаксис для использования аннотаций

Далее давайте посмотрим на синтаксис аннотаций, то есть на то, как использовать аннотации.

Для аннотаций мы знаем, как это определить, например, просто определить аннотацию:

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

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

В это время он сообщит об ошибке, сообщая нам, что нам нужно значение значения. На самом деле это легко понять. В вашем определении аннотации определен атрибут значения. Затем вам нужно использовать это значение атрибута при использовании Это. Затем вы говорите мне: «Вы можете не использовать его?» Да, когда вы определяете атрибут аннотации, вам нужно добавить к атрибуту значение по умолчанию, которое выглядит следующим образом:

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

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

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

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

PS: В приведенном выше введении мы обнаружим, что аннотация — это странное место, то есть для аннотаций мы можем определить атрибуты, но атрибуты аннотаций действительно выглядят как методы, но в аннотациях это атрибут, вы можете Непосредственно Задание, здесь нужно обратить внимание!

тип собственности

Атрибуты аннотаций кратко представлены выше, так какие типы значений могут принимать эти атрибуты? Примерно так:

1. базовый тип данных
2. String
3. перечислить
4. Class
5. Тип аннотации
6. Массивы (одномерные массивы вышеуказанных типов)

Для примера массива, такого как этот:

То же самое верно при использовании:

Как правильно понимать аннотации

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

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

Итак, начиная с сегодняшнего дня, я надеюсь, вы помните, что для аннотаций он должен иметь следующие три процесса:

1. определить аннотации
2. использовать аннотации
3. Прочитайте и выполните соответствующий процесс

Давайте посмотрим на эти три процесса с аннотацией @Repository. Первый — определить аннотацию. Мы можем нажать Ctrl в IDEA и щелкнуть @Repository, чтобы увидеть ее, например:

](Woohoo.IT Хуан Цин.VIP/Боюсь-довольный/…)

Это определение аннотации @Repository, затем давайте посмотрим на использование @Repository:

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

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

Но я думаю, вам должно быть так же любопытно, как и мне, почему после добавления аннотации @Repository этот UserBean загружается в контейнер Sring для создания bean-компонента?

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

Итак, здесь, в исходном коде Spring, должна быть какая-то программа или программы, делающие это.

Чтение аннотаций (как работают аннотации)

Вышеизложенное объясняет, как использовать определение аннотаций. Здесь я вынесу чтение аннотаций отдельно. Из-за этого мы понимаем ключевые моменты аннотаций. Многие люди думают, что одна из причин, по которой они не понимают аннотаций, заключается в том, что они неясны после добавления аннотации. Что вы сделали?

То есть, как работают аннотации? Понимание этого очень поможет вам понять аннотации.

Аннотации в основном читаются путем отражения

Для чтения аннотаций это обычно реализуется с помощью технологии отражения. Здесь есть точки знаний. Для отражения он может только прочитать информацию о байт-коде в памяти, а затем запомнить область действия аннотаций, о которых мы упоминали ранее. @Target?

В нем есть несколько основных прицелов, вот эта картинка, давайте рассмотрим:

Для RetentionPolicy.CLASS это относится к этапу байт-кода. В это время файл байт-кода генерируется исходным файлом Java, скомпилированным javac. В это время файл байт-кода класса все еще находится на диске, и в памяти нет .

Отражение может только считывать информацию о байт-коде в памяти, поэтому политика хранения аннотации заключается в том, что этот @Target может быть только RUNTIME, то есть его все еще можно прочитать во время работы.

мое понимание (суть)

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

1. Зачем использовать это таким образом?
2. Каков принцип и как это работает?

Вы думаете, мы просто пишем такое имя аннотации @+ на классе или методе? Как работает продолжение? Здесь вы должны сначала уяснить, что аннотирование состоит из трех шагов:

1. определить аннотации
2. использовать аннотации
3. Читайте аннотации (это то, чего не хватает большинству людей, и это также ключ к тому, чтобы большинство людей не понимали аннотаций)

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

Чтобы понять вышеизложенное, проиллюстрируем это на примере Spring.

Все знают IOC за простоту Spring. Грубо говоря, вам не нужен ваш новый объект. То, что вам нужно, получается непосредственно из контейнера Spring. Затем нам сначала нужно зарегистрировать наши bean-компоненты в контейнере Spring. xml методы конфигурации и метод аннотации, конечно же, мы хотим поговорить здесь о методе аннотации, то есть форме использования имени аннотации @+, для простого примера следующим образом:

Эта аннотация знакома, она предназначена для регистрации нашего класса Person в контейнере Spring, конечно, вот использование этой аннотации, давайте нажмем, чтобы увидеть, как определяется эта аннотация:

Мы должны быть знакомы с этим определением. Это также аннотация для @Component. На самом деле это самая основная аннотация для регистрации классов в контейнере Spring. Позже, как мы говорим сейчас, @Repositoy, @Service и @Controller все на основе @Component.

Тут надо обратить внимание.На самом деле неважно какие из этих аннотаций,надо четко понимать что толку от них,причина зачем нужны эти аннотации это автоматическая регистрация класса на какой класс вы хотите использовать эти аннотации. В контейнере Spring это намного проще, чем писать конфигурацию xml. Мы просто пишем @Repositoy в классе, и он регистрируется в контейнере Spring?

Разве это не удивительно, а потом посмотрите на определение аннотации, оно тоже очень простое, в нем нет ничего, почему оно автоматически прописывается в контейнере Spring?

Помните три шага, чтобы аннотировать раньше? Прежде всего, вам нужно определить аннотацию, а затем использовать аннотацию, то, как работает аннотация, требует, чтобы программа читала аннотацию.Эта аннотация похожа на знак, метку, например, здесь @Repositoy, когда класс аннотируется этим знаком аннотации, то когда уникальная программа читает эту аннотацию, программа знает, о, оказывается, что этот класс должен быть зарегистрирован в контейнере Spring, так как же программа знает, чтобы зарегистрировать этот класс в контейнере Spring ? Вот что говорит @Repositoy. Кроме того, мы знаем, что аннотации обычно могут устанавливать значение атрибута значения, которое можно получить с помощью технологии отражения и т. д., затем это значение атрибута значения может использоваться в конкретном процессе регистрации этого класса в контейнере Spring, например, установка это как имя компонента.

Обычно мы используем аннотации, и пакетное сканирование аннотаций необходимо настроить в файле конфигурации Spring:

<context:component-scan base-package="com.ithuangqing.*"/>1

На самом деле это сканирование, чтобы увидеть, какие классы используют аннотации @Repositoy, а отсканированные требуют специальной обработки, чтобы зарегистрировать их в контейнере Spring. Подумайте об этом, здесь Spring будет фактически анализировать этот тег, основной код:

registerBeanDefinitionParser("component-scan", new ComponentScanBeanDefinitionParser());1

Затем конкретный поток обработки обрабатывается в ComponentScanBeanDefinitionParser, код выглядит следующим образом:

@Override	public BeanDefinition parse(Element element, ParserContext parserContext) {		String basePackage = element.getAttribute(BASE_PACKAGE_ATTRIBUTE);		basePackage = parserContext.getReaderContext().getEnvironment().resolvePlaceholders(basePackage);		String[] basePackages = StringUtils.tokenizeToStringArray(basePackage,				ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS);		// Actually scan for bean definitions and register them.		ClassPathBeanDefinitionScanner scanner = configureScanner(parserContext, element);    //得到扫描器		Set<BeanDefinitionHolder> beanDefinitions = scanner.doScan(basePackages);             //扫描文件，并转化为spring bean，并注册		registerComponents(parserContext.getReaderContext(), beanDefinitions, element);       //注册其他相关组件		return null;	}1234567891011121314

Основная функция приведенного выше кода - сканировать файлы в базовом пакете, затем преобразовать их в структуру bean-компонента в Spring, а затем зарегистрировать их в контейнере...

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

Получить свойства аннотации

Приведенное выше объяснение того, как работают аннотации, очень важно. Его нужно понять. Давайте поговорим о последнем шаге в использовании аннотаций: уникальной программе для чтения аннотаций.

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

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

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

/**是否存在对应 Annotation 对象*/public boolean isAnnotationPresent(Class<? extends Annotation> annotationClass) {    return GenericDeclaration.super.isAnnotationPresent(annotationClass);}/**获取 Annotation 对象*/public <A extends Annotation> A getAnnotation(Class<A> annotationClass) {    return (A) annotationData().annotations.get(annotationClass);}/**获取所有 Annotation 对象数组*/   public Annotation[] getAnnotations() {    return AnnotationParser.toArray(annotationData().annotations);}1234567891011121314151617

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

public class Test {    public static void main(String[] args) throws Exception {        Class<Test> testClass = Test.class;        Method toGetString = testClass.getMethod("toGetString");        //获取注解对象        Main main = toGetString.getAnnotation(Main.class);        System.out.println(main.value());    }    @Main("这是自定义注解的value值")    public static String toGetString() {        return "";    }}123456789101112131415

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

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

Суммировать

На данный момент объяснение аннотаций почти такое же, может быть вы забыли его после прочтения, а можете вообще не читать, но я надеюсь запомнить содержание:

1. определить аннотации
2. использовать аннотации
3. читать аннотации