मैंने प्रतिबिंब का उपयोग करके जावा में कॉलबैक / प्रतिनिधि समर्थन लागू किया है। विवरण और कार्य स्रोत मेरी वेबसाइट पर उपलब्ध हैं ।
यह काम किस प्रकार करता है
WithParms नाम के नेस्टेड क्लास के साथ कॉलबैक नाम का एक सिद्धांत वर्ग है। जिस API को कॉलबैक की आवश्यकता है, वह एक कॉलबैक ऑब्जेक्ट को एक पैरामीटर के रूप में लेगा और यदि neccessary है, तो एक कॉलबैक .Parms विधि चर के रूप में बनाएं। चूंकि इस ऑब्जेक्ट के बहुत सारे अनुप्रयोग पुनरावर्ती होंगे, यह बहुत सफाई से काम करता है।
प्रदर्शन के साथ मेरे लिए अभी भी एक उच्च प्राथमिकता है, मैं हर आह्वान के लिए मापदंडों को रखने के लिए एक भगोड़ा वस्तु सरणी बनाने के लिए आवश्यक नहीं होना चाहता था - आखिरकार एक बड़ी डेटा संरचना में हजारों तत्व हो सकते हैं, और एक संदेश प्रसंस्करण में परिदृश्य हम अंत में हजारों डेटा संरचनाओं के प्रसंस्करण को समाप्त कर सकते हैं।
थ्रेडसेफ़ होने के लिए, पैरामीटर सरणी को एपीआई विधि के प्रत्येक आह्वान के लिए विशिष्ट रूप से मौजूद होना चाहिए, और दक्षता के लिए कॉलबैक के प्रत्येक आह्वान के लिए उसी का उपयोग किया जाना चाहिए; मुझे दूसरी वस्तु की आवश्यकता थी, जो मंगलाचरण के लिए एक पैरामीटर सरणी के साथ कॉलबैक को बांधने के लिए बनाने के लिए सस्ता होगा। लेकिन, कुछ परिदृश्यों में, इनवॉकर में पहले से ही अन्य कारणों के लिए पैरामीटर सरणी होगी। इन दो कारणों से, पैरामीटर सरणी कॉलबैक ऑब्जेक्ट में नहीं है। इसके अलावा आह्वान का विकल्प (मापदंडों को एक सरणी के रूप में या व्यक्तिगत वस्तुओं के रूप में पारित करना) एपीआई के हाथों में होता है जो कॉलबैक का उपयोग करके सक्षम बनाता है जो भी मंगलाचरण का उपयोग करता है वह अपने आंतरिक कामकाज के लिए सबसे उपयुक्त है।
WithParms नेस्टेड क्लास है, तब, वैकल्पिक है और दो उद्देश्यों को पूरा करता है, इसमें कॉलबैक इनवोकेशन के लिए आवश्यक पैरामीटर ऑब्जेक्ट सरणी है, और यह 10 ओवरलोडेड इनवोक () विधियों (1 से 10 मापदंडों के साथ) प्रदान करता है जो पैरामीटर सरणी को लोड करते हैं और फिर कॉलबैक लक्ष्य प्राप्त करें।
निर्देशिका ट्री में फ़ाइलों को संसाधित करने के लिए कॉलबैक का उपयोग करके एक उदाहरण निम्न है। यह एक प्रारंभिक सत्यापन पास है जो सिर्फ फाइलों को प्रोसेस करने के लिए गिनता है और यह सुनिश्चित करता है कि कोई पूर्व निर्धारित अधिकतम आकार से अधिक न हो। इस मामले में हम बस एपीआई इनवोकेशन के साथ कॉलबैक इनलाइन बनाते हैं। हालाँकि, हम लक्ष्य पद्धति को एक स्थिर मूल्य के रूप में दर्शाते हैं ताकि प्रतिबिंब हर बार न हो।
static private final Method COUNT =Callback.getMethod(Xxx.class,"callback_count",true,File.class,File.class);
...
IoUtil.processDirectory(root,new Callback(this,COUNT),selector);
...
private void callback_count(File dir, File fil) {
if(fil!=null) { // file is null for processing a directory
fileTotal++;
if(fil.length()>fileSizeLimit) {
throw new Abort("Failed","File size exceeds maximum of "+TextUtil.formatNumber(fileSizeLimit)+" bytes: "+fil);
}
}
progress("Counting",dir,fileTotal);
}
IoUtil.processDirectory ():
/**
* Process a directory using callbacks. To interrupt, the callback must throw an (unchecked) exception.
* Subdirectories are processed only if the selector is null or selects the directories, and are done
* after the files in any given directory. When the callback is invoked for a directory, the file
* argument is null;
* <p>
* The callback signature is:
* <pre> void callback(File dir, File ent);</pre>
* <p>
* @return The number of files processed.
*/
static public int processDirectory(File dir, Callback cbk, FileSelector sel) {
return _processDirectory(dir,new Callback.WithParms(cbk,2),sel);
}
static private int _processDirectory(File dir, Callback.WithParms cbk, FileSelector sel) {
int cnt=0;
if(!dir.isDirectory()) {
if(sel==null || sel.accept(dir)) { cbk.invoke(dir.getParent(),dir); cnt++; }
}
else {
cbk.invoke(dir,(Object[])null);
File[] lst=(sel==null ? dir.listFiles() : dir.listFiles(sel));
if(lst!=null) {
for(int xa=0; xa<lst.length; xa++) {
File ent=lst[xa];
if(!ent.isDirectory()) {
cbk.invoke(dir,ent);
lst[xa]=null;
cnt++;
}
}
for(int xa=0; xa<lst.length; xa++) {
File ent=lst[xa];
if(ent!=null) { cnt+=_processDirectory(ent,cbk,sel); }
}
}
}
return cnt;
}
यह उदाहरण इस दृष्टिकोण की सुंदरता को दिखाता है - एप्लिकेशन विशिष्ट लॉजिक कॉलबैक में सारगर्भित है, और एक डायरेक्टरी ट्री घूमने के नशे में पूरी तरह से पुन: प्रयोज्य स्थैतिक उपयोगिता विधि में अच्छी तरह से टक गया है। और हमें हर नए उपयोग के लिए इंटरफ़ेस को परिभाषित करने और लागू करने की कीमत बार-बार चुकानी नहीं पड़ती है। बेशक, तर्क के लिए , लेकिन व्यवहार में मैं नहीं मिला है यह कॉलबैक परिभाषा सही पाने के लिए एक समस्या हो - एक अंतरफलक यह (यह लागू है बस दस्तावेज नहीं) कहीं अधिक क्या लागू करने के बारे में स्पष्ट है।
एक इंटरफ़ेस को परिभाषित करना और लागू करना वास्तव में इतना बुरा नहीं है (जब तक कि आप एप्लेट वितरित नहीं कर रहे हैं, जैसा कि मैं हूं, जहां वास्तव में अतिरिक्त कक्षाएं बनाने से बचा जाता है) मायने रखता है, लेकिन जहां यह वास्तव में चमकता है जब आपके पास एक एकल वर्ग में कई कॉलबैक होते हैं। न केवल उन्हें एक अलग आंतरिक वर्ग में एक अलग धक्का दिया जा रहा है जो तैनात अनुप्रयोग में उपरि से जोड़ा गया है, लेकिन यह प्रोग्राम के लिए सर्वथा थकाऊ है और यह सब बॉयलर-प्लेट कोड वास्तव में सिर्फ "शोर" है।
