tipos - todas las excepciones en java

¿Está bien usar try catch dentro finalmente?

Question

Estoy usando un escritor en buffer y mi código, cierra el escritor en el bloque finally. Mi código es así.

 ...........
    BufferedWriter theBufferedWriter = null;
    try{
    theBufferedWriter =.....
    ....
    ......
    .....
    } catch (IOException anException) {
    ....
    } finally {
        try {
            theBufferedWriter.close();              
        } catch (IOException anException) {
            anException.printStackTrace();
            }
    }

Tengo que usar la captura de prueba dentro del código de limpieza finalmente, ya que TheBufferedWriter también podría arrojar una IOException. No quiero lanzar esta excepción a la llamada methos. ¿Es una buena práctica usar una captura de prueba finalmente? Si no, ¿cuál es la alternativa? Por favor recomiende.

Saludos, Hiral

Answer 1

En pre Java 7, diría que lo que has escrito es la mejor solución.

En Java 7 en adelante, tiene la gestión automática de recursos para simplificar estas cosas. Con esta característica, puedes hacer

BufferedWriter theBufferedWriter = null;
try (BufferedWriter theBufferedWriter = ...) {
....
......
.....
} catch (IOException anException) {
....
}

Answer 2

Está bien poner un try-catch en un finalmente. Es la herramienta que hace lo que quieres hacer. Sin embargo, creo que la IOException lanzada de cerca es bastante poco común como para permitir que suprima cualquier excepción en el cuerpo.

try {
    BufferedWriter writer = .....
    try {
        .....
    } finally {
       writer.close();
    }
 } catch (IOException e) {
     ....
 }

Answer 3

Está bien, pero debería probar si theBufferedWriter no es nulo antes de cerrarlo.
También podrías hacer:

BufferedWriter theBufferedWriter;
try {
    theBufferedWriter = new ...
    try {
        ...
    } finally {
        try {
            theBufferedWriter.close();
        } catch (IOException closeException) {
            closeException.printStackTrace();
        }
    }
} catch (IOException anException) {
    ...
}

o:

BufferedWriter theBufferedWriter;
try {
    theBufferedWriter = new ...
} catch (IOException createException) {
    // do something with createException 
    return;  // assuming we are in a method returning void
}

try {
    ...
} catch (IOException anException) {
    ...
    // assuming we don''t return here
}

try {
    theBufferedWriter.close();
} catch (IOException closeException) {
    closeException.printStackTrace();
}

pero la mayoría de las veces hago tales operaciones (por ejemplo, escribir un archivo) en un método dedicado y prefiero lanzar / an Exception para que la persona que llama pueda manejarlo (por ejemplo, solicitando otro archivo, deteniendo la aplicación, ...):

void someMethod(...) throws IOException {
    BufferedWriter theBufferedWriter = new ...

    try {
        ...
    } catch (IOExcepption anException) {
        try {
            theBufferedWriter.close();
        } catch (IOException closeException) {
            closeException.printStackTrace();
            // closeException is not thrown, anException represents the main/first problem
        }
        throw anException;
    }

    theBufferedWriter.close();  //  throws the Exception, if any
}

_{Tenga en cuenta: el inglés no es mi primer idioma ni mi segundo idioma, cualquier ayuda sería apreciada}

Answer 4

Esto es con lo que tendremos que vivir hasta los bloques Java 7 y ARM .

Answer 5

O puede usar Lombok y la anotación @Cleanup y nunca más volverá a escribir una captura de prueba.

Así es como normalmente lo escribirías (Nota: throws IOException ):

//Vanilly Java

import java.io.*;

public class CleanupExample {
  public static void main(String[] args) throws IOException {
    InputStream in = new FileInputStream(args[0]);
    try {
      OutputStream out = new FileOutputStream(args[1]);
      try {
        byte[] b = new byte[10000];
        while (true) {
          int r = in.read(b);
          if (r == -1) break;
          out.write(b, 0, r);
        }
      } finally {
        out.close();
      }
    } finally {
      in.close();
    }
  }
}

Ahora con Lombok, simplemente escribe @Cleanup en las transmisiones

import lombok.Cleanup;
import java.io.*;

 public class CleanupExample {
   public static void main(String[] args) throws IOException {
     @Cleanup InputStream in = new FileInputStream(args[0]);
     @Cleanup OutputStream out = new FileOutputStream(args[1]);
     byte[] b = new byte[10000];
     while (true) {
       int r = in.read(b);
       if (r == -1) break;
       out.write(b, 0, r);
     }
   }
 }

Answer 6

Una forma un poco más agradable de hacer esto es usar IOUtils.closeQuiety de Apache commons-io . Mantiene el código ordenado y elimina algunas de las repeticiones que son inherentes a Java.

Tu código se convierte en:

BufferedWriter theBufferedWriter = null;
try{
    theBufferedWriter = ...
    ...
} catch (IOException anException) {
    ...
} finally {
    IOUtils.closeQuietly(theBufferedWriter);
}

Mucho mejor y más expresivo.