Spring全局异常处理的三种方式

  在J2EE项目的开发中,不管是对底层的数据库操作过程,还是业务层的处理过程,还是控制层的处理过程,都不可避免会遇到各种可预知的、不可预知的异常需要处理。每个过程都单独处理异常,系统的代码耦合度高,工作量大且不好统一,维护的工作量也很大。 那么,能不能将所有类型的异常处理从各处理过程解耦出来,这样既保证了相关处理过程的功能较单一,也实现了异常信息的统一处理和维护?答案是肯定的。下面将介绍使用Spring MVC统一处理异常的解决和实现过程。

  • 使用Spring MVC提供的SimpleMappingExceptionResolver
  • 实现Spring的异常处理接口HandlerExceptionResolver 自定义自己的异常处理器
  • 使用@ExceptionHandler注解实现异常处理

  (一) SimpleMappingExceptionResolver 
  使用这种方式具有集成简单、有良好的扩展性、对已有代码没有入侵性等优点,但该方法仅能获取到异常信息,若在出现异常时,对需要获取除异常以外的数据的情况不适用。

 1 @Configuration
 2 @EnableWebMvc
 3 @ComponentScan(basePackages = {"com.balbala.mvc.web"})
 4 public class WebMVCConfig extends WebMvcConfigurerAdapter{
 5   @Bean
 6     public SimpleMappingExceptionResolver simpleMappingExceptionResolver()
 7     {
 8         SimpleMappingExceptionResolver b = new SimpleMappingExceptionResolver();
 9         Properties mappings = new Properties();
10         mappings.put("org.springframework.web.servlet.PageNotFound", "page-404");
11         mappings.put("org.springframework.dao.DataAccessException", "data-access");
12         mappings.put("org.springframework.transaction.TransactionException", "transaction-Failure");
13         b.setExceptionMappings(mappings);
14         return b;
15     }
16 }

  (二) HandlerExceptionResolver
  相比第一种来说,HandlerExceptionResolver能准确显示定义的异常处理页面,达到了统一异常处理的目标
  1.定义一个类实现HandlerExceptionResolver接口

 1 public class GlobalHandlerExceptionResolver implements HandlerExceptionResolver {
 2  private static final Logger LOG = LoggerFactory.getLogger(GlobalHandlerExceptionResolver.class);
 3    /**
 4     * 在这里处理所有得异常信息
 5     */
 6    @Override
 7    public ModelAndView resolveException(HttpServletRequest req,                                         HttpServletResponse resp, Object o, Exception ex) {
 8        ex.printStackTrace();
 9        if (ex instanceof AthenaException) {
10            //AthenaException为一个自定义异常
11            ex.printStackTrace();
12            printWrite(ex.toString(), resp);
13            return new ModelAndView();
14         }
15        //RspMsg为一个自定义处理异常信息的类
16        //ResponseCode为一个自定义错误码的接口
17        RspMsg unknownException = null;
18        if (ex instanceof NullPointerException) {
19            unknownException = new RspMsg(ResponseCode.CODE_UNKNOWN, "业务判空异常", null);
20        } else {
21            unknownException = new RspMsg(ResponseCode.CODE_UNKNOWN, ex.getMessage(), null);        }
22            printWrite(unknownException.toString(), resp);
23            return new ModelAndView();
24    }
25
26    /**
27    * 将错误信息添加到response中
28    *
29    * @param msg
30    * @param response
31    * @throws IOException
32    */
33     public static void printWrite(String msg, HttpServletResponse response) {
34          try {
35              PrintWriter pw = response.getWriter();
36              pw.write(msg);
37              pw.flush();
38              pw.close();
39           } catch (Exception e) {
40              e.printStackTrace();
41           }
42     }
43 }

  这种方式实现的异常处理,可以针对不同的异常和自己定义的异常码进行翻译,然后输出到response中,在前端展示。

  (三)@ExceptionHandler

  1.首先定义一个父类,实现一些基础的方法

 1 public class BaseGlobalExceptionHandler {
 2      protected static final Logger logger = null;
 3      protected static final String DEFAULT_ERROR_MESSAGE = "系统忙,请稍后再试";
 4
 5      protected ModelAndView handleError(HttpServletRequest req, HttpServletResponse rsp, Exception e, String viewName, HttpStatus status) throws Exception {
 6          if (AnnotationUtils.findAnnotation(e.getClass(), ResponseStatus.class) != null)
 7          throw e;
 8          String errorMsg = e instanceof MessageException ? e.getMessage() : DEFAULT_ERROR_MESSAGE;
 9          String errorStack = Throwables.getStackTraceAsString(e);
10
11          getLogger().error("Request: {} raised {}", req.getRequestURI(), errorStack);
12          if (Ajax.isAjax(req)) {
13               return handleAjaxError(rsp, errorMsg, status);
14          }
15          return handleViewError(req.getRequestURL().toString(), errorStack, errorMsg, viewName);
16      }
17
18      protected ModelAndView handleViewError(String url, String errorStack, String errorMessage, String viewName) {
19           ModelAndView mav = new ModelAndView();
20           mav.addObject("exception", errorStack);
21           mav.addObject("url", url);
22           mav.addObject("message", errorMessage);
23           mav.addObject("timestamp", new Date());
24           mav.setViewName(viewName);
25           return mav;
26        }
27
28      protected ModelAndView handleAjaxError(HttpServletResponse rsp, String errorMessage, HttpStatus status) throws IOException {
29             rsp.setCharacterEncoding("UTF-8");
30             rsp.setStatus(status.value());
31             PrintWriter writer = rsp.getWriter();
32             writer.write(errorMessage);
33             writer.flush();
34             return null;
35       }
36
37      public Logger getLogger() {
38            return LoggerFactory.getLogger(BaseGlobalExceptionHandler.class);
39      }
40 }

  2.针对你需要捕捉的异常实现相对应的处理方式

 1 @ControllerAdvice
 2 public class GlobalExceptionHandler extends BaseGlobalExceptionHandler {
 3
 4       //比如404的异常就会被这个方法捕获
 5       @ExceptionHandler(NoHandlerFoundException.class)
 6       @ResponseStatus(HttpStatus.NOT_FOUND)
 7        public ModelAndView handle404Error(HttpServletRequest req, HttpServletResponse rsp, Exception e) throws Exception {
 8              return handleError(req, rsp, e, "error-front", HttpStatus.NOT_FOUND);
 9        }
10
11       //500的异常会被这个方法捕获
12       @ExceptionHandler(Exception.class)
13       @ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR)
14       public ModelAndView handleError(HttpServletRequest req, HttpServletResponse rsp, Exception e) throws Exception {
15              return handleError(req, rsp, e, "error-front", HttpStatus.INTERNAL_SERVER_ERROR);
16       }
17
18      //TODO  你也可以再写一个方法来捕获你的自定义异常
19      //TRY NOW!!!
20
21       @Override
22       public Logger getLogger() {
23             return LoggerFactory.getLogger(GlobalExceptionHandler.class);
24       }
25
26   }
时间: 2024-10-10 10:21:03

Spring全局异常处理的三种方式的相关文章

SSH深度历险(八) 剖析SSH核心原理+Spring依赖注入的三种方式

在java开发中,程序员在某个类中需要依赖其它类的方法,则通常是new一个依赖类再调用类实例的方法,这种开发存在的问题是new的类实例不好统一管理,spring提出了依赖注入的思想,即依赖类不由程序员实例化,而是通过spring容器帮我们new指定实例并且将实例注入到需要该对象的类中.依赖注入的另一种说法是"控制反转",通俗的理解是:平常我们new一个实例,这个实例的控制权是我们程序员,而控制反转是指new实例工作不由我们程序员来做而是交给spring容器来做. Spring依赖注入(

Spring 使用AspectJ的三种方式

Spring 使用AspectJ 的三种方式 一,使用JavaConfig 二,使用注解隐式配置 三,使用XML 配置 背景知识: 注意 使用AspectJ 的 时候 要导入相应的Jar 包 嗯 昨天还碰到了这样的问题: Caused by: java.lang.IllegalArgumentEx http://pic.cnhubei.com/space.php?uid=1132&do=album&id=814854http://pic.cnhubei.com/space.php?uid=

Web开发中获取Spring的ApplicationContext的三种方式

在 WEB 开发中,可能会很少需要显示的获得 ApplicationContext 来得到由 Spring 进行管理的某些 Bean, 今天我就遇到了,在这里和大家分享一下, WEB 开发中,怎么获取 ApplicationContext 一       要想怎么获取 ApplicationContext, 首先必须明白 Spring 内部 ApplicationContext 是怎样存储的.下面我们来跟踪一下源码 首先:从大家最熟悉的地方开始 Java代码   <listener> <

Spring学习(二)spring ioc注入的三种方式

一.spring ioc注入有哪三种方式: a setter 原理 : 在目标对象中,定义需要注入的依赖对象对应的属性和setter方法:"让ioc容器调用该setter方法",将ioc容器实例化的依赖对象通过setter注入给目标对象,封装在目标对象的属性中. b 构造器 原理 : 为目标对象提供一个构造方法,在构造方法中添加一个依赖对象对应的参数.ioc容器解析时,实例化目标对象时会自动调用构造方法,ioc只需要为构造器中的参数进行赋值:将ioc实例化的依赖对象作为构造器的参数传入

【SSH三大框架】Spring基础第二篇:Spring依赖注入的三种方式

控制反转(Inversion of Control)和依赖注入(Dependency Injection): 应用控制反转,对象在被创建的时候,由一个调控系统内所有对象的外界实体将其所依赖的对象的引用传递给它.也可以说,依赖被注入到对象中.所以,控制反转是,关于一个对象如何获取他所依赖的对象的引用,这个责任的反转. 对于依赖注入,有三种方式: 1.使用属性的setter方法注入 2.使用构造器注入 3.使用注解注入 下面我们介绍下这三种方式: 一.使用属性的setter方法注入 首先,我们写一个

【Spring】创建对象的三种方式

关于Spring的搭建可参见:浅析Spring框架的搭建.在测试之前还是应该先将环境配置好,将相关Jar包导进来.Spring创建的对象,默认情况下都是单例模式,除非通过scope指定. 一.通过构造函数创建对象. 2.1 利用无参构造函数+setter方法注入值 最基本的对象创建方式,只需要有一个无参构造函数(类中没有写任何的构造函数,默认就是有一个构造函数,如果写了任何一个构造函数,默认的无参构造函数就不会自动创建哦!!)和字段的setter方法. Person类: package com.

Spring依赖注入的三种方式

Spring依赖注入(DI)的三种方式,分别为: 1. 接口注入 2. Setter方法注入 3. 构造方法注入 下面介绍一下这三种依赖注入在Spring中是怎么样实现的. 首先我们需要以下几个类: 接口 Logic.java 接口实现类 LogicImpl.java 一个处理类 LoginAction.java 还有一个测试类 TestMain.java Logic.java如下: package com.spring.test.di; public interface Logic { pub

spring mvc handler的三种方式

springmvc.xml 三种方式不能针对一个controller同时使用 <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:mvc="

Spring 集成Hibernate的三种方式

首先把hibernate的配置文件hibernate.cfg.xml放入spring的src目录下,并且为了便于测试导入了一个实体类Student.java以及它的Student.hbm.xml文件 第一种集成方式:首先定义一个MySessionFactory的类 package com.tz.core; import org.hibernate.SessionFactory; import org.hibernate.cfg.Configuration; import org.springfr