कोड की 0/35/निष्पादित शाखाओं की लंबी सूची के लिए सर्वश्रेष्ठ डिज़ाइन पैटर्न/दृष्टिकोण

Question

मेरे पास एक "विरासत" कोड है जिसे मैं रिफैक्टर करना चाहता हूं।
कोड मूल रूप से सर्वर पर एक दूरस्थ कॉल करता है और एक उत्तर वापस ले जाता है। फिर जवाब के अनुसार निष्पादित करता है।
कोड का कंकाल का उदाहरण:

public Object processResponse(String responseType, Object response) { 
    if(responseType.equals(CLIENT_REGISTERED)) { 
     //code 
     //code ... 
    } 
    else if (responseType.equals(CLIENT_ABORTED)) { 
     //code 
     //code.... 
    }  
    else if (responseType.equals(DATA_SPLIT)) { 
     //code 
     //code... 
    } 
    etc 

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

Answer 1

दो दृष्टिकोण:

1. रणनीति पैटर्न http://www.dofactory.com/javascript/strategy-design-pattern
2. , शब्दकोश बनाएं जहां कुंजी मेटाडाटा (अपने मामले मेटाडाटा में है responseType) है और मूल्य एक समारोह है।

उदाहरण के लिए: निर्माता में

रखें इस

responses = new HashMap<string, SomeAbstraction>(); responses.Put(CLIENT_REGISTERED, new ImplementationForRegisteredClient()); responses.Put(CLIENT_ABORTED, new ImplementationForAbortedClient());

जहां ImplementationForRegisteredClient और ImplementationForAbortedClient responses.get(responseType).MethodOfYourAbstraction(SomeParams);

के माध्यम से लागू SomeAbstraction

और इस शब्दकोश फोन 0

यदि आप DI के सिद्धांत का पालन करना चाहते हैं, तो आप इस क्लाइंट क्लास में इस शब्दकोश को इंजेक्ट कर सकते हैं।

Answer 2

मेरी पहली कटौती को बदलने के लिए हो सकता है अगर/else if स्विच/मामले के साथ संरचनाओं:

public Object processResponse(String responseType, Object response) { 
    switch(responseType) { 
     case CLIENT_REGISTERED: { 
     //code ... 
    } 
    case CLIENT_ABORTED: { 
     //code.... 
    }  
    case DATA_SPLIT: { 
     //code... 
    } 

वहां से मैं शायद एक विधि के रूप प्रत्येक ब्लॉक निकालने चाहते हैं, और वहाँ से रणनीति पैटर्न लागू होते हैं। जो कुछ भी सही लगता है उसे रोको।

Answer 3

आपके द्वारा वर्णित मामला रणनीति पैटर्न के आवेदन के लिए पूरी तरह से फिट लगता है। विशेष रूप से, आपके पास एल्गोरिदम के कई रूप हैं, यानी रिमोट सर्वर कॉल की प्रतिक्रिया के अनुसार निष्पादित कोड।

stategy पैटर्न को लागू करने का मतलब है आप एक वर्ग पदानुक्रम परिभाषित करने के लिए है, जैसे कि निम्न:

public interface ResponseProcessor { 
    public void execute(Context ctx); 
} 
class ClientRegistered implements ResponseProcessor { 
    public void execute(Context ctx) { 
     // Actions corresponding to a client that is registered 
     // ... 
    } 
} 
class ClientAborted implements ResponseProcessor { 
    public void execute(Context ctx) { 
     // Actions corresponding to a client aborted 
     // ... 
    } 
} 
// and so on... 

Context प्रकार सभी जानकारी है कि प्रत्येक 'रणनीति' पर अमल करने की जरूरत है शामिल करना चाहिए।ध्यान दें कि यदि विभिन्न रणनीतियों में कुछ एल्गोरिदम टुकड़े साझा करते हैं, तो आप टेम्पलेट विधि पैटर्न का भी उपयोग कर सकते हैं।

रनटाइम पर एक विशेष रणनीति बनाने के लिए आपको फैक्टरी की आवश्यकता है। फैक्ट्री प्राप्त प्रतिक्रिया से शुरू एक रणनीति तैयार करेगा। @ सट्टा इमामोव द्वारा सुझाए गए एक संभावित कार्यान्वयन को होना चाहिए। कारखाने में if .. else कोड होगा।

यदि रणनीति वर्गों को निर्माण करने के लिए भारी नहीं है और उन्हें निर्माण समय पर किसी बाहरी जानकारी की आवश्यकता नहीं है, तो आप प्रत्येक रणनीति को गणना के मूल्य पर भी मैप कर सकते हैं।

public enum ResponseType { 
    CLIENT_REGISTERED(new ClientRegistered()), 
    CLIENT_ABORTED(new ClientAborted()), 
    DATA_SPLIT(new DataSplit()); 

    // Processor associated to a response 
    private ResponseProcessor processor; 

    private ResponseType(ResponseProcessor processor) { 
     this.processor = processor; 
    } 
    public ResponseProcessor getProcessor() { 
     return this.processor; 
    } 
}