转自:http://www.importnew.com/18994.html
在程序设计中,进行异常处理是非常关键和重要的一部分。一个程序的异常处理框架的好坏直接影响到整个项目的代码质量以及后期维护成本和难度。试想一下,如果一个项目从头到尾没有考虑过异常处理,当程序出错从哪里寻找出错的根源?但是如果一个项目异常处理设计地过多,又会严重影响到代码质量以及程序的性能。因此,如何高效简洁地设计异常处理是一门艺术,本文下面先讲述Java异常机制最基础的知识,然后给出在进行Java异常处理设计时的几个建议。
若有不正之处,请多多谅解和指正,不胜感激。
一.什么是异常
异常的英文单词是exception,字面翻译就是“意外、例外”的意思,也就是非正常情况。事实上,异常本质上是程序上的错误,包括程序逻辑错误和系统错误。比如使用空的引用、数组下标越界、内存溢出错误等,这些都是意外的情况,背离我们程序本身的意图。错误在我们编写程序的过程中会经常发生,包括编译期间和运行期间的错误,在编译期间出现的错误有编译器帮助我们一起修正,然而运行期间的错误便不是编译器力所能及了,并且运行期间的错误往往是难以预料的。假若程序在运行期间出现了错误,如果置之不理,程序便会终止或直接导致系统崩溃,显然这不是我们希望看到的结果。因此,如何对运行期间出现的错误进行处理和补救呢?Java提供了异常机制来进行处理,通过异常机制来处理程序运行期间出现的错误。通过异常机制,我们可以更好地提升程序的健壮性。
在Java中异常被当做对象来处理,根类是java.lang.Throwable类,在Java中定义了很多异常类(如OutOfMemoryError、NullPointerException、IndexOutOfBoundsException等),这些异常类分为两大类:Error和Exception。
Error是无法处理的异常,比如OutOfMemoryError,一般发生这种异常,JVM会选择终止程序。因此我们编写程序时不需要关心这类异常。
Exception,也就是我们经常见到的一些异常情况,比如NullPointerException、IndexOutOfBoundsException,这些异常是我们可以处理的异常。
Exception类的异常包括checked exception和unchecked exception(unchecked exception也称运行时异常RuntimeException,当然这里的运行时异常并不是前面我所说的运行期间的异常,只是Java中用运行时异常这个术语来表示,Exception类的异常都是在运行期间发生的)。
unchecked exception(非检查异常),也称运行时异常(RuntimeException),比如常见的NullPointerException、IndexOutOfBoundsException。对于运行时异常,java编译器不要求必须进行异常捕获处理或者抛出声明,由程序员自行决定。
checked exception(检查异常),也称非运行时异常(运行时异常以外的异常就是非运行时异常),java编译器强制程序员必须进行捕获处理,比如常见的IOExeption和SQLException。对于非运行时异常如果不进行捕获或者抛出声明处理,编译都不会通过。
在Java中,异常类的结构层次图如下图所示:
在Java中,所有异常类的父类是Throwable类,Error类是error类型异常的父类,Exception类是exception类型异常的父类,RuntimeException类是所有运行时异常的父类,RuntimeException以外的并且继承Exception的类是非运行时异常。
典型的RuntimeException包括NullPointerException、IndexOutOfBoundsException、IllegalArgumentException等。
典型的非RuntimeException包括IOException、SQLException等。
二.Java中如何处理异常
在Java中如果需要处理异常,必须先对异常进行捕获,然后再对异常情况进行处理。如何对可能发生异常的代码进行异常捕获和处理呢?使用try和catch关键字即可,如下面一段代码所示:
1 2 3 4 5 6 7 |
|
被try块包围的代码说明这段代码可能会发生异常,一旦发生异常,异常便会被catch捕获到,然后需要在catch块中进行异常处理。
这是一种处理异常的方式。在Java中还提供了另一种异常处理方式即抛出异常,顾名思义,也就是说一旦发生异常,我把这个异常抛出去,让调用者去进行处理,自己不进行具体的处理,此时需要用到throw和throws关键字。
下面看一个示例:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
|
这段代码和上面一段代码的区别是,在实际的createFile方法中并没有捕获异常,而是用throws关键字声明抛出异常,即告知这个方法的调用者此方法可能会抛出IOException。那么在main方法中调用createFile方法的时候,采用try…catch块进行了异常捕获处理。
当然还可以采用throw关键字手动来抛出异常对象。下面看一个例子:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
|
然后在catch块中进行捕获。
也就说在Java中进行异常处理的话,对于可能会发生异常的代码,可以选择三种方法来进行异常处理:
1)对代码块用try..catch进行异常捕获处理;
2)在 该代码的方法体外用throws进行抛出声明,告知此方法的调用者这段代码可能会出现这些异常,你需要谨慎处理。此时有两种情况:
如果声明抛出的异常是非运行时异常,此方法的调用者必须显示地用try..catch块进行捕获或者继续向上层抛出异常。
如果声明抛出的异常是运行时异常,此方法的调用者可以选择地进行异常捕获处理。
3)在代码块用throw手动抛出一个异常对象,此时也有两种情况,跟2)中的类似:
如果抛出的异常对象是非运行时异常,此方法的调用者必须显示地用try..catch块进行捕获或者继续向上层抛出异常。
如果抛出的异常对象是运行时异常,此方法的调用者可以选择地进行异常捕获处理。
(如果最终将异常抛给main方法,则相当于交给jvm自动处理,此时jvm会简单地打印异常信息)
三.深刻理解try,catch,finally,throws,throw五个关键字
下面我们来看一下异常机制中五个关键字的用法以及需要注意的地方。
1.try,catch,finally
try关键字用来包围可能会出现异常的逻辑代码,它单独无法使用,必须配合catch或者finally使用。Java编译器允许的组合使用形式只有以下三种形式:
try…catch…; try….finally……; try….catch…finally…
当然catch块可以有多个,注意try块只能有一个,finally块是可选的(但是最多只能有一个finally块)。
三个块执行的顺序为try—>catch—>finally。
当然如果没有发生异常,则catch块不会执行。但是finally块无论在什么情况下都是会执行的(这点要非常注意,因此部分情况下,都会将释放资源的操作放在finally块中进行)。
在有多个catch块的时候,是按照catch块的先后顺序进行匹配的,一旦异常类型被一个catch块匹配,则不会与后面的catch块进行匹配。
在使用try..catch..finally块的时候,注意千万不要在finally块中使用return,因为finally中的return会覆盖已有的返回值。下面看一个例子:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 |
|
这段程序的输出结果为:
可以看出,在try块中发生FileNotFoundException之后,就跳到第一个catch块,打印”file not found”信息,并将”step2″赋值给返回值,然后执行finally块,最后将返回值返回。
从这个例子说明,无论try块或者catch块中是否包含return语句,都会执行finally块。
如果将这个程序稍微修改一下,将finally块中的return语句注释去掉,运行结果是:
最后打印出的是”finally”,返回值被重新覆盖了。
因此如果方法有返回值,切忌不要再finally中使用return,这样会使得程序结构变得混乱。
2.throws和thow关键字
1)throws出现在方法的声明中,表示该方法可能会抛出的异常,然后交给上层调用它的方法程序处理,允许throws后面跟着多个异常类型;
2)一般会用于程序出现某种逻辑时程序员主动抛出某种特定类型的异常。throw只会出现在方法体中,当方法在执行过程中遇到异常情况时,将异常信息封装为异常对象,然后throw出去。throw关键字的一个非常重要的作用就是 异常类型的转换(会在后面阐述道)。
throws表示出现异常的一种可能性,并不一定会发生这些异常;throw则是抛出了异常,执行throw则一定抛出了某种异常对象。两者都是消极处理异常的方式(这里的消极并不是说这种方式不好),只是抛出或者可能抛出异常,但是不会由方法去处理异常,真正的处理异常由此方法的上层调用处理。
四.在类继承的时候,方法覆盖时如何进行异常抛出声明
本小节讨论子类重写父类方法的时候,如何确定异常抛出声明的类型。下面是三点原则:
1)父类的方法没有声明异常,子类在重写该方法的时候不能声明异常;
2)如果父类的方法声明一个异常exception1,则子类在重写该方法的时候声明的异常不能是exception1的父类;
3)如果父类的方法声明的异常类型只有非运行时异常(运行时异常),则子类在重写该方法的时候声明的异常也只能有非运行时异常(运行时异常),不能含有运行时异常(非运行时异常)。
五.异常处理和设计的几个建议
以下是根据前人总结的一些异常处理的建议:
1.只在必要使用异常的地方才使用异常,不要用异常去控制程序的流程
谨慎地使用异常,异常捕获的代价非常高昂,异常使用过多会严重影响程序的性能。如果在程序中能够用if语句和Boolean变量来进行逻辑判断,那么尽量减少异常的使用,从而避免不必要的异常捕获和处理。比如下面这段经典的程序:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
|
上边的useExceptionsForFlowControl()用一个无限循环来增加count直到抛出异常,这种做法并没有说让代码不易读,而是使得程序执行效率降低。
2.切忌使用空catch块
在捕获了异常之后什么都不做,相当于忽略了这个异常。千万不要使用空的catch块,空的catch块意味着你在程序中隐藏了错误和异常,并且很可能导致程序出现不可控的执行结果。如果你非常肯定捕获到的异常不会以任何方式对程序造成影响,最好用Log日志将该异常进行记录,以便日后方便更新和维护。
3.检查异常和非检查异常的选择
一旦你决定抛出异常,你就要决定抛出什么异常。这里面的主要问题就是抛出检查异常还是非检查异常。
检查异常导致了太多的try…catch代码,可能有很多检查异常对开发人员来说是无法合理地进行处理的,比如SQLException,而开发人员却不得不去进行try…catch,这样就会导致经常出现这样一种情况:逻辑代码只有很少的几行,而进行异常捕获和处理的代码却有很多行。这样不仅导致逻辑代码阅读起来晦涩难懂,而且降低了程序的性能。
我个人建议尽量避免检查异常的使用,如果确实该异常情况的出现很普遍,需要提醒调用者注意处理的话,就使用检查异常;否则使用非检查异常。
因此,在一般情况下,我觉得尽量将检查异常转变为非检查异常交给上层处理。
4.注意catch块的顺序
不要把上层类的异常放在最前面的catch块。比如下面这段代码:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
|
第二个catch的FileNotFoundException将永远不会被捕获到,因为FileNotFoundException是IOException的子类。
5.不要将提供给用户看的信息放在异常信息里
比如下面这段代码:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
|
展示给用户错误提示信息最好不要跟程序混淆一起,比较好的方式是将所有错误提示信息放在一个配置文件中统一管理。
6.避免多次在日志信息中记录同一个异常
只在异常最开始发生的地方进行日志信息记录。很多情况下异常都是层层向上跑出的,如果在每次向上抛出的时候,都Log到日志系统中,则会导致无从查找异常发生的根源。
7. 异常处理尽量放在高层进行
尽量将异常统一抛给上层调用者,由上层调用者统一之时如何进行处理。如果在每个出现异常的地方都直接进行处理,会导致程序异常处理流程混乱,不利于后期维护和异常错误排查。由上层统一进行处理会使得整个程序的流程清晰易懂。
8. 在finally中释放资源
如果有使用文件读取、网络操作以及数据库操作等,记得在finally中释放资源。这样不仅会使得程序占用更少的资源,也会避免不必要的由于资源未释放而发生的异常情况。
转自:https://blog.csdn.net/junlixxu/article/details/6096266
一、 异常的概念和Java异常体系结构
异常是程序运行过程中出现的错误。本文主要讲授的是Java语言的异常处理。Java语言的异常处理框架,
是Java语言健壮性的一个重要体现。
Java把异常当作对象来处理,并定义一个基类java.lang.Throwable作为所有异常的超类。
在Java API中已经定义了许多异常类,这些异常类分为两大类,错误Error和异常Exception。
Java异常体系结构呈树状,其层次结构图如图 1所示:
图 1 Java异常体系结构
Thorwable类所有异常和错误的超类,有两个子类Error和Exception,分别表示错误和异常。
其中异常类Exception又分为运行时异常(RuntimeException)和非运行时异常,
这两种异常有很大的区别,也称之为不检查异常(Unchecked Exception)
和检查异常(Checked Exception)。下面将详细讲述这些异常之间的区别与联系:
1、Error与Exception
Error是程序无法处理的错误,比如OutOfMemoryError、ThreadDeath等。这些异常发生时,
Java虚拟机(JVM)一般会选择线程终止。
Exception是程序本身可以处理的异常,这种异常分两大类运行时异常和非运行时异常。
程序中应当尽可能去处理这些异常。
2、运行时异常和非运行时异常
运行时异常都是RuntimeException类及其子类异常,如NullPointerException、IndexOutOfBoundsException等,
这些异常是不检查异常,程序中可以选择捕获处理,也可以不处理。这些异常一般是由程序逻辑错误引起的,
程序应该从逻辑角度尽可能避免这类异常的发生。
非运行时异常是RuntimeException以外的异常,类型上都属于Exception类及其子类。
从程序语法角度讲是必须进行处理的异常,如果不处理,程序就不能编译通过。
如IOException、SQLException等以及用户自定义的Exception异常,一般情况下不自定义检查异常。
二、 异常的捕获和处理
Java异常的捕获和处理是一个不容易把握的事情,如果处理不当,不但会让程序代码的可读性大大降低,
而且导致系统性能低下,甚至引发一些难以发现的错误。
Java异常处理涉及到五个关键字,分别是:try、catch、finally、throw、throws。下面将骤一介绍,
通过认识这五个关键字,掌握基本异常处理知识。
1、 异常处理的基本语法
在java中,异常处理的完整语法是:
Java代码
- try{
- //(尝试运行的)程序代码
- }catch(异常类型 异常的变量名){
- //异常处理代码
- }finally{
- //异常发生,方法返回之前,总是要执行的代码
- }
-
try{
-
//(尝试运行的)程序代码
-
}catch(异常类型 异常的变量名){
-
//异常处理代码
-
}finally{
-
//异常发生,方法返回之前,总是要执行的代码
-
}
以上语法有三个代码块:
try语句块,表示要尝试运行代码,try语句块中代码受异常监控,其中代码发生异常时,会抛出异常对象。
catch语句块会捕获try代码块中发生的异常并在其代码块中做异常处理,catch语句带一个Throwable类型的参数,
表示可捕获异常类型。当try中出现异常时,catch会捕获到发生的异常,并和自己的异常类型匹配,
若匹配,则执行catch块中代码,并将catch块参数指向所抛的异常对象。catch语句可以有多个,
用来匹配多个中的一个异常,一旦匹配上后,就不再尝试匹配别的catch块了。
通过异常对象可以获取异常发生时完整的JVM堆栈信息,以及异常信息和异常发生的原因等。
finally语句块是紧跟catch语句后的语句块,这个语句块总是会在方法返回前执行,
而不管是否try语句块是否发生异常。并且这个语句块总是在方法返回前执行。
目的是给程序一个补救的机会。这样做也体现了Java语言的健壮性。
2、 try、catch、finally三个语句块应注意的问题
第一、try、catch、finally三个语句块均不能单独使用,三者可以组成 try...catch...finally、try...catch、
try...finally三种结构,catch语句可以有一个或多个,finally语句最多一个。
第二、try、catch、finally三个代码块中变量的作用域为代码块内部,分别独立而不能相互访问。
如果要在三个块中都可以访问,则需要将变量定义到这些块的外面。
第三、多个catch块时候,只会匹配其中一个异常类并执行catch块代码,而不会再执行别的catch块,
并且匹配catch语句的顺序是由上到下。
3、throw、throws关键字
throw关键字是用于方法体内部,用来抛出一个Throwable类型的异常。如果抛出了检查异常,
则还应该在方法头部声明方法可能抛出的异常类型。该方法的调用者也必须检查处理抛出的异常。
如果所有方法都层层上抛获取的异常,最终JVM会进行处理,处理也很简单,就是打印异常消息和堆栈信息。
如果抛出的是Error或RuntimeException,则该方法的调用者可选择处理该异常。有关异常的转译会在下面说明。
throws关键字用于方法体外部的方法声明部分,用来声明方法可能会抛出某些异常。仅当抛出了检查异常,
该方法的调用者才必须处理或者重新抛出该异常。当方法的调用者无力处理该异常的时候,应该继续抛出,
而不是囫囵吞枣一般在catch块中打印一下堆栈信息做个勉强处理。下面给出一个简单例子,
看看如何使用这两个关键字:
Java代码
- public static void test3() throws Exception{
- //抛出一个检查异常
- throw new Exception("方法test3中的Exception");
- }
-
public static void test3() throws Exception{
-
//抛出一个检查异常
-
throw new Exception("方法test3中的Exception");
-
}
4、 Throwable类中的常用方法
getCause():返回抛出异常的原因。如果 cause 不存在或未知,则返回 null。
getMessage():返回异常的消息信息。
printStackTrace():对象的堆栈跟踪输出至错误输出流,作为字段 System.err 的值。
三、 异常处理的一般原则
1、 能处理就早处理,抛出不去还不能处理的就想法消化掉或者转换为RuntimeException处理。
因为对于一个应用系统来说,抛出大量异常是有问题的,应该从程序开发角度尽可能的控制异常发生的可能。
2、 对于检查异常,如果不能行之有效的处理,还不如转换为RuntimeException抛出。
这样也让上层的代码有选择的余地――可处理也可不处理。
3、 对于一个应用系统来说,应该有自己的一套异常处理框架,这样当异常发生时,也能得到统一的处理风格,
将优雅的异常信息反馈给用户。
四、 异常的转译与异常链
1、异常转译的原理
所谓的异常转译就是将一种异常转换另一种新的异常,也许这种新的异常更能准确表达程序发生异常。
在Java中有个概念就是异常原因,异常原因导致当前抛出异常的那个异常对象,
几乎所有带异常原因的异常构造方法都使用Throwable类型做参数,这也就为异常的转译提供了直接的支持,
因为任何形式的异常和错误都是Throwable的子类。比如将SQLException转换为另外一个新的异常DAOException,
可以这么写:
先自定义一个异常DAOException:
Java代码
- public class DAOException extends RuntimeException {
- /(省略了部分代码)
- public DAOException(String message, Throwable cause) {
- super(message, cause);
- }
-
public class DAOException extends RuntimeException {
-
//(省略了部分代码)
-
public DAOException(String message, Throwable cause) {
-
super(message, cause);
-
}
-
}
比如有一个SQLException类型的异常对象e,要转换为DAOException,可以这么写:
Java代码
- DAOException daoEx = new DAOException ( "SQL异常", e);
DAOException daoEx = new DAOException ( "SQL异常", e);
异常转译是针对所有继承Throwable超类的类而言的,从编程的语法角度讲,其子类之间都可以相互转换。
但是,从合理性和系统设计角度考虑,可将异常分为三类:Error、Exception、RuntimeException,笔者认为,
合理的转译关系图应该如图 2:
图 2 异常转译
为什么要这么做呢?笔者认为,异常的处理存在着一套哲学思想:对于一个应用系统来说,
系统所发生的任何异常或者错误对操作用户来说都是系统"运行时"异常,都是这个应用系统内部的异常。
这也是异常转译和应用系统异常框架设计的指导原则。在系统中大量处理非检查异常的负面影响很多,
最重要的一个方面就是代码可读性降低,程序编写复杂,异常处理的代码也很苍白无力。
因此,很有必要将这些检查异常Exception和错误Error转换为RuntimeException异常,
让程序员根据情况来决定是否捕获和处理所发生的异常。
图中的三条线标识转换的方向,分三种情况:
①:Error到Exception:将错误转换为异常,并继续抛出。例如Spring WEB框架中,
将org.springframework.web.servlet.DispatcherServlet的doDispatch()方法中,
将捕获的错误转译为一个NestedServletException异常。这样做的目的是为了最大限度挽回因错误发生带来的负面影响。
因为一个Error常常是很严重的错误,可能会引起系统挂起。
②:Exception到RuntimeException:将检查异常转换为RuntimeException可以让程序代码变得更优雅,
让开发人员集中经理设计更合理的程序代码,反过来也增加了系统发生异常的可能性。
③:Error到RuntimeException:目的还是一样的。把所有的异常和错误转译为不检查异常,
这样可以让代码更为简洁,还有利于对错误和异常信息的统一处理。
1、 异常链
异常链顾名思义就是将异常发生的原因一个传一个串起来,即把底层的异常信息传给上层,这样逐层抛出。
Java API文档中给出了一个简单的模型:
Java代码
- try {
- lowLevelOp();
- } catch (LowLevelException le) {
- throw (HighLevelException)
- new HighLevelException().initCause(le);
- }
-
try {
-
lowLevelOp();
-
} catch (LowLevelException le) {
-
throw (HighLevelException)
-
new HighLevelException().initCause(le);
-
}
当程序捕获到了一个底层异常le,在处理部分选择了继续抛出一个更高级别的新异常给此方法的调用者。
这样异常的原因就会逐层传递。这样,位于高层的异常递归调用getCause()方法,就可以遍历各层的异常原因。
这就是Java异常链的原理。异常链的实际应用很少,发生异常时候逐层上抛不是个好注意,
上层拿到这些异常又能奈之何?而且异常逐层上抛会消耗大量资源,
因为要保存一个完整的异常链信息.
五、 设计一个高效合理的异常处理框架
对于一个应用系统来说,发生所有异常在用户看来都是应用系统内部的异常。因此应该设计一套应用系统的异常框架,
以处理系统运行过程中的所有异常。
基于这种观点,可以设计一个应用系统的异常比如叫做AppException。并且对用户来说,
这些异常都是运行应用系统运行时发生的,因此AppException应该继承RuntimeException,
这样系统中所有的其他异常都转译为AppException,当异常发生的时候,前端接收到AppExcetpion并做统一的处理。
画出异常处理框架如图 3 :
图 3 一个应用系统的异常处理框架
在这个设计图中,AppRuntimeException是系统异常的基类,对外只抛出这个异常,
这个异常可以由前端(客户端)接收处理,当异常发生时,客户端的相关组件捕获并处理这些异常,
将"友好"的信息展示给客户。
在AppRuntimeException下层,有各种各样的异常和错误,最终都转译为AppRuntimeException,
AppRuntimeException下面还可以设计一些别的子类异常,比如AppDAOException、OtherException等,
这些都根据实际需要灵活处理。
在往下就是如何将捕获的原始异常比如SQLException、HibernateException转换为更高级一点AppDAOException。
有关异常框架设计这方面公认比较好的就是Spring,Spring中的所有异常都可以用org.springframework.core.NestedRuntimeException来表示,并且该基类继承的是RuntimeException。
Spring框架很庞大,因此设计了很多NestedRuntimeException的子类,还有异常转换的工具,
这些都是非常优秀的设计思想。
六、 Java异常处理总结
回顾全文,总结一下Java异常处理的要点:
1、 异常是程序运行过程过程出现的错误,在Java中用类来描述,用对象来表示具体的异常。
Java将其区分为Error与Exception,Error是程序无力处理的错误,Exception是程序可以处理的错误。
异常处理是为了程序的健壮性。
2、 Java异常类来自于Java API定义和用户扩展。通过继承Java API异常类可以实现异常的转译。
3、 异常能处理就处理,不能处理就抛出,最终没有处理的异常JVM会进行处理。
4、 异常可以传播,也可以相互转译,但应该根据需要选择合理的异常转译的方向。
5、 对于一个应用系统,设计一套良好的异常处理体系很重要。这一点在系统设计的时候就应该考虑到。