jee 异常处理

引自于：http://bbs.csdn.net/topics/370168373

在实际的j2ee项目中，系统内部难免会出现一些异常，如果把异常放任不管直接打印到浏览器可能会让用户感觉莫名其妙，也有可能让某些用户找到破解系统的方法。

出来工作一年时间了，我也大概对异常处理有了一些了解，在这呢小弟简单介绍下个人对异常处理的见解，抛砖引玉，希望各位大神提出宝贵的意见和建议。

 

就拿spring+struts2+hibernate项目说明：通常一个页面请求到后台以后，首先是到action（也就是所谓mvc的controller），在action层会调用业务逻辑service，servce层会调用持久层dao获取数据。最后执行结果会汇总到action，然后通过action控制转发到指定页面，执行流程如下图所示：

 

而这三层其实都有可能发生异常，比如dao层可能会有SQLException，service可能会有NullPointException，action可能会有IOException，一但发生异常并且程序员未做处理，那么该层不会再往下执行，而是向调用自己的方法抛出异常，如果dao、service、action层都未处理异常的话，异常信息会抛到服务器，然后服务器会把异常直接打印到页面，结果就会如下图所示：

 

 

其实这种错误对于客户来说毫无意义，因为他们通常是看不懂这是什么意思的。

刚学java的时候，我们处理异常通常两种方法：①直接throws，放任不管；②写try...catch，在catch块中不作任何操作，或者仅仅printStackTrace()把异常打印到控制台。第一种方法最后就造就了上图的结果；而第二种方法更杯具：页面不报错，但是也不执行用户的请求，简单的说，其实这就是bug（委婉点：通常是这样）！

 

那么发生异常到底应该怎么办呢？我想在大家对java异常有一定了解以后，会知道：异常应该在action控制转发之前尽量处理，同时记录log日志，然后在页面以友好的错误提示告诉用户出错了。大家看下面的代码：

Java代码  

1. //创建日志对象  

2. Log log = LogFactory.getLog(this.getClass());  

3.   

4. //action层执行数据添加操作  

5. public String save(){  

6.    try{  

7.          //调用service的save方法  

8.          service.save(obj);  

9.    }catch(Exception e){  

10.         log.error(...);   //记录log日志  

11.      return "error"; 到指定error页面  

12.   }  

13.   return "success";  

14.}  

 

如果按照上面的方式处理异常以后，我们用户最后看到的页面可能就会是下面这种形式（我想这种错误提示应该稍微友好点了吧）：

 

 

然后我们回到刚才处理异常的地方，如果大家积累了一些项目经验以后会发现使用上面那种处理异常的方式可能还不够灵活：

①因为spring把大多数非运行时异常都转换成运行时异常（RuntimeException）最后导致程序员根本不知道什么地方应该进行try...catch操作

②每个方法都重复写try...catch，而且catch块内的代码都很相似，这明显做了很多重复工作而且还很容易出错，同时也加大了单元测试的用例数（项目经理通常喜欢根据代码行来估算UT case）

③发生异常有很多种情况：可能有数据库增删改查错误，可能是文件读写错误，等等。用户觉得每次发生异常都是“访问过程中产生错误，请重试”的提示完全不能说明错误情况，他们希望让异常信息更详尽些，比如：在执行数据删除时发生错误，这样他们可以更准确地给维护人员提供bug信息。

 

如何解决上面的问题呢？我是这样做的：JDK异常或自定义异常+异常拦截器

struts2拦截器的作用在网上有很多资料，在此不再赘述，我的异常拦截器原理如下图所示：

 首先我的action类、service类和dao类如果有必要捕获异常，我都会try...catch，catch块内不记录log，通常是抛出一个新异常，并且注明错误信息：

Java代码  

1. //action层执行数据添加操作  

2. public String save(){  

3.    try{  

4.          //调用service的save方法  

5.          service.save(obj);  

6.    }catch(Exception e){  

7.       //你问我为什么抛出Runtime异常？因为我懒得在方法后写throws  xx  

8.       throw new RuntimeException("添加数据时发生错误！",e);  

9.   }  

10.   return "success";  

11.}  

 

 

然后在异常拦截器对异常进行处理，看下面的代码：

Java代码  

1. public String intercept(ActionInvocation actioninvocation) {  

2.   

3.         String result = null; // Action的返回值  

4.         try {  

5.             // 运行被拦截的Action,期间如果发生异常会被catch住  

6.             result = actioninvocation.invoke();  

7.             return result;  

8.         } catch (Exception e) {  

9.             /** 

10.             * 处理异常 

11.             */  

12.            String errorMsg = "未知错误！";  

13.            //通过instanceof判断到底是什么异常类型  

14.            if (e instanceof BaseException) {  

15.                BaseException be = (BaseException) e;  

16.                be.printStackTrace(); //开发时打印异常信息，方便调试  

17.                if(be.getMessage()!=null||Constants.BLANK.equals(be.getMessage().trim())){  

18.                    //获得错误信息  

19.                    errorMsg = be.getMessage().trim();  

20.                }  

21.            } else if(e instanceof RuntimeException){  

22.                //未知的运行时异常  

23.                RuntimeException re = (RuntimeException)e;  

24.                re.printStackTrace();  

25.            } else{  

26.                //未知的严重异常  

27.                e.printStackTrace();  

28.            }  

29.            //把自定义错误信息  

30.            HttpServletRequest request = (HttpServletRequest) actioninvocation  

31.                    .getInvocationContext().get(StrutsStatics.HTTP_REQUEST);  

32.              

33.            /** 

34.             * 发送错误消息到页面 

35.             */  

36.            request.setAttribute("errorMsg", errorMsg);  

37.          

38.            /** 

39.             * log4j记录日志 

40.             */  

41.            Log log = LogFactory  

42.                    .getLog(actioninvocation.getAction().getClass());  

43.            if (e.getCause() != null){  

44.                log.error(errorMsg, e);  

45.            }else{  

46.                log.error(errorMsg, e);  

47.            }  

48.  

49.            return "error";  

50.        }// ...end of catch  

51.    }  

 需要注意的是:在使用instanceof判断异常类型的时候一定要从子到父依次找，比如BaseException继承与RuntimeException，则必须首先判断是否是BaseException再判断是否是RuntimeException。

 

 

最后在error JSP页面显示具体的错误消息即可：

Java代码  

1. <body>  

2. <s:if test="%{#request.errorMsg==null}">  

3.     <p>对不起，系统发生了未知的错误</p>  

4. </s:if>  

5. <s:else>  

6.     <p>${requestScope.errorMsg}</p>  

7. </s:else>  

8. </body>  

 

以上方式可以拦截后台代码所有的异常，但如果出现数据库连接异常时不能被捕获的，大家可以使用struts2的全局异常处理机制来处理：

Java代码  

1. <global-results>  

2.     <result name="error" >/Web/common/page/error.jsp</result>  

3. </global-results>  

4.            

5. <global-exception-mappings>  

6.     <exception-mapping result="error" exception="java.lang.Exception"></exception-mapping>  

7. </global-exception-mappings>  

 

上面这是一个很简单的异常拦截器，大家可以使用自定义异常，那样会更灵活一些。

 

以上异常拦截器可以使用其它很多技术替换：比如spring aop，servlet filter等，根据项目实际情况处理。

 

【补充】ajax也可以进行拦截，但是因为ajax属于异步操作，action通过response形式直接把数据返回给ajax回调函数，如果发生异常，ajax是不会执行页面跳转的，所以必须把错误信息返回给回调函数，我针对json数据的ajax是这样做的：

Java代码  

1. /** 

2.  * 读取文件，获取对应错误消息 

3.  */  

4. HttpServletResponse response = (HttpServletResponse)actioninvocation.getInvocationContext().get(StrutsStatics.HTTP_RESPONSE);  

5. response.setCharacterEncoding(Constants.ENCODING_UTF8);  

6. /** 

7.  * 发送错误消息到页面 

8.  */  

9. PrintWriter out;  

10.try {  

11.    out = response.getWriter();  

12.    Message msg = new Message(errorMsg);  

13.    //把异常信息转换成json格式返回给前台  

14.    out.print(JSONObject.fromObject(msg).toString());  

15.} catch (IOException e1) {  

16.    throw e;  

17.}  

 

 

不错，我之前基于struts1也是类似这样的处理思路； 
这样在业务和数据层到异常可以只捕获再抛出新的定义异常；剩下交拦截器处理。 
记录log的工作还是没从业务和数据层剥离出来，传统的log记录是在数据层-业务层-控制层分别记录来跟踪出现bug的程序流程；如果在拦截器那里记录日志，又担心没法记录详细的bug出现流程信息；是否根据捕获的exception实例中可以获取到？如果可以，那如果存在业务层和数据层都有spring代理管理的话，又该如何？

异常的重要信息是放在Throwable中的，只要Throwable不要丢失，就不会有问题 
try{ 
   .... 
}catch(IOException e){ 
   throw new RuntimeException(e); 
} 

业务层和数据层由spring代理也不会有问题，只要spring未对异常进行处理消化，最终异常始终会到action层被拦截器捕获。

 

不错，思路清晰，格式良好 
如果要针对不同的异常类型做出不同的响应又该如何呢？

这位朋友过奖了。 

不同异常类型依然通过instanceof来判断，判断后就可以做不同操作 
if (e instanceof Exception1) { 
  Exception1 e1 = (Exception1) e; 
  //做其它不不同响应 
} else if(e instanceof Exception2){ 
  Exception2re = (Exception2)e; 
  //做其它不不同响应 
}

 

个人认为，根据异常类的类型来区分异常是不是有些臃肿并且难以扩展。我比较喜欢的做法是，自己定义一个BaseException，继承自RuntimeException，然后给BaseException里弄一个errorCode，用errorCode来区分异常类型，这样你只需要维护一张errorCode与异常类型的对应表，就不用定义那么多Exception类了，维护方便，扩展也方便。抛异常的时候只需设置errorCode，捕获异常之后根据errorCode去判断异常类型并做相应处理。

 

这位朋友跟我想法一致，目前我们公司项目做整体架构的时候，我就是这样设计的。我上面的意思是在开发过程中，我们可能需要引用其它的组件，而其它的组件的自定义异常是不依赖于目前项目的异常的，所以需要分开处理。 
就行下图这样，我们整个项目的异常父类是DywlException（继承自RuntimeException），另外我们把系统权限OSPMS组件整合进来了，所以还需要对权限的异常进行处理。 


 

 

我现在也是这么处理，包含如果是ajax的处理。我用的是spring mvc 

Java代码  

1. //~ Methods ========================================================================================================  

2.     @ExceptionHandler()  

3.     public @ResponseBody String handle(Exception exception, HttpServletRequest request, HttpServletResponse response) {  

4.         logger.error(request.getRequestURI() + " 请求失败", exception);  

5.           

6.         ResponseData data = new ResponseData(false, exception.getClass() + ": " + exception.getMessage());  

7.         data.setRequestURI(request.getRequestURI());  

8.           

9.         StackTraceElement[] trace = exception.getStackTrace();  

10.        StringBuilder traceContent = new StringBuilder();  

11.        for (int i=0; i < trace.length; i++)  

12.            traceContent.append("\tat " + trace[i]);  

13.        data.setExecptionTrace(traceContent.toString());  

14.          

15.        String json = "";  

16.        try {  

17.            json = mapper.writeValueAsString(data);  

18.        } catch (Exception e1) {  

19.            e1.printStackTrace();  

20.        }  

21.          

22.        if(!(request.getRequestURI().endsWith(".json") || request.getRequestURI().endsWith("Json")))  

23.            throw new RuntimeException(exception);  

24.          

25.        response.setStatus(500);//服务端处理失败  

26.        response.setContentType("application/json;charset=UTF-8");  

27.        return json;  

28.    }  

如果是ajax请求，提示处理： 

Java代码  

1. //Ajax请求完成执行。判断Session超时，如果超时或者无效，返回的内容为login.jsp页面的内容,页面包含：AJAX-AccessDeniedException  

2. //如果页面包含AJAX-AccessDeniedException，说明session超时或者无效。  

3. Ext.Ajax.on('requestcomplete', function(conn, response, options){  

4.     if(options.params['REQUEST_MODE'] == "AJAX" &&  

5.         response.responseText.indexOf("AJAX-AccessDeniedException") != -1) {  

6.         Ext.Msg.alert('提示', '会话超时，请重新登录!', function(){  

7.             window.location = './login';   

8.         });  

9.     }  

10.});  

11.  

12.Ext.Ajax.on('requestexception', function(conn, response, options){  

13.    //ajax请求，出现异常，弹出窗口提示信息。  

14.    //var json = response.responseText.replace("</generated></generated>", "");  

15.    var json = response.responseText;  

16.    var data = Ext.decode(json);  

17.  

18.    Ext.Msg.alert('提示', "请求URI："+ data.requestURI + "<br>错误信息："+   

19.        data.message + "<br><a href='#'>错误堆栈信息</a>", function(){  

20.    });  

21.    return false;  

22.});