अपवादों की ग्रैन्युलैरिटी


9

मैं कुछ दोस्तों और आई के बीच एक बहस में चला गया हूं। वे अपवाद के क्षेत्रों के रूप में ClientErrorExceptionऔर ServerErrorExceptionविस्तार के साथ सामान्य अपवाद पसंद करते हैं, जबकि मैं चीजों को अधिक विशिष्ट बनाना पसंद करता हूं। उदाहरण के लिए, मेरे पास कुछ अपवाद हो सकते हैं जैसे:

  • BadRequestException
  • AuthenticationFailureException
  • ProductNotFoundException

इनमें से प्रत्येक त्रुटि कोड के आधार पर बनाया गया है जो एपीआई से लौटा है।

अपवाद के लाभ के बाद यह जावा के लिए मुहावरेदार लगता है। हालाँकि, मेरे दोस्तों की राय बिल्कुल असामान्य नहीं है।

क्या कोड पठनीयता और एपीआई प्रयोज्य के संदर्भ में एक पसंदीदा तरीका है, या क्या यह वास्तव में वरीयता के लिए नीचे आता है?


पेज आप लिंक होने की संभावना सबसे अच्छा है निश्चित जवाब हम प्राप्त कर सकते हैं। आप एक राय के लिए पूछ रहे हैं, वास्तव में। मैं अपने अनुभव और राय के साथ जवाब दे सकता हूं, लेकिन यह एक वस्तुनिष्ठ उत्तर नहीं है।
marstato

@marstato वह निष्पक्ष है। मुझे लगता है कि मैं अपनी स्थिति में औचित्य की तलाश कर रहा हूं। मैं इसके बजाय अपने द्वारा लिखे गए पुस्तकालयों में लोगों से क्या अपेक्षा रखता हूं, एक गाइड का पालन करने के बजाय अगर इसका मतलब है कि यह मेरे सामान का उपयोग करना आसान बनाता है, तो आप जानते हैं?

मैं पूरी तरह से सहमत हूं। मेरे पास मेरे अपवाद वर्ग दानेदार भी हैं। इसके अलावा, आप abstractगेटर तरीकों के साथ अपवाद कक्षाओं को परिभाषित और सामान्यीकृत कर सकते हैं और फिर बारीकियों को सामान्य लोगों का विस्तार कर सकते हैं। जैसे AuthenticationFaliureException extends ClientErrorException। इस तरह, प्रत्येक उपयोगकर्ता यह चुन सकता है कि वे अपवादों से कैसे निपटना चाहते हैं। यह हालांकि अधिक काम करता है, जाहिर है। हालांकि, जब एक आवेदन (एक पुस्तकालय के बजाय) लिख रहा है, तो यह एक अलग स्थिति आईएमएचओ है। उस मामले में मैं अपवादों को आपकी जरूरत से ज्यादा दानेदार नहीं बनाऊंगा, सरलता के लिए।
marstato

@marstato जो वास्तव में है कि मैं इसे अब कैसे लागू करता हूं। मुझे खुशी है कि आप सहमत हैं। मैं रात भर इस सवाल को खुला छोड़ देता हूं, लेकिन कृपया मुझे एक पोस्ट में समेकित करें ताकि मैं कम से कम हरे रंग की जांच कर

जवाबों:


15

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

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

  • क्या आप वास्तव में अपने कोड के कॉलर से उन विभिन्न प्रकार की त्रुटियों के लिए नियंत्रण के विभिन्न प्रवाह के साथ प्रतिक्रिया करने की उम्मीद करते हैं?

इसका कोई एक आकार-फिट-सभी समाधान नहीं है, कोई भी braindead "सर्वोत्तम अभ्यास" आप प्रत्येक और हर जगह लागू नहीं कर सकते हैं। इस सवाल का जवाब बहुत हद तक इस बात पर निर्भर करता है कि आप किस तरह का सॉफ्टवेयर या कंपोनेंट डिजाइन कर रहे हैं:

  • कुछ एप्लिकेशन, जहां आपके या टीम के पास पूरा कोड आधार आपके नियंत्रण में है?

  • या तीसरे पक्ष के लिए कुछ पुन: प्रयोज्य घटक, जहां आपको सभी संभावित कॉलर नहीं पता हैं?

  • लंबे समय तक चलने वाला सर्वर एप्लिकेशन, जहां विभिन्न प्रकार की त्रुटियां पूरे सिस्टम को तुरंत नहीं तोड़ना चाहिए और विभिन्न प्रकार के त्रुटि शमन की आवश्यकता हो सकती है?

  • एक लघु-जीवित अनुप्रयोग प्रक्रिया जहां उपयोगकर्ता को एक त्रुटि संदेश प्रदर्शित करने के लिए एक त्रुटि के मामले में यह पर्याप्त है और फिर प्रक्रिया को पुनरारंभ करें?

तो जितना अधिक आप अपने घटक के संभावित कॉलर्स के बारे में जानते हैं, उतना ही बेहतर होगा कि आप अपने छूट के लिए विस्तार के सही स्तर के बारे में फैसला कर सकें।


3
"क्या आप वास्तव में अपने कोड के कॉलर को विभिन्न प्रकार की त्रुटियों के साथ नियंत्रण के विभिन्न प्रवाह के साथ प्रतिक्रिया करने की उम्मीद करते हैं?" यह एक महान प्रश्न है। धन्यवाद, मैं इसे याद करने जा रहा हूं।

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

1

उत्तर इस बात पर निर्भर करता है कि हम किस स्तर की त्रुटि रिपोर्ट के बारे में बात कर रहे हैं।

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

यदि अशक्त (NullReferenceException) को संदर्भित करने के लिए एक सामान्य, प्रसिद्ध अपवाद है, तो आपको अपना स्वयं का MyObjectIsNullException नहीं बनाना चाहिए। यह सिर्फ मानव दुभाषिया के लिए भ्रम की एक परत जोड़ देगा, एक अतिरिक्त चीज जो सीखने के लिए है जो कुछ भी स्पष्ट नहीं करती है।

केवल तभी जब आपका अपवाद इतना विशेष है कि कोई पूर्वनिर्धारित नहीं है जो मूल कारण को कवर करता है जिसे आपको अपना बनाना चाहिए।

हालाँकि, आपको वहाँ रुकना नहीं है। सामान्य त्रुटि आपके किसी घटक में हो सकती है और आप यह बताना चाहते हैं कि आपके घटक में कोई समस्या थी । तो न केवल क्या गलत हुआ, बल्कि यह भी कि कहाँ गया। तब MyComponentException में पहले अपवाद को लपेटना उचित होगा। जो आपको दोनों दुनिया के लिए सर्वश्रेष्ठ देगा।

पहले यह स्पष्ट हो जाएगा कि आपका घटक परेशानी में है। कम लीवर पर, विशिष्ट कारण आंतरिक अपवाद में होगा।


ये उचित है। तो आप एक अच्छा अपवाद पहले से मौजूद है जब एक नया अपवाद का आविष्कार नहीं कर रहे हैं सुझाव दे रहे हैं?

@rec हां, क्योंकि हर कोई पहले से ही पूर्वनिर्धारित जानता है। यही कारण है कि वे वहाँ के लिए हैं।
मार्टिन माट
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.