किसी विधि में एकाधिक प्रयास/कैच ब्लॉक संयुक्त होना चाहिए

Question

मेरी विधि को देखते हुए मुझे यकीन नहीं है कि मुझे तीन अलग-अलग प्रयास/पकड़ ब्लॉक का उपयोग करना है। क्या मुझे पूरी विधि के लिए केवल एक का उपयोग करना चाहिए? एक अच्छा अभ्यास क्या है?

public void save(Object object, File file) {  

     BufferedWriter writter = null; 

     try { 
      writter = new BufferedWriter(new FileWriter(file)); 
     } catch (IOException e) { 
      e.printStackTrace(); 
     } 

     Dictionary dictionary = (Dictionary)object; 
     ArrayList<Card> cardList = dictionary.getCardList(); 
     for (Card card: cardList) { 
      String line = card.getForeignWord() + "/" + card.getNativeWord(); 
      try { 
       writter.write(line); 
      } catch (IOException e) { 
       e.printStackTrace(); 
      } 
     } 
     try { 
      writter.flush(); 
      writter.close(); 
     } catch (IOException e) { 
      e.printStackTrace(); 
     } 
    } 

Answer 1

आप निश्चित रूप से कोड के साथ तीन अलग-अलग ब्लॉक नहीं चाहते हैं। पहले ब्लॉक में, आप writer को सेट करने में त्रुटि प्राप्त कर रहे हैं, लेकिन उसके बाद के बाद के ब्लॉक में writer का उपयोग कर, जो पहली ब्लॉक विफल होने पर समझ में नहीं आता है। जब आप I/O त्रुटि   — आदर्श नहीं होते हैं तो आप NullPointerException फेंक देंगे। :-)

इस सामान में शैली के लिए बहुत सी जगह है, लेकिन यहां आपके कार्य की एक काफी मानक पुनरावृत्ति है। (हालांकि आप एक तिहाई वापस जोड़ने के लिए चुन सकते हैं; कोड में टिप्पणियां देखें) यह केवल दो ब्लॉकों का उपयोग करता है: finally खंड पर

public void save(Object object, File file) {  

    BufferedWriter writter = null; 

    try { 
     writter = new BufferedWriter(new FileWriter(file)); 

     Dictionary dictionary = (Dictionary)object; 
     ArrayList<Card> cardList = dictionary.getCardList(); 
     for (Card card: cardList) { 
      String line = card.getForeignWord() + "/" + card.getNativeWord(); 
      writter.write(line); // <== I removed the block around this, on 
           // the assumption that if writing one card fails, 
           // you want the whole operation to fail. If you 
           // just want to ignore it, you would put back 
           // the block. 
     } 

     writter.flush(); // <== This is unnecessary, `close` will flush 
     writter.close(); 
     writter = null; // <== null `writter` when done with it, as a flag 
    } catch (IOException e) { 
     e.printStackTrace(); // <== Usually want to do something more useful with this 
    } finally { 
     // Handle the case where something failed that you *didn't* catch 
     if (writter != null) { 
      try { 
       writter.close(); 
       writter = null; 
      } catch (Exception e2) { 
      } 
     } 
    } 
} 

नोट: यहाँ, आप सामान्य मामले से निपटने के किया जा सकता है (इस स्थिति में writternull होगा), या हो सकता है कि आप एक ऐसा अपवाद संभालें जो आपने नहीं पकड़ा था (जो असामान्य नहीं है, अपवादों के मुख्य बिंदुओं में से एक यह है कि इस स्तर पर उचित क्या है और कॉलर तक कुछ और पास करने के लिए) । यदि writter!null है, तो इसे बंद करें। और जब आप इसे बंद करते हैं, कोई अपवाद होता है या आप मूल को अस्पष्ट करेंगे। (मेरे पास वास्तव में इस स्थिति के लिए अपवाद खाने के दौरान चीजों को बंद करने के लिए उपयोगिता कार्य है। मेरे लिए, यह writter = Utils.silentClose(writter); [silentClose हमेशा null] लौटा सकता है)। अब, इस कोड में आप अन्य अपवादों की अपेक्षा नहीं कर सकते हैं, लेकिन ए) आप इसे बाद में बदल सकते हैं, और बी) RuntimeException एस किसी भी समय हो सकता है। पैटर्न का उपयोग करने के लिए उपयोग करने के लिए सबसे अच्छा है।

Answer 2

यह स्वाद का विषय है - इसका कोई सही जवाब नहीं है।

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

public void save(Object object, File file) throws IOException 
{ 

    BufferedWriter writer = null; 

    try { 
    writer = new BufferedWriter(new FileWriter(file)); 

    Dictionary dictionary = (Dictionary) object; 
    ArrayList<Card> cardList = dictionary.getCardList(); 
    for (Card card : cardList) 
    { 
     String line = card.getForeignWord() + "/" + card.getNativeWord(); 
     writer.write(line); 
    } 
    } 
    finally 
    { 
     IOUtils.close(writer); 
    }  
} 

मैं एक IOUtils वर्ग कि नदियों, पाठकों और लेखकों के समुचित समापन संपुटित होता होगा:

यहाँ कैसे मुझे लगता है कि विधि लिखते हैं है। आप बार-बार उस कोड को लिखेंगे। मैं इसे कक्षा में एक स्थिर विधि के रूप में एक लाइनर बनाउंगा - या अपाचे कॉमन्स IO का उपयोग जार का उपयोग करता हूं यदि मुझे कोई अन्य निर्भरता नहीं है।

Answer 3

अच्छा क्या है आपके कोड का क्या इरादा है इस पर निर्भर करता है। उदाहरण के लिए, दूसरा प्रयास/पकड़ एक लूप के अंदर है, जिसका अर्थ है, यह सूची में सभी card एस को संसाधित करेगा, भले ही किसी की प्रसंस्करण विफल हो। यदि आप पूरी विधि के लिए try/catch का उपयोग करते हैं, तो यह व्यवहार बदला जाएगा। यदि आपका अहंकार अनुमति देता है तो एक try/catch का उपयोग करें।

Answer 4

कोशिश करने के साथ, 'डू' की तुलना में अधिक 'नहीं' हैं मुझे डर है ...

इस दस्तावेज़ को उनमें से कुछ को सूचीबद्ध करता है:

http://today.java.net/article/2006/04/04/exception-handling-antipatterns

फिर भी, कुछ वहाँ बाहर है करते हैं, मैं इस रोचक लगा:

http://www.wikijava.org/wiki/10_best_practices_with_Exceptions

Answer 5

मैं के विशिष्ट मामले में/ओआई सुझाव देता है कि आप गुवा और जकार्ता कॉमन्स जैसे कुछ सामान्य मुक्ति उपलब्ध कराते हैं। चुप बंद करने के लिए उनके पास कुछ अच्छी स्क्रिप्ट हैं।

उदा। Commons IO IOUtils

ये काफ़ी

Answer 6

मैं दो कोशिश ब्लॉक, अंत में के लिए एक और पकड़ के लिए एक लिखने के लिए पसंद करते हैं अपने कोड को साफ कर सकते हैं। जिस तरह से लिखा गया है, आप कभी भी कूड़े को शून्य पर सेट नहीं करते हैं, न ही आपको बंद होने पर शून्य के खिलाफ जांचना पड़ता है। एकमात्र समस्या एक अपवाद है जबकि बंद होने पर प्रसंस्करण करते समय अपवाद छिपाएगा, लेकिन यह केवल एक समस्या है यदि आप दो अपवादों को अलग-अलग संभालना चाहते हैं।

public void save(Object object, File file) { 
    try { 
     BufferedWriter writter = new BufferedWriter(new FileWriter(file)); 
     try { 
      Dictionary dictionary = (Dictionary)object; 
      ArrayList<Card> cardList = dictionary.getCardList(); 
      for (Card card: cardList) { 
       String line = card.getForeignWord() + "/" + card.getNativeWord(); 
       writter.write(line); 
      } 
     } finally { 
      writter.flush(); 
      writter.close(); 
     } 
    } catch (IOException e) { 
     e.printStackTrace(); //Or something more useful 
    } 
}