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

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块中编写关闭代码，您应该看看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();
    }
  }
}

使用 Lombok，您可以编写

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

，并且它会生成关闭 Stream 的正确方法。这适用于所有 Closeable 接口

Answer 2

我通常将 finally 块的内容放在助手中。就像这个

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

Closeable 接口是由许多类（输入流、数据库连接等）实现的，所以这是一种通用的帮助器。

Answer 3

是的，从java 1.5开始就有一个Closeable接口。您可以使用静态方法来关闭任何 Closeable 类型。

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

Answer 4

Java 7正在尝试资源支持。检查这个更多信息。

我在这里引用相关文本和代码示例：

使用 Java 7 中新的 try-with-resource 语言功能，您可以有效地将流参数声明为 try-construct 的一部分，并且编译器会自动生成管理这些资源的代码并为您干净利落。

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 5

我倾向于同意其他人提供的采用 Closeable 的方法，但由于维护寿命很长的程序，我使用的解决方案略有不同。基本上它需要一个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

我发现通常最好不要将 try catch 和 finally 全部放在同一个块中。通常最好有一个 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 7

将其写在方法中...

BuffereWriter getMyWriter()
{

// your code....

return w;
}

Answer 8

可以在此处应用模板方法模式：

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