java - sinonimos - ¿Puedo evitar un intento tan engorroso?

muy engorroso

Question

Por lo general, cuando se trata de código IO de Java, esto es lo que escribí

    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) {
            }
        }
    }

Como puede ver, mientras trato de cerrar el flujo de archivos, tengo que tratar con otro bloque try ... catch.

Parezca molesto :(

¿Hay alguna forma de evitar? No me siento cómodo al poner el código de cierre en el bloque no final, ya que la excepción causada por otros códigos no dará ninguna posibilidad de que se llame al "cierre".

Answer 1

Discusión en

Prueba-captura-finalmente y luego otra vez prueba de captura

y

¿Hay una preferencia por los bloques de prueba / captura anidados?

Básicamente, la pregunta es si vale la pena atrapar una excepción close() .

Answer 2

Es muy importante que cierres las secuencias de una manera definitiva. Puede simplificar este proceso con un método de utilidad como:

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

Hago un punto de al menos el registro de un error de cierre de flujo. El uso entonces se convierte en:

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

En Java 7, creo que las transmisiones se cerrarán automáticamente y la necesidad de tales bloques debería ser mayormente redundante.

Answer 3

Escribe un método que se vea como a continuación; Llama desde tu finalmente bloque ...

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

Answer 4

Separa tu prueba / captura y prueba / finalmente bloquea.

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

La captura exterior también atrapará cualquier cosa lanzada al cierre.

Answer 5

Tiendo a usar funciones de utilidad para esto:

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

lo que cambia el código a un poco más apetecible:

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

Realmente no se puede hacer mucho mejor en Java al menos hasta que Java 7 cuando (con suerte) los bloques ARM ("Administración automática de recursos") ayuden un poco.

Answer 6

El Proyecto Lombok proporciona una anotación @Cleanup que elimina la necesidad de probar los bloques catch catch todos juntos. Aquí hay un ejemplo .

Answer 7

La administración automática de recursos está disponible en Java 7, que proporcionará automáticamente el manejo de esto. Hasta entonces, los objetos como OutputStream , InputStream y otros implementan la interfaz de Closeable desde Java 5. Le sugiero que proporcione un método de utilidad para cerrarlos de manera segura. Estos métodos generalmente comen excepciones, así que asegúrese de que solo los use cuando quiera ignorar las excepciones (por ejemplo, en el método finally). Por ejemplo:

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

Tenga en cuenta que el método close() puede llamarse varias veces, si ya está cerrado, las llamadas subsiguientes no tendrán ningún efecto, por lo que también proporcione una llamada para cerrar durante el funcionamiento normal del bloque try, donde no se ignorará una excepción. De la documentación de Closeable.close :

Si el flujo ya está cerrado, entonces invocar este método no tiene efecto.

Entonces, cierre el flujo de salida en el flujo regular del código y el método safeClose solo funcionará de cerca si algo falla en el bloque try:

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