ఉల్లేఖనాలను సృష్టించడం అనేది చాలా సులభమైన ప్రక్రియ, అయితే ఇది కొన్ని నియమాల ద్వారా పరిమితం చేయబడింది. ఇప్పుడు అవి ఏ ఆచరణాత్మక ప్రయోజనం కోసం పనిచేస్తాయో మనం గుర్తించాలి.
మన స్వంత ఉల్లేఖనాన్ని ఎలా సృష్టించాలో గుర్తుచేసుకుందాం.
మేము తరగతులు మరియు పద్ధతుల కోసం ఉల్లేఖనాన్ని వ్రాస్తాము మరియు కోడ్ యొక్క రచయిత మరియు సంస్కరణకు సంబంధించిన సమాచారాన్ని కలిగి ఉన్నాము:
@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 పద్ధతికి పాస్ చేస్తాము.
అప్పుడు మనం రీడ్అనోటేషన్ పద్ధతికి ఒక క్లాస్తో పాటు ఒక పద్ధతిని కూడా పాస్ చేయవచ్చు . అలా చేద్దాం — మేము క్లాస్ ఆబ్జెక్ట్ మరియు మెథడ్ ఆబ్జెక్ట్ని పాస్ చేస్తాము. ఇది ఉల్లేఖన ఎలిమెంట్ ఇంటర్ఫేస్ను అమలు చేసే వస్తువును తీసుకుంటుంది . ఇది ఆబ్జెక్ట్ నుండి ఉల్లేఖనాల జాబితాను పొందేందుకు మరియు వాటిలో ప్రతి దాని గురించి సమాచారాన్ని పొందడానికి అనుమతిస్తుంది.
ఉల్లేఖన మా ఉల్లేఖన రకానికి చెందినదో కాదో తనిఖీ చేసిన తర్వాత మాత్రమే మేము సమాచారాన్ని పొందుతామని గమనించండి: if (సమాచారం యొక్క ఉల్లేఖన ఉదాహరణ) .
ప్రోగ్రామ్ అవుట్పుట్ ఉల్లేఖనాల నుండి మాకు పూర్తి సమాచారాన్ని అందిస్తుంది:
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.మెథడ్ రచయిత: అనామక వెర్షన్: 4.0
అందువలన, ప్రతిబింబం సహాయంతో, మేము మెటాడేటాను సంగ్రహించగలిగాము.
ఇప్పుడు కోడ్ను మెరుగుపరచడానికి ఉల్లేఖనాలను ఉపయోగించడం యొక్క ఉదాహరణను చూద్దాం, ఇందులో సాధారణంగా చదవగలిగే, వేగం మరియు నాణ్యతను పెంచడం వంటివి ఉన్నాయి. Lombok ఈ విషయంలో మాకు సహాయం చేస్తుంది.
లాంబాక్ అనేది కంపైలర్ ప్లగ్ఇన్, ఇది భారీ మొత్తంలో కోడ్ను దాచడానికి మరియు భాషను విస్తరించడానికి ఉల్లేఖనాలను ఉపయోగిస్తుంది, తద్వారా అభివృద్ధిని సులభతరం చేస్తుంది మరియు కొంత కార్యాచరణను జోడిస్తుంది.
లాంబాక్ నుండి ఉల్లేఖనాల ఉదాహరణను పరిగణించండి:
@ToString | ఆబ్జెక్ట్ యొక్క సమగ్ర ప్రాతినిధ్యంతో కూడిన toString() పద్ధతి యొక్క అమలును రూపొందిస్తుంది : తరగతి పేరు, అన్ని ఫీల్డ్లు మరియు వాటి విలువలు. |
|
@EqualsAndHashCode | డిఫాల్ట్గా నాన్-స్టాటిక్ మరియు నాన్-స్టాటిక్ ఫీల్డ్లను ఉపయోగించే ఈక్వల్లు మరియు హ్యాష్కోడ్ అమలులను రూపొందిస్తుంది , కానీ కాన్ఫిగర్ చేయవచ్చు. | మరిన్ని వివరాలను ప్రాజెక్ట్ వెబ్సైట్లో చూడవచ్చు . అక్కడ మీరు @EqualsAndHashCodeని ఉపయోగించే ఒక ఉదాహరణను కనుగొంటారు మరియు ఉల్లేఖన లేకుండా ప్రామాణిక అమలును కూడా చూపుతారు. |
@గెట్టర్ / @సెట్టర్ | ప్రైవేట్ ఫీల్డ్ల కోసం గెట్టర్లు మరియు సెట్టర్లను ఉత్పత్తి చేస్తుంది. |
|
@NonNull | ఆబ్జెక్ట్ ఇన్స్టాంటియేట్ అయినప్పుడు ఫీల్డ్లు శూన్యం కాదని నొక్కి చెప్పడానికి ఉపయోగిస్తారు. లేకపోతే, ఒక NullPointerException విసిరివేయబడుతుంది. |
|
లాంబాక్లో చాలా ఉపయోగకరమైన ఉల్లేఖనాలు తక్కువ తరచుగా ఉపయోగించబడతాయి. మేము దాని సరళమైన ఉల్లేఖనాలను పరిగణించాము. మీరు అధికారిక వెబ్సైట్లో ప్రాజెక్ట్ గురించి మరింత చదువుకోవచ్చు .
GO TO FULL VERSION