पकड़ने अलग अपवादों या instanceof का उपयोग करें - जावा 6

Question

मान लें कि कोड के इस टुकड़े 20 स्थानों में है और हमेशा एक ही

try { 
    // do something 
} catch (FirstException e) { 
    // log it 
} catch (SecondException e) { 
    // log it 
} 

बेहतर उपयोग करने के लिए इस या instanceof की तरह कुछ नहीं है अच्छा समाधान नहीं होगा?

try { 
    // do something 
} catch(Exception e) { 
    logException(e); 
} 

void logException(Exception e) { 
    if (e instanceof FirstException) { 
     // log it 
    } else if (e instanceof SecondException) { 
     // log it differently 
    } else { 
     // do something with other exception 
    } 
} 

केवल बात यह है कि मैं वास्तव में समाधान के बारे में नफरत Exception पकड़ने जो definitelly सबसे अच्छा तरीका नहीं है ... क्या कोई बेहतर तरीका है?

Answer 1

1. जावा 7 में, आप का उपयोग catch (FirstException1 | SecondException | ...)
2. catch (Exception e) — के साथ गलत कुछ भी नहीं हो सकता है आप सभी अपवाद लॉग ऑन करना चाहते हैं, है ना? मैं वास्तव में catch (Throwable t) सलाह देता हूं क्योंकि OutOfMemoryError s और StackOverflowError भी लॉग इन करना चाहते हैं।

लॉगिंग अपवादों के साथ कई वर्षों के अनुभव से एक सलाह उन सभी को लॉग इन करना है। अपवाद संदेश मानव-पठनीय पाठ के रूप में पर्याप्त है, और डेवलपर को वास्तव में डिबगिंग के लिए क्या चाहिए, वह स्टैक ट्रेस है।

बस एक बात के बारे में सावधान रहना: बहुत जल्दी अपवादों को पकड़ने कभी नहीं: उन्हें पूरी आवेदन के लिए एक ही स्थान पर पकड़, तथाकथित अपवाद बाधा — यह स्तर है जहाँ आप में प्रवेश करने और की एक इकाई से बाहर निकलने पर है काम।

जांचे हुए अपवादों आप निचले स्तर पर परेशानी दे रहे हैं, तो उन्हें RuntimeException में लपेट:

try { 
    ... 
} 
catch (RuntimeException e) {throw e;} 
catch (Exception e) {throw new RuntimeException(e);} 

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

Answer 2

पहला दृष्टिकोण निश्चित रूप से बेहतर है। आम तौर पर Exception पकड़ने के लिए यह एक बुरी आदत है क्योंकि इस मामले में आप RuntimeException एस भी पकड़ते हैं।

Answer 3

यदि आपको केवल अपवाद लॉग करना है तो पूर्व स्वच्छ और बढ़िया समाधान है।

अन्यथा पहला दृष्टिकोण बेहतर है।

Answer 4

"रेफैक्टरिंग टू पैटर्न" पुस्तक में सामान्य रेफैक्टरिंग्स में से एक "पॉलीमोर्फिज्म के साथ उदाहरण को प्रतिस्थापित करें" - दूसरे शब्दों में जब भी आप उदाहरण का उपयोग करते हैं, तो विचार करें कि वास्तव में पॉलिमॉर्फिज्म बेहतर काम करेगा या नहीं। । ।

यह कहकर, इस विशेष प्रश्न के लिए रनटाइम अपवादों के साथ चेक अपवादों को बदलने के वसंत दर्शन को ध्यान में रखते हुए (पन क्षमा करें)।

विचार यह है कि चेक अपवादों का अधिक उपयोग किया जा सकता है - क्या अपवाद कुछ है जिसे पुनर्प्राप्त किया जा सकता है? यदि हाँ, ठीक है। । । यदि नहीं, तो बस इसे श्रृंखला का प्रचार करने दें।आप इसे कर सकते हैं:

• इसे फिर से फेंकना। । । (लेकिन बेहतर अभी भी)
• एक RuntimeException

एक प्रवेश पहलू बनाएं में लपेट:

एक और बात पर विचार करना है कि आप ठीक बिंदु वे होते हैं पर ये अपवाद प्रवेश करने की आवश्यकता है, तो उन्हें चेन का प्रचार करने के बजाय, और कि वे 20 अलग-अलग स्थानों में होते हैं, फिर वे एक क्रॉस-कटिंग चिंता कर रहे हैं। । । आप नियमित विधि को अपवाद को फिर से उखाड़ फेंक सकते हैं, और फिर उन्हें पकड़ने और लॉग इन करने के लिए एक पहलू लिख सकते हैं। । । । फिर वसंत का उपयोग करना यह आसान बनाता है।