मेरे उपयोग के मामले के लिए उपयोग करने के लिए कौन सा डिज़ाइन पैटर्न?

Question

मेरे पास एक उपयोग केस है जहां इनपुट पैरामीटर (ए, बी, सी, डी) और डेटा (एक्सवाईजेड कहें) का सेट है। पैरामीटर (ए, बी, सी, डी) के आधार पर मुझे डेटा (एक्सवाईजेड) को संसाधित करना होगा और वापस जवाब देना होगा। प्रसंस्करण तर्क पैरामीटर के आधार पर अद्वितीय या सामान्य हो सकता है (कहें कि कुछ # 1 केवल तभी करें जब ए, ए और सी करते समय कुछ # 2 करें, बी, सी और डी आदि पर कुछ # 2 करें)। मुझे प्रसंस्करण के आदेश को बनाए रखने की भी आवश्यकता हो सकती है।

वर्तमान कार्यान्वयन if-else loops पर आधारित है। मैं जिम्मेदारी की श्रृंखला, पाइपलाइन डिजाइन पैटर्न देख रहा हूँ। लेकिन उपरोक्त कार्य के लिए कोई अन्य उपयुक्त डिजाइन पैटर्न है?

उदाहरण का उपयोग करते हुए अगर-को अवरोधित कर देते:

आई/पी: एक = {A1, A2, A3}, बी = {B1, B2, बी 3}, सी = {C1, C2, सी 3}, डी = {डी 1, डी 2, डी 3} और XYZ = "foo"

if (A == A1) 
{ 
    //dosomething-A1 

    if (B == B1) 
    { 
     //dosomething-B1 

     if (C == C2) 
     { 
      //dosomething-C2 
     } 
    } 
    else if (B == B2) 
    { 
     //dosomething-B2 
    } 

    if (C == C2) 
    { 
     //dosomething-C2 

     if (D == D1) 
     { 
      //dosomething-D1 
     } 
     else if (D == D3) 
     { 
      //dosomething-D3 
     } 
    } 
} 
else if (A == A2) 
{ 
    //dosomething-A2 
    ... 
} 
else if (A == A3) 
{ 
    //dosomething-A3 
    ... 
} 

Answer 1

चेन अगर यह पुन: उपयोग किया जाता है बहुत अच्छी तरह से इस फिट करने के लिए, लग रहे हैं। एक और विकल्प मानचित्र में संग्रहीत हैंडलर का उपयोग करना है, जहां कुंजी उचित पैरामीटर मान है। यह पैरामीटर के रूप में पारित संभावित मूल्यों के सीमित सेट के लिए अच्छी तरह से काम करता है। आपको कुछ ऐसा मिलेगा:

handlers.get(a).handle(XYZ) 

तो, पूरी तरह से यदि आपके हिस्से पर कम है। लेकिन फिर, यह सभी उद्देश्यों के अनुरूप नहीं है।

Answer 2

कमांड पैटर्न की तरह कुछ ढूंढें। पैरामीटर डेटा के आधार पर संसाधित होने की आवश्यकता है। आंतरिक कार्यान्वयन बाहर खुलासा नहीं किया जाना चाहिए। इसलिए, खुला इंटरफ़ेस परिप्रेक्ष्य से इसे पैरामीटर लेना होगा और डेटा और कमांड पैटर्न को पैरामीटर के आधार पर निष्पादित करने की विधि को पहचानने की आवश्यकता है।

Answer 3

वास्तविक शब्द के मामले के बिना यह कहना मुश्किल है, लेकिन अधिकतर संभावना है कि आप कक्षाओं के अच्छे पदानुक्रम के साथ अपने/अन्य पेड़ के आकार को कम करने में सक्षम होंगे।

पॉलिमॉर्फिज्म इसे और अधिक ऑब्जेक्ट उन्मुख बना देगा।

Answer 4

अगर-तो-अन्य बयानों की आपकी सूची मुझे rule-based system की याद दिलाती है। एक नियम आधार संक्षेप में डेटाबेस है जिसमें Condition -> Action के नियम शामिल हैं। जावा 8 में एक शर्त के कार्यान्वयन ऐसा दिखाई दे सकता:

@FunctionalInterface 
interface Condition { 
    boolean matches(A a, B b, C c, D d); 
} 

Action आप बस एक Runnable इस्तेमाल कर सकते हैं के लिए।

static final Map<Condition, Runnable> BASE = 
     ImmutableMap.<Condition, Runnable>builder() 
      .put((a, b, c, d) -> a == A1,() -> doSomethingA1()) 
      .put((a, b, c, d) -> a == A1 && b == B1,() -> doSomethingB1()) 
      .put((a, b, c, d) -> a == A1 && b == B1 && c == C2,() -> doSomethingC2()) 
      .put((a, b, c, d) -> a == A1 && b == B2,() -> doSomethingB2()) 
      .put((a, b, c, d) -> c == C2,() -> doSomethingC2()) 
      .put((a, b, c, d) -> c == C2 && d == D1,() -> doSomethingD1()) 
      .put((a, b, c, d) -> c == C2 && d == D3,() -> doSomethingD3()) 
      .put((a, b, c, d) -> a == A2,() -> doSomethingA2()) 
      .put((a, b, c, d) -> a == A3,() -> doSomethingA3()) 
      .build(); 

इस नियम के आधार का उपयोग करने के लिए आप बस निम्न विधि परिभाषित कर सकते हैं:

static void evaluate(A a, B b, C c, D d) { 
     BASE.entrySet().stream() 
      .filter((entry) -> entry.getKey().matches(a, b, c, d)) 
      .forEach((e) -> e.getValue().run()); 
} 

आप इसे इस तरह कॉल करने के लिए अनुमति देता है कौन सा: अपने कोड के आधार पर rulebase परिभाषा इस प्रकार के रूप में परिभाषित किया जा सकता है

evaluate(A1, B1, null, null); 
// executes doSomethingA1() and doSomethingB1()