Bearbetar annotering vid körning

Att skapa kommentarer är en ganska enkel process, även om den begränsas av vissa regler. Nu måste vi ta reda på vilket praktiskt syfte de tjänar.

Låt oss komma ihåg hur vi skapar vår egen anteckning.

Vi kommer att skriva en kommentar som är för klasser och metoder och som innehåller information om kodens författare och version:

@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface Info {
   String author() default "Author";
   String version() default "0.0";
}

Här är våra klasser som vi kommenterade:

@Info
public class MyClass1 {
   @Info
   public void myClassMethod() {}
}

@Info(version = "2.0")
public class MyClass2 {
   @Info(author = "Anonymous")
   public void myClassMethod() {}
}

@Info(author = "Anonymous", version = "2.0")
public class MyClass3 {
   @Info(author = "Anonymous", version = "4.0")
   public void myClassMethod() {}
}

Hur kan vi använda denna data under körning?

Genom att använda reflektion för att extrahera metadata från kommentarer. Kom ihåg vad reflektion är. Reflektion är en mekanism för att undersöka data om ett program under körning. Reflektion låter dig få information om fält, metoder, klasskonstruktörer och klasser.

Vi använder reflektion för att läsa kommentarerna i en klass och visa den information vi vill ha.

Vi läser data från våra klasser i huvudmetoden :

import java.lang.annotation.Annotation;
import java.lang.reflect.AnnotatedElement;
import java.lang.reflect.Method;

public class Main {
   public static void main(String[] args) throws NoSuchMethodException {
       readMyClass(MyClass1.class);
       readMyClass(MyClass2.class);
       readMyClass(MyClass3.class);
   }

   static void readMyClass(Class<?> myClassObj) throws NoSuchMethodException {
       System.out.println("\nClass: " + myClassObj.getName());
       readAnnotation(myClassObj);
       Method method = myClassObj.getMethod("myClassMethod");
       readAnnotation(method);
   }

   static void readAnnotation(AnnotatedElement element) {
       try {
           System.out.println("Search for annotations in " + element.getClass().getName());
           Annotation[] annotations = element.getAnnotations();
           for (Annotation annotation : annotations) {
               if (annotation instanceof Info) {
                   final Info fileInfo = (Info) annotation;
                   System.out.println("Author: " + fileInfo.author());
                   System.out.println("Version: " + fileInfo.version());
               }
           }
       } catch (Exception e) {
           e.printStackTrace();
       }
   }
}

Vi skickar en instans av vår klass till readMyClass -metoden.

Sedan kan vi skicka en klass såväl som en metod till readAnnotation -metoden. Låt oss göra det — vi skickar ett klassobjekt och ett metodobjekt. Det tar ett objekt som implementerar gränssnittet AnnotatedElement . Detta låter oss få en lista med kommentarer från objektet och få information om var och en av dem.

Observera att vi bara får information efter att ha kontrollerat om anteckningen tillhör vår anteckningstyp: if (anteckningsinstans av Info) .

Programutgången ger oss fullständig information från anteckningarna:

Med hjälp av reflektion kunde vi alltså extrahera metadata.

Låt oss nu titta på ett exempel på hur du använder annoteringar för att förbättra koden, inklusive ökad läsbarhet, hastighet och kvalitet i allmänhet. Lombok hjälper oss med detta.

Lombok är ett kompilatorplugin som använder anteckningar för att dölja en enorm mängd kod och utöka språket, och därigenom förenkla utvecklingen och lägga till en del funktionalitet.

Betrakta ett exempel på kommentarer från Lombok:

@ToString
public class Example

@Getter
@Setter
private String name = "name";

public Example(@NonNull P p) {
 super("Hello");
 this.name = p.getName();
}

Lombok har många fler användbara kommentarer som används mindre ofta. Vi har övervägt dess enklaste anteckningar. Du kan läsa mer om projektet på den officiella hemsidan .