कमांड पैटर्न बनाम प्रतिबिंब

Question

मेरे पास नियंत्रक है जो यूआरएल से लिया गया कमांड नाम के अनुसार कुछ आदेश निष्पादित करता है। मुख्य बिंदु का उपयोग नहीं किया जाता है अगर खंड और स्विच स्विच करें। जैसा कि मुझे पता है कि इसे कैसे करना है केवल दो तरीके हैं - 1) कमांड पैटर्न 2) प्रतिबिंब।

//Command pattern 
class Controller{ 
    private HashMap<String,Command> commands; 
    public void executeCommand(String commandName){ 
    commands.get(commandName).execute(); 
    } 
    ... 
} 

//reflection 
class Controller{ 
    public void readCommand(){ 
    .... 
    } 
    public void executeCommand(String commandName){ 
    this.getClass().getMethod(commandName+"Command").invoke(this); 
    } 
    ... 
} 

तो questios:

1. कौन सा बेहतर है?
2. क्या यह एक अनुप्रयोग में सामान्य है कि डेवलपर्स को उनके इच्छित तरीकों में से एक का उपयोग करने दें।
3. क्या अन्य तरीके हैं?

Answer 1

1. पहला रास्ता बेहतर है, प्रतिबिंब का उपयोग अन्य विकल्प नहीं है केवल जब।
2. एक आवेदन में एक तरह की समस्या को हल करने के लिए एक दृष्टिकोण होना चाहिए।
3. मुझे लगता है कि पहला दृष्टिकोण ठीक है। (यदि बेहतर/अन्य ब्लॉक)

Answer 2

मुझे लगता है कि आपके पहले दृष्टिकोण के लिए 2 अलग-अलग तरीके हैं। प्रत्येक आदेश अमूर्त वर्ग कमांड का उप-वर्ग हो सकता है। या प्रत्येक आदेश कक्षा कमांड का एक उदाहरण हो सकता है। यह इस बात पर निर्भर करता है कि यह कितना लचीला होना चाहिए, और क्या पैरामीटर हैं और कमांड के लिए मान वापस कर रहे हैं? यहाँ अपने जवाब

abstract public class Command { 
    abstract public void execute(); 
} 

public class LsCommand extends Command 
{ 
    @Override 
    public void execute() { 
     try { 
      Runtime.getRuntime().exec("ls"); 
     } catch (IOException e) {} 
    } 
} 

public class ChdirCommand extends Command 
{ 
    @Override 
    public void execute() { 
     try { 
      Runtime.getRuntime().exec("chdir"); 
     } catch (IOException e) {} 
    } 
} 

: उपवर्गों यह इस प्रकार दिखाई देगा के साथ (सिर्फ विचार प्राप्त करने)

1. आपका पहला रास्ता बेहतर है। हमेशा प्रतिबिंब पर डिजाइन पैटर्न पसंद करते हैं।
2. क्षमा करें मुझे प्रश्न 2 समझ में नहीं आता है, लेकिन इसके पास कोई प्रश्न चिह्न नहीं है, इसलिए मैं इसे छोड़ देता हूं :)
3. आप Strategy design pattern में देख सकते हैं, जहां प्रत्येक कमांड भी बनाया जा सकता है उप आदेश के विभिन्न भागों। एक और विचार Factory design pattern होगा। उस स्थिति में आप प्रत्येक आदेश को कक्षा में डाल देंगे और फिर क्लासलोडर का उपयोग नाम से कक्षा को लोड करें।

Answer 3

कौन सा बेहतर है?

स्पष्ट रूप से पहले एक बेहतर है। भले ही आपने उद्धृत किया है कि आप कमांड पैटर्न का उपयोग कर रहे हैं, यह पूर्ण "कमांड" पैटर्न नहीं है। कमांड पैटर्न में कमांड (सार), कंक्रीट कमांड, रिसीवर, इनवॉकर और क्लाइंट होगा।

Using Command Design pattern

अलावा कमान पैटन से, मैं पेशेवरों और प्रतिबिंब के विपक्ष को उजागर करना चाहते हैं:

इस सवाल पर एक नज़र डालें।

लाभ:

1. निर्भरता इंजेक्शन
2. हैंडलिंग प्लग और खेलने का विकास चौखटे

विपक्ष:

1. प्रतिबिंब कॉल धीमी हैं
2. आप सुरक्षा का उल्लंघन कर सकते हैं और खराब इरादे से आवेदन विस्फोट कर सकते हैं (उदा। एक वर्ग है, जो अन्य वर्ग के लिए अदृश्य है)

प्रतिबिंब के बारे में संबंधित एसई सवाल पर एक नज़र डालें के निजी चर की स्थापना:

What is reflection and why is it useful?

यह एक आवेदन डेवलपर्स जाने के लिए सामान्य है वे जिस तरीके से चाहते हैं उसका उपयोग करें।

डेवलपर्स के लिए किसी विशेष समस्या को हल करने के लिए सर्वोत्तम विधि चुनना सामान्य बात है।

क्या अन्य तरीके हैं?

यह उस समस्या के प्रकार पर निर्भर करता है जिसे आप संबोधित करने जा रहे हैं। डिजाइन पैटर्न पुनरावर्ती समस्याओं के समाधान प्रदान करता है।

सभी समाधान मौजूदा डिजाइन पैटर्न में फिट नहीं हो सकते हैं। आपने अपनी समस्या का समाधान करने के लिए नए पैटर्न विकसित किए होंगे।