GVKun编程网logo

如何在Spring Exception Handler中处理包装的异常？[重复]（spring包装struts）

27

在这篇文章中，我们将带领您了解如何在SpringExceptionHandler中处理包装的异常？[重复]的全貌，包括spring包装struts的相关情况。同时，我们还将为您介绍有关java–如何在

在这篇文章中，我们将带领您了解如何在Spring Exception Handler中处理包装的异常？[重复]的全貌，包括spring包装struts的相关情况。同时，我们还将为您介绍有关java – 如何在Spring Interceptor中使用@ExceptionHandler？、Java深入 - Spring 异常处理HandlerExceptionResolver、spring 3-为NoSuchRequestHandlingMethodException创建ExceptionHandler、Spring @ControllerAdvice @ExceptionHandler 全局处理异常的知识，以帮助您更好地理解这个主题。

本文目录一览：

如何在Spring Exception Handler中处理包装的异常？[重复]（spring包装struts）

如何在Spring Exception Handler中处理包装的异常？[重复]（spring包装struts）

我有Spring MVC和杰克逊。当我发出不正确的请求时，杰克逊映射失败并被UnrecognizedPropertyException抛出。我想使用

@ExceptionHandlerpublic String handle(UnrecognizedPropertyException e) {  ...}

但是Spring封装了这个异常，HttpMessageConversionException因此上面的代码不起作用。Spring是否有可能处理Jackson特定（或一般库特定）的异常？

答案1

小编典典

不幸的是，UnrecognizedPropertyException是的子类型IOException。在RequestResponseBodyMethodProcessor一个处理@RequestBody（我认为这就是发生异常）具有特殊处理IOException（如解析请求输入流的失败），在其包装HttpMessageNotReadableException。另外，如果在期间发生转换错误，HttpMessageConverter则指定接口抛出。HttpMessageNotReadableExceptionread

无论如何，您都将不得不处理该问题（如果杰克逊抛出了未经检查的异常，情况可能会有所不同）。

幸运的是，从4.3开始，Spring
MVCExceptionHandlerMethodResolver（处理@ExceptionHandler）可以解开cause异常的包装（请参阅SPR-14291）。因此，假设您的处理HttpMessageNotReadableException程序方法的继承层次结构中没有任何异常的处理程序

@ExceptionHandlerpublic String handle(UnrecognizedPropertyException e) {    ...}

将用于处理异常。在Spring
MVC寻找可以处理的处理程序方法HttpMessageNotReadableException之后，然后使用展开嵌套的异常Throwable#getCause并再次尝试查找，就会发生这种情况。

在4.3之前的版本中，或者如果您在HttpMessageNotReadableException继承层次结构中确实有针对异常类型的处理程序，则始终可以在自己提取出原因之后委托。

@ExceptionHandlerpublic String handle(HttpMessageConversionException e) throws Throwable {    Throwable cause = e.getCause();    if (cause instanceof UnrecognizedPropertyException) {        handle((UnrecognizedPropertyException) cause);    }    ...}public String handle(UnrecognizedPropertyException e) {    ...}

java – 如何在Spring Interceptor中使用@ExceptionHandler？

java – 如何在Spring Interceptor中使用@ExceptionHandler？

我正在使用springmvc为客户端创建restful api,我有一个用于检查accesstoken的拦截器.

public class AccesstokenInterceptor extends handlerinterceptorAdapter
{    
@Override
public boolean preHandle(HttpServletRequest request,HttpServletResponse response,Object handler) throws Exception
{
    if (handler instanceof HandlerMethod)
    {
        HandlerMethod handlerMethod = (HandlerMethod) handler;
        Authorize authorizerequired = handlerMethod.getmethodAnnotation(Authorize.class);
        if (authorizerequired != null)
        {
            String token = request.getHeader("accesstoken");
            Validatetoken(token);
        }
    }
    return true;
}

protected long Validatetoken(String token)
{
    Accesstoken accesstoken = TokenImpl.GetAccesstoken(token);

    if (accesstoken != null)
    {
        if (accesstoken.getExpirationDate().compareto(new Date()) > 0)
        {
            throw new TokenExpiredException();
        }
        return accesstoken.getUserId();
    }
    else
    {
        throw new InvalidTokenException();
    }
}

在我的控制器中,我使用@ExceptionHandler来处理异常,处理InvalidTokenException的代码看起来像

@ExceptionHandler(InvalidTokenException.class)
public @ResponseBody
Response handleInvalidTokenException(InvalidTokenException e)
{
    Log.p.debug(e.getMessage());
    Response rs = new Response();
    rs.setErrorCode(ErrorCode.INVALID_TOKEN);
    return rs;
}

但不幸的是,preHandle方法抛出的异常并未被控制器中定义的异常处理程序捕获.

任何人都可以给我一个处理异常的解决方案吗？
PS：我的控制器方法使用以下代码生成json和xml：

@RequestMapping(value = "login",method = RequestMethod.POST,produces =
{
    "application/xml","application/json"
})
最佳答案
使用其他方法解决,捕获异常并转发到另一个控制器.

try
{
    Validatetoken(token);
} catch (InvalidTokenException ex)
{
    request.getRequestdispatcher("/api/error/invalidtoken").forward(request,response);
    return false;
} catch (TokenExpiredException ex)
{
    request.getRequestdispatcher("/api/error/tokenexpired").forward(request,response);
    return false;
}

Java深入 - Spring 异常处理HandlerExceptionResolver

Java深入 - Spring 异常处理HandlerExceptionResolver

spring的异常统一处理非常简单，首先我们需要看一下Spring中定义的HandlerExceptionResolver接口：

/** 
 * Interface to be implemented by objects than can resolve exceptions thrown 
 * during handler mapping or execution, in the typical case to error views. 
 * Implementors are typically registered as beans in the application context. 
 * 
 * <p>Error views are analogous to the error page JSPs, but can be used with 
 * any kind of exception including any checked exception, with potentially 
 * fine-granular mappings for specific handlers. 
 * 
 * @author Juergen Hoeller 
 * @since 22.11.2003 
 */  
public interface HandlerExceptionResolver {  
  
    /** 
     * Try to resolve the given exception that got thrown during on handler execution, 
     * returning a ModelAndView that represents a specific error page if appropriate. 
     * <p>The returned ModelAndView may be {@linkplain ModelAndView#isEmpty() empty} 
     * to indicate that the exception has been resolved successfully but that no view 
     * should be rendered, for instance by setting a status code. 
     * @param request current HTTP request 
     * @param response current HTTP response 
     * @param handler the executed handler, or <code>null</code> if none chosen at the 
     * time of the exception (for example, if multipart resolution failed) 
     * @param ex the exception that got thrown during handler execution 
     * @return a corresponding ModelAndView to forward to, 
     * or <code>null</code> for default processing 
     */  
    ModelAndView resolveException(  
            HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex);  
  
}

他定义了一个resolveException方法，我们如果要处理异常的话，需要实现这个接口类，并且实现resolveException方法，在resolveException方法中处理自己的异常逻辑。 例如我设计一个自定义的异常处理类：

/** 
 * 自定义一个异常捕获处理类 
 * @author zhuli 
 * @date 2014-9-3 
 */  
public class MyExceptionResolver implements HandlerExceptionResolver {  
  
    private static final Logger logger = LoggerFactory.getLogger(MyExceptionResolver.class);  
  
    @Override  
    public ModelAndView resolveException(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) {  
          
        //可以自由处理各种异常逻辑  
        if (ex instanceof org.springframework.web.HttpRequestMethodNotSupportedException) {  
            logger.warn(Logger.ACTION.DEFAULT, "Http Method Error");  
        }  
        return null;  
    }  
  
}

然后需要将我们的我们自定义的MyExceptionResolver类注入到bean中

<bean id="MyExceptionResolver"/>

具体Spring是怎么调用的？我们可以先看下Spring中的doDispatch方法中，有这么一段代码：

catch (ModelAndViewDefiningException ex) {  
    logger.debug("ModelAndViewDefiningException encountered", ex);  
    mv = ex.getModelAndView();  
}  
catch (Exception ex) {  
    Object handler = (mappedHandler != null ? mappedHandler.getHandler() : null);  
    mv = processHandlerException(processedRequest, response, handler, ex);  
    errorView = (mv != null);  
}

其中processHandlerException方法就是来捕获异常处理的，那么继续看processHandlerException这个方法：

protected ModelAndView processHandlerException(HttpServletRequest request, HttpServletResponse response,  
        Object handler, Exception ex) throws Exception {  
  
    // Check registered HandlerExceptionResolvers...  
    ModelAndView exMv = null;  
    for (HandlerExceptionResolver handlerExceptionResolver : this.handlerExceptionResolvers) {  
        exMv = handlerExceptionResolver.resolveException(request, response, handler, ex);  
        if (exMv != null) {  
            break;  
        }  
    }  
    if (exMv != null) {  
        if (exMv.isEmpty()) {  
            return null;  
        }  
        // We might still need view name translation for a plain error model...  
        if (!exMv.hasView()) {  
            exMv.setViewName(getDefaultViewName(request));  
        }  
        if (logger.isDebugEnabled()) {  
            logger.debug("Handler execution resulted in exception - forwarding to resolved error view: " + exMv, ex);  
        }  
        WebUtils.exposeErrorRequestAttributes(request, ex, getServletName());  
        return exMv;  
    }  
  
    throw ex;  
}

这个方法中的handlerExceptionResolver.resolveException就是用来捕获异常的，并且Spring允许多个自定义的异常类实现。 可以看this.handlerExceptionResolvers方法，跟踪进去

private void initHandlerExceptionResolvers(ApplicationContext context) {  
        this.handlerExceptionResolvers = null;  
  
        if (this.detectAllHandlerExceptionResolvers) {  
            // Find all HandlerExceptionResolvers in the ApplicationContext, including ancestor contexts.  
            Map<String, HandlerExceptionResolver> matchingBeans = BeanFactoryUtils  
                    .beansOfTypeIncludingAncestors(context, HandlerExceptionResolver.class, true, false);  
            if (!matchingBeans.isEmpty()) {  
                this.handlerExceptionResolvers = new ArrayList<HandlerExceptionResolver>(matchingBeans.values());  
                // We keep HandlerExceptionResolvers in sorted order.  
                OrderComparator.sort(this.handlerExceptionResolvers);  
            }  
        }  
        else {  
            try {  
                HandlerExceptionResolver her =  
                        context.getBean(HANDLER_EXCEPTION_RESOLVER_BEAN_NAME, HandlerExceptionResolver.class);  
                this.handlerExceptionResolvers = Collections.singletonList(her);  
            }  
            catch (NoSuchBeanDefinitionException ex) {  
                // Ignore, no HandlerExceptionResolver is fine too.  
            }  
        }  
  
        // Ensure we have at least some HandlerExceptionResolvers, by registering  
        // default HandlerExceptionResolvers if no other resolvers are found.  
        if (this.handlerExceptionResolvers == null) {  
            this.handlerExceptionResolvers = getDefaultStrategies(context, HandlerExceptionResolver.class);  
            if (logger.isDebugEnabled()) {  
                logger.debug("No HandlerExceptionResolvers found in servlet ''" + getServletName() + "'': using default");  
            }  
        }  
    }

可以清洗看到这个方法是将handlerExceptionResolvers进行了初始化，并将自定义的异常处理类（可以多个）写入this.handlerExceptionResolvers

spring 3-为NoSuchRequestHandlingMethodException创建ExceptionHandler

spring 3-为NoSuchRequestHandlingMethodException创建ExceptionHandler

使用Spring 3，我想使用 ExceptionHandler 注释创建一个异常处理程序，该注释将处理 “找不到页面（404）”
请求。我正在使用以下代码来执行此操作。但是，当我指向一个不存在的URL时，将调用Spring定义的默认异常处理程序。

可能是我正在处理 NoSuchRequestHandlingMethodException 异常。如果是，那我应该注册什么例外？

您能看一下下面的代码，看看我在做什么错吗？

注意：如果我将 @ExceptionHandler中 的异常更改为 NullPointerException 并创建一个
RequestMapping 来引发空指针，那将起作用。

    import org.springframework.stereotype.Controller;    import org.springframework.web.bind.annotation.ExceptionHandler;    import org.springframework.web.bind.annotation.RequestMapping;    import org.springframework.web.servlet.mvc.multiaction.NoSuchRequestHandlingMethodException;    import org.apache.commons.logging.Log;    import org.apache.commons.logging.LogFactory;    import org.springframework.web.servlet.ModelAndView;    @Controller    public class GeneralHandler {      private final Log logger = LogFactory.getLog(getClass());      @ExceptionHandler(NoSuchRequestHandlingMethodException.class)      public ModelAndView handleException (NoSuchRequestHandlingMethodException ex) {        ModelAndView mav = new ModelAndView();        logger.error("Exception found: " + ex);        return mav;      }    }

答案1

小编典典

@ExceptionHandler当@RequestMapping同一类上的方法引发异常时，将调用带注释的方法。因此，当您添加了引发的映射时NullPointerException，该方法就起作用了，因为映射的方法和异常处理程序在同一个类中。

当找不到映射时，Spring无法将关联到NoSuchRequestHandlingMethodException您的@ExceptionHandler，因为它无法将请求与处理程序方法进行匹配。在文档中没有明确提到，但这是我观察到的行为。

如果要专门处理此异常，则必须使用更通用的HandlerExceptionResolver方法，而不是更专门的@ExceptionHandler技术。

Spring @ControllerAdvice @ExceptionHandler 全局处理异常

Spring @ControllerAdvice @ExceptionHandler 全局处理异常

对于与数据库相关的 Spring MVC 项目，我们通常会把 事务 配置在 Service层，当数据库操作失败时让 Service 层抛出运行时异常，Spring 事物管理器就会进行回滚。

如此一来，我们的 Controller 层就不得不进行 try-catch Service 层的异常，否则会返回一些不友好的错误信息到客户端。但是，Controller 层每个方法体都写一些模板化的 try-catch 的代码，很难看也难维护，特别是还需要对 Service 层的不同异常进行不同处理的时候。例如以下 Controller 方法代码（非常难看且冗余）：

/**
 * 手动处理 Service 层异常和数据校验异常的示例
 * @param dog
 * @param errors
 * @return
 */
@PostMapping(value = "") AppResponse add(@Validated(Add.class) @RequestBody Dog dog, Errors errors){ AppResponse resp = new AppResponse(); try { // 数据校验 BSUtil.controllerValidate(errors); // 执行业务 Dog newDog = dogService.save(dog); // 返回数据 resp.setData(newDog); }catch (BusinessException e){ LOGGER.error(e.getMessage(), e); resp.setFail(e.getMessage()); }catch (Exception e){ LOGGER.error(e.getMessage(), e); resp.setFail("操作失败！"); } return resp; }

 

本文讲解使用 @ControllerAdvice + @ExceptionHandler 进行全局的 Controller 层异常处理，只要设计得当，就再也不用在 Controller 层进行 try-catch 了！而且，@Validated 校验器注解的异常，也可以一起处理，无需手动判断绑定校验结果 BindingResult/Errors 了！

一、优缺点

  • 优点：将 Controller 层的异常和数据校验的异常进行统一处理，减少模板代码，减少编码量，提升扩展性和可维护性。
  • 缺点：只能处理 Controller 层未捕获（往外抛）的异常，对于 Interceptor（拦截器）层的异常，Spring 框架层的异常，就无能为力了。

二、基本使用示例

2.1 @ControllerAdvice 注解定义全局异常处理类

@ControllerAdvice
public class GlobalExceptionHandler { }

 

请确保此 GlobalExceptionHandler 类能被扫描到并装载进 Spring 容器中。

2.2 @ExceptionHandler 注解声明异常处理方法

@ControllerAdvice
public class GlobalExceptionHandler { @ExceptionHandler(Exception.class) @ResponseBody String handleException(){ return "Exception Deal!"; } }

 

方法 handleException() 就会处理所有 Controller 层抛出的 Exception 及其子类的异常，这是最基本的用法了。

被 @ExceptionHandler 注解的方法的参数列表里，还可以声明很多种类型的参数，详见文档。其原型如下：

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface ExceptionHandler { /** * Exceptions handled by the annotated method. If empty, will default to any * exceptions listed in the method argument list. */ Class<? extends Throwable>[] value() default {}; }

 

如果 @ExceptionHandler 注解中未声明要处理的异常类型，则默认为参数列表中的异常类型。所以上面的写法，还可以写成这样：

@ControllerAdvice
public class GlobalExceptionHandler { @ExceptionHandler() @ResponseBody String handleException(Exception e){ return "Exception Deal! " + e.getMessage(); } }

 

参数对象就是 Controller 层抛出的异常对象！

三、处理 Service 层上抛的业务异常

有时我们会在复杂的带有数据库事务的业务中，当出现不和预期的数据时，直接抛出封装后的业务级运行时异常，进行数据库事务回滚，并希望该异常信息能被返回显示给用户。

3.1 代码示例

封装的业务异常类：

public class BusinessException extends RuntimeException { public BusinessException(String message){ super(message); } }

 

Service 实现类：

@Service
public class DogService { @Transactional public Dog update(Dog dog){ // some database options // 模拟狗狗新名字与其他狗狗的名字冲突 BSUtil.isTrue(false, "狗狗名字已经被使用了..."); // update database dog info return dog; } }

 

其中辅助工具类 BSUtil

public static void isTrue(boolean expression, String error){ if(!expression) { throw new BusinessException(error); } }

 

那么，我们应该在 GlobalExceptionHandler 类中声明该业务异常类，并进行相应的处理，然后返回给用户。更贴近真实项目的代码，应该长这样子：

/**
 * Created by kinginblue on 2017/4/10.
 * @ControllerAdvice + @ExceptionHandler 实现全局的 Controller 层的异常处理
 */
@ControllerAdvice
public class GlobalExceptionHandler { private static final Logger LOGGER = LoggerFactory.getLogger(GlobalExceptionHandler.class); /** * 处理所有不可知的异常 * @param e * @return */ @ExceptionHandler(Exception.class) @ResponseBody AppResponse handleException(Exception e){ LOGGER.error(e.getMessage(), e); AppResponse response = new AppResponse(); response.setFail("操作失败！"); return response; } /** * 处理所有业务异常 * @param e * @return */ @ExceptionHandler(BusinessException.class) @ResponseBody AppResponse handleBusinessException(BusinessException e){ LOGGER.error(e.getMessage(), e); AppResponse response = new AppResponse(); response.setFail(e.getMessage()); return response; } }

 

Controller 层的代码，就不需要进行异常处理了：

@RestController
@RequestMapping(value = "/dogs", consumes = {MediaType.APPLICATION_JSON_UTF8_VALUE})
public class DogController { @Autowired private DogService dogService; @PatchMapping(value = "") Dog update(@Validated(Update.class) @RequestBody Dog dog){ return dogService.update(dog); } }

 

3.2 代码说明

Logger 进行所有的异常日志记录。

@ExceptionHandler(BusinessException.class) 声明了对 BusinessException 业务异常的处理，并获取该业务异常中的错误提示，构造后返回给客户端。

@ExceptionHandler(Exception.class) 声明了对 Exception 异常的处理，起到兜底作用，不管 Controller 层执行的代码出现了什么未能考虑到的异常，都返回统一的错误提示给客户端。

备注：以上 GlobalExceptionHandler 只是返回 Json 给客户端，更大的发挥空间需要按需求情况来做。

四、处理 Controller 数据绑定、数据校验的异常

在 Dog 类中的字段上的注解数据校验规则：

@Data
public class Dog { @NotNull(message = "{Dog.id.non}", groups = {Update.class}) @Min(value = 1, message = "{Dog.age.lt1}", groups = {Update.class}) private Long id; @NotBlank(message = "{Dog.name.non}", groups = {Add.class, Update.class}) private String name; @Min(value = 1, message = "{Dog.age.lt1}", groups = {Add.class, Update.class}) private Integer age; }

 

说明：@NotNull、@Min、@NotBlank 这些注解的使用方法，不在本文范围内。如果不熟悉，请查找资料学习即可。

其他说明：
@Data 注解是 **Lombok** 项目的注解，可以使我们不用再在代码里手动加 getter & setter。
在 Eclipse 和 IntelliJ IDEA 中使用时，还需要安装相关插件，这个步骤自行Google/Baidu 吧！

 

Lombok 使用方法见：Java奇淫巧技之Lombok

SpringMVC 中对于 RESTFUL 的 Json 接口来说，数据绑定和校验，是这样的：

/**
 * 使用 GlobalExceptionHandler 全局处理 Controller 层异常的示例
 * @param dog
 * @return
 */
@PatchMapping(value = "") AppResponse update(@Validated(Update.class) @RequestBody Dog dog){ AppResponse resp = new AppResponse(); // 执行业务 Dog newDog = dogService.update(dog); // 返回数据 resp.setData(newDog); return resp; }

使用 @Validated + @RequestBody 注解实现。

当使用了 @Validated + @RequestBody 注解但是没有在绑定的数据对象后面跟上 Errors 类型的参数声明的话，Spring MVC 框架会抛出 MethodArgumentNotValidException 异常。

所以，在 GlobalExceptionHandler 中加上对 MethodArgumentNotValidException 异常的声明和处理，就可以全局处理数据校验的异常了！加完后的代码如下：

/**
 * Created by kinginblue on 2017/4/10.
 * @ControllerAdvice + @ExceptionHandler 实现全局的 Controller 层的异常处理
 */
@ControllerAdvice
public class GlobalExceptionHandler { private static final Logger LOGGER = LoggerFactory.getLogger(GlobalExceptionHandler.class); /** * 处理所有不可知的异常 * @param e * @return */ @ExceptionHandler(Exception.class) @ResponseBody AppResponse handleException(Exception e){ LOGGER.error(e.getMessage(), e); AppResponse response = new AppResponse(); response.setFail("操作失败！"); return response; } /** * 处理所有业务异常 * @param e * @return */ @ExceptionHandler(BusinessException.class) @ResponseBody AppResponse handleBusinessException(BusinessException e){ LOGGER.error(e.getMessage(), e); AppResponse response = new AppResponse(); response.setFail(e.getMessage()); return response; } /** * 处理所有接口数据验证异常 * @param e * @return */ @ExceptionHandler(MethodArgumentNotValidException.class) @ResponseBody AppResponse handleMethodArgumentNotValidException(MethodArgumentNotValidException e){ LOGGER.error(e.getMessage(), e); AppResponse response = new AppResponse(); response.setFail(e.getBindingResult().getAllErrors().get(0).getDefaultMessage()); return response; } }

 

注意到了吗，所有的 Controller 层的异常的日志记录，都是在这个 GlobalExceptionHandler 中进行记录。也就是说，Controller 层也不需要在手动记录错误日志了。

五、总结

本文主要讲 @ControllerAdvice + @ExceptionHandler 组合进行的 Controller 层上抛的异常全局统一处理。

其实，被 @ExceptionHandler 注解的方法还可以声明很多参数，详见文档。

@ControllerAdvice 也还可以结合 @InitBinder、@ModelAttribute 等注解一起使用，应用在所有被 @RequestMapping 注解的方法上，详见搜索引擎。

关于如何在Spring Exception Handler中处理包装的异常？[重复]和spring包装struts的问题我们已经讲解完毕，感谢您的阅读，如果还想了解更多关于java – 如何在Spring Interceptor中使用@ExceptionHandler？、Java深入 - Spring 异常处理HandlerExceptionResolver、spring 3-为NoSuchRequestHandlingMethodException创建ExceptionHandler、Spring @ControllerAdvice @ExceptionHandler 全局处理异常等相关内容，可以在本站寻找。

本文标签：

上一篇没有注释的Spring MVC 3.1？（没有注释的代码）

下一篇使用休眠+ Spring MVC在保存时获取自动生成的密钥

相关文章