रन टाइम पर एनोटेशन को प्रोसेस करना

एनोटेशन बनाना काफी सरल प्रक्रिया है, हालांकि यह कुछ नियमों द्वारा सीमित है। अब हमें यह पता लगाने की जरूरत है कि वे किस व्यावहारिक उद्देश्य की पूर्ति करते हैं।

आइए याद करें कि हम अपना एनोटेशन कैसे बनाते हैं।

हम एक एनोटेशन लिखेंगे जो कक्षाओं और विधियों के लिए है और इसमें कोड के लेखक और संस्करण के बारे में जानकारी शामिल है:

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

यहां हमारी कक्षाएं हैं जिन्हें हमने एनोटेट किया है:

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

हम रनटाइम पर इस डेटा का उपयोग कैसे कर सकते हैं?

एनोटेशन से मेटाडेटा निकालने के लिए प्रतिबिंब का उपयोग करके। स्मरण करो कि प्रतिबिंब क्या है। प्रतिबिंब रनटाइम पर किसी प्रोग्राम के बारे में डेटा की जांच करने के लिए एक तंत्र है। प्रतिबिंब आपको फ़ील्ड्स, विधियों, वर्ग निर्माणकर्ताओं और कक्षाओं के बारे में जानकारी प्राप्त करने देता है।

हम कक्षा में एनोटेशन पढ़ने के लिए प्रतिबिंब का उपयोग करेंगे और जो जानकारी हम चाहते हैं उसे प्रदर्शित करेंगे।

हम मुख्य विधि में अपनी कक्षाओं से डेटा पढ़ेंगे :

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

हम अपनी कक्षा का एक उदाहरण readMyClass विधि से पास करते हैं।

तब हम एक क्लास के साथ-साथ रीडएनोटेशन मेथड के लिए एक मेथड पास कर सकते हैं। चलिए ऐसा करते हैं — हम एक क्लास ऑब्जेक्ट और एक मेथड ऑब्जेक्ट पास करेंगे। यह एक ऑब्जेक्ट लेता है जो AnnotatedElement इंटरफ़ेस लागू करता है। यह हमें ऑब्जेक्ट से एनोटेशन की सूची प्राप्त करने और उनमें से प्रत्येक के बारे में जानकारी प्राप्त करने देता है।

ध्यान दें कि हमें केवल यह जांचने के बाद जानकारी मिलती है कि एनोटेशन हमारे एनोटेशन प्रकार से संबंधित है या नहीं: if (एनोटेशन इंस्टेंसऑफ इंफो) ।

प्रोग्राम आउटपुट हमें एनोटेशन से पूरी जानकारी देता है:

इस प्रकार, प्रतिबिंब की सहायता से, हम मेटाडेटा निकालने में सक्षम थे।

अब आइए कोड को बेहतर बनाने के लिए एनोटेशन का उपयोग करने का एक उदाहरण देखें, जिसमें सामान्य रूप से पठनीयता, गति और गुणवत्ता बढ़ाना शामिल है। लोम्बोक इसमें हमारी मदद करेगा।

लोम्बोक एक कंपाइलर प्लगइन है जो भारी मात्रा में कोड को छिपाने और भाषा का विस्तार करने के लिए एनोटेशन का उपयोग करता है, जिससे विकास को सरल करता है और कुछ कार्यक्षमता जोड़ता है।

लोम्बोक से एनोटेशन के उदाहरण पर विचार करें:

@ToString
public class Example

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

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

लोम्बोक में कई और उपयोगी एनोटेशन हैं जिनका उपयोग कम बार किया जाता है। हमने इसके सरलतम एनोटेशन पर विचार किया है। आप आधिकारिक वेबसाइट पर परियोजना के बारे में अधिक पढ़ सकते हैं ।