कस्टम एनोटेशन प्रीप्रोसेसर - Android- एप्लिकेशन और इंटेलीज आईडीईए में कॉन्फ़िगरेशन के आधार पर निर्माण

सभी को नमस्कार!

हाल ही में, मुझे अपने स्वयं के कस्टम एनोटेशन लिखने और संकलन के दौरान उन्हें संसाधित करने के कार्य का सामना करना पड़ा। पहला सवाल मैंने खुद से पूछा: कहां से शुरू करें? विश्लेषण के बाद, मैंने आपके साथ इस प्रश्न का उत्तर साझा करने का निर्णय लिया।
मुझे लगता है कि यह बताने का कोई मतलब नहीं है कि जावा में क्या एनोटेशन हैं और उनके साथ क्या खाया जाता है, क्योंकि हर युवा प्रोग्रामर इससे परिचित है (और जो इससे परिचित नहीं है, वह इसे अपने दम पर पढ़ सकता है)। इसके अलावा, इस घटना पर एक दिलचस्प तथ्य-खोज लेख है।
लेकिन आज मैं विशेष रूप से एंड्रॉइड एप्लिकेशन में कस्टम एनोटेशन के बारे में बात करना चाहता हूं जो आपके अपने हैंडलर द्वारा प्रोजेक्ट के संकलन के दौरान संसाधित किए जाते हैं और उन पर आधारित ऑटो-पीढ़ी की कक्षाओं के बारे में। और इसके साथ ही, मैं आपको बताता हूं कि कैसे जल्दी से सब कुछ IDEA में सेट किया जाए (मैं खुद संस्करण 12.1 का उपयोग करता हूं, शायद दूसरों में मतभेद हैं)।

कार्यान्वयन के लिए, हमें 2 परियोजनाओं की आवश्यकता है: पहले में, हम अपने कस्टम एनोटेशन और उनके हैंडलर का वर्णन करेंगे, इसमें से हम एक जार फाइल तैयार करेंगे, जिसे हम दूसरे टेस्ट प्रोजेक्ट से कनेक्ट करेंगे, जो हमारे एनोटेशन का उपयोग करेगा।

चरण 1

हम एक नया पुस्तकालय प्रोजेक्ट बनाते हैं जिसमें हम अपने एनोटेशन का वर्णन करते हैं। एक एनोटेट वर्ग कुछ इस तरह दिखता है:

@Target(ElementType.METHOD) @Retention(RetentionPolicy.SOURCE) public @interface CustomAnnotation { String className(); String value() default "Hello"; int type() default 0; } 

@ रिटेंशन कहता है कि हमारा एनोटेशन केवल सोर्स कोड में मौजूद होगा और कंपाइलर द्वारा खारिज किया जाएगा (और उस क्षण तक हम इसे प्रोसेस करेंगे)।

चरण 2

हम सीधे अपना एनोटेशन प्रोसेसर बनाते हैं। यह एक वर्ग है जो AbstractProcessor का विस्तार करता है। हम उसे बताते हैं कि वह सभी एनोटेशन को संसाधित करेगा और इस तरह से स्रोत फ़ाइलों के समर्थित संस्करण को इंगित करेगा:

 @SupportedAnnotationTypes({"*"}) @SupportedSourceVersion(SourceVersion.RELEASE_6) public class CustomProcessor extends AbstractProcessor { } 

अगला, हम प्रक्रिया विधि को फिर से परिभाषित करते हैं, जिसमें हम एक नया वर्ग उत्पन्न करने के लिए तर्क लिखते हैं। मेरा तरीका इस तरह दिखता है:

 @Override public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) { for (Element e : roundEnv.getElementsAnnotatedWith(CustomAnnotation.class)) { CustomAnnotation ca = e.getAnnotation(CustomAnnotation.class); String name = e.getSimpleName().toString(); char[] c = name.toCharArray(); c[0] = Character.toUpperCase(c[0]); name = new String(name); TypeElement clazz = (TypeElement) e.getEnclosingElement(); try { JavaFileObject f = processingEnv.getFiler(). createSourceFile(clazz.getQualifiedName() + "Autogenerate"); processingEnv.getMessager().printMessage(Diagnostic.Kind.NOTE, "Creating " + f.toUri()); Writer w = f.openWriter(); try { String pack = clazz.getQualifiedName().toString(); PrintWriter pw = new PrintWriter(w); pw.println("package " + pack.substring(0, pack.lastIndexOf('.')) + ";"); pw.println("\npublic class " + clazz.getSimpleName() + "Autogenerate {"); TypeMirror type = e.asType(); pw.println("\n public " + ca.className() + " result = \"" + ca.value() + "\";"); pw.println(" public int type = " + ca.type() + ";"); pw.println("\n protected " + clazz.getSimpleName() + "Autogenerate() {}"); pw.println("\n /** Handle something. */"); pw.println(" protected final void handle" + name + "(" + ca.className() + " value" + ") {"); pw.println("\n//" + e); pw.println("//" + ca); pw.println("\n System.out.println(value);"); pw.println(" }"); pw.println("}"); pw.flush(); } finally { w.close(); } } catch (IOException x) { processingEnv.getMessager().printMessage(Diagnostic.Kind.ERROR, x.toString()); } } return true; } 

इस स्तर पर, आप कल्पना को चालू कर सकते हैं और लिख सकते हैं कि आपकी दिल की इच्छाएं (अच्छी तरह से, या क्या आवश्यक है =)। जब आप एनोटेशन प्रोसेसर के साथ समाप्त हो जाते हैं और अपने सभी कस्टम एनोटेशन का वर्णन करते हैं, तो आपको इस प्रोजेक्ट से एक जार फ़ाइल जेनरेट करनी होगी। आइडिया 12 में, यह काफी सरलता से किया गया है: प्रोजेक्ट सेटिंग्स -> कलाकृतियां -> ऐड -> जार -> मॉड्यूल से ... अगला, बिल्ड -> प्रोजेक्ट का पुनर्निर्माण करें और प्रोजेक्ट के आउटपुट डायरेक्टरी में हमारी उत्पन्न जार फ़ाइल ढूंढें।

चरण 3

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

 public class MyActivity extends Activity { public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); } @CustomAnnotation(className = "String", type = 1) public void annotatedMethod(String value) { } } 

याद रखें कि हमने अपने एनोटेशन @Target(ElementType.METHOD) इंगित किया है, जिसका अर्थ है कि हम केवल विधि से पहले इसे पंजीकृत कर सकते हैं।

चरण 4

अब कहते हैं कि आइडिया हमारे एनोटेशन प्रोसेसर का उपयोग करता है और जादू काम करना शुरू कर देगा! ऐसा करने के लिए, कंपाइलर -> एनोटेशन प्रोसेसर अनुभाग में सेटिंग्स पर जाएं। हम एनोटेशन प्रसंस्करण को सक्षम करते हैं , प्रोसेसर पथ क्षेत्र में हमारी उत्पन्न जार फ़ाइल के लिए पथ निर्दिष्ट करते हैं। इसके अलावा प्रोसेसर FQ नाम विंडो में, उस वर्ग का पूरा नाम दर्ज करें जो प्रसंस्करण के लिए जिम्मेदार है। हमारे मामले में, यह एक कस्टमप्रोसेसर है। भरी हुई खिड़की कुछ इस तरह दिखनी चाहिए।

चरण 5

हम बिल्ड -> प्रोजेक्ट का पुनर्निर्माण करते हैं और परिणामों का आनंद लेते हैं। उत्पन्न फ़ोल्डर प्रोजेक्ट ट्री में दिखाई देना चाहिए, जिसमें नई फाइलें झूठ होंगी।
यहाँ मुझे क्या मिला है:

 public class MyActivityAutogenerate { public String result = "Hello"; public int type = 1; protected MyActivityAutogenerate() {} /** Handle something. */ protected final void handleannotatedMethod(String value) { //annotatedMethod(java.lang.String) //@com.example.AnnotationsProcessor.CustomAnnotation(type=1, value=Hello, className=String) System.out.println(value); } } 

हैप्पी कोडिंग!