verwenden von benutzerdefinierten Anmerkungen

Ist hier ein minimal-Beispiel. Der folgende code veranschaulicht die Verwendung des benutzerdefinierten annotation.

Ist es, über Mitarbeiter und Leistungen. Wenn wir eine Anforderung haben, so dass BasicBenefits die angewendet werden, um alle Arten von verkaufsangestellten, dann können wir kommen mit benutzerdefinierten annotation wie BasicBenefits, und kommentieren Sie alle Arten von Mitarbeiter-Implementierungen (z.B. CorporateEmployee, ContractEmployee, ManagerEmployee etc. etc.) mit der BasicBenefits.

Benutzerdefinierten Annotation-Klasse(interface)

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

Klasse mit dem benutzerdefinierten annotation(nicht importiert):

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

Fahrer Klasse zu testen, die oben genannten.

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

Ihr code Aussehen fast da, nur zwei Dinge, die enthalten sein müssen in der main-Methode.

1.) Müssen Referenz auf MyClass
2.) Brauchen, um die Anmerkung mit der spiegelung von MyClass.

Hier ist ein wenig modifiziert-code aus, was Sie haben:

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

Von nutzen sein, Annotationen müssen analysiert werden, ersten. Die integrierte Anmerkungen (wie @Override oder @FunctionalInterface zu nennen-die meisten offensichtlichen) analysiert werden, indem der compiler selbst. Für individuelle Anmerkungen, diese Jungs sind Häufig analysiert, die von Drittanbieter-frameworks, obwohl wir können auch die reflection-Mechanismus, um zu demonstrieren, wurde diese Technik im standalone-code.

Durch ein Beispiel, der folgende code ändert sein Verhalten zur Laufzeit abhängig vom Wert des Feldes erklärt werden in der benutzerdefinierten annotation namens @SwitchingAnnotation:

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

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@interface SwitchingAnnotation{
    boolean flag();
}

public class Worker{
    void doThis(){ System.out.println("Doing this"); }
    void doThat(){ System.out.println("Doing that"); }
    @SwitchingAnnotation(
        flag = false
    )
    public void work(boolean flag) {
        if (flag) doThis();
        else doThat();
    }
}

class Test{
    public static void main(String[] args) {
        try{
            SwitchingAnnotation sw = Worker.class.getMethod("work", boolean.class)
                                                 .getAnnotation(SwitchingAnnotation.class);

            new Worker().work(sw.flag());    //prints Doing that
        }
        catch(NoSuchMethodException nsme){
            System.out.println(nsme);
        }
    }
}