हैंडलिंग कई अपवाद

Question

मैं एक वर्ग है जो अपने आवेदन के विन्यास वस्तुओं लोड करता है और उन पर नज़र रखता है ताकि मैं आसानी से परिवर्तन को लिखने या एक ही विधि कॉल के साथ एक ही बार में पूरे विन्यास को फिर से लोड कर सकते हैं लिखा है। हालांकि, प्रत्येक विन्यास वस्तु संभवतः जब आईओ कर एक अपवाद फेंक सकती है, फिर भी मैं उन त्रुटियों क्रम अन्य वस्तुओं अभी भी फिर से लोड करने/लिखने का मौका देने के लिए समग्र प्रक्रिया को रद्द नहीं करना चाहती। इसलिए मैं सभी अपवादों जो वस्तुओं से अधिक पुनरावृत्ति और उन्हें एक सुपर अपवाद है, जो लूप के बाद फेंक दिया जाता है में स्टोर जबकि फेंक दिया जाता है, क्योंकि प्रत्येक अपवाद अभी भी नियंत्रित किया जाना चाहिए और किसी को वास्तव में क्या गलत हो गया था के बारे में सूचित किया जाना है एकत्रित करते हैं। हालांकि, यह दृष्टिकोण मेरे लिए थोड़ा अजीब लग रहा है। क्लीनर समाधान के साथ कोई बाहर?

public synchronized void store() throws MultipleCauseException 
    { 
    MultipleCauseException me = new MultipleCauseException("unable to store some resources"); 
    for(Resource resource : this.resources.values()) 
     { 
     try 
      { 
      resource.store(); 
      } 
     catch(StoreException e) 
      { 
      me.addCause(e); 
      } 
     } 
    if(me.hasCauses()) 
     throw me; 
    } 

Answer 1

आप आपरेशनों, ऐसा लगता है जो आप कर के रूप में आप जानबूझकर पर ले जाने के परिणामों को बनाए रखना चाहते हैं, तो एक अपवाद फेंकने गलत बात है:

यहाँ उल्लेख वर्ग के कुछ कोड है करने के लिए। आम तौर पर आपको अपवाद फेंकने पर कुछ भी परेशान न करने का लक्ष्य रखना चाहिए।

मैं क्या सुझाव कॉलबैक से निपटने के रूप में आप साथ जाने अपवाद है, या उन्हें से प्राप्त डेटा गुजर रहा है एक त्रुटि के लिए।

public interface StoreExceptionHandler { 
    void handle(StoreException exc); 
} 

public synchronized void store(StoreExceptionHandler excHandler) { 
    for (Resource resource : this.resources.values()) { 
     try { 
      resource.store(); 
     } catch (StoreException exc) { 
      excHandler.handle(exc); 
     } 
    } 
    /* ... return normally ... */ 
] 

Answer 2

वहाँ डिजाइनिंग क्या और कब अपवाद फेंक दिया जाना चाहिए में मार्गदर्शक सिद्धांतों रहे हैं, और इस परिदृश्य के लिए दो प्रासंगिक हैं:

• फेंक अपवाद अमूर्त के लिए उपयुक्त (यानी अपवाद अनुवाद प्रतिमान)
• फेंक अपवाद जल्दी आप MultipleCauseException से करने के लिए StoreException का अनुवाद संभव हो तो

रास्ता मेरे लिए उचित है, हालांकि एक में विभिन्न प्रकार के अपवाद को लंपना सबसे अच्छा विचार नहीं हो सकता है। दुर्भाग्य से जावा सामान्य Throwable रों का समर्थन नहीं करता है, तो शायद एकमात्र विकल्प बजाय एक अलग MultipleStoreException उपवर्ग तैयार करना है।

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

आपके मामले में, यदि कई स्वतंत्र कार्यों के रूप में संसाधनों को संग्रहीत करने के बारे में सोचने के लिए यह समझ में आता है, तो आपके द्वारा किए गए अपवाद के "बैच प्रक्रिया" को ठीक करना ठीक हो सकता है। अन्य परिस्थितियों में जहां कार्यों में अधिक जटिल परस्पर निर्भरता संबंध है, हालांकि, इसे सभी को एक साथ जोड़कर अपवादों का विश्लेषण कठिन हो जाएगा।

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