CodeGym /Java Course /தொகுதி 2: ஜாவா கோர் /இயக்க நேரத்தில் சிறுகுறிப்பைச் செயலாக்குகிறது

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

தொகுதி 2: ஜாவா கோர்
நிலை 18 , பாடம் 4
கிடைக்கப்பெறுகிறது

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

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

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


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

சிறுகுறிப்பு எங்கள் சிறுகுறிப்பு வகையைச் சேர்ந்ததா என்பதைச் சரிபார்த்த பின்னரே எங்களுக்குத் தகவல் கிடைக்கும் என்பதை நினைவில் கொள்ளவும்: என்றால் (தகவலின் சிறுகுறிப்பு நிகழ்வு) .

நிரல் வெளியீடு சிறுகுறிப்புகளிலிருந்து முழுமையான தகவலை நமக்கு வழங்குகிறது:

வகுப்பு: annotation.MyClass1
java.lang இல் சிறுகுறிப்புகளைத் தேடவும். வகுப்பு
ஆசிரியர்: ஆசிரியர்
பதிப்பு: 0.0
java.lang.reflect இல் சிறுகுறிப்புகளைத் தேடவும். முறை
ஆசிரியர்: ஆசிரியர்
பதிப்பு: 0.0

வகுப்பு: annotation.MyClass2
java இல் சிறுகுறிப்புகளைத் தேடவும். வகுப்பு
ஆசிரியர்: ஆசிரியர்
பதிப்பு: 2.0
java.lang.reflect இல் சிறுகுறிப்புகளைத் தேடுங்கள். முறை ஆசிரியர்
: அநாமதேய
பதிப்பு: 0.0

வகுப்பு: annotation.MyClass3 java.lang இல் சிறுகுறிப்புகளைத்
தேடுங்கள் . lang.reflect.Method ஆசிரியர்: அநாமதேய பதிப்பு: 4.0




இதனால், பிரதிபலிப்பு உதவியுடன், மெட்டாடேட்டாவைப் பிரித்தெடுக்க முடிந்தது.

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

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

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

@ToString பொருளின் முழுமையான பிரதிநிதித்துவத்தை உள்ளடக்கிய toString() முறையின் செயலாக்கத்தை உருவாக்குகிறது : வர்க்கத்தின் பெயர், அனைத்து புலங்கள் மற்றும் அவற்றின் மதிப்புகள்.

@ToString
public class Example
@EqualsAndHashCode இயல்புநிலையாக நிலையான மற்றும் நிலையான அல்லாத புலங்களைப் பயன்படுத்தும் சமன்கள் மற்றும் ஹாஷ்கோட் செயல்படுத்தல்களை உருவாக்குகிறது , ஆனால் அவை கட்டமைக்கப்படுகின்றன. மேலும் விவரங்களை திட்டத்தின் இணையதளத்தில் காணலாம் . @EqualsAndHashCode ஐப் பயன்படுத்தும் ஒரு உதாரணத்தை நீங்கள் அங்கு காணலாம் மற்றும் சிறுகுறிப்பு இல்லாமல் ஒரு நிலையான செயலாக்கத்தையும் காண்பீர்கள்.
@Getter / @Setter தனியார் வயல்களுக்கு பெறுபவர்கள் மற்றும் செட்டர்களை உருவாக்குகிறது.

@Getter 
@Setter 
private String name = "name";
@NonNull ஒரு பொருளைத் தூண்டும் போது புலங்கள் பூஜ்யமாக இருக்காது என்பதை வலியுறுத்தப் பயன்படுகிறது. இல்லையெனில், ஒரு NullPointerException தூக்கி எறியப்படும்.

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

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

கருத்துக்கள்
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION