问题引入看如下测试代码:
![](https://i-blog.csdnimg.cn/blog_migrate/8f900a89c6347c561fdf2122f13be562.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/961ddebeb323a10fe0623af514929fc1.gif)
import java.io.*;
public class HideException {
//一个函数同时读取两个文件
public void readTwoFile() throws FileNotFoundException, IOException{
BufferedReader br1 = null;
BufferedReader br2 = null;
FileReader fr = null;
try{
fr = new FileReader("A.txt"); //1
br1 = new BufferedReader(fr);
int count = br1.read(); //2
//process code1....
fr = new FileReader("B.txt"); //3
br2 = new BufferedReader(fr);
count = br2.read(); //4
//process code2
}finally{
if(br1 != null)
br1.close(); //5
if(br2 != null)
br2.close(); //6
}
}
//测试客户端
public static void main(String[] args){
HideException he = new HideException();
try {
he.readTwoFile();
} catch (FileNotFoundException e) {
//...
e.printStackTrace(); //7
} catch (IOException e) {
//...
e.printStackTrace(); //8
}
}
}
如代码片段3所示,readTwoFile用来读取两个文件。其中语句//1与语句//3有可能会抛出FileNotFoundException;语句//2、//4、//5、//6有可能会抛出IOException。按照对控制流的执行逻辑分析,上述代码中的finally子句是无论如何都会被执行的。当//3、//5同时发生异常时,会执行main函数中的哪条/哪些语句?
答案揭晓:当//3产生了一个FileNotFoundException时,控制流会转向到finally子句,但是其中//5又发生了IOException,那么这个时候返回main调用端的将会是IOException而不是FileNotFoundException。因为//3产生的异常被//5抛出的异常所覆盖了。为此,将执行main函数中的语句//8。
重点:一个函数尽管抛出了多个异常,但是只有一个异常可被传播到调用端。
记住:最后被抛出的异常时唯一被调用端接收的异常,其他异常都会被吞没掩盖。如果调用端要知道造成失败的最初原因,程序之中就绝不能掩盖任何异常。
一、自定异常封装类
上述的问题原因是异常被抛弃了为此,一个简单的想法就是我们需要把函数执行过程中被【丢弃】的异常保存下来即可。一个解决思路是:可以定义一个列表,用于包含所有的异常。在函数最后抛出一个异常,该异常包括了上述所有的异常。这样,我们就可以保证不会出现【丢弃】的现象。
第一步:定义一个自定义的异常封装类,用于包含所有的抛出的异常。如下述代码所示:
代码片段1
CustomException异常只是一个异常集合,可以容纳多个异常,但是它本身并非真正意义上的异常,它只是为了解决可一次抛出多个异常。
第二步:改造业务代码,解决异常【丢弃】的问题。建立一个容纳可能抛出多个异常的容器,然后在可能抛出异常位置均把异常加入到容器内即可。如代码片段2所示。
代码片段2
![](https://i-blog.csdnimg.cn/blog_migrate/8f900a89c6347c561fdf2122f13be562.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/961ddebeb323a10fe0623af514929fc1.gif)
public class HideException { // 自定义异常类 class CustomeException extends Exception { // 此处省略,详见代码片段1 } // 一个函数同时读取两个文件 public void readTwoFile() throws CustomeException { BufferedReader br1 = null; BufferedReader br2 = null; FileReader fr = null; List<Throwable> list = new ArrayList<Throwable>(); try { fr = new FileReader("A.txt"); // 1 br1 = new BufferedReader(fr); int count = br1.read(); // 2 // process code1.... fr = new FileReader("B.txt"); // 3 br2 = new BufferedReader(fr); count = br2.read(); // 4 // process code2 } catch (FileNotFoundException ffe) { list.add(ffe); //防止丢弃异常 } catch (IOException ie) { list.add(ie);//防止丢弃异常 } finally { if (br1 != null) { try { br1.close(); } catch (IOException ie) { list.add(ie);//防止丢弃异常 } } if (br2 != null) { try { br2.close(); } catch (IOException ie) { list.add(ie);//防止丢弃异常 } } } // 检查异常的数目 if (list.size() > 0) throw new CustomeException(list); } // 测试客户端 public static void main(String[] args) { HideException he = new HideException(); try { he.readTwoFile(); } catch (CustomeException ce) { // 异常处理代码 // ...... } } }
上诉代码把每一个异常都添加到一个异常集合里,解决了异常丢弃异常,同时也可以将异常进行集中处理。
二、异常链
定义:代码由一层层的函数调用组成。如果一个函数抛出了异常,一种方法是就地解决;一种方法是调用throw方法将异常抛出给上层调用函数;同理,上层调用函数仍然可以再次调用throw方法继续抛出该方法的异常;如此,就会产生一条由异常构成的异常链。
为什么:对于有些异常如果采取就地解决,就会让上层调用函数不知道是什么原因引起了程序异常,为此就不便于程序排错或用户操作反馈。为此,需要异常链的层层传递,最终让有相应处理职责的函数进行异常处理。
异常链实现异常传递如下代码:
public class ExceptionChainTest {
class CustomeException extends Exception {
//1 空构造函数
public CustomeException() {
super();
}
//2 定义异常原因
public CustomeException(String message) {
super(message);
}
//3 定义异常原因,并保留原始信息
public CustomeException(String message, Throwable cause) {
super(message, cause);
}
//4 保留原始信息
public CustomeException(Throwable cause) {
super(cause);
}
}
//底层测试函数
public void func2() throws Exception {
throw new Exception("func2 exception ....");
}
//上层测试函数
public void func1() throws Exception {
try {
func2();
} catch (Exception ex) {
throw new CustomeException("func1 exception");//5
}
}
//客户端测试函数
public static void main(String[] args) {
ExceptionChainTest test = new ExceptionChainTest();
try {
test.func1();
} catch (Exception e) {
e.printStackTrace();
}
}
}
第一步:我们首先自定义了一个异常类:CustomeException。该构造函数中的第//3与第//4种方式是实现异常链的核心,即保留了原始的异常信息。
第二步,我们模拟了一个例子来说明是如何实现异常链传递的,函数调用链是:main函数->func1函数->func1函数。按照执行逻辑,最底层函数func2() 函数会抛出一个Exception类型的异常给上层func1( ) ,func1()函数没有对异常做具体的处理,只是重新生成了一个异常对象抛给main函数。
大家思考一分钟,想想会输出什么信息:
觉得上面的信息是不是少了一点什么?是的,居然丢弃了最原始的引起异常的原因。老铁们想想可以怎么解决了?
解决问题的方法也很简单,就是把代码片段中的//5
throw new CustomeException("func1 exception");//5
替换为:
throw new CustomeException("func1 exception", ex); //6
替换以后,程序运行结果为:
OK!世界又回到了和谐状态,从抛出的异常中我们找到了造成异常的最原始原因。注意代码片段//5 中,丢失了原始异常信息,而修改后的//6 是真正的异常封装,保留了原始异常信息。
重点:上层调用函数捕捉到异常后,可以对异常进行封装(如上例中第3、4种构造函数的方式)后再抛出,这样后续调用函数所获得的异常信息就不会丢失,进而就能获得产生异常的根本原因,以便程序员解决问题或反馈给使用用户。
三、小结
-
异常需要封装和传递,对待异常,我们不要“吞噬”异常,也不要直接抛出异常,可采取一个异常容器对代码执行过程中抛出的异常进行收集,最后反馈给调用端,如此就不会丢弃异常,方便用户获取产生异常的根本原因。该技术常用于一个函数可能会抛出多种异常的情况。
-
异常链也是一种传递异常的实用方法,该技术常用于有一定函数调用深度的业务场景。
本文来自该公众号——程序员Chatbook