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

Я нашел несколько связанных (не дублированных) вопросов, но они меня не удовлетворили.

Я не могу понять, где и почему использовать custom annotations?

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

@interface MyAnno
{
    String str();
    int val();
}

class MyClass
{
    @MyAnno(str = "Annotation example", val = 100)
    public static void myMeth()
    {
        System.out.println("Inside myMeth()");
    }
}

class CustomAnno
{
    public static void main(String args[])
    {
        MyClass.myMeth();
    }
}

Вывод будет таким, как ожидалось Inside myMeth().

У меня мало вопросов относительно этого примера.

1- Как я могу использовать String str() и int val() в этой программе? ИЛИ

Какое использование абстрактного метода custom annotation?

2- Почему custom annotations. Я имею в виду, какое влияние они оказывают на любой код.

3 Как создать аннотацию, которая имеет такие эффекты, как @override, имеет? (я имею в виду любой вид эффекта, который можно заметить)

Если этот пример для вас бесполезен, пожалуйста, дайте мне подходящий небольшой пример, в котором используется custom annotation.

ОТВЕТЫ

Ответ 1

Вот минимальный пример. Следующий код демонстрирует использование пользовательской аннотации.

Это о сотрудниках и преимуществах. Если у нас есть требование, чтобы BasicBenefits применялось ко всем типам работодателей, тогда мы можем придумать пользовательскую аннотацию, такую ​​как BasicBenefits, и аннотировать все типы реализаций Employee (например, CorporateEmployee, ContractEmployee, ManagerEmployee и т.д.) С помощью BasicBenefits.

Пользовательский класс аннотации (интерфейс)

import java.lang.annotation.*;
@Inherited
@Documented
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)

@interface BasicBenefits {
    String bId() default "B-101";
    String bName() default "General Class A Employee";
}

Класс с использованием пользовательской аннотации (без необходимости импорта):

@BasicBenefits(bId="B-400", bName="General Plus Class A Employee")
public class Employee {
    String eId;
    String eName;
    public Employee(String eId, String eName){
        this.eId = eId;
        this.eName = eName;
    }

    public void getEmployeeDetails(){
        System.out.println("Employee ID: "+eId);
        System.out.println("Employee Name: "+eName);
    }
}

Класс драйвера, чтобы проверить выше.

import java.lang.annotation.Annotation;
public class TestCustomAnnotationBasicBenefits {
    public static void main(String[] args) throws Exception{
        Employee emp = new Employee("E-100", "user3320018");
        emp.getEmployeeDetails();
        Class reflectedClass = emp.getClass();
        Annotation hopeBenefitAnn = reflectedClass.getAnnotation(BasicBenefits.class);
        BasicBenefits bBenefits = (BasicBenefits)hopeBenefitAnn;
        System.out.println("Benefit ID: "+bBenefits.bId());
        System.out.println("Benefit Name: "+bBenefits.bName());
    }
}

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

1.) Нужна ссылка на MyClass 2.) Нужно получить аннотацию, используя отражение от MyClass.

Вот немного измененный код из того, что у вас есть:

@Inherited
@Documented
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnno
{
    String str();
    int val();
}

//using above custom annotation on class level
//can also use method level
//just need to change t @Target(ElementType.METHOD)
@MyAnno(str = "Annotation example", val = 100)
class MyClass
{

    public static void myMeth()
    {
        System.out.println("Inside myMeth()");
    }
}

import java.lang.annotation.Annotation;
class CustomAnno
{
    public static void main(String args[])
    {
        //1. getting reference to the class where the custom annotation is applied.
        //2. then getting the annotation to get the values 
        MyClass myClass = new MyClass();
        Class cls = myClass.getClass();
        Annotation getMyAnno = cls.getAnnotation(MyAnno.class);
        MyAnno myAnno = (MyAnno)getMyAnno;
        MyClass.myMeth(); //left this as is.
        System.out.println("myAnno.str(): "+ myAnno.str());
        System.out.println("myAnno.str(): "+ myAnno.val());     
    }
}

Ответ 2

Три основные причины использования пользовательских аннотаций:

  • Чтобы уменьшить усилие написания кода (процессор компиляции времени аннотации генерирует для вас код). Вот учебник: часть 1, часть 2.
  • Чтобы предоставить дополнительные гарантии корректности (процессор комментариев компиляции предупреждает вас об ошибках). Одним из хороших инструментов для этого является Checker Framework, который предотвращает поиск нулевых указателей, ошибки concurrency и т.д.
  • Чтобы настроить поведение (во время выполнения ваш код проверяет аннотацию с использованием отражения и ведет себя по-разному в зависимости от присутствия аннотации). Такие рамки, как Hibernate, используют аннотации таким образом; также см. статья Oracle.

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

Ответ 3

Абстрактные методы аннотации определяют значения, которые вы можете передать ему (в вашем случае str = "Annotation example", val = 100). Вы можете получить к ним доступ с помощью отражения (Method.<T>getAnnotation(Class<T>)). Пользовательские аннотации не имеют прямого воздействия. Они полезны только при их оценке.

Обратите внимание, что вы должны аннотировать свою пользовательскую аннотацию @Retention(value=RUNTIME), чтобы читать ее с помощью отражения.