இயக்க நேரத்தில் சிறுகுறிப்பைச் செயலாக்குகிறது

சிறுகுறிப்புகளை உருவாக்குவது மிகவும் எளிமையான செயலாகும், இருப்பினும் இது சில விதிகளால் வரையறுக்கப்பட்டுள்ளது. அவை என்ன நடைமுறை நோக்கத்திற்காக சேவை செய்கின்றன என்பதை இப்போது நாம் கண்டுபிடிக்க வேண்டும்.

எங்கள் சொந்த சிறுகுறிப்பை எவ்வாறு உருவாக்குகிறோம் என்பதை நினைவில் கொள்வோம்.

வகுப்புகள் மற்றும் முறைகளுக்கான சிறுகுறிப்பை எழுதுவோம், மேலும் குறியீட்டின் ஆசிரியர் மற்றும் பதிப்பு பற்றிய தகவலைக் கொண்டுள்ளோம்:

@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 என்பது ஒரு கம்பைலர் செருகுநிரலாகும், இது ஒரு பெரிய அளவிலான குறியீட்டை மறைப்பதற்கும், மொழியை நீட்டிப்பதற்கும் சிறுகுறிப்புகளைப் பயன்படுத்துகிறது, இதன் மூலம் வளர்ச்சியை எளிதாக்குகிறது மற்றும் சில செயல்பாடுகளைச் சேர்க்கிறது.

லோம்போக்கிலிருந்து சிறுகுறிப்புகளின் உதாரணத்தைக் கவனியுங்கள்:

@ToString
public class Example

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

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

லோம்பாக் இன்னும் பல பயனுள்ள சிறுகுறிப்புகளைக் கொண்டுள்ளது, அவை குறைவாகவே பயன்படுத்தப்படுகின்றன. அதன் எளிமையான சிறுகுறிப்புகளை நாங்கள் பரிசீலித்தோம். அதிகாரப்பூர்வ இணையதளத்தில் திட்டத்தைப் பற்றி மேலும் படிக்கலாம் .