mogę uniknąć takich kłopotliwych try ... catch bloku

Question

Zazwyczaj, gdy mamy do czynienia z kodem Java IO, oto co napisałem

FileOutputStream out = null; 
    try 
    { 
     out = new FileOutputStream("myfile.txt"); 
     // More and more code goes here... 
    } 
    catch (Exception e) 
    { 
    } 
    finally 
    { 
     // I put the close code in finally block, to enture the opened 
     // file stream is always closed even there is exception happened. 
     if (out != null) { 
      // Another try catch block, troublesome. 
      try { 
       out.close(); 
      } catch (IOException ex) { 
      } 
     } 
    } 

Jak widać, podczas gdy próbuję zamknąć strumienia pliku, I potrzebuję poradzić sobie z innym spróbuj ... catch catch.

Spójrz kłopotliwe :(

Czy jest jakiś sposób mogę uniknąć? Nie czuję się komfortowo w oddanie ścisły kod w niewyspecjalizowanych wreszcie zablokować, jako wyjątek spowodowany przez inne kody uczyni żadnej szansy na „zamknij "miano.

Answer 1

Bardzo ważne jest, aby zamknąć strumienie w końcu. Możesz uprościć ten proces za pomocą metody użytkowej, takiej jak:

public static void closeStream(Closeable closeable) { 
    if(null != closeable) { 
     try { 
     closeable.close(); 
     } catch(IOException ex) { 
     LOG.warning("Failed to properly close closeable.", ex); 
     } 
    } 
    } 

Ustanawiam punkt co najmniej logowania awarii bliskiego strumienia. Wykorzystanie wówczas postać:

FileOutputStream out = null; 
try 
{ 
    out = new FileOutputStream("myfile.txt"); 
    // More and more code goes here... 
} 
catch (Exception e) 
{ 
} 
finally 
{ 
    closeStream(out); 
} 

W Javie 7 wierzę, że strumienie będą zamknięte automatycznie, a zapotrzebowanie na takie bloki powinny być przede wszystkim zbędne.

Answer 2

Dyskusja na

Try-catch-finally and then again a try catch

i

Is there a preference for nested try/catch blocks?

zasadniczo chodzi o to, czy warto złapać wyjątek od close().

Answer 3

staram się wykorzystywać funkcje ułatwiające to:

public static void safeClose(OutputStream out) { 
    try { 
    out.close(); 
    } catch (Exception e) { 
    // do nothing 
    } 
} 

który zmienia kod do nieco bardziej smaczna:

FileOutputStream out = null; 
try { 
    out = new FileOutputStream("myfile.txt"); 
    // do stuff 
} catch (Exception e) { 
    // do something 
} finally { 
    safeClose(out); 
} 

Naprawdę nie można zrobić o wiele lepiej w Javie co najmniej do Java 7, gdy (miejmy nadzieję) ARM ("Automatic Resource Management") blocks pomoże nieco.

Answer 4

Automatic Resource Management pojawi się w Javie 7, który automatycznie zapewni obsługę tego. Do tego czasu obiekty takie jak OutputStream, InputStream i inne implementują interfejs Closeable od wersji Java 5. Proponuję podać metodę narzędzia do bezpiecznego zamknięcia tych. Te metody na ogół wykorzystują wyjątki, więc upewnij się, że używasz ich tylko wtedy, gdy chcesz ignorować wyjątki (np. W metodzie finally). Na przykład:

public class IOUtils { 
    public static void safeClose(Closeable c) { 
     try { 
      if (c != null) 
       c.close(); 
     } catch (IOException e) { 
     } 
    } 
} 

Należy zauważyć, że metoda close() można nazwać kilka razy, jeśli jest już zamknięte kolejne wywołania będzie miała żadnego wpływu, więc również wezwanie, aby zamknąć podczas normalnej eksploatacji bloku try gdzie wyjątek nie zostanie zignorowany.From the Closeable.close documentation:

Jeśli strumień jest już zamknięta, a następnie wywoływanie tej metody nie ma wpływu

Więc zamknij strumień wyjściowy w regularny przepływ kodu oraz metody safeClose będą wykonywać tylko blisko, jeśli coś nie powiodło się w bloku try:

FileOutputStream out = null; 
try { 
    out = new FileOutputStream("myfile.txt"); 
    //... 
    out.close(); 
    out = null; 
} finally { 
    IOUtils.safeClose(out); 
} 

Answer 5

Napisz metodę, która wygląda jak poniżej; zadzwonić ze swojego bloku finally ...

static void wrappedClose(OutputStream os) { 
    if (os != null) { 
    try { 
     os.close(); 
    } 
    catch (IOException ex) { 
     // perhaps log something here? 
    } 
    } 

Answer 6

Project Lombok zapewnia adnotacji @Cleanup który usuwa potrzebę bloków catch spróbować wszystkich razem. Here's an example.

Answer 7

Oddziel swoje try/catch i try/finally blocks.

try 
{ 
    FileOutputStream out = new FileOutputStream("myfile.txt"); 
    try 
    { 
     // More and more code goes here... 
    } 
    finally 
    { 
     out.close(); 
    } 
} 
catch (Exception e) 
{ 
    //handle all exceptions 
} 

Zewnętrzny zaczep złapie również wszystko, co zostanie rzucone przy zamknięciu.