रन टाइमवर भाष्यावर प्रक्रिया करत आहे

भाष्ये तयार करणे ही अगदी सोपी प्रक्रिया आहे, जरी ती काही नियमांद्वारे मर्यादित आहे. ते कोणते व्यावहारिक उद्देश पूर्ण करतात हे आता आपण शोधले पाहिजे.

आपण आपले स्वतःचे भाष्य कसे तयार करतो ते आठवूया.

आम्ही एक भाष्य लिहू जे वर्ग आणि पद्धतींसाठी आहे आणि कोडच्या लेखक आणि आवृत्तीबद्दल माहिती असेल:

@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 इंटरफेस लागू करते. हे आपल्याला ऑब्जेक्टवरून भाष्यांची सूची मिळवू देते आणि त्या प्रत्येकाबद्दल माहिती मिळवू देते.

लक्षात घ्या की भाष्य आमच्या भाष्य प्रकाराचे आहे की नाही हे तपासल्यानंतरच आम्हाला माहिती मिळते: जर (माहितीचे भाष्य उदाहरण) .

प्रोग्राम आउटपुट आम्हाला भाष्यांमधून संपूर्ण माहिती देते:

अशा प्रकारे, प्रतिबिंबाच्या मदतीने, आम्ही मेटाडेटा काढू शकलो.

आता सामान्यत: वाचनीयता, गती आणि गुणवत्ता वाढविण्यासह, कोड सुधारण्यासाठी भाष्ये वापरण्याचे उदाहरण पाहू. Lombok आम्हाला यामध्ये मदत करेल.

Lombok एक कंपाइलर प्लगइन आहे जे मोठ्या प्रमाणात कोड लपवण्यासाठी आणि भाषा वाढवण्यासाठी भाष्ये वापरते, ज्यामुळे विकास सुलभ होतो आणि काही कार्यक्षमता जोडली जाते.

लोम्बोकमधील भाष्यांचे उदाहरण विचारात घ्या:

@ToString
public class Example

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

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

लोम्बोकमध्ये अनेक उपयुक्त भाष्ये आहेत जी कमी वेळा वापरली जातात. आम्ही त्याची सर्वात सोपी भाष्ये विचारात घेतली आहेत. आपण अधिकृत वेबसाइटवर प्रकल्पाबद्दल अधिक वाचू शकता .