如何简化/重用这个异常处理代码

Question

我倾向于写代码如下所示的很多：

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

，通常需要抛出异常，需要关闭，对象和关闭它也可能抛出异常。

我想知道上面的代码是否可以简化或以任何方式重用。

Answer 1

我通常会将finally块的内容放入帮助程序中。像这样

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

Closeable接口由许多类（输入流，数据库连接等）来实现，所以这是有点通用的帮手。

Answer 2

写它的方法...

BuffereWriter getMyWriter() 
{ 

// your code.... 

return w; 
} 

Answer 3

是，由于Java 1.5有一个可关闭的接口。您可以有一个关闭任何可关闭类型的静态方法。

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

Answer 4

模板方法图案这里可以应用：

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

我倾向于与其他人谁提供服用Closeable的方法达成一致，但由于maintining很长住计划，我用的解决方案略有不同。基本上它需要一个OutputStream来提供灵活性。

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

} 

这样做的主要好处是，你可以把它在多种方式，不再需要专门的工具来处理日志记录异常到stderr，stdout和文件。

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

除了这一个增加的功能，它基本上是其他人提供的相同的解决方案。

Answer 6

Java 7正在尝试资源支持。查看this了解更多信息。

我引用了相关的文字和代码示例这里：

在Java 7中的新的尝试，与资源的语言功能，有效申报的流参数作为尝试，构造的一部分，和编译器会生成代码，为您自动管理这些资源。

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

我发现通常最好不要尝试捕捉并最终全部在同一个块中。有一个try-catch块和一个单独的try-finally块通常会更好。

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

这也避免了任何需要空检查W上。

Answer 8

如果你不想写代码在finally块关闭，你应该看看Project Lombok

而不是写正常

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

随着龙目岛，你可以写

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

更可读，和它产生关闭流的正确的方法。这适用于所有的Closeable接口