小架构step系列31：处理异常

最新推荐文章于 2025-12-12 00:08:08 发布
原创 最新推荐文章于 2025-12-12 00:08:08 发布 · 697 阅读 · 16 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#架构 #spring #java

1 概述

在Web请求处理的过程中，如果发生异常，就需要对异常进行处理。异常可能是各种各样的，有些需要特殊处理，有些通用处理即可。这些处理的逻辑如果到处放，维护起来也比较困难，Spring提供的异常处理机制考虑了这些问题，本文了解一下其原理。

2 原理

2.1 配置HandlerExceptionResolver

开启@EnableWebMvc的时候，会初始化HandlerExceptionResolver：
  • 初始化的时候，先通过WebMvcConfigurer的configureHandlerExceptionResolvers配置自定义的HandlerExceptionResolver；
  • 如果没有配置则提供默认的三个HandlerExceptionResolver：ExceptionHandlerExceptionResolver、ResponseStatusExceptionResolver、DefaultHandlerExceptionResolver。默认配置的和通过WebMvcConfigurer的configureHandlerExceptionResolvers配置的属于二选一，而不是合并起来。
  • 再通过WebMvcConfigurer的extendHandlerExceptionResolvers增加额外的HandlerExceptionResolver，这个是额外增加的，不影响之前添加的。
  • 把所有HandlerExceptionResolver设置到HandlerExceptionResolverComposite，它也实现了HandlerExceptionResolver接口，并成为Spring的一个bean，这样可以通过接口查找到这个bean，方便注入。
// 源码位置：org.springframework.web.servlet.config.annotation.EnableWebMvc
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Documented
@Import(DelegatingWebMvcConfiguration.class)
public @interface EnableWebMvc {
}

// 源码位置：org.springframework.web.servlet.config.annotation.DelegatingWebMvcConfiguration
@Configuration(proxyBeanMethods = false)
public class DelegatingWebMvcConfiguration extends WebMvcConfigurationSupport {
}

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

// 源码位置：org.springframework.web.servlet.config.annotation.DelegatingWebMvcConfiguration
@Override
protected void configureHandlerExceptionResolvers(List<HandlerExceptionResolver> exceptionResolvers) {
    // 2. configurers为WebMvcConfigurerComposite，里面注入了实现了WebMvcConfigurer接口的所有类
    this.configurers.configureHandlerExceptionResolvers(exceptionResolvers);
}

// 源码位置：org.springframework.web.servlet.config.annotation.WebMvcConfigurerComposite
public void configureHandlerExceptionResolvers(List<HandlerExceptionResolver> exceptionResolvers) {
    for (WebMvcConfigurer delegate : this.delegates) {
        // 3. 遍历所有的WebMvcConfigurer，执行它的configureHandlerExceptionResolvers，把得到的HandlerExceptionResolver加到exceptionResolvers列表里
        delegate.configureHandlerExceptionResolvers(exceptionResolvers);
    }
}

// 回到WebMvcConfigurationSupport的handlerExceptionResolver继续处理
// 源码位置：org.springframework.web.servlet.config.annotation.WebMvcConfigurationSupport
@Bean
public HandlerExceptionResolver handlerExceptionResolver(@Qualifier("mvcContentNegotiationManager") ContentNegotiationManager contentNegotiationManager) {
    List<HandlerExceptionResolver> exceptionResolvers = new ArrayList<>();
    // 1. 配置ExceptionResolver
    configureHandlerExceptionResolvers(exceptionResolvers);
    if (exceptionResolvers.isEmpty()) {
        // 4. 如果WebMvcConfigurer没有提供HandlerExceptionResolver，则添加默认的HandlerExceptionResolver
        addDefaultHandlerExceptionResolvers(exceptionResolvers, contentNegotiationManager);
    }
    extendHandlerExceptionResolvers(exceptionResolvers);
    HandlerExceptionResolverComposite composite = new HandlerExceptionResolverComposite();
    composite.setOrder(0);
    composite.setExceptionResolvers(exceptionResolvers);
    return composite;
}

// 源码位置：org.springframework.web.servlet.config.annotation.WebMvcConfigurationSupport
protected final void addDefaultHandlerExceptionResolvers(List<HandlerExceptionResolver> exceptionResolvers, ContentNegotiationManager mvcContentNegotiationManager) {
    // 5. 添加ExceptionHandlerExceptionResolver，并把ArgumentResolver、ReturnValueHandler、MessageConverter等组装进去，相当于要处理一个请求的形式
    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);
    }
    exceptionHandlerResolver.afterPropertiesSet();
    exceptionResolvers.add(exceptionHandlerResolver);

    // 6. 添加ResponseStatusExceptionResolver
    ResponseStatusExceptionResolver responseStatusResolver = new ResponseStatusExceptionResolver();
    responseStatusResolver.setMessageSource(this.applicationContext);
    exceptionResolvers.add(responseStatusResolver);

    // 7. 添加DefaultHandlerExceptionResolver
    exceptionResolvers.add(new DefaultHandlerExceptionResolver());
}

// 回到WebMvcConfigurationSupport的handlerExceptionResolver继续处理
// 源码位置：org.springframework.web.servlet.config.annotation.WebMvcConfigurationSupport
@Bean
public HandlerExceptionResolver handlerExceptionResolver(@Qualifier("mvcContentNegotiationManager") ContentNegotiationManager contentNegotiationManager) {
    List<HandlerExceptionResolver> exceptionResolvers = new ArrayList<>();
    // 1. 配置ExceptionResolver
    configureHandlerExceptionResolvers(exceptionResolvers);
    if (exceptionResolvers.isEmpty()) {
        // 4. 如果WebMvcConfigurer没有提供HandlerExceptionResolver，则添加默认的HandlerExceptionResolver
        addDefaultHandlerExceptionResolvers(exceptionResolvers, contentNegotiationManager);
    }
    
    // 8. WebMvcConfigurer还可以通过extendHandlerExceptionResolvers配置exceptionResolver
    extendHandlerExceptionResolvers(exceptionResolvers);
    
    // 9. HandlerExceptionResolverComposite也实现HandlerExceptionResolver接口，它成为一个可以查找的bean，里面带了上面配置的所有exceptionResolver
    HandlerExceptionResolverComposite composite = new HandlerExceptionResolverComposite();
    composite.setOrder(0);
    composite.setExceptionResolvers(exceptionResolvers); // 设置exceptionResolver
    return composite;
}

 2.2 处理异常流程

客户端发起的http请求由DispatcherServlet处理，DispatcherServlet初始化的时候把上面初始化的ExceptionResolver对应的bean都取到，然后在处理请求的时候，通过ExceptionResolver进行异常处理。

// DispatcherServlet初始化的时候把HandlerExceptionResolver对应的bean都找到放handlerExceptionResolvers里
// 源码位置：org.springframework.web.servlet.DispatcherServlet
private void initHandlerExceptionResolvers(ApplicationContext context) {
    this.handlerExceptionResolvers = null;

    if (this.detectAllHandlerExceptionResolvers) {
        // 1. 根据HandlerExceptionResolver接口获取实现了该接口的bean，如果没有自定义额外的bean，则默认能找到两个：
        //        org.springframework.boot.web.servlet.error.DefaultErrorAttributes
        //        org.springframework.web.servlet.handler.HandlerExceptionResolverComposite
        //    注意：通过WebMvcConfigurer配置的并不是bean，它配置的HandlerExceptionResolver是存到HandlerExceptionResolverComposite里的
        Map<String, HandlerExceptionResolver> matchingBeans = BeanFactoryUtils.beansOfTypeIncludingAncestors(context, HandlerExceptionResolver.class, true, false);
        if (!matchingBeans.isEmpty()) {
            // 2. 赋值给handlerExceptionResolvers，供后面处理异常的时候使用
            this.handlerExceptionResolvers = new ArrayList<>(matchingBeans.values());
            AnnotationAwareOrderComparator.sort(this.handlerExceptionResolvers);
        }
    }
    else {
        try {
            // 3. detectAllHandlerExceptionResolvers默认为true，如果关掉了，需要提供一个名称为handlerExceptionResolver的HandlerExceptionResolver
            //    HANDLER_EXCEPTION_RESOLVER_BEAN_NAME = "handlerExceptionResolver"
            HandlerExceptionResolver her = context.getBean(HANDLER_EXCEPTION_RESOLVER_BEAN_NAME, HandlerExceptionResolver.class);
            this.handlerExceptionResolvers = Collections.singletonList(her);
        }
        catch (NoSuchBeanDefinitionException ex) {
        }
    }

    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");
        }
    }
}

// DispatcherServlet在处理http请求的时候，从handlerExceptionResolvers里取出HandlerExceptionResolver进行异常处理
// 源码位置：org.springframework.web.servlet.DispatcherServlet
protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
    HttpServletRequest processedRequest = request;
    HandlerExecutionChain mappedHandler = null;
    boolean multipartRequestParsed = false;

    WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);

    try {
        ModelAndView mv = null;
        Exception dispatchException = null;

        try {
            processedRequest = checkMultipart(request);
            multipartRequestParsed = (processedRequest != request);
            mappedHandler = getHandler(processedRequest);
            if (mappedHandler == null) {
                noHandlerFound(processedRequest, response);
                return;
            }
            HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());
            String method = request.getMethod();
            boolean isGet = HttpMethod.GET.matches(method);
            if (isGet || HttpMethod.HEAD.matches(method)) {
                long lastModified = ha.getLastModified(request, mappedHandler.getHandler());
                if (new ServletWebRequest(request, response).checkNotModified(lastModified) && isGet) {
                    return;
                }
            }
            if (!mappedHandler.applyPreHandle(processedRequest, response)) {
                return;
            }
            mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
            if (asyncManager.isConcurrentHandlingStarted()) {
                return;
            }
            applyDefaultViewName(processedRequest, mv);
            mappedHandler.applyPostHandle(processedRequest, response, mv);
        }
        catch (Exception ex) {
            dispatchException = ex;
        }
        catch (Throwable err) {
            dispatchException = new NestedServletException("Handler dispatch failed", err);
        }
        
        // 4. 处理请求的结果
        processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
    }
    // 省略部分代码
}


// 源码位置：org.springframework.web.servlet.DispatcherServlet
private void processDispatchResult(HttpServletRequest request, HttpServletResponse response,
        @Nullable HandlerExecutionChain mappedHandler, @Nullable ModelAndView mv,
        @Nullable Exception exception) throws Exception {
    boolean errorView = false;

    if (exception != null) {
        if (exception instanceof ModelAndViewDefiningException) {
            logger.debug("ModelAndViewDefiningException encountered", exception);
            mv = ((ModelAndViewDefiningException) exception).getModelAndView();
        }
        else {
            Object handler = (mappedHandler != null ? mappedHandler.getHandler() : null);
            
            // 5. 如果有异常，则把异常处理成一个结果
            mv = processHandlerException(request, response, handler, exception);
            errorView = (mv != null);
        }
    }

    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()) {
        return;
    }

    if (mappedHandler != null) {
        mappedHandler.triggerAfterCompletion(request, response, null);
    }
}


// 源码位置：org.springframework.web.servlet.DispatcherServlet
protected ModelAndView processHandlerException(HttpServletRequest request, HttpServletResponse response, @Nullable Object handler, Exception ex) throws Exception {
    request.removeAttribute(HandlerMapping.PRODUCIBLE_MEDIA_TYPES_ATTRIBUTE);
    ModelAndView exMv = null;
    
    // 6. 遍历所有ExceptionResolver，执行通用方法resolveException，只要执行到一个有返回值的，则忽略后面的ExceptionResolver
    //    handlerExceptionResolvers是上面DispatcherServlet初始化的时候赋值的，默认有两个：
    //        org.springframework.boot.web.servlet.error.DefaultErrorAttributes
    //        org.springframework.web.servlet.handler.HandlerExceptionResolverComposite
    //    重点看一下HandlerExceptionResolverComposite的处理，它里面设置了所有配置的非bean的ExceptionResolver
    if (this.handlerExceptionResolvers != null) {
        for (HandlerExceptionResolver resolver : this.handlerExceptionResolvers) {
            exMv = resolver.resolveException(request, response, handler, ex);
            if (exMv != null) {
                break;
            }
        }
    }
    if (exMv != null) {
        if (exMv.isEmpty()) {
            request.setAttribute(EXCEPTION_ATTRIBUTE, ex);
            return null;
        }
        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;
}

// 源码位置：org.springframework.web.servlet.handler.HandlerExceptionResolverComposite
public ModelAndView resolveException(HttpServletRequest request, HttpServletResponse response, @Nullable Object handler, Exception ex) {
    // 7. 遍历包装的HandlerExceptionResolver，执行resolveException()方法，默认包装了3个，主要看一下ExceptionHandlerExceptionResolver：
    //    org.springframework.web.servlet.mvc.method.annotation.ExceptionHandlerExceptionResolver
    //    org.springframework.web.servlet.mvc.annotation.ResponseStatusExceptionResolver
    //    org.springframework.web.servlet.mvc.support.DefaultHandlerExceptionResolver
    if (this.resolvers != null) {
        for (HandlerExceptionResolver handlerExceptionResolver : this.resolvers) {
            ModelAndView mav = handlerExceptionResolver.resolveException(request, response, handler, ex);
            if (mav != null) {
                return mav;
            }
        }
    }
    return null;
}

// 继承关系：ExceptionHandlerExceptionResolver < AbstractHandlerMethodExceptionResolver < AbstractHandlerExceptionResolver
// resolveException()由AbstractHandlerExceptionResolver提供，ExceptionHandlerExceptionResolver重载了doResolveException()方法
// org.springframework.web.servlet.handler.AbstractHandlerExceptionResolver
public ModelAndView resolveException(HttpServletRequest request, HttpServletResponse response, @Nullable Object handler, Exception ex) {
    if (shouldApplyTo(request, handler)) {
        prepareResponse(ex, response);
        // 8. 处理异常
        ModelAndView result = doResolveException(request, response, handler, ex);
        if (result != null) {
            if (logger.isDebugEnabled() && (this.warnLogger == null || !this.warnLogger.isWarnEnabled())) {
                logger.debug(buildLogMessage(ex, request) + (result.isEmpty() ? "" : " to " + result));
            }
            logException(ex, request);
        }
        return result;
    }
    else {
        return null;
    }
}

// 源码位置：org.springframework.web.servlet.mvc.method.annotation.ExceptionHandlerExceptionResolver
protected ModelAndView doResolveHandlerMethodException(HttpServletRequest request, HttpServletResponse response, @Nullable HandlerMethod handlerMethod, Exception exception) {
    // 9. 获取处理异常的方法，handlerMethod对应的是Controller接收请求的Method
    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);
    }
    // 省略部分代码
}

// 源码位置：org.springframework.web.servlet.mvc.method.annotation.ExceptionHandlerExceptionResolver
protected ServletInvocableHandlerMethod getExceptionHandlerMethod(@Nullable HandlerMethod handlerMethod, Exception exception) {
    Class<?> handlerType = null;

    if (handlerMethod != null) {
        // 10. 取到Controller的类
        handlerType = handlerMethod.getBeanType();
        // 11. 根据Controller类从缓存exceptionHandlerCache里取ExceptionHandlerMethodResolver
        ExceptionHandlerMethodResolver resolver = this.exceptionHandlerCache.get(handlerType);
        if (resolver == null) {
            // 12. 如果exceptionHandlerCache没有取到ExceptionHandlerMethodResolver，则创建一个
            resolver = new ExceptionHandlerMethodResolver(handlerType);
            this.exceptionHandlerCache.put(handlerType, resolver);
        }
        Method method = resolver.resolveMethod(exception);
        if (method != null) {
            return new ServletInvocableHandlerMethod(handlerMethod.getBean(), method, this.applicationContext);
        }
        if (Proxy.isProxyClass(handlerType)) {
            handlerType = AopUtils.getTargetClass(handlerMethod.getBean());
        }
    }

    for (Map.Entry<ControllerAdviceBean, ExceptionHandlerMethodResolver> entry : this.exceptionHandlerAdviceCache.entrySet()) {
        ControllerAdviceBean advice = entry.getKey();
        if (advice.isApplicableToBeanType(handlerType)) {
            ExceptionHandlerMethodResolver resolver = entry.getValue();
            Method method = resolver.resolveMethod(exception);
            if (method != null) {
                return new ServletInvocableHandlerMethod(advice.resolveBean(), method, this.applicationContext);
            }
        }
    }

    return null;
}

// 源码位置：org.springframework.web.method.annotation.ExceptionHandlerMethodResolver
public static final MethodFilter EXCEPTION_HANDLER_METHODS = method -> AnnotatedElementUtils.hasAnnotation(method, ExceptionHandler.class);
public ExceptionHandlerMethodResolver(Class<?> handlerType) {
    // 13. EXCEPTION_HANDLER_METHODS为一个function，主要是过滤是否有@ExceptionHandler注解，
    //     即遍历Controller里的方法，把标注了@ExceptionHandler注解的方法过滤出来
    for (Method method : MethodIntrospector.selectMethods(handlerType, EXCEPTION_HANDLER_METHODS)) {
        for (Class<? extends Throwable> exceptionType : detectExceptionMappings(method)) {
            addExceptionMapping(exceptionType, method); // 过滤出的结果放到this.mappedMethods
        }
    }
}

// 回到ExceptionHandlerExceptionResolver的getExceptionHandlerMethod()继续处理
// 源码位置：org.springframework.web.servlet.mvc.method.annotation.ExceptionHandlerExceptionResolver
protected ServletInvocableHandlerMethod getExceptionHandlerMethod(@Nullable HandlerMethod handlerMethod, Exception exception) {
    Class<?> handlerType = null;

    if (handlerMethod != null) {
        // 10. 取到Controller的类
        handlerType = handlerMethod.getBeanType();
        // 11. 根据Controller类从缓存exceptionHandlerCache里取ExceptionHandlerMethodResolver
        ExceptionHandlerMethodResolver resolver = this.exceptionHandlerCache.get(handlerType);
        if (resolver == null) {
            // 12. 如果exceptionHandlerCache没有取到ExceptionHandlerMethodResolver，则创建一个
            resolver = new ExceptionHandlerMethodResolver(handlerType);
            
            // 14. 把新创建的ExceptionHandlerMethodResolver的缓存起来，避免每次请求都需要重复创建
            this.exceptionHandlerCache.put(handlerType, resolver);
        }
        
        // 15. @ExceptionHandler注解需要指定一种Exception类型，需要根据具体的异常匹配到具体的method
        Method method = resolver.resolveMethod(exception);
        if (method != null) {
            return new ServletInvocableHandlerMethod(handlerMethod.getBean(), method, this.applicationContext);
        }
        if (Proxy.isProxyClass(handlerType)) {
            handlerType = AopUtils.getTargetClass(handlerMethod.getBean());
        }
    }

    // 16. ExceptionHandlerExceptionResolver初始化的时候initExceptionHandlerAdviceCache()，会把@ControllerAdvice标注的类里的方法也作为处理异常的方法
    //     通过具体的异常匹配到处理异常的方法，原理和上面一样
    for (Map.Entry<ControllerAdviceBean, ExceptionHandlerMethodResolver> entry : this.exceptionHandlerAdviceCache.entrySet()) {
        ControllerAdviceBean advice = entry.getKey();
        if (advice.isApplicableToBeanType(handlerType)) {
            ExceptionHandlerMethodResolver resolver = entry.getValue();
            Method method = resolver.resolveMethod(exception);
            if (method != null) {
                return new ServletInvocableHandlerMethod(advice.resolveBean(), method, this.applicationContext);
            }
        }
    }

    return null;
}
private void initExceptionHandlerAdviceCache() {
    // 省略部分代码
    
    // 17. 如果类上标注了@ControllerAdvice，这个类也会被Spring实例化为bean，也需要用ExceptionHandlerMethodResolver从这些类里找到对应处理异常的方法
    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 resolver = new ExceptionHandlerMethodResolver(beanType);
        if (resolver.hasExceptionMappings()) {
            this.exceptionHandlerAdviceCache.put(adviceBean, resolver);
        }
        if (ResponseBodyAdvice.class.isAssignableFrom(beanType)) {
            this.responseBodyAdvice.add(adviceBean);
        }
    }
    // 省略部分代码
}

// 回到ExceptionHandlerExceptionResolver的doResolveHandlerMethodException()继续处理
// 源码位置：org.springframework.web.servlet.mvc.method.annotation.ExceptionHandlerExceptionResolver
protected ModelAndView doResolveHandlerMethodException(HttpServletRequest request, HttpServletResponse response, @Nullable HandlerMethod handlerMethod, Exception exception) {
    // 9. 获取处理异常的方法，handlerMethod对应的是Controller接收请求的Method
    ServletInvocableHandlerMethod exceptionHandlerMethod = getExceptionHandlerMethod(handlerMethod, exception);
    if (exceptionHandlerMethod == null) {
        return null;
    }

    // 10. 给ServletInvocableHandlerMethod设置argumentResolvers、returnValueHandlers等，并调用实际方法处理异常
    //     可以看作：当调用Controller的一个业务方法service1()产生异常的时候，相当于执行的是对应的异常处理方法exception1()，
    //     两个方法的过程基本一样：处理参数、调用方法执行逻辑、处理返回值等。
    if (this.argumentResolvers != null) {
        exceptionHandlerMethod.setHandlerMethodArgumentResolvers(this.argumentResolvers);
    }
    if (this.returnValueHandlers != null) {
        exceptionHandlerMethod.setHandlerMethodReturnValueHandlers(this.returnValueHandlers);
    }
    ServletWebRequest webRequest = new ServletWebRequest(request, response);
    ModelAndViewContainer mavContainer = new ModelAndViewContainer();
    ArrayList<Throwable> exceptions = new ArrayList<>();
    try {
        if (logger.isDebugEnabled()) {
            logger.debug("Using @ExceptionHandler " + exceptionHandlerMethod);
        }
        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.toArray(arguments);
        arguments[arguments.length - 1] = handlerMethod;
        exceptionHandlerMethod.invokeAndHandle(webRequest, mavContainer, arguments);
    }
    catch (Throwable invocationEx) {
        if (!exceptions.contains(invocationEx) && logger.isWarnEnabled()) {
            logger.warn("Failure in @ExceptionHandler " + exceptionHandlerMethod, invocationEx);
        }
        return null;
    }

    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;
    }
}

2.3 使用

SpringMVC在处理Http请求的时候，留了两种方式供介入异常处理：

1) 自行定义HandlerExceptionResolver，需实现HandlerExceptionResolver接口

public interface HandlerExceptionResolver {
    ModelAndView resolveException(HttpServletRequest request, HttpServletResponse response, @Nullable Object handler, Exception ex);
}

然后用WebMvcConfigurer的下面接口把它注入到Spring中：

public interface WebMvcConfigurer {
    default void configureHandlerExceptionResolvers(List<HandlerExceptionResolver> resolvers) {
    }
    default void extendHandlerExceptionResolvers(List<HandlerExceptionResolver> resolvers) {
    }
}
注意：
  • 如果configureHandlerExceptionResolvers()提供了HandlerExceptionResolver，那么默认的HandlerExceptionResolver就没有了，需要自行处理所有的异常。如果只是针对某几种场景的异常希望自行处理，需要通过extendHandlerExceptionResolvers()提供。
  • 处理请求的时候，只会用一个HandlerExceptionResolver，只要有一个HandlerExceptionResolver返回了处理结果(不为null)，那么后面的HandlerExceptionResolver就被忽略掉了。
  • 这种方式提供的HandlerExceptionResolver需要处理比较多事情，如何通过异常匹配到具体的异常处理方法、如何处理返回值等，而这一块Spring已经提供比较好的实现，所以非特殊情况不推荐自行实现HandlerExceptionResolver。
2) 使用ExceptionHandlerExceptionResolver提供的@ControllerAdvice和@ExceptionHandler机制
这种情形也有两种方式：
  • 第一种是直接在Controller里的方法加上@ExceptionHandler注解，这样这个方法就会成为处理异常的方法了。参数是要处理的异常，返回值和普通的Controller方法一样规则。如果只希望这个Controller的请求产生的异常有一种特殊的处理方式，那么推荐用这个方法。
  • 第二种是在某个类上先加上@ControllerAdvice注解，这样Spring会把这个类作为Bean加载。这个类里的方法如果加上@ExceptionHandler注解，那么也会成为处理异常的方法。如果是处理全局异常，推荐用这个方法。

3 架构一小步

1) 特殊处理某个Controller的异常时，把处理异常处理方法放Controller里，并加上@ExceptionHandler注解。
2) 处理全局异常时，单独用一个类提供方法处理，类上面标注@ControllerAdvice注解，方法标注@ExceptionHandler注解。
秋千码途
关注
AI架构师必知必会系列：强化学习在金融领域的应用
AI天才研究院
12-05 1万+
在金融领域，如何制定最优决策以实现收益最大化和风险最小化一直是一个核心问题。传统的金融决策方法主要依赖于统计模型和专家经验,但在面对日益复杂多变的金融市场时,这些方法往往难以适应和优化。近年来,随着人工智能技术的快速发展,强化学习作为一种智能决策方法受到了金融领域的广泛关注。
智能客服平台的架构设计：实现高效、安全、可靠的服务运行
AI天才研究院
07-13 4660
在当今数字化时代,客户服务已成为企业与客户之间沟通的关键纽带。随着人工智能技术的快速发展,智能客服平台应运而生,为企业提供了一种高效、经济且全天候的客户服务解决方案。智能客服平台不仅能够大幅提升客户服务质量,还能降低企业运营成本,实现客户满意度与企业效益的双赢。然而,要建立一个真正高效、安全、可靠的智能客服平台,需要精心的架构设计和全面的技术考量。本文将深入探讨智能客服平台的架构设计原则、关键技术以及实现方法,为读者提供一个全面而深入的理解。
RISC-V 学习篇之特权架构下的中断异常处理
m0_53157173的博客
06-01 8400
RISC-V 学习篇之特权架构下的中断异常处理
英伟达Jetson AGX Orin 系列块架构全面解析
weixin_43199439的博客
12-27 1362
3. 系统缓存模块NVDLA 是一款针对 AI 深度学习推理任务的高效硬件加速器，特别优化了卷积神经网络的计算路径，凭借其高效的内存管理、低功耗设计和高性能计算，已成为自动驾驶、边缘计算、医疗影像分析等领域的关键技术支撑。视频输入模块在现代自动驾驶、智能座舱、ADAS 和工业自动化等领域中具有重要应用。其高带宽的传输能力、强大的多路同步处理功能以及低延迟设计，使其能够在高性能和高实时性要求的场景中提供可靠的解决方案，为各类高精度视觉系统的实现提供有力支持。
Java——异常处理（详解）
guochaoHNU的博客
09-30 2846
目录定义概念：异常类型异常处理：try...catchtry...catch finally 定义概念： 所谓异常就是程序运行时可能出现的一些错误，比如试图打开一个根本不存在的文件、配置问题、错误输入等问题，异常处理将会改变程序的控制流程，让程序有机会对错误做出处理。语法错误和逻辑错误不是异常。 java异常处理过程： （1）当程序运行到某一句时，发生了异常，那么程序会先停下来 （2）程序会在这句代码处，查看原因，生成一个合理“异常对象”，然后“抛”出 （3）JVM会检测在这句代码的外围，是否有try…c
AMD64(x86_64)架构abi文档：上
大昱的博客
07-23 2196
本节为AMD64处理器系列定义了带有任意记录格式的调试(DWARF)调试格式。AMD64ABI没有定义调试格式。然而，所有在AMD64上实现DWARF的系统应使用以下定义。DWARF是一个用于符号级、源代码级调试的规范。调试信息格式不适合任何编译器或调试器的设计。有关DWARF的更多信息，请参见DWARF调试格式标准，可在以下网站获得http。...
TOGAF架构开发方法
百老讲数据
12-30 2974
就像不同的企业能够接受不同程度的风险一样，为这些评估标准的制定建立统一的实施指南是非常困难的，但随着架构开发方法的不断实践，治理机构的成熟度水平会日渐提高，这些标准也会根据特定的需求而逐渐清晰起来。但在这一过程中，起重要作用的企业架构并不是凭空产生的，在它的周围总是存在着一系列正在创造价值（也许效率不是最优）并等待被整合的基础设施和业务，而针对他们的整合变更，以及外界环境对他们的变更需求，都在企业架构的演进过程中充当了驱动力。对待这些变更请求，治理行为是必不可少的，并且一个吸取经验教训的过程也是必要的。
AI系统架构原理与代码实战案例讲解
AI天才研究院
08-10 1456
人工智能的概念可以追溯到上世纪50年代，图灵测试的提出标志着人工智能作为一门学科的诞生。早期的研究主要集中在符号推理、专家系统等领域，取得了一些突破，例如机器定理证明、西洋跳棋程序等。上世纪80年代，随着专家系统的兴起，人工智能进入了一个黄金时期。专家系统通过模拟人类专家的知识和经验进行推理和决策，在医疗诊断、故障诊断等领域取得了成功应用。进入90年代，由于计算能力的限制和数据量的不足，人工智能的发展陷入低谷。近年来，随着深度学习技术的突破、大数据的兴起以及计算能力的提升，人工智能迎来了第三次发展浪潮，在图
数据采集平台的架构设计
AI天才研究院
08-04 3329
数据采集平台作为企业数据分析、处理的关键环节，在企业中扮演着至关重要的角色，但往往由于业务复杂、技术门槛高、软硬件成本等各种因素导致采集系统建设比较费力。如何设计一个具有可靠性、扩展性、安全性的数据采集平台是一个非常具有挑战性的问题。本文将从数据采集平台的功能需求出发，对数据采集平台的结构设计进行阐述。数据采集平台包括数据采集模块、数据存储模块、数据分析模块、数据展示模块、用户权限管理模块、数据质量管理模块等多个子模块。
AI人工智能深度学习算法：代理工作流中的异常处理与容错
AI天才研究院
08-13 1156
1. 背景介绍 1.1. 代理工作流的兴起 近年来，随着人工智能（AI）技术的快速发展，代理工作流（Agent Workflow）逐渐成为了一种新兴的软件架构范式。代理工作流利用多个自主代理（Agent）协同工作，以完成复杂的计算任务。每个代理都拥有特定的技能和知识，能够独立地执行任务、收集信息、与
小架构step系列26：Spring提供的validator
swingline的专栏
07-26 1419
对于Web服务，需要对请求的参数进行校验，可以对不合法的参数进行提示，提高用户体验。也可以防止有人恶意用一些非法的参数对网站造成破坏。如果是对每个参数都写一段代码来判断值是否合法，那校验的代码就很多，也很繁琐。Spring提供了一套校验机制，先来了解一下。
小架构step系列08：logback.xml的配置
swingline的专栏
07-08 781
logback.xml配置文件的详细配置，很多地方都说得比较细，本文主要从几个重点来看一下原理，了解原理能够帮助确定哪些应该配置，以及如何配置。logback.xml是为打印日志服务的，打印的内容一般打印到控制台(Console)和文件(file)里，在生产环境中主要是打印到文件里，然后用扫描工具汇总到某个地方方便查询(如ELK)。打印的内容要符合一定的格式，提供足够的信息，方便进行日志查询和分析；
小架构step系列19：请求和响应
swingline的专栏
07-19 1436
作为Web程序，通用形式是发起HTTP请求并获取返回的结果，在这个过程中，需要把请求映射到代码的接口上，提供这种接口的类一般称为Controller，也就是需要把请求映射到Controller的接口方法上，把请求的参数映射到接口的参数中，并从接口返回接口处理的结果。在后端渲染页面的场景中，返回的结果需要处理为视图View。而现在更普遍的是前后端分离，返回的结果一般处理为JSON格式的数据，前端拿到这种数据再进行处理和页面的渲染。本文来了解一下这个请求和响应的过程。
AI架构师必知必会系列：AI安全与隐私保护
AI天才研究院
10-18 782
随着人工智能（AI）技术的快速发展，AI系统在各个领域的应用越来越广泛。然而，随着AI的普及，安全与隐私问题也日益凸显。AI系统在处理大量数据时，如何确保数据的安全性和用户隐私成为了一个亟待解决的问题。数据泄露、模型攻击、隐私侵犯等问题频频发生，引起了广泛的关注和讨论。差分隐私的核心思想是通过在数据中添加噪声，使得任何单个数据的变化不会显著影响整体统计结果，从而保护个体隐私。具体来说，差分隐私通过引入噪声机制（如拉普拉斯机制和高斯机制）来实现数据隐私保护。
《K8s 入门实战：架构原理拆解》
m0_56953101的博客
12-10 814
Kubernetes（K8S）是一个容器集群管理平台，用于部署和管理微服务应用。其架构分为Master控制节点（包含API Server、ETCD、调度器等核心组件）和Worker工作节点（运行kubelet、kube-proxy及Pod）。K8S通过中心化的工作流程运作：用户指令经kubectl提交后，由Master节点协调调度，最终在Worker节点创建并运行Pod。关键机制包括List-watch监听、控制器状态维护和kube-proxy网络管理，实现自动化部署、扩缩容和负载均衡等功能。
AI大模型架构简单理解
12-10 332
2017年谷歌团队提出的这一架构，直接颠覆了此前的AI技术路线，如今所有主流大模型（无论是GPT系列还是国产模型），本质上都是在Transformer的基础上优化而来。：文字、图片、视频、语音、3D模型等信息会深度整合，模型能像人一样“全方位感知世界”（如未来模型能看懂设计图并生成施工方案，或听懂需求并生成视频）。：在通用大模型基础上，针对医疗、法律、教育等行业做“领域微调”（如医疗大模型专注疾病诊断，法律大模型专注法条解读），让模型更懂行业知识；：传统大模型是“密集型”的，每次计算都会激活所有神经元；
【字节开源Golang框架Eino】技术详解：架构原理+实战落地+避坑指南（附代码）
最新发布
分享技术干货，聚焦AI前沿科技
12-12 900
摘要： 字节跳动开源的Golang微服务框架Eino，专为高并发、低延迟场景设计，整合了服务注册发现、RPC通信、配置中心、服务治理等核心能力。经过抖音、飞书等亿级流量业务验证，Eino提供高性能（亚毫秒级延迟）、强可观测性和易扩展性，兼容主流Golang生态（如Kitex、Prometheus）。其模块化架构支持按需启用组件，提供低侵入式API，适合中大型分布式系统快速落地微服务治理能力。代码示例展示了基于Nacos的服务注册发现和动态配置功能，体现其高效与易用性。
Redis三种服务架构
m0_48877765的博客
12-11 1166
上次和读者们讲解了关于redis的配置与优化，今天我主要分享一下关于redis三种服务架构的主要内容。1.Redis三种模式概述Redis群集有三种模式，分别是主从同步复制、哨兵模式、Cluster，下面会讲解一下三种模式的工作方式，以及如何搭建cluster群集主从复制：主从复制是高可用Redis的基础，哨兵和集群都是在主从复制基础上实现高可用的。主从复制主要实现了数据的多机备份，以及对于读操作的负载均衡和简单的故障恢复。缺陷：故障恢复无法自动化；写操作无法负载均衡；
CentOS Stream 9入门学习教程，从入门到精通，CentOS Stream 9 使用 LNMP 架构部署网站 —— 语法详解与实战案例(12）
qq_45746668的博客
12-11 1117
本文介绍了在 CentOS Stream 9 系统上部署LNMP架构的详细步骤。LNMP由Linux、Nginx、MariaDB和PHP组成，具有高并发、低内存占用等优势。文章首先讲解了LNMP各组件的作用及工作原理，然后详细演示了Nginx的安装配置过程，包括防火墙设置、服务管理命令和配置文件解析。通过创建测试站点和配置示例，帮助读者快速上手LNMP架构部署。后续章节还将介绍PHP、MariaDB的安装配置及完整网站部署方案。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值