Как и где аннотации используются в Java?

Каковы основные области, в которых мы можем использовать аннотации? Является ли эта функция заменой конфигурации на основе XML?

Аннотации - это мета-мета-объекты, которые можно использовать для описания других мета-объектов . Мета-объекты - это классы, поля и методы. Запрос объекта для его мета-объекта (например anObj.getClass()) называется интроспекцией . Самоанализ может пойти дальше, и мы можем спросить мета-объект, каковы его аннотации (например aClass.getAnnotations). Самоанализ и аннотации относятся к тому, что называется рефлексией и метапрограммированием .

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

Обработка аннотаций является очень мощным механизмом и может использоваться различными способами:

• описать ограничения или использование элемента: например @Deprecated, @Override, или@NotNull
• описать «природу» элемента, например @Entity, @TestCase, @WebService
• описать поведение элемента: @Statefull, @Transaction
• описать, как обрабатывать элемент: @Column, @XmlElement

Во всех случаях аннотация используется для описания элемента и уточнения его значения .

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

Использование аннотаций:

• Документация, например, XDoclet
• компиляция
• IDE
• Среда тестирования, например, JUnit
• Контейнер IoC, например, как Spring
• Сериализация, например, XML
• Аспектно-ориентированное программирование (AOP), например Spring AOP
• Серверы приложений, например, контейнер EJB, веб-сервис
• Объектно-реляционное отображение (ORM), например Hibernate, JPA
• и многое другое ...

... посмотрите, например, на проект Lombok , который использует аннотации, чтобы определить, как генерировать equalsили hashCodeметоды.

Существует множество приложений для аннотаций Java. Прежде всего, они могут использоваться компилятором (или расширениями компилятора). Рассмотрим, например, аннотацию Override :

class Foo {

    @Override public boolean equals(Object other) {
        return ...;
    }
}

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

class Foo {

    @Override public boolean equals(Foo other) {  // Compiler signals an error for this one
        return ...;
    }
}

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

public void processSomething(@NotNull String text) {
    ...
}

что позволяет компилятору предупреждать вас о неправильном / непроверенном использовании переменных и нулевых значений.

Другое более продвинутое приложение для аннотаций включает в себя отражение и обработку аннотаций во время выполнения. Это (я думаю) то, что вы имели в виду, когда говорите об аннотациях как о «замене конфигурации на основе XML». Этот вид обработки аннотаций используется, например, различными платформами и стандартами JCP (постоянство, внедрение зависимостей, вы называете это) для предоставления необходимых метаданных и информации о конфигурации.

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

• JUnit 4 - вы добавляете @Testаннотацию к каждому методу тестирования, который вы хотите запустить JUnit. Есть также дополнительные аннотации для настройки тестирования (например, @Beforeи @BeforeClass). Все они обрабатываются бегуном JUnit, который соответствующим образом запускает тесты. Можно сказать, что это замена конфигурации XML, но аннотации иногда более мощные (например, они могут использовать отражение), а также они ближе к коду, на который ссылаются ( @Testаннотация находится прямо перед тестовым методом, поэтому цель этот метод понятен - также служит документацией). Конфигурация XML, с другой стороны, может быть более сложной и включать гораздо больше данных, чем аннотации.

• Терракота - использует как аннотации, так и файлы конфигурации XML. Например, @Rootаннотация сообщает среде выполнения Terracotta, что аннотированное поле является корневым и его память должна быть распределена между экземплярами виртуальной машины. Файл конфигурации XML используется для настройки сервера и указания ему, какие классы использовать.

• Google Guice - примером может служить @Injectаннотация, которая при применении к конструктору заставляет среду исполнения Guice искать значения для каждого параметра на основе определенных инжекторов. @InjectАннотаций будет довольно трудно воспроизвести с помощью конфигурационных файлов XML, а также его близости к конструктору он ссылается на весьма полезно (представьте себе, искать в огромный файл XML , чтобы найти все инъекции зависимостей , которые вы установили).

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

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

Эта функция часто используется библиотеками и SDK (hibernate, JUnit, Spring Framework), чтобы упростить или уменьшить объем кода, который программист мог бы использовать для работы с этими библиотеками или SDK. Поэтому справедливо сказать, что аннотации и Отражение работы рука об руку в Java.

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

Driver.java

package io.hamzeen;

import java.lang.annotation.Annotation;

public class Driver {

    public static void main(String[] args) {
        Class<TestAlpha> obj = TestAlpha.class;
        if (obj.isAnnotationPresent(IssueInfo.class)) {

            Annotation annotation = obj.getAnnotation(IssueInfo.class);
            IssueInfo testerInfo = (IssueInfo) annotation;

            System.out.printf("%nType: %s", testerInfo.type());
            System.out.printf("%nReporter: %s", testerInfo.reporter());
            System.out.printf("%nCreated On: %s%n%n",
                    testerInfo.created());
        }
    }
}

TestAlpha.java

package io.hamzeen;

import io.hamzeen.IssueInfo;
import io.hamzeen.IssueInfo.Type;

@IssueInfo(type = Type.IMPROVEMENT, reporter = "Hamzeen. H.")
public class TestAlpha {

}

IssueInfo.java

package io.hamzeen;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * @author Hamzeen. H.
 * @created 10/01/2015
 * 
 * IssueInfo annotation definition
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface IssueInfo {

    public enum Type {
        BUG, IMPROVEMENT, FEATURE
    }

    Type type() default Type.BUG;

    String reporter() default "Vimesh";

    String created() default "10/01/2015";
}

Это замена для конфигурации на основе XML?

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

Есть 2 вида аннотаций

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

2. По мнению поставщика, представление аннотации процессором является более легковесным «интерфейсом», ваша программа сталкивается с НЕКОТОРЫМ, но без явного «реализации» конкретного интерфейса (здесь, то есть аннотации)

например, в jpa вы определяете что-то вроде

@Entity class Foo {...}

вместо того

class Foo implements Entity {...}

оба говорят одно и то же "Foo - это класс Entity"

Где можно использовать аннотации

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

Обновление Java SE 8: аннотации также могут применяться к использованию типов. Вот некоторые примеры:

• Выражение создания экземпляра класса:

  new @Interned MyObject ();

• Тип актерского состава:

  myString = (@NonNull String) str;

• реализует пункт:

  Класс UnmodifiableList реализует @Readonly List <@Readonly T> {...}

• Брошенное исключение:

  void monitorTempera () создает @Critical TemperatureException {...}

Такие фреймворки, как Hibernate, требовали много конфигурации / сопоставления, интенсивно использует аннотации.

Взгляните на Hibernate Аннотации

JPA (из Java EE 5) является отличным примером (чрезмерного) использования аннотаций. Java EE 6 также представит аннотации во многих новых областях, таких как веб-сервисы RESTful и новые аннотации для каждого старого доброго API сервлета.

Вот несколько ресурсов:

• Sun - API персистентности Java
• Учебник по Java EE 5 - JPA
• Представляем платформу Java EE 6 (проверьте все три страницы).

Это не только особенности конфигурации, которые могут / могут быть приняты аннотациями, но они также могут использоваться для управления поведением. Это хорошо видно в примерах JAX-RS для Java EE 6.

Это полезно для аннотирования ваших классов, либо на уровне метода, класса или поля, что-то об этом классе, которое не совсем связано с классом.

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

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

Это просто еще один инструмент, у него много целей.

Он добавляет дополнительную информацию о коде с помощью (а) проверки компилятора или (б) анализа кода

**

• Ниже приведены встроенные аннотации :: 2 типа

**

Тип 1) Аннотации, применяемые к Java-коду:

@Override // gives error if signature is wrong while overriding.
Public boolean equals (Object Obj) 

@Deprecated // indicates the deprecated method
Public doSomething()....

@SuppressWarnings() // stops the warnings from printing while compiling.
SuppressWarnings({"unchecked","fallthrough"})

Тип 2) Аннотации, применяемые к другим аннотациям:

@Retention - Specifies how the marked annotation is stored—Whether in code only, compiled into the class, or available at run-time through reflection.

@Documented - Marks another annotation for inclusion in the documentation.

@Target - Marks another annotation to restrict what kind of java elements the annotation may be applied to

@Inherited - Marks another annotation to be inherited to subclasses of annotated class (by default annotations are not inherited to subclasses).

**

• Пользовательские аннотации ::

** http://en.wikipedia.org/wiki/Java_annotation#Custom_annotations

ДЛЯ ЛУЧШЕГО ПОНЯТИЯ ПОПРОБУЙТЕ НИЖЕ ССЫЛКУ: РАЗРАБОТАТЬ С ПРИМЕРАМИ

http://www.javabeat.net/2007/08/annotations-in-java-5-0/

Аннотации могут использоваться как альтернатива внешним файлам конфигурации, но не могут считаться полной заменой. Вы можете найти много примеров, когда annotationi использовались для замены файлов конфигурации, таких как Hibernate, JPA, EJB 3 и почти все технологии, включенные в Java EE.

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

Аннотации гораздо больше подходят для украшения исходного кода дополнительной информацией, которая инструктирует инструменты обработки, как во время компиляции, так и во время выполнения, обрабатывать классы и структуры классов особым образом. @Overrideи JUnit's @Testявляются хорошими примерами такого использования, подробно объясненного в других ответах.

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

Java EE 5 поддерживает использование аннотаций поверх конфигурации XML. Например, в EJB3 атрибуты транзакции в методе EJB указываются с помощью аннотаций. Они даже используют аннотации, чтобы пометить POJO как EJB и указать конкретные методы как методы жизненного цикла, вместо того, чтобы требовать реализации интерфейса.

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

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

Читайте подробно на аннотации Java .

Ниже приведены некоторые места, где вы можете использовать аннотации.

a. Annotations can be used by compiler to detect errors and suppress warnings
b. Software tools can use annotations to generate code, xml files, documentation etc., For example, Javadoc use annotations while generating java documentation for your class.
c. Runtime processing of the application can be possible via annotations.
d. You can use annotations to describe the constraints (Ex: @Null, @NotNull, @Max, @Min, @Email).
e. Annotations can be used to describe type of an element. Ex: @Entity, @Repository, @Service, @Controller, @RestController, @Resource etc.,
f. Annotation can be used to specify the behaviour. Ex: @Transactional, @Stateful
g. Annotation are used to specify how to process an element. Ex: @Column, @Embeddable, @EmbeddedId
h. Test frameworks like junit and testing use annotations to define test cases (@Test), define test suites (@Suite) etc.,
i. AOP (Aspect Oriented programming) use annotations (@Before, @After, @Around etc.,)
j. ORM tools like Hibernate, Eclipselink use annotations

Вы можете обратиться по этой ссылке для более подробной информации об аннотациях.

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