[Path to Java Development] (20) try-with-resource exception Declaration

[Path to Java Development] (20) try-with-resource exception Declaration

Try-with-resources is a new exception handling mechanism in Java 7, which can easily close the resources used in the try-catch Block.

Before Java 7, the resources used in the program need to be explicitly disabled, and the process is a bit cumbersome, as shown below:

1. package com.qunar.lectures.tryResource;
2.  
3. import java.io.*;
4. import java.util.ArrayList;
5. import java.util.List;
6.  
7. /**
8. * Created by xiaosi on 16-3-4.
9. */
10. public class TryResourceDemo {
11. // Obtain resource data
12. public static List readLines(String resourcePath) {
13. String path = TryResourceDemo.class.getResource(resourcePath).getPath();
14. File file = new File(path);
15.  
16. if (!file.exists()) {
17. throw new RuntimeException("Can not find file + " + resourcePath);
18. }//if
19.  
20. if (!file.isFile()) {
21. throw new RuntimeException(resourcePath + " is not a regular file");
22. }//if
23.  
24. FileInputStream fis;
25. InputStreamReader isr;
26. BufferedReader br = null;
27. try {
28. fis = new FileInputStream(file);
29. isr = new InputStreamReader(fis, "UTF-8");
30. br = new BufferedReader(isr);
31. List lines = new ArrayList ();
32. String line;
33. while ((line = br.readLine()) != null) {
34. lines.add(line);
35. }//while
36. return lines;
37. }
38. catch (IOException e) {
39. throw new RuntimeException("Read file failed , file=" + resourcePath, e);
40. }
41. finally {
42. if(br != null){
43. try {
44. br.close();
45. } catch (IOException e) {
46. e.printStackTrace();
47. }
48. }//if
49. }//finally
50. }
51. public static void main(String[] args) {
52. List lines = readLines("/a.txt");
53. for(String line : lines){
54. System.out.println("line：" + line);
55. }//for
56. }
57. }

Assume that the try statement block throws an exception and the finally statement block is executed. It is also assumed that the finally statement block throws an exception. Which exception will be propagated out of the Call Stack? Even if the exception thrown in the try statement block is more relevant to the Exception Propagation, the exception finally thrown in the finally statement block will be propagated outward Based on the call stack.

1. private static void printFileJava7() throws IOException {
2. try(FileInputStream input = new FileInputStream("file.txt")) {
3. int data = input.read();
4. while(data != -1){
5. System.out.print((char) data);
6. data = input.read();
7. }
8. }
9. }

We can see the first line:

1. try(FileInputStream input = new FileInputStream("file.txt")) {

This is the usage of the try-with-resource structure. The FileInputStream type variable is declared and assigned a value in parentheses after the try keyword. The declared variables can be directly used in the following code, that is, in the same scope. When the try statement block stops running, FileInputStream is automatically disabled. This is because FileInputStream implements the java. lang. AutoCloseable interface in java. All classes that implement this interface can be used in the try-with-resources structure.

When an exception is thrown in the try-with-resources structure and the FileInputStreami is closed (the close method is called), an exception is thrown, the exceptions thrown in the try-with-resources structure will be propagated out, and the exceptions thrown when the FileInputStreami is disabled are blocked. This is opposite to the example of using the old style code at the beginning of the article (Closing the resource in the finally statement block.

In JDK 7, you can use try-with-resource to handle exceptions and disable resources as long as you implement classes or interfaces of the AutoCloseable or Closeable interfaces.

You can use multiple resources in the block and these resources can be automatically disabled:

1. package com.qunar.lectures.tryResource;
2.  
3. import java.io.*;
4. import java.util.ArrayList;
5. import java.util.List;
6.  
7. /**
8. * Created by xiaosi on 16-3-4.
9. */
10. public class TryResourceDemo {
11. // Obtain resource data
12. public static List readLines(String resourcePath) {
13. String path = TryResourceDemo.class.getResource(resourcePath).getPath();
14. File file = new File(path);
15.  
16. if (!file.exists()) {
17. throw new RuntimeException("Can not find file + " + resourcePath);
18. }//if
19.  
20. if (!file.isFile()) {
21. throw new RuntimeException(resourcePath + " is not a regular file");
22. }//if
23. // Use the try-with-resource Method to automatically release resources
24. try (FileInputStream fis = new FileInputStream(file);
25. InputStreamReader isr = new InputStreamReader(fis);
26. BufferedReader br = new BufferedReader(isr)){
27. List lines = new ArrayList ();
28. String line;
29. while ((line = br.readLine()) != null) {
30. lines.add(line);
31. }//while
32. return lines;
33. }
34. catch (IOException e) {
35. throw new RuntimeException("Read file failed , file=" + resourcePath, e);
36. }
37. }
38. public static void main(String[] args) {
39. List lines = readLines("/a.txt");
40. for(String line : lines){
41. System.out.println("line：" + line);
42. }//for
43. }
44. }