💆🏾 👩🏽‍🤝‍👨🏿 🚕 एक सार्वभौमिक श्रोता के लिए नुस्खा 💃🏼 👨🏽‍✈️ 🕤

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

समस्या का सार

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

/** *         */ public void addMyObjectListener(IMyObjectListener listener); /** *     */ public void removeMyObjectListener(IMyObjectListener listener);

जहाँ IMyObjectListener एक इंटरफ़ेस है जो इस वस्तु की निगरानी करने की क्षमता निर्धारित करता है, उदाहरण के लिए:

 public interface IMyObjectListener { public void dataAdded(MyObjectEvent event); public void dataRemoved(MyObjectEvent event); public void dataChanged(MyObjectEvent event); }

अवलोकन योग्य वस्तु के लिए वर्णित कार्यक्षमता को लागू करते समय, आपको यह करना होगा:

श्रोताओं की एक सूची (प्रकार IMyObjectListener की वस्तुओं) रखें और addMyObjectListener (IMyObjectListener) को लागू करके और इसे हटाएं।
श्रोता इंटरफेस में परिभाषित प्रत्येक विधि के लिए, टाइप एईईईवेंट (...) के प्रकार की एक विधि प्रदान करें। उदाहरण के लिए, IMyObjectListener प्रकार के श्रोताओं का समर्थन करने के लिए, आपको तीन आंतरिक तरीकों को लागू करना होगा:
- fireDataAdded (MyObjectEvent ईवेंट)
- फ़ायरडॉटरेम (MyObjectEvent ईवेंट)
- फायरडाटाचेंज (MyObjectEvent इवेंट)
ये सभी तरीके उसी तरह से काम करते हैं, जो सभी पंजीकृत श्रोताओं को संबंधित घटना के बारे में सूचनाएं भेजते हैं।
परिवर्तन के ग्राहकों को सूचित करने के लिए जहां भी आवश्यक हो, फायरएक्सएक्सएक्सएक्सएक्स (...) विधियों को कॉल करें।

एक दर्जन या दो दर्जन ऐसी वस्तुओं का कार्यान्वयन काफी बोझ और थकाऊ हो सकता है, क्योंकि आपको अनिवार्य रूप से एक ही कोड लिखना होगा। इसके अलावा, अवलोकनीय व्यवहार के कार्यान्वयन में कई बारीकियों को ध्यान में रखा जाना चाहिए। उदाहरण के लिए:

आपको अवलोकन योग्य वस्तु के बहुआयामी उपयोग की देखभाल करने की आवश्यकता है। किसी भी परिस्थिति में श्रोताओं की सूची की अखंडता और उनके अधिसूचना तंत्र का उल्लंघन नहीं किया जाना चाहिए;
क्या होगा यदि श्रोता में से कोई एक घटना को संसाधित करते समय एक अपवाद फेंकता है?
इसे ट्रैक करना और किसी तरह चक्रीय अलर्ट का जवाब देना आवश्यक है।

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

समाधान का विचार

ऊपर उल्लिखित IMyObjectListener इंटरफ़ेस और ऐसे अन्य इंटरफ़ेस पर विचार करें:

 public interface IListenerSupport<T> { /** *    */ public void addListener(T listener); /** *     */ public void removeListener(T listener); }

क्या होगा यदि हमारे पास एक वर्ग है जो इन दोनों इंटरफेस को इस प्रकार लागू करता है:

 class MyObjectListenerSupport implements IMyObjectListener, IListenerSupport<IMyObjectListener> { public void addListener(IMyObjectListener listener) { // todo:  listener    } public void removeListener(IMyObjectListener listener) { // todo:  listener    } public void dataAdded(MyObjectEvent event) { // todo:      dataAdded } public void dataRemoved(MyObjectEvent event) { // todo:      dataRemoved } public void dataChanged(MyObjectEvent event) { // todo:      dataChanged } }

फिर लक्ष्य वर्ग को इस तरह लागू किया जा सकता है:

 public class MyObject { private MyObjectListenerSupport listeners = new MyObjectListenerSupport(); public void addMyObjectListener(IMyObjectListener listener) { listeners.addListener(listener); } public void removeMyObjectListener(IMyObjectListener listener) { listeners.removeListener(listener); } protected void fireDataAdded(MyObjectEvent event) { listeners.dataAdded(event); } protected void fireDataRemoved(MyObjectEvent event) { listeners.dataRemoved(event); } protected void fireDataChanged(MyObjectEvent event) { listeners.dataChanged(event); } }

प्रस्तावित दृष्टिकोण में, श्रोताओं और सूचनाओं की सूची के प्रबंधन के लिए सभी तर्क एक अलग वर्ग में ले जाया गया है और लक्ष्य अवलोकन योग्य कक्षा बहुत सरल हो गई है। यदि, इसके अलावा, इस वर्ग को भविष्य में विरासत में नहीं माना जाता है, तो फायरएक्सएएनएक्सएक्स (...) विधियों को पूरी तरह से छोड़ा जा सकता है, क्योंकि उनके पास कोड की केवल एक पंक्ति है, जो काफी जानकारीपूर्ण है और सीधे उपयोग की जा सकती है।
अगली उपधारा यह दिखाएगी कि इस मामले को सामान्य मामले तक कैसे बढ़ाया जाए और XXXXListenerSupport जैसी कक्षाओं का लगातार उत्पादन न किया जाए।

सामान्य नुस्खा

सामान्य स्थिति के लिए, गतिशील प्रॉक्सी कक्षाओं के निर्माण के आधार पर, निम्नलिखित दृष्टिकोण प्रस्तावित है।
मैं विशेष रूप से कुछ भी वर्णन नहीं करूंगा, ज्यादातर जावा प्रोग्रामर के लिए यहां सब कुछ स्पष्ट है।

 public class ListenerSupportFactory { private ListenerSupportFactory() {} @SuppressWarnings("unchecked") public static <T> T createListenerSupport(Class<T> listenerInterface) { return (T)Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(), new Class<?>[] { IListenerSupport.class, listenerInterface }, new ListenerInvocationHandler<T>(listenerInterface)); } private static class ListenerInvocationHandler<T> implements InvocationHandler { private final Class<T> _listener_iface; private final Logger _log; private final List<T> _listeners = Collections.synchronizedList(new ArrayList<T>()); private final Set<String> _current_events = Collections.synchronizedSet(new HashSet<String>()); private ListenerInvocationHandler(Class<T> listenerInterface) { _listener_iface = listenerInterface; // todo: find a more sensitive class for logger _log = LoggerFactory.getLogger(listenerInterface); } @SuppressWarnings({"unchecked", "SuspiciousMethodCalls"}) public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { String methodName = method.getName(); // (1) handle IListenerSupport methods if (method.getDeclaringClass().equals(IListenerSupport.class)) { if ("addListener".equals(methodName)) { _listeners.add( (T)args[0] ); } else if ("removeListener".equals(methodName)) { _listeners.remove( args[0] ); } return null; } // (2) handle listener interface if (method.getDeclaringClass().equals(_listener_iface)) { if (_current_events.contains(methodName)) { throw new RuleViolationException("Cyclic event invocation detected: " + methodName); } _current_events.add(methodName); for (T listener : _listeners) { try { method.invoke(listener, args); } catch (Exception ex) { _log.error("Listener invocation failure", ex); } } _current_events.remove(methodName); return null; } // (3) handle all other stuff (equals(), hashCode(), etc.) return method.invoke(this, args); } } }

बस इतना ही।
श्रोता का उपयोग करना, सक्रियण, केवल श्रोता इंटरफ़ेस IMyObjectListener, लक्ष्य अवलोकन वर्ग को निम्न प्रकार से कार्यान्वित किया जाता है:

 public class MyObject { private final MyObjectListener listeners; public MyObject() { listeners = ListenerSupportFactory.createListenerSupport(MyObjectListener.class); } public void addMyObjectListener(IMyObjectListener listener) { ((IListenerSupport<MyObjectListener>)listeners).addListener(listener); } public void removeMyObjectListener(IMyObjectListener listener) { ((IListenerSupport<MyObjectListener>)listeners).removeListener(listener); } /** *  -    **/ public void someSuperBusinessMethod(SuperMethodArgs args) { // todo: perform some cool stuff here //     MyObjectEvent event = new MyObjectEvent(); //    listeners.dataAdded(event); } }

एक सार्वभौमिक श्रोता के लिए नुस्खा

समस्या का सार

समाधान का विचार

सामान्य नुस्खा

More articles: