Question

我正在使用缓冲编写器和我的代码，关闭finally块中的writer。我的代码是这样的。

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

我必须在清理代码中使用try catch，因为theBufferedWriter也可能抛出IOException。我不想把这个异常抛给调用的方法。最后使用try catch是一个好习惯吗？如果不是什么替代方案？请建议。

此致 Hiral

Answer 1

更好的方法是使用Apache IOUtils.closeQuiety中的commons-io。它使您的代码保持整洁，并消除了Java中固有的一些样板。

然后您的代码变为：

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

更好，更富有表现力。

Answer 2

在Java 7之前，我会说你写的是最好的解决方案。

在Java 7及更高版本中，您Automatic Resource Management旨在简化这些事情。使用此功能，您可以执行

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

Answer 3

或者你可以使用Lombok和@Cleanup注释，你最后再也不会写一个try catch。

这就是你通常写它的方式（注意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();
    }
  }
}

现在使用Lombok，您只需在流上编写@Cleanup

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 4

这是我们在Java 7和ARM Blocks之前必须使用的内容。

Answer 5

没关系，但你应该在关闭之前测试theBufferedWriter是否为空你也可以这样做：

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

或：

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

但主要是我在专用方法中执行此类操作（例如编写文件）并且更喜欢抛出/ an Exception以便调用者可以处理它（例如，请求另一个文件，停止应用程序，......）： / p>

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
}

_{请注意：英语不是我的第一语言，也不是我的第二语言，任何帮助都将不胜感激}

Answer 6

最后把一个try-catch放进去是可以的。它是完成您想要做的工具。但是，我觉得关闭时抛出的IOException非常罕见，我会允许它像这样抑制正文中的任何异常。

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

最后可以使用try catch吗？

6 个答案: