J2EE项目中异常的设计与处理

2022-09-11 10:47:38

异常设计

0.J2EE中的异常设计
             3层结构 Dao，Service，Controller
   异常处理原则：
              应该在Controller控制转发之前尽量处理，同时记录log日志，然后在页面以友好的错误提示告诉用户出错了
   eg：
       //创建日志对象
       Log log = LogFactory.getLog(this.getClass());

       //action层执行数据添加操作
       public String save(){
          try{
                //调用service的save方法
                service.save(obj);
          }catch(Exception e){
                log.error(...);   //记录log日志
             return "error"; 到指定error页面
          }
          return "success";
       }

   1.Dao层异常
              可预测异常        抛给Service层处理，有些包含了很有用的信息，eg：用户名重复的异常
              不可预测异常      自己封装起来，然后重新包装自定义的异常，抛给Service处理
   2.Service层异常
              类似DAO层异常处理
   3.Controller层处理异常
              1.Controller中可以处理任何来自底层的异常，如果是有用的信息，我们可以抛给用户，以便提示用户
              2.定义统一异常处理(Spring方式或Struts2的xml方式)，也可以分类处理异常     ---  最重要，减少手动编程，灵活处理
   4.框架本身异常或其他未知异常
              在web.xml中配置<error-page>便签，由服务容器来处理并定向到指定的页面
              配置404、400、500等异常的页面用户展示

      1.自定义异常  --- 主要用于包装异常
         eg：
           public class BaseException extends Exception {

               private static final long serialVersionUID = -4368304810297242836L;

               private String errorCode;

               private Exception exception;

               private String errorMessage;

               /**
                * @param e which cause exception
                * @param errorCode which is defined in @ErrorCodeUtil
                */
               public BaseException(Exception e, String errorCode) {
                  this.errorCode = errorCode;
                  this.exception = e;
               }

               public BaseException(Exception e) {
                  this.exception = e;
               }

               public BaseException(String errorCode) {
                  this.errorCode = errorCode;
               }

               public BaseException(String errorCode, String errorMessage) {
                  this.errorCode = errorCode;
                  this.errorMessage = errorMessage;
               }

               public BaseException(Exception e, String errorCode, String errorMessage) {
                  this.exception = e;
                  this.errorCode = errorCode;
                  this.errorMessage = errorMessage;
               }

               /**
                * @description errorCode which is defined in @ErrorCodeUtil
                * @author Jay He
                * @time Sep 28, 2015 10:34:15 AM
                * @return String
                */
               public String getErrorCode() {
                  return errorCode;
               }

               public Exception getException() {
                  return exception;
               }

               public String getErrorMessage() {
                   return errorMessage;
               }

           }

      2.DAO层异常，继承自BaseException
         eg：
           public class DataException extends BaseException{

               private static final long serialVersionUID = 1L;

               public DataException(Exception e, String errorcode) {
                   super(e, errorcode);
               }

               public DataException(String errorcode) {
                   super(errorcode);
               }

               public DataException(String errorCode, String errorMessage) {
                  super(errorCode, errorMessage);
               }

               public DataException(Exception e, String errorCode, String errorMessage) {
                  super(e,errorCode, errorMessage);
               }
           }

      3.Service层异常，继承BaseException
         eg：
           public class ServiceException extends BaseException{

           private static final long serialVersionUID = 1L;

           public ServiceException(Exception e, String errorcode) {
            super(e, errorcode);
           }

           public ServiceException(String errorcode) {
            super(errorcode);
           }

            public ServiceException(String errorCode, String errorMessage) {
                super(errorCode, errorMessage);
            }

            public ServiceException(Exception e, String errorCode, String errorMessage) {
                super(e,errorCode, errorMessage);
            }
           }
      4.其他异常   ---  根据实际需求自定义的异常
          1.权限异常
             eg：
               public class AuthorityException extends BaseException{

                   private static final long serialVersionUID = -4529873012715523511L;

                   public AuthorityException(Exception e, String errorcode) {
                       super(e, errorcode);
                   }

                   public AuthorityException(String errorcode) {
                       super(errorcode);
                   }

                   public AuthorityException(String errorCode, String errorMessage) {
                      super(errorCode, errorMessage);
                   }

                   public AuthorityException(Exception e, String errorCode, String errorMessage) {
                      super(e,errorCode, errorMessage);
                   }
               }

          2.其他自定义异常
             eg:
               public class ParameterException extends BaseException{

                   private static final long serialVersionUID = -5488824506686142281L;

                   public ParameterException(Exception e, String errorcode) {
                       super(e, errorcode);
                   }

                   public ParameterException(String errorcode) {
                       super(errorcode);
                   }

                   public ParameterException(String errorCode, String errorMessage) {
                      super(errorCode, errorMessage);
                   }

                   public ParameterException(Exception e, String errorCode, String errorMessage) {
                      super(e,errorCode, errorMessage);
                   }
               }

1.异常处理
    1.Dao与Service异常处理
        接口：
            eg:
               SigProfile saveSigProfile(SigProfile sigProfile) throws Exception;
        实现：
            eg:
               public SigProfile saveSigProfile(SigProfile sigProfile) throws Exception {
               try {
                  // 逻辑处理代码
               } catch (Exception e) {
               throw new ServiceException(errorMsg + e.getMessage());
               }
               }
    2.Controller层异常处理
            1.统一异常处理
            2.特定异常处理
    3.异常页面
            web.xml中配置常见的400、403、404、500等页面跳转

    对异常进行分离出来，并进行封装输出
     eg:
       public void doStuff()
       {
         try
         {
           //do something
         }
         catch (FileNotFoundException e)
         {
           log.info("文件未找到!文件为:xxx");
         }
         catch (SecurityException e)
         {
           log.error("无权访问,原因:xxx");
           e.printStackTrace();
         }
       }


2.整体异常处理机制

在实际的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());
  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. thrownew RuntimeException("添加数据时发生错误！",e);
  9.   }
  10. return"success";
  11. }

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

Java代码收藏代码
  1. public String intercept(ActionInvocation actioninvocation) {
  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 (einstanceof 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.             }elseif(einstanceof 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);
  33. /**
  34.              * 发送错误消息到页面
  35.              */
  36.             request.setAttribute("errorMsg", errorMsg);
  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.             }
  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>
  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. }


3.使用Spring MVC统一异常处理

1 描述
在J2EE项目的开发中，不管是对底层的数据库操作过程，还是业务层的处理过程，还是控制层的处理过程，都不可避免会遇到各种可预知的、不可预知的异常需要处理。每个过程都单独处理异常，系统的代码耦合度高，工作量大且不好统一，维护的工作量也很大。
那么，能不能将所有类型的异常处

  • 作者：小飞鹤
  • 原文链接：https://blog.csdn.net/he90227/article/details/49332407
    更新时间：2022-09-11 10:47:38