Java异常处理-CSDN博客

异常处理

Java语言的设计从根本上便于我们写出整洁、设计良好的代码；尽管如此，在程序运行中仍可能有各种各样的错误出现。

1 、概念

采用新的异常处理机制

在以往的程序开发过程中，常常采用返回值进行处理。例如，在编写一个方法，可以返回一个状态代码，调用者根据状态代码判断出错与否。若状态代码表示一个错误，则调用这进行相应的处理，或显示一个错误页面或错误信息。通过返回值进行处理的方法是有效的，但是有它的许多不足之处。

1、程序复杂

2、可靠性差

3、返回信息有限

4、返回代码标准化困难

采用错误代码和异常处理相结合的方式的优越性：

1、把错误代码与常规代码分开

2、可以在 catch 中传播错误信息

3、可以对错误类型分组

4、方便定位错误，维护

异常

异常就是异常事件，它是程序遇到异常情况所激发的事件。许多异常，如程序错误，空指针，数组溢出等。下面是一个出错流程

上图中：

第一步：插入用户的 Keynet ，登录系统

第二步：服务器验证用户的身份，判断用户的权限

第三步：返回错误的信息。

这是一个简单的异常处理示例，怎样简单、方便、快捷的得到错误信息。可以采用错误代码和异常两种方式相结合的方式处理。

2 、异常处理

Java 的异常是面向对象的。一个 Java 的 Exception 是一个描述异常情况的对象 . 当出现异常情况时，一个 Exception 对象就产生了 , 并放到异常的成员函数里。

Java 的异常处理是通过 5 个关键词来实现的： try,catch,throw,throws 和 finally 。在 Java 语言的错误处理结构由 try ， catch ， finally 三个块组成。其中 try 块存放将可能发生异常的 Java 语言，并管理相关的异常指针； catch 块紧跟在 try 块后面，用来激发被捕获的异常； finally 块包含清除程序没有释放的资源，句柄等。不管 try 块中的代码如何退出，都将执行 finally 块。

try… catch… 块

可以采用 try 来指定一块预防所有异常的程序。紧跟在 try 程序块后面，应包含一个

或多个 catch 子句来指定你想要捕获的异常类型： try catch 的格式一般为：

try{

/**do something*/

}catch(…){

…

}catch(…){

…

}

例如：

try{

int a= 100/0

}catch(Exception e){

System.out.println(e.getMessage());

}

每当 Java程序激发一个异常时，它实际上是激发了一个对象，而只有其超类为Throwable类的对象才能被激发。Throwable类中的提供了一些方法。如：其中的getMessage()方法打印出异常对应信息。

Catch子句的目标是解决异常情况，把变量设到合理的状态，并象没有出错一样继续运行。如果一个子程序不处理没个异常，则返回到上一级处理，如此可以不断的递归向上直到最外一级。

finally 块

finally 关键字是对 Java 异常处理模型的最佳补充。 finally 结构使代码总会执行，而不管有无异常发生。使用 finally 可以维护对象的内部状态，并可以清理非内存资源。如果没有 finally，您的代码就会很费解。例如，下面的代码说明，在不使用 finally 的情况下您必须如何编写代码来释放非内存资源：

import java.net.*; import java.io.*; class WithoutFinally { public void foo() throws IOException { //在任一个空闲的端口上创建一个套接字 ServerSocket ss = new ServerSocket(0); try { Socket socket = ss.accept(); //此处的其他代码... } catch (IOException e) { ss.close(); //1 throw e; } //... ss.close(); //2 } }

这段代码创建了一个套接字，并调用 accept 方法。在退出该方法之前，您必须关闭此套接字，以避免资源漏洞。为了完成这一任务，我们在 //2 处调用 close，它是该方法的最后一条语句。但是，如果 try 块中发生一个异常会怎么样呢？在这种情况下，//2 处的 close 调用永远不会发生。因此，您必须捕获这个异常，并在重新发出这个异常之前在 //1 处插入对 close 的另一个调用。这样就可以确保在退出该方法之前关闭套接字。

这样编写代码既麻烦又易于出错，但在没有 finally 的情况下这是必不可少的。不幸的是，在没有 finally 机制的语言中，程序员就可能忘记以这种方式组织他们的代码，从而导致资源漏洞。Java 中的 finally 子句解决了这个问题。有了 finally，前面的代码就可以重写为以下的形式：

import java.net.*; import java.io.*; class WithFinally { public void foo2() throws IOException { //在任一个空闲的端口上创建一个套接字 ServerSocket ss = new ServerSocket(0); try { Socket socket = ss.accept(); //此处的其他代码... } finally { ss.close(); } } }

finally 块确保 close 方法总被执行，而不管 try 块内是否发出异常。因此，可以确保在退出该方法之前总会调用 close 方法。这样您就可以确信套接字被关闭并且您没有泄漏资源。在此方法中不需要再有一个 catch 块。在第一个示例中提供 catch 块只是为了关闭套接字，现在这是通过 finally 关闭的。如果您确实提供了一个 catch 块，则 finally 块中的代码在 catch 块完成以后执行。

finally 块必须与 try 或 try/catch 块配合使用。此外，不可能退出 try 块而不执行其 finally 块。如果 finally 块存在，则它总会执行。（无论从那点看，这个陈述都是正确的。有一种方法可以退出 try 块而不执行 finally 块。如果代码在 try 内部执行一条 System.exit(0); 语句，则应用程序终止而不会执行 finally 执行。另一方面，如果您在 try 块执行期间拨掉电源，finally 也不会执行。）

try…catch…finally 块

最好采用此结构处理异常 . 在 catch 中捕获异常 , 在 finally 块中清除不需要的资源 , 这样程序结构将会更完善 , 健壮 . 例如 :

try{

/**to do */

}

catch(Exception ex){

System.out.println(ex.getMessage());

}

finally{

clearUpAll()

}

3 、激发异常

Java 语言可以不在方法中直接捕获，而用 throw 语句将异常抛给上层的调用者。 Throw 语句就是来明确地抛出一个异常；首先你必需得到一个 Throwable 的实例句柄，通过参数传到 catch 中，或者采用 new 操作符来创建一个。

格式： throw new WhcaException(e.getMessage);

程序会在 throw 语句后立即终止，它后面的语句都不执行，然后在包含它的所有 try 块中从里到外寻找含有与其匹配的 catch.

声明异常类

当 throw 语句被用在方法说明中时， throw 有用 throws 代替。关键字 throws 用来标明一个方法可能抛出的各种异常。对大多数 Exception 子类来说， Java 编译器会强迫你声明在一个方法中抛出的异常的类型。如下：

格式： type method_name(arg_list) throws WhcaException{

……

}

例如： public void execute(String str,int index) throws WhcaException{

try{

}

catch(Exception e){

throw new WhcaException(“JB: M:”+e.getMessage);

}

4 、创建自己的异常类

当程序员为提供一些特定的功能用 Java类时，往往需要保证类之间有良好的关系，而且类之间的接口易于理解和实现，这是定义一个新的异常类。建议创建自己的异常类，便于维护，管理。

定义一个新的异常类

通常采用 Exception 作为异常类的超类，如：

package whca.common;

public class WhcaException extends Exception{

public WhcaException(){

}

public WhcaException(String s){

super(s);

}

5 、示例

下面是示例： TestServlet 调用TestDB和TestPsi，（附代码）如果发生异常怎样最快解决程序发生的异常错误。

在整个项目的开发过程中，指定 错误代码表，并分类。如 PSI类，数据库异常类代码，应用异常类代码，XML异常，网络通讯异常等等；

采用自己的异常类，当遇到异常是，激发的异常携带错误类或异常方法的路径：

如： setFlag(“PSI001”);

throw new WhcaException(“JB:TestA M:exe1 ”+e.getMessage);

这里： PSI001为错误代码，“JB:TestA M:exe1”为 异常链，e.getMessage为异常信息。

例如：遇到错误信息列表为： JB:TestB M:exe2 JB:TestA M:exe1 java.sql.SQLException,说明TestB 的方法exe2调用TestA的方法exe1发生了操作数据库异常。则可以迅速，准确的定位到那个类那个方法发生了异常。

注：（简写）JB：JavaBean M：Method

访问数据库类

//Class: TestDB

package corbaidl;

/**

* Title:

* Description:

* Company:

* @author

* @version 1.0

import java.io.*;

import java.sql.*;

import whca.common.WhcaException;

public class TestDB {

private PreparedStatement pstmt =null;

private Connection conn = null;

private String flag;

public TestDB() {

}

public void CreateSysMan() throws WhcaException{

try {

/**@todo: CreateSysMan method*/

}

catch (Exception ex) {

setFlag(ORA004);

throw new WhcaException(JB:TestDB M:CreateSysMan ERR=+ex.getMessage());

}

finally {

cleanUpAll();

}

public void PublishCert() throws WhcaException{

try {

/**@todo: PublishCert method*/

}

catch (Exception ex) {

setFlag(ORA005);

throw new WhcaException(JB:TestDB M:PublishCert ERR=+ex.getMessage());

}

finally {

cleanUpAll();

}

public void cleanUpAll() throws WhcaException {

try {

if (pstmt != null)

pstmt.close();

if (conn != null)

conn.close();

} catch (Exception e) {

throw new WhcaException(JB:RootCaDB M:cleanUpAll Exception + e.getMessage());

}

public void setFlag(String flag) {

this.flag = flag;

}

public String getFlag() {

return flag;

}

Psi 调用公共类

//Class: TestPsi

package corbaidl;

/**

* Title:

* Description:

* Company:

* @author

* @version 1.0

import psi.*;

import whca.common.WhcaException;

public class TestPsi {

private PSIJni psijni;

private String flag;

private int exeHandle=0;

public TestPsi() {

}

public int exePsiInit() throws WhcaException {

try {

//Step 1:psijni init

int ret;

int handle;

psijni = new PSIJni();

ret = psijni.pkiInit();

if (ret != 0) {

setFlag(PSI001);

throw new WhcaException(Initialize library environment failed!);

}

//Step 2:psijni getHandle

handle = psijni.getHandle();

if (handle < 0) {

setFlag(PSI002);

throw new WhcaException(Get handle error);

}

return handle;

} catch (Exception ex) {

throw new WhcaException(ex.getMessage());

}

public void exePsiEnd(int handle) throws WhcaException {

try {

psijni.destroyHandle(handle);

psijni.pkiEnd();

} catch (Exception ex) {

throw new WhcaException(ex.getMessage());

}

public void exeGetCert(String tcCert) throws WhcaException {

try {

PKI_DATA inData;

PKI_CERTINFO certInfo;

//Step 1:psijni init

int exeHandle = exePsiInit();

//Step 2:ReadLable

inData = new PKI_DATA();

int ret = psijni.pkiReadLabel(exeHandle, tcCert, LABEL_TYPE.LBL_CERT, inData);

if (ret != 0) {

setFlag(PSI003);

throw new WhcaException(ReadLabel Error);

}

byte[] cert_temp = inData.getValue();

} catch (Exception ex) {

throw new WhcaException(JB:RootCaPsi M:exeCertSN Exception + ex.getMessage());

} finally{

//一定要执行的关闭PSI

exePsiEnd(exeHandle);

}

public void setFlag(String flag) {

this.flag = flag;

}

public String getFlag() {

return flag;

}

JavaServlet 处理类

//Class:TestServlet

Servlet调用TestDB,TestPsi,将错误异常都抛给Catch处理

package corbaidl;

import javax.servlet.*;

import javax.servlet.http.*;

import java.io.*;

import java.util.*;

import java.sql.*;

import whca.common.*;

public class TestServlet extends HttpServlet {

private static final String CONTENT_TYPE = text/html; charset=GBK;

private WhcaLog whcalog = new WhcaLog();

private Connection conn =null;

private String TmpErr=;

private String outpage=;

private String SuccPage=;

private String FailPage=;

/**Initialize global variables*/

public void init() throws ServletException {

}

/**Process the HTTP Get request*/

public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

try {

PerformTask(request,response);

}

catch (Exception ex) {

whcalog.log(whcalog.REN_ZHIGUO,ex.getMessage());

}

/**Process the HTTP Put request*/

public void doPut(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

try {

PerformTask(request,response);

}

catch (Exception ex) {

whcalog.log(whcalog.REN_ZHIGUO,ex.getMessage());

}

/**PerformTask*/

public void PerformTask(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException,WhcaException {

try {

//Step 1:

SuccPage = /CaApp/subca/initial/disa/DiSAInit.jsp;

FailPage = /CaApp/subca/yhgl/error.jsp;

//Step 2:

DB_Connection ds = new DB_Connection();

try {

conn = ds.subca();

}

catch (Exception ex) {

TmpErr=ORA001;

throw new WhcaException(连接数据库失败+ex.getMessage());

}

//Step 3:

TestDB testdb = new TestDB();

try {

testdb.CreateSysMan();

}

catch (Exception ex) {

TmpErr=testdb.getFlag();

throw new WhcaException(创建系统管理员失败+ex.getMessage());

}

//Step 4:psi

TestPsi testpsi = new TestPsi();

try {

testpsi.exeGetCert(ROOTCA_CERT);

}

catch (Exception ex) {

TmpErr=testdb.getFlag();

throw new WhcaException(取根证书信息失败+ex.getMessage());

}

//Step 5:

outpage=SuccPage;

invokejsp(request,response,成功);

}

catch (Exception ex) {

whcalog.log(whcalog.REN_ZHIGUO,ex.getMessage());

outpage=FailPage;

invokejsp(request,response,ErrorMsg(TmpErr));

}

finally{

cleanUpAll();

}

/**Clean up resources*/

public void destroy() {

}

public void cleanUpAll() throws WhcaException {

try {

if (conn != null)

conn.close();

} catch (Exception e) {

throw new WhcaException(Servlet:TestServlet M:cleanUpAll Exception + e.getMessage());

}

public void invokejsp(HttpServletRequest req, HttpServletResponse res, String msg) throws ServletException {

try {

req.setAttribute(Msg, msg);

RequestDispatcher rd = getServletContext().getRequestDispatcher(outpage);

rd.forward(req, res);

} catch (IOException ex) {

/**可能会发生网页错误*/

whcalog.log(whcalog.REN_ZHIGUO,invokejsp+ex.getMessage());

}

public String ErrorMsg(String msg) throws WhcaException {

try {

WhcaErrorCode ErrorCode = new WhcaErrorCode();

return ErrorCode.exeErrorCode(conn, msg,0);

} catch (Exception ex) {

/**可能会发生数据库连接失败*/

whcalog.log(whcalog.REN_ZHIGUO,ErrorMsg+ex.getMessage());

throw new WhcaException(ErrorMsg Error+ex.getMessage());

}