cómo simplificar/reutilizar el código de control de excepciones

Question

tiendo a escribir código como el siguiente mucho:

BufferedWriter w = null; // Or any other object that throws exceptions and needs to be closed 
try { 
    w = new BufferedWriter(new FileWriter(file)); 
    // Do something with w 
} catch (IOException e) { 
    e.printStackTrace(); 
} finally { 
    if (w != null) { 
     try { 
      w.close(); 
     } catch (IOException e) { 
      e.printStackTrace(); 
     } 
    } 
} 

lo general, implica un objeto que emite excepciones y necesita ser cerrado, y que cerrar también puede lanza una excepción

Me preguntaba si el código anterior se puede simplificar o reutilizar de cualquier manera.

Answer 1

Normalmente pongo el contenido de tu bloque finally en un helper. Al igual que esta interfaz

void close(Closeable c) { 
    if (c != null) { 
     try { 
      c.close(); 
     } catch (IOException e) { 
      // perform logging or just ignore error 
     } 
    } 
} 

Closeable es implementado por muchas clases (flujos de entrada, las conexiones de bases de datos, etc.), así que esto es un poco de ayuda de propósito general.

Answer 2

escribirlo en un método ...

BuffereWriter getMyWriter() 
{ 

// your code.... 

return w; 
} 

Answer 3

Sí, ya que Java 1.5 hay una interfaz que se puede cerrar. Puede tener un método estático que cierre cualquier tipo de Cierre.

public static void closeIO(Closeable closeable){ 
     if (closeable != null) { 
     try { 
      closeable.close(); 
     } catch (IOException e) { 
      e.printStackTrace(); 
     } 
    } 
} 

Answer 4

Un patrón método de la plantilla se puede aplicar aquí:

public class FileTemplate { 
    public void write(File file, WriteCallback c) { 
     BufferedWriter w = null; // Or any other object that throws exceptions and needs to be closed 
     try { 
      w = new BufferedWriter(new FileWriter(file)); 
      c.writeFile(w); 
     } catch (IOException e) { 
      e.printStackTrace(); 
     } finally { 
      if (w != null) { 
       try { 
        w.close(); 
       } catch (IOException e) { 
        e.printStackTrace(); 
       } 
      } 
     } 
    } 
} 

public interface WriteCallback { 
    public void writeFile(BufferedWriter w) throws IOException; 
} 

.

new FileTemplate().write(file, new WriteCallback() { 
    public void writeFile(BufferedWriter w) { ... } 
}); 

Answer 5

estoy de acuerdo con otros que ofrecen un método de tomar una Closeable, pero debido a maintining programas de muy larga duración, la solución que uso es un poco diferente. Básicamente se necesita OutputStream para proporcionar flexibilidad.

public class IOHandler { 

    private IOHandler(); 

    public static void close(OutputStream out, Closeable c) { 
    if (c != null) { 
     try { 
     c.close(); 
    } catch (IOException e) { 
     out.print(c.printStackTrace().getBytes()); 
    } 
    } 

} 

Las principales ventajas de esto es que se puede llamar así en una variedad de formas, eliminando la necesidad de utilidades especializadas para manejar excepciones de registro en stderr, stdout, y archivos.

IOHandler.close(System.out, openFile); 
IOHandler.close(System.err, openFile); 
IOHandler.close(logFile, openFile); 

Aparte de esta característica adicional, es básicamente la misma solución que otros han ofrecido.

Answer 6

Java 7 está intentándolo con soporte de recursos. Consulte this para obtener más información.

cito el texto relevante y un ejemplo de código aquí:

con la nueva característica del lenguaje try-con-recursos en Java 7, se declara con eficacia sus argumentos corriente como parte del try-construcción, y el el compilador genera código que administra esos recursos de manera automática y limpia para usted.

private static void customBufferStreamCopy(File source, File target) { 
    try (InputStream fis = new FileInputStream(source); 
     OutputStream fos = new FileOutputStream(target)){ 

     byte[] buf = new byte[8192]; 

     int i; 
     while ((i = fis.read(buf)) != -1) { 
      fos.write(buf, 0, i); 
     } 
    } 
    catch (Exception e) { 
     e.printStackTrace(); 
    } 
} 

Answer 7

Encuentro que generalmente es mejor no intentar atrapar y finalmente todo en el mismo bloque. A menudo es mejor tener un bloque try-catch y un bloque try-finally separado.

try { 
    BufferedWriter w = new BufferedWriter(new FileWriter(file)); // Or any other object that throws exceptions and needs to be closed 
    try { 
     // Do something with w 
    } finally { 
     w.close(); 
    } 
} catch (IOException e) { 
    e.printStackTrace(); 
} 

Esto también evita la necesidad de anular la comprobación w.

Answer 8

Si no desea escribir código para cerrar finalmente en bloque, usted debe echar un vistazo a Project Lombok

En lugar de escribir la normalidad

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(); 
    } 
    } 
} 

Con Lombok se puede escribir

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

Mucho más legible, y genera la forma correcta de cerrar el flujo. Esto funciona con todas las interfaces Closeable