मैं जावा में कोडित एक जटिल उद्यम अनुप्रयोग पर काम कर रहा हूं जो जटिल ऑब्जेक्ट रचनाओं द्वारा संचालित है। उदाहरण के लिए: एक विशेष परिदृश्य में, कोई कार्रवाई करने के इस प्रवाह है:क्या यह विधियों को लिखने के लिए एक अच्छा अभ्यास है जो शून्य लौटाता है?
login() ->
Followed by defined sequence of 10 to 20 method calls in different classes ->
Followed by a logout()
ढांचे के भीतर, लगभग सभी लॉगिन, लॉगआउट था और इसमें 10 से 20 विधि कॉल के कई कार्यों कोई वापसी है प्रकार के। किसी भी गलत व्यवहार ढांचे द्वारा संभाला जाता है। लॉगिन
public void login(){
try{
//login actions
//chained sequence of calls
}catch(){
// framework handling exceptions and other rollback options
}
}
मध्यवर्ती 10 से 20 कार्यों में कहते हैं, विधि ढांचे के पदानुक्रम के विभिन्न स्तरों पर विभिन्न वस्तुओं पर कॉल कर रहे हैं।
एक यादृच्छिक वर्ग इस प्रकार दिखाई देगा:
class someobject{
def variable
void action1(){ do something on variable }
void action2(){ do something on variable }
...
}
चर परिवर्तन अक्सर राज्य और इन कार्यों एक दृश्य ढांचा जो मैं बहुत कष्टप्रद द्वारा केवल परिभाषित किया गया है।
मैं कहूंगा कि शायद login() के मामले में बूलियन कहने पर उचित वापसी प्रकार या कम से कम इनमें से कुछ विधियां थीं, तो जीवन बहुत आसान होगा। शून्य वापसी कार्यों की एक श्रृंखला के इस कड़े अनुपालन के कारण, मुझे प्रवाह को समझने के लिए डीबग करना मुश्किल लगता है और यूनिट परीक्षण भी मेरे लिए एक दुःस्वप्न बन गया।
तो अब, मैं इस धारणा के तहत हूं कि कुछ ऐसा काम लिखना हमेशा बेहतर होता है, जो विशेष रूप से जब क्रियाओं की एक श्रृंखला होती है। तो, क्या यह एक सुरक्षित धारणा है? मैं इस पर आपकी राय लेना चाहता हूं। अगर मैं गलत हूं तो मुझे सही करो।
जो आप यहां समझाते हैं वह ऐसा लगता है कि आप एक उचित घटक संचालित डिज़ाइन खो रहे हैं। दृष्टिकोण का परिणाम अनजान 'स्पैगेटी कोड' होगा। आपको कुछ इंटरमीडिएट परतों को पेश करने की आवश्यकता हो सकती है ... – home