uso di annotazioni personalizzate

Question

Ho trovato diverse domande correlate (non duplicate) a questo, ma non mi soddisfacevano.

Non riesco a capire dove e perché utilizzare custom annotations?

Ho letto un esempio di annotazione personalizzata in un libro, ma non è stato spiegato a fondo.

@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(); 
    } 
} 

L'uscita è come previsto Inside myMeth().

Ho alcune domande su questo esempio.

1- Come posso usare String str() e int val() in questo programma? OR

A cosa serve un metodo astratto di custom annotation?

2- Perché custom annotations. Intendo dire quale effetto stanno avendo su qualsiasi codice.

3- Come posso creare un'annotazione che sta avendo effetti come @Override sta avendo? (Intendo qualsiasi tipo di effetto che può essere notato)

Se questo esempio è inutile per voi, allora per favore dammi un piccolo esempio adatto in cui viene utilizzato un custom annotation.

Answer 1

I metodi astratti dell'annotazione definiscono i valori che è possibile passare ad esso (nel tuo caso str = "Annotation example", val = 100). È possibile accedervi utilizzando la riflessione (Method.<T>getAnnotation(Class<T>)). Le annotazioni personalizzate non hanno impatto diretto. Sono utili solo se li valuti.

Si noti che è necessario annotare l'annotazione personalizzata con @Retention(value=RUNTIME) per poterlo leggere tramite la riflessione.

Answer 2

Ecco un esempio minimo. Il seguente codice dimostra l'uso di annotazioni personalizzate.

Riguarda Dipendenti e Benefici. Se abbiamo un requisito tale che BasicBenefits deve essere applicato a tutti i tipi di datori di lavoro, allora possiamo presentare annotazioni personalizzate come Basic Benefits e annotare tutti i tipi di implementazioni dei Dipendenti (ad esempio CorporateEmployee, ContractEmployee, ManagerEmployee, ecc. Ecc.) Con il BasicBenefits.

personalizzato Classe Annotazione (interfaccia)

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"; 
} 

Classe usando l'annotazione personalizzato (non c'è bisogno di nessun importazioni):

@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); 
    } 
} 

classe Driver prova quanto sopra.

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()); 
    } 
} 

Il codice sembra quasi, solo due cose devono essere inclusi nel metodo principale.

1.) Necessità riferimento alla MyClass 2.) necessario per ottenere l'annotazione utilizzando la riflessione da MyClass.

Qui è un po 'di codice modificato da quello che hai:

@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());  
    } 
} 

Answer 3

Tre ragioni principali per usare le annotazioni personalizzate sono:

• per ridurre lo sforzo di scrivere codice (una di compilazione il processore dell'annotazione dell'ora genera il codice per te). Ecco un tutorial: part 1, part 2.
• Fornire ulteriori garanzie di correttezza (un processore di annotazione in fase di compilazione avvisa in caso di errori). Uno strumento utile per questo è il Checker Framework, che impedisce i riferimenti negativi ai puntatori, gli errori di concorrenza e altro ancora.
• Per personalizzare il comportamento (in fase di esecuzione, il codice controlla l'annotazione utilizzando il riflesso e si comporta in modo diverso a seconda che l'annotazione sia presente). Framework come Hibernate utilizzano le annotazioni in questo modo; anche vedere un Oracle article.

In ogni caso, l'uso di annotazioni riduce la probabilità di errori nel codice, rispetto ad altri approcci non di annotazione.