Spring全局异常处理的使用及源码分析

已于 2023-03-10 21:30:02 修改
阅读量102 收藏
点赞数
分类专栏： Springboot 文章标签： spring java spring boot
于 2023-03-10 21:27:01 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_47938500/article/details/129453487
版权

又是美好的一天呀~
个人博客地址： huanghong.top

本文预估阅读时长为20分钟左右~

往下看看~

ExceptionHanlder的使用

handler定义

package com.huang.handler;

import com.huang.controller.demo1.DemoController;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;
import javax.servlet.http.HttpServletRequest;
import java.io.IOException;

/**
 * @Time 2023-02-28 17:25
 * Created by Huang
 * className: GlobalExceptionHandler
 * Description:
 */
//@RestControllerAdvice
//@RestControllerAdvice(basePackages = "com.huang.controller.demo1")
@RestControllerAdvice(basePackageClasses = DemoController.class)
public class GlobalExceptionHandler {

    @ExceptionHandler(value = RuntimeException.class)
    public String runtimeExceptionHandler(HttpServletRequest request, RuntimeException exception) {
        return exception.getMessage();
    }

    @ExceptionHandler(value = IOException.class)
    public String IOExceptionHandler(HttpServletRequest request, IOException exception) {
        return exception.getMessage();
    }

    @ExceptionHandler(value = Exception.class)
    public String exceptionHandler(HttpServletRequest request, Exception exception) {
        return exception.getMessage();
    }

    @ExceptionHandler(value = NullPointerException.class)
    public String nullPointerExceptionHandler(HttpServletRequest request, NullPointerException exception) {
        return exception.getMessage();
    }
}
  1. @RestControllerAdvice是一个组合注解，由@ControllerAdvice和@ResponseBody组成，相同于**@RestController与@Controller之间的区别，增加@ResponseBody**注解则返回的结果直接写入 HTTP response body 中，反之直接返回view。
  2. 通过指定@RestControllerAdvice中的basePackages和basePackageClasses的属性可以扫描指定包路径下或类的异常。

controller定义

package com.huang.controller.demo1;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.io.IOException;

/**
 * @Time 2023-02-28 17:20
 * Created by Huang
 * className: DemoController
 * Description:
 */
@RestController("demo1")
@RequestMapping
public class DemoController {

    @GetMapping("/demo1/normal")
    public String normal(){
        return "normal";
    }

    @GetMapping("/demo1/NullPointerException")
    public String NullPointerException(){
        throw new NullPointerException("demo1 NullPointerException");
    }

    @GetMapping("/demo1/RuntimeException")
    public String RuntimeException(){
        throw new RuntimeException("demo1 RuntimeException");
    }

    @GetMapping("/demo1/IOException")
    public String IOException() throws IOException {
        throw new IOException("demo1 IOException");
    }
}

package com.huang.controller.demo2;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.io.IOException;

/**
 * @Time 2023-02-28 17:20
 * Created by Huang
 * className: DemoController
 * Description:
 */
@RestController("demo2")
@RequestMapping
public class DemoController {

    @GetMapping("/demo2/normal")
    public String normal(){
        return "normal";
    }

    @GetMapping("/demo2/NullPointerException")
    public String NullPointerException(){
        throw new NullPointerException("demo2 NullPointerException");
    }

    @GetMapping("/demo2/RuntimeException")
    public String RuntimeException(){
        throw new RuntimeException("demo2 RuntimeException");
    }

    @GetMapping("/demo2/IOException")
    public String IOException() throws IOException {
        throw new IOException("demo2 IOException");
    }
}

结论

  1. 指定basePackages则只扫描处理对应路径下的异常内容。
  2. 指定basePackageClasses则只扫描处理对应类中的异常内容。
  3. 异常捕获由最下级异常至最高级，比如抛出NullPointerException：handler处理顺序为nullPointerExceptionHandler->runtimeExceptionHandler->exceptionHandler。
  4. 单个ExceptionHandler可指定多个异常，比如**@ExceptionHandler(value = {NullPointerException.class,IOException.class})**

全局异常处理源码分析

异常处理配置

方式一：配置默认视图
package com.huang.handler;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.handler.SimpleMappingExceptionResolver;

import java.util.Properties;

/**
 * @Time 2023-02-28 21:22
 * Created by Huang
 * className: GlobalExceptionViewHandler
 * Description:
 */
@Configuration
public class GlobalExceptionViewHandler {
    @Bean
    public SimpleMappingExceptionResolver getSimpleMappingExceptionResolver(){
        SimpleMappingExceptionResolver simpleMappingExceptionResolver = new SimpleMappingExceptionResolver();
        simpleMappingExceptionResolver.setDefaultErrorView("defaultErrorView");
        Properties properties = new Properties();
        properties.setProperty("java.lang.Exception", "ExceptionErrorView");
        properties.setProperty("java.io.IOException", "IOExceptionErrorView");
        properties.setProperty("java.lang.NullPointerException", "NullPointerExceptionErrorView");
        properties.setProperty("java.lang.RuntimeException", "RuntimeExceptionErrorView");
        properties.setProperty("java.lang.IllegalArgumentException", "IllegalArgumentExceptionErrorView");
        simpleMappingExceptionResolver.setExceptionMappings(properties);
        return simpleMappingExceptionResolver;
    }
}
方式二：配置ControllerAdvice
package com.huang.handler;

import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;

import javax.servlet.http.HttpServletRequest;
import java.io.IOException;

/**
 * @Time 2023-02-28 17:25
 * Created by Huang
 * className: GlobalExceptionHandler
 * Description:
 */
@RestControllerAdvice
//@RestControllerAdvice(basePackages = "com.huang.controller.demo1")
//@RestControllerAdvice(basePackageClasses = DemoController.class)
public class GlobalExceptionHandler {

    @ExceptionHandler(value = RuntimeException.class)
    public String exceptionHandler(HttpServletRequest request, RuntimeException exception) {
        return exception.getMessage();
    }

    @ExceptionHandler(value = IOException.class)
    public String exceptionHandler(HttpServletRequest request, IOException exception) {
        return exception.getMessage();
    }

    @ExceptionHandler(value = Exception.class)
    public String exceptionHandler(HttpServletRequest request, Exception exception) {
        return exception.getMessage();
    }

    @ExceptionHandler(value = NullPointerException.class)
    public String exceptionHandler(HttpServletRequest request, NullPointerException exception) {
        return exception.getMessage();
    }
}

注: 如果两者同时配置，则在请求访问的过程中，DispatcherServlet进行初始化执行initStrategies方法，在执行initHandlerExceptionResolvers中会获取所有异常解析器HandlerExceptionResolver然后加以排序操作**（AnnotationAwareOrderComparator.sort(this.handlerExceptionResolvers)）**

以上述代码为例，根据ExceptionResolvers的PriorityOrdered、Ordered来进行排序

image-20230228222714501

  1. org.springframework.boot.web.servlet.error.DefaultErrorAttributes(@Order(Ordered.HIGHEST_PRECEDENCE))默认处理返回null。

    public ModelAndView resolveException(HttpServletRequest request,
      HttpServletResponse response, Object handler, Exception ex) {
   storeErrorAttributes(request, ex);
   return null;
}

private void storeErrorAttributes(HttpServletRequest request, Exception ex) {
    request.setAttribute(ERROR_ATTRIBUTE, ex);
}

  2. org.springframework.web.servlet.handler.AbstractHandlerExceptionResolver(Ordered.LOWEST_PRECEDENCE)子类异常视图处理器org.springframework.web.servlet.handler.SimpleMappingExceptionResolver

  3. HandlerExceptionResolverComposite(Ordered=0)中的ExceptionHandlerExceptionResolver在初始化会解析ControllerAdvice中的异常处理方案，存在对应处理NullPointerException的处理器则进行处理返回，直接跳过GlobalExceptionViewHandler处理器。

image-20230228223048494

//org.springframework.web.servlet.config.annotation.WebMvcConfigurationSupport
@Bean
public HandlerExceptionResolver handlerExceptionResolver(
    @Qualifier("mvcContentNegotiationManager") ContentNegotiationManager contentNegotiationManager) {
    List<HandlerExceptionResolver> exceptionResolvers = new ArrayList<>();
    configureHandlerExceptionResolvers(exceptionResolvers);
    if (exceptionResolvers.isEmpty()) {
        addDefaultHandlerExceptionResolvers(exceptionResolvers, contentNegotiationManager);
    }
    extendHandlerExceptionResolvers(exceptionResolvers);
    HandlerExceptionResolverComposite composite = new HandlerExceptionResolverComposite();
    //设置Order=0
    composite.setOrder(0);
    composite.setExceptionResolvers(exceptionResolvers);
    return composite;
}

总结：异常解析处理器执行顺序DefaultErrorAttributes->HandlerExceptionResolverComposite->SimpleMappingExceptionResolver,同时配置异常视图处理器和ControllerAdvice，ControllerAdvice会优先处理异常。

构建HandlerExceptionResolverComposite

org.springframework.web.servlet.config.annotation.WebMvcConfigurationSupport

@Bean
public HandlerExceptionResolver handlerExceptionResolver(
      @Qualifier("mvcContentNegotiationManager") ContentNegotiationManager contentNegotiationManager) {
   List<HandlerExceptionResolver> exceptionResolvers = new ArrayList<>();
   //自动注入WebMvcConfigurerComposite中扩展resolvers，不存在
   configureHandlerExceptionResolvers(exceptionResolvers);
   if (exceptionResolvers.isEmpty()) {
      //添加异常解析器
      addDefaultHandlerExceptionResolvers(exceptionResolvers, contentNegotiationManager);
   }
   extendHandlerExceptionResolvers(exceptionResolvers);
   HandlerExceptionResolverComposite composite = new HandlerExceptionResolverComposite();
   //order设置为0
   composite.setOrder(0);
   //设置异常解析器
   composite.setExceptionResolvers(exceptionResolvers);
   return composite;
}
addDefaultHandlerExceptionResolvers

org.springframework.web.servlet.config.annotation.WebMvcConfigurationSupport#addDefaultHandlerExceptionResolvers

protected final void addDefaultHandlerExceptionResolvers(List<HandlerExceptionResolver> exceptionResolvers,
      ContentNegotiationManager mvcContentNegotiationManager) {
   //创建org.springframework.web.servlet.mvc.method.annotation.ExceptionHandlerExceptionResolver实例
   ExceptionHandlerExceptionResolver exceptionHandlerResolver = createExceptionHandlerExceptionResolver();
   exceptionHandlerResolver.setContentNegotiationManager(mvcContentNegotiationManager);
   exceptionHandlerResolver.setMessageConverters(getMessageConverters());
   exceptionHandlerResolver.setCustomArgumentResolvers(getArgumentResolvers());
   exceptionHandlerResolver.setCustomReturnValueHandlers(getReturnValueHandlers());
   if (jackson2Present) {
      exceptionHandlerResolver.setResponseBodyAdvice(
            Collections.singletonList(new JsonViewResponseBodyAdvice()));
   }
   if (this.applicationContext != null) {
      exceptionHandlerResolver.setApplicationContext(this.applicationContext);
   }
   //执行afterPropertiesSet
   exceptionHandlerResolver.afterPropertiesSet();
   exceptionResolvers.add(exceptionHandlerResolver);
   //添加ResponseStatusExceptionResolver
   ResponseStatusExceptionResolver responseStatusResolver = new ResponseStatusExceptionResolver();
   responseStatusResolver.setMessageSource(this.applicationContext);
   exceptionResolvers.add(responseStatusResolver);
   //添加DefaultHandlerExceptionResolver
   exceptionResolvers.add(new DefaultHandlerExceptionResolver());
}
//小结：HandlerExceptionResolverComposite中ExceptionResolvers包含上述三个实例(ExceptionHandlerExceptionResolver/ResponseStatusExceptionResolver/DefaultHandlerExceptionResolver)
initExceptionHandlerAdviceCache

org.springframework.web.servlet.mvc.method.annotation.ExceptionHandlerExceptionResolver#initExceptionHandlerAdviceCache

private void initExceptionHandlerAdviceCache() {
   if (getApplicationContext() == null) {
      return;
   }
   //获取Spring容器中所有ControllerAdvice Bean
   List<ControllerAdviceBean> adviceBeans = ControllerAdviceBean.findAnnotatedBeans(getApplicationContext());
   for (ControllerAdviceBean adviceBean : adviceBeans) {
      Class<?> beanType = adviceBean.getBeanType();
      if (beanType == null) {
         throw new IllegalStateException("Unresolvable type for ControllerAdviceBean: " + adviceBean);
      }
      //构建ExceptionHandlerMethodResolver对象，解析ControllerAdvice中的ExceptionHandler
      ExceptionHandlerMethodResolver resolver = new ExceptionHandlerMethodResolver(beanType);
      if (resolver.hasExceptionMappings()) {
         //如果存在@ExceptionHandler，放入本地缓存中
         this.exceptionHandlerAdviceCache.put(adviceBean, resolver);
      }
      // 如果该 beanType 类型是 ResponseBodyAdvice 子类，则添加到 responseBodyAdvice 中
      if (ResponseBodyAdvice.class.isAssignableFrom(beanType)) {
         this.responseBodyAdvice.add(adviceBean);
      }
   }
}

//ExceptionHandlerMethodResolver初始化
//mappedMethods key:异常类型 value: ControllerAdvice中的ExceptionHandler方法
private final Map<Class<? extends Throwable>, Method> mappedMethods = new HashMap<>(16);

public ExceptionHandlerMethodResolver(Class<?> handlerType) {
    //遍历@ExceptionHandler的方法
    for (Method method : MethodIntrospector.selectMethods(handlerType, EXCEPTION_HANDLER_METHODS)) {
        //遍历处理的异常集合
        for (Class<? extends Throwable> exceptionType : detectExceptionMappings(method)) {
            //添加到mappedMethods中
            addExceptionMapping(exceptionType, method);
        }
    }
}

DispatcherServlet初始化

//org.springframework.web.servlet.DispatcherServlet
protected void onRefresh(ApplicationContext context) {
   initStrategies(context);
}

protected void initStrategies(ApplicationContext context) {
    ...
    initHandlerExceptionResolvers(context);
    ...
}

private void initHandlerExceptionResolvers(ApplicationContext context) {
    this.handlerExceptionResolvers = null;
	//默认检测所有异常解析器
    if (this.detectAllHandlerExceptionResolvers) {
        //查询上下文所有异常解析器
        Map<String, HandlerExceptionResolver> matchingBeans = BeanFactoryUtils
            .beansOfTypeIncludingAncestors(context, HandlerExceptionResolver.class, true, false);
        //解析器不为空，根据ExceptionResolvers的PriorityOrdered、Ordered来进行排序
        if (!matchingBeans.isEmpty()) {
            this.handlerExceptionResolvers = new ArrayList<>(matchingBeans.values());
            // We keep HandlerExceptionResolvers in sorted order.
            AnnotationAwareOrderComparator.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.isTraceEnabled()) {
            logger.trace("No HandlerExceptionResolvers declared in servlet '" + getServletName() +
                         "': using default strategies from DispatcherServlet.properties");
        }
    }
}

Spring容器自动注入异常解析器

//org.springframework.boot.autoconfigure.web.servlet.error.ErrorMvcAutoConfiguration
@Bean
@ConditionalOnMissingBean(value = ErrorAttributes.class, search = SearchStrategy.CURRENT)
public DefaultErrorAttributes errorAttributes() {
   return new DefaultErrorAttributes();
}

//org.springframework.web.servlet.config.annotation.WebMvcConfigurationSupport
@Bean
public HandlerExceptionResolver handlerExceptionResolver(
      @Qualifier("mvcContentNegotiationManager") ContentNegotiationManager contentNegotiationManager) {
   List<HandlerExceptionResolver> exceptionResolvers = new ArrayList<>();
   //自动注入WebMvcConfigurerComposite中扩展resolvers，不存在
   configureHandlerExceptionResolvers(exceptionResolvers);
   if (exceptionResolvers.isEmpty()) {
      //添加异常解析器
      addDefaultHandlerExceptionResolvers(exceptionResolvers, contentNegotiationManager);
   }
   extendHandlerExceptionResolvers(exceptionResolvers);
   HandlerExceptionResolverComposite composite = new HandlerExceptionResolverComposite();
   //order设置为0
   composite.setOrder(0);
   //设置异常解析器
   composite.setExceptionResolvers(exceptionResolvers);
   return composite;
}
processDispatchResult

org.springframework.web.servlet.DispatcherServlet#processDispatchResult

private void processDispatchResult(HttpServletRequest request, HttpServletResponse response,
      @Nullable HandlerExecutionChain mappedHandler, @Nullable ModelAndView mv,
      @Nullable Exception exception) throws Exception {
   boolean errorView = false;
   if (exception != null) {
      //如果是ModelAndViewDefiningException，则获取对应的ModelAndView
      if (exception instanceof ModelAndViewDefiningException) {
         logger.debug("ModelAndViewDefiningException encountered", exception);
         mv = ((ModelAndViewDefiningException) exception).getModelAndView();
      }
      else {
         //获取对应mappedHandler进行异常处理
         Object handler = (mappedHandler != null ? mappedHandler.getHandler() : null);
         //mv不为空则返回错误页面
         mv = processHandlerException(request, response, handler, exception);
         errorView = (mv != null);
      }
   }

   // Did the handler return a view to render?
   if (mv != null && !mv.wasCleared()) {
      //视图数据渲染
      render(mv, request, response);
      if (errorView) {
         WebUtils.clearErrorRequestAttributes(request);
      }
   }
   else {
      if (logger.isTraceEnabled()) {
         logger.trace("No view rendering, null ModelAndView returned.");
      }
   }

   if (WebAsyncUtils.getAsyncManager(request).isConcurrentHandlingStarted()) {
      // Concurrent handling started during a forward
      return;
   }

   if (mappedHandler != null) {
      // Exception (if any) is already handled..
      //异常处理完成后执行HandlerInterceptor的afterCompletion方法
      mappedHandler.triggerAfterCompletion(request, response, null);
   }
}
processHandlerException

org.springframework.web.servlet.DispatcherServlet#processHandlerException

protected ModelAndView processHandlerException(HttpServletRequest request, HttpServletResponse response,
      @Nullable Object handler, Exception ex) throws Exception {

   // Success and error responses may use different content types
   request.removeAttribute(HandlerMapping.PRODUCIBLE_MEDIA_TYPES_ATTRIBUTE);

   // Check registered HandlerExceptionResolvers...
   ModelAndView exMv = null;
   if (this.handlerExceptionResolvers != null) {
      //遍历handlerExceptionResolvers，使用逐个handlerExceptionResolver处理异常，如果exMv不为空则跳过后续处理
      for (HandlerExceptionResolver resolver : this.handlerExceptionResolvers) {
         //DefaultErrorAttributes 处理返回null
         //HandlerExceptionResolver 自主定义ControllerAdvice
         //如果仍定义了SimpleMappingExceptionResolver则会被跳过
         exMv = resolver.resolveException(request, response, handler, ex);
         if (exMv != null) {
            break;
         }
      }
   }
   if (exMv != null) {
      if (exMv.isEmpty()) {
         request.setAttribute(EXCEPTION_ATTRIBUTE, ex);
         return null;
      }
      // We might still need view name translation for a plain error model...
      if (!exMv.hasView()) {
         String defaultViewName = getDefaultViewName(request);
         if (defaultViewName != null) {
            exMv.setViewName(defaultViewName);
         }
      }
      if (logger.isTraceEnabled()) {
         logger.trace("Using resolved error view: " + exMv, ex);
      }
      else if (logger.isDebugEnabled()) {
         logger.debug("Using resolved error view: " + exMv);
      }
      WebUtils.exposeErrorRequestAttributes(request, ex, getServletName());
      return exMv;
   }

   throw ex;
}
resolveException

ControllerAdvice对应的异常处理逻辑

org.springframework.web.servlet.handler.AbstractHandlerMethodExceptionResolver#doResolveException

protected final ModelAndView doResolveException(
      HttpServletRequest request, HttpServletResponse response, @Nullable Object handler, Exception ex) {
   //对应controller
   HandlerMethod handlerMethod = (handler instanceof HandlerMethod ? (HandlerMethod) handler : null);
   return doResolveHandlerMethodException(request, response, handlerMethod, ex);
}
doResolveHandlerMethodException

org.springframework.web.servlet.mvc.method.annotation.ExceptionHandlerExceptionResolver#doResolveHandlerMethodException

protected ModelAndView doResolveHandlerMethodException(HttpServletRequest request,
      HttpServletResponse response, @Nullable HandlerMethod handlerMethod, Exception exception) {
   //根据controller和异常类型匹配到对应的ExceptionHandler方法
   ServletInvocableHandlerMethod exceptionHandlerMethod = getExceptionHandlerMethod(handlerMethod, exception);
   if (exceptionHandlerMethod == null) {
      return null;
   }

   if (this.argumentResolvers != null) {
      //设置参数解析器
      exceptionHandlerMethod.setHandlerMethodArgumentResolvers(this.argumentResolvers);
   }
   if (this.returnValueHandlers != null) {
      //设置返回值处理器
      exceptionHandlerMethod.setHandlerMethodReturnValueHandlers(this.returnValueHandlers);
   }
   //根据原生request和response构建一个新的webRequest
   ServletWebRequest webRequest = new ServletWebRequest(request, response);
   ModelAndViewContainer mavContainer = new ModelAndViewContainer();

   ArrayList<Throwable> exceptions = new ArrayList<>();
   try {
      if (logger.isDebugEnabled()) {
         logger.debug("Using @ExceptionHandler " + exceptionHandlerMethod);
      }
      // Expose causes as provided arguments as well
      Throwable exToExpose = exception;
      while (exToExpose != null) {
         exceptions.add(exToExpose);
         Throwable cause = exToExpose.getCause();
         exToExpose = (cause != exToExpose ? cause : null);
      }
      Object[] arguments = new Object[exceptions.size() + 1];
      //构建参数 exceptions + handlerMethod
      exceptions.toArray(arguments);  // efficient arraycopy call in ArrayList
      arguments[arguments.length - 1] = handlerMethod;
      //通过ExceptionHandler的异常处理逻辑来处理异常
      exceptionHandlerMethod.invokeAndHandle(webRequest, mavContainer, arguments);
   }
   catch (Throwable invocationEx) {
      // Any other than the original exception (or a cause) is unintended here,
      // probably an accident (e.g. failed assertion or the like).
      if (!exceptions.contains(invocationEx) && logger.isWarnEnabled()) {
         logger.warn("Failure in @ExceptionHandler " + exceptionHandlerMethod, invocationEx);
      }
      // Continue with default processing of the original exception...
      return null;
   }
   //通过RequestResponseBodyMethodProcessor中handleReturnValue的方法设置mavContainer.setRequestHandled(true);
   //直接返回new ModelAndView();
   if (mavContainer.isRequestHandled()) {
      return new ModelAndView();
   }
   else {
      ModelMap model = mavContainer.getModel();
      HttpStatus status = mavContainer.getStatus();
      ModelAndView mav = new ModelAndView(mavContainer.getViewName(), model, status);
      mav.setViewName(mavContainer.getViewName());
      if (!mavContainer.isViewReference()) {
         mav.setView((View) mavContainer.getView());
      }
      if (model instanceof RedirectAttributes) {
         Map<String, ?> flashAttributes = ((RedirectAttributes) model).getFlashAttributes();
         RequestContextUtils.getOutputFlashMap(request).putAll(flashAttributes);
      }
      return mav;
   }
}

感谢阅读完本篇文章！！！
个人博客地址： huanghong.top

喜欢正常冰的冰美式
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
springMVC3学习(八)--全局的异常处理(源码)
05-21
springMVC3学习(八)--全局的异常处理(源码) 文章地址：http://blog.csdn.net/itmyhome1990/article/details/26286435
springboot的异常处理机制源码解析
zhonghuan5281852的博客
12-26 399
springboot的异常处理机制源码详解
SpringBoot全局处理系列--全局异常处理
IT利刃出鞘的博客
06-11 3119
本文用实例介绍SpringBoot如何进行全局异常处理。
SpringMVC全局异常处理机制以及源码解析
yehongzhi1994的博客
06-16 917
学会SpringMVC的全局异常的处理，对以后成为架构师有很大帮助。
SpringMVC全局异常统一处理
热门推荐
12-05 2万+
SpringMVC全局异常统一处理以及处理顺序 最近在使用SpringMVC做全局异常统一处理的时候遇到的问题，就是想把ajax请求和普通的网页请求分开返回json错误信息或者跳转到错误页。 在实际做的时候先按照标准的方式自定义一个HandlerExceptionResolver，命名为SpringHandlerExceptionResolver，实现HandlerExceptionResol
Spring Cloud Gateway全局异常处理的方法详解
08-26
主要给大家介绍了关于Spring Cloud Gateway全局异常处理的相关资料,需要的朋友可以参考下
详解Spring Boot2 Webflux的全局异常处理
08-26
主要介绍了详解Spring Boot2 Webflux的全局异常处理，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
Spring Cloud Gateway的全局异常处理
11-26
Spring Cloud Gateway中的全局异常处理不能直接用@ControllerAdvice来处理，通过跟踪异常信息的抛出，找到对应的源码，自定义一些处理逻辑来符合业务的需求。 网关都是给接口做代理转发的，后端对应的都是REST API，...
详解Spring全局异常处理的三种方式
08-30
主要介绍了详解Spring全局异常处理的三种方式,小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
Spring Cloud Gateway全局通用异常处理的实现
08-19
主要介绍了Spring Cloud Gateway全局通用异常处理的实现，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
【SpringBoot】处理全局异常(附源码)
qq_32106647的博客
06-20 464
自定义一个业务异常 @Data public class CustomerException extends RuntimeException{ private static final long serialVersionUID = 1L; /** 错误码 **/ private Integer code; public CustomerExceptio...
Spring AI 抢先体验，5 分钟玩转 Java AI 应用开发
阿里巴巴云原生的博客
04-29 952
Spring Cloud Alibaba AI 以 Spring AI 为基础，并在此基础上提供阿里云通义系列大模型全面适配，让用户在 5 分钟内开发基于通义大模型的 Java AI 应用。
springboot集成-mybatis-puls
csy08845的博客
04-29 251
Spring Boot中集成MyBatis Plus是一个相对简单的过程，MyBatis Plus是一个MyBatis的增强工具，它简化了CRUD操作，并且提供了一些额外的功能，比如性能优化、自动填充等。3.配置MyBatis Plus：通常，MyBatis Plus的配置与MyBatis类似，不需要额外的配置，因为它会自动配置。6.使用Mapper：在你的Service中注入Mapper，并使用它。7.配置扫描：确保Spring Boot扫描到你的Mapper接口。
SpringBoot中实现发送邮件
m0_64289188的博客
04-30 490
当你添加了spring-boot-starter-mail依赖后，Spring Boot会自动配置JavaMailSender实例，并根据application.yml文件中的属性来配置这个实例。你可以直接在需要发送邮件的地方通过@Autowired注解将JavaMailSender实例注入到你的类中，然后使用它来发送邮件。：首先，需要在你的pom.xml文件中添加Spring Boot的邮件发送器依赖。，简化了在Spring Boot应用程序中发送电子邮件的设置过程。Spring Boot的。
springboot 获取maven打包时间
I do more ，you do less
04-30 376
【代码】springboot 获取maven打包时间。
SpringBoot指标监控
最新发布
刘浩琦的博客
05-01 285
SpringBoot指标监控添加Actuator功能SpringBoot指标监控添加Actuator功能。
SpringBoot之@Conditional注解实现选择性的创建Bean操作
qq_52822387的博客
05-01 311
Condition 是在Spring 4.0增加的条件判断功能，通过这个功能可以实现选择性的创建Bean操作。需求：在Spring的IOC容器中有一个User的Bean，现要求：导入Jedis坐标后，加载该Bean，没导入，则不加载。2、创建ClassCondition类实现Condition接口，重写matches方法。参数context：上下文对象，用于获取环境、IOC容器、ClassLoader对象。我们在代码中加入一个@Conditional注解，查看这个注解。3、获取user，打印出来。
springboot 自动配置源码解读
weixin_46591962的博客
05-01 637
当我们程序依赖第三方功能组件时，不需要手动将这些组件类加载到IOC容器中。例如 当程序需要用到redis时，在pom.xml文件中引入依赖，然后使用依赖注入的方式直接从IOC容器中拿到相应RedisTemplate实例。
SpringCloudAlibaba：2.nacos
m0_63040701的博客
04-26 978
Nacos是阿里巴巴开源的服务注册中心以及配置中心Nacos=注册中心Eureka + 服务配置Config + 服务总线Bus。
spring全局异常处理
07-25
// 处理异常逻辑 ModelAndView modelAndView = new ModelAndView(); modelAndView.setViewName("error"); // 设置错误页面 modelAndView.addObject("errorMsg", ex.getMessage()); // 将异常信息传递给错误页面 ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

喜欢正常冰的冰美式

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值