CodeGym /Java tanfolyam / /Annotáció feldolgozása futási időben

Annotáció feldolgozása futási időben

Szint , Lecke
Elérhető

A kommentárok létrehozása meglehetősen egyszerű folyamat, bár bizonyos szabályok korlátozzák. Most azt kell kitalálni, hogy milyen gyakorlati célt szolgálnak.

Emlékezzünk vissza, hogyan hozzuk létre saját kommentárunkat.

Írunk egy megjegyzést, amely osztályokra és metódusokra vonatkozik, és információkat tartalmaz a kód szerzőjéről és verziójáról:


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

Itt vannak az általunk jegyzett osztályaink:


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

Hogyan használhatjuk fel ezeket az adatokat futás közben?

Reflexió segítségével metaadatok kinyerésére a megjegyzésekből. Emlékezzünk vissza, mi a tükröződés. A tükrözés egy olyan mechanizmus, amellyel a program futás közbeni adatait vizsgálja. A Reflexió segítségével információkat kaphat a mezőkről, metódusokról, osztálykonstruktorokról és osztályokról.

Reflexiót használunk az osztály megjegyzéseinek elolvasásához és a kívánt információk megjelenítéséhez.

Az osztályaink adatait a metódusban olvassuk be:


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

Osztályunk egy példányát átadjuk a readMyClass metódusnak.

Ezután egy osztályt és egy metódust is átadhatunk a readAnnotation metódusnak. Tegyük meg – átadunk egy Class objektumot és egy Method objektumot. Egy objektumot vesz igénybe, amely megvalósítja az AnnotatedElement felületet. Ez lehetővé teszi, hogy egy listát kapjunk az objektum megjegyzéseiről, és mindegyikről információt kapjunk.

Ne feledje, hogy csak azután kapunk információkat, miután ellenőriztük, hogy az annotáció a mi megjegyzéstípusunkhoz tartozik-e: if (annotation instanceof Info) .

A program kimenete teljes információt ad a megjegyzésekből:

Osztály: annotation.MyClass1
Jegyzetek keresése java.lang.Class
Szerző: Szerző
Verzió: 0.0
Annotációk keresése a java.lang.reflect.Method
Szerző: Szerző
Verzió: 0.0

Osztály: annotation.MyClass2
Annotation keresése a java.lang nyelven. Osztály
Szerző: Szerző
Verzió: 2.0
Jegyzetek keresése a java.lang.reflect.Methodban
Szerző: Anonymous
Verzió: 0.0

Osztály: annotation.MyClass3
Jegyzetek keresése a java.lang.Class
Szerző: Anonymous
Version: 2.0
Megjegyzések keresése a java nyelven. lang.reflect.Method
Szerző: Anonymous
Verzió: 4.0

Így a reflexió segítségével kinyerhettük a metaadatokat.

Most nézzünk egy példát a megjegyzések használatára a kód javítására, beleértve az olvashatóság, a sebesség és általában a minőség javítását. Ebben Lombok lesz a segítségünkre.

A Lombok egy olyan fordítóbővítmény, amely megjegyzésekkel rejti el a hatalmas mennyiségű kódot és bővíti a nyelvet, ezáltal leegyszerűsíti a fejlesztést és hozzáad bizonyos funkciókat.

Vegyünk egy példát a Lombok-jegyzetekre:

@ToString Létrehozza a toString() metódus megvalósítását , amely az objektum alapos ábrázolásából áll: az osztálynév, az összes mező és értékeik.

@ToString
public class Example
@EqualsAndHashCode Egyenlő és hashCode implementációit hoz létre , amelyek alapértelmezés szerint nem statikus és nem statikus mezőket használnak, de konfigurálhatók. További részletek a projekt honlapján találhatók . Itt talál egy példát, amely az @EqualsAndHashCode kódot használja , és egy szabványos implementációt is mutat, megjegyzés nélkül.
@Getter / @Setter Gettereket és settereket generál a privát mezőkhöz.

@Getter 
@Setter 
private String name = "name";
@NonNull Arra használják, hogy kijelentsék, hogy a mezők nem nullák, amikor egy objektumot példányosítanak. Ellenkező esetben egy NullPointerException kerül kidobásra.

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

Lombokon sokkal több hasznos megjegyzés található, amelyeket ritkábban használnak. Megfontoltuk a legegyszerűbb megjegyzéseit. A projektről bővebben a hivatalos weboldalon olvashat .

Hozzászólások
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION