SpringMVC

拦截器

什么时候会触发拦截器？拦截器的配置拦截器的三个方法

DispatcherServlet 部分源码拦截器案例代码多个拦截器的执行顺序

HandlerExecutionChain 部分源码案例（拦截器全部为true的效果）异常处理器

基于配置的异常处理

DefaultHandlerExceptionResolver 说明SimpleMappingExceptionResolver 说明基于配置文件实现异常处理

获取异常信息基于注解实现异常处理注解配置 SpringMVC

创建初始化类，代替 web.xml 文件

说明实现创建 SpringConfig 配置类，代替 Spring 的配置文件创建 SpringMVCConfig 配置类，代替 SpringMVC 的配置文件

配置视图解析器配置拦截器配置视图控制器配置文件上传解析器配置异常处理器

拦截器

创建一个新的工程用来测试代码，前面已经创建过很多次了，初始代码就是那些，所以这里就不写了，可看下面的大致架构

Controller 和 html 页面可以先创建好，后面需要写了在写；web、spring-mvc、pom 都是和之前一样的

什么时候会触发拦截器？

拦截器的配置

SpringMVC 中的拦截器用于拦截控制器方法的执行。SpringMVC 中的拦截器需要实现 HandlerInterceptor 接口。SpringMVC 的拦截器必须在 SpringMVC 的配置文件中进行配置拦截器的三个方法

SpringMVC 中的拦截器有三个方法：

preHandle：控制器方法执行之前执行 preHandle()，其 boolean 类型的返回值表示是否拦截或放行，返回 true 为放行，即调用控制器方法；返回 false 表示拦截，即不调用控制器方法。postHandle：控制器方法执行之后执行 postHandle() 方法afterComplation：处理完视图和模型数据，渲染视图完毕之后执行 afterComplation() 方法 DispatcherServlet 部分源码

在该源码中会默认帮我们去调用所有的拦截器（SpringMVC默认有一个拦截器，我们也可以手动创建拦截器）

public class DispatcherServlet extends frameworkServlet {
	protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
		// 调用所有拦截器的 preHandle()方法（在控制器方法执行前调用）
		if (!mappedHandler.applyPreHandle(processedRequest, response)) {
			return;
		}
		
		// 调用所有拦截器的 postHandle() 方法（在控制器方法执行之后调用）
		mappedHandler.applyPostHandle(processedRequest, response, mv);
		
		processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
	}
	
	private void processDispatchResult(HttpServletRequest request, HttpServletResponse response,
			@Nullable HandlerExecutionChain mappedHandler, @Nullable ModelAndView mv,
			@Nullable Exception exception) throws Exception {
		if (mv != null && !mv.wasCleared()) {
			// 渲染视图
			render(mv, request, response);
			if (errorView) {
				WebUtils.clearErrorRequestAttributes(request);
			}
		}
		if (mappedHandler != null) {
			// 调用所有拦截器的 afterCompletion() 方法（在视图渲染完之后调用）
			mappedHandler.triggerAfterCompletion(request, response, null);
		}
	}
}

拦截器案例代码

在 index.html 中编写超链接




    
    首页


    首页
    测试拦截器

success.html 页面就弄个文字就好了，因为只是用来跳转的。

编写对应的控制器方法

package com.laoyang.mvc.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;


@Controller
public class InterceptorController {
    @RequestMapping("interceptor")
    public String interceptor() {
        return "success";
    }
}

编写拦截器

package com.laoyang.mvc.config;

import org.springframework.stereotype.Component;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;


public class InterceptorConfig implements HandlerInterceptor {
    
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("在控制器执行之前执行");
        return true;
    }

    
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("在控制器执行之后执行");
    }

    
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("在视图渲染之后执行");
    }
}

在 spring-mvc.xml 文件中配置拦截器



    
    
    
        


        
            
			HandlerInterceptor interceptor = this.interceptorList.get(i);
			try {
				interceptor.afterCompletion(request, response, this.handler, ex);
			}
			catch (Throwable ex2) {
				logger.error("HandlerInterceptor.afterCompletion threw exception", ex2);
			}
		}
	}
}

感兴趣的小伙伴可以自己进入底层代码中进行查看及测试。

案例（拦截器全部为true的效果）

将刚才创建的拦截器打印信息改成这样：

package com.laoyang.mvc.config;

import org.springframework.stereotype.Component;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;


@Component
public class InterceptorConfig implements HandlerInterceptor {
    
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("InterceptorConfig在控制器执行之前执行");
        return true;
    }

    
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("InterceptorConfig在控制器执行之后执行");
    }

    
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("InterceptorConfig在视图渲染之后执行");
    }
}

然后在创建一个拦截器，和上面那个差不错，把打印信息稍微换一下就行

package com.laoyang.mvc.config;

import org.springframework.stereotype.Component;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;


@Component
public class SecondInterceptorConfig implements HandlerInterceptor {
    
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("SecondInterceptorConfig在控制器执行之前执行");
        return true;
    }

    
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("SecondInterceptorConfig在控制器执行之后执行");
    }

    
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("SecondInterceptorConfig在视图渲染之后执行");
    }
}

在 spring-mvc.xml 文件中配置这俩拦截器

这里我就写关键的代码了，大家把这段代码加到配置文件中就好了

启动 Tomcat 查看控制台效果

interceptorConfig 拦截器在上的效果

我们可以看到，刚开始是按正序执行 interceptorConfig 拦截器的 preHandle() 方法的，然后在执行的 secondInterceptorConfig 拦截器的 preHandle() 方法，而后面的两个方法则是先执行的 secondInterceptorConfig 拦截器，在执行 interceptorConfig 拦截器，这就是刚才源码中说的拦截器执行顺序

secondInterceptorConfig 拦截器在上的效果

注意：这里说的 “在上” 指的是 spring-mvc.xml 配置文件中拦截器的配置顺序，大家可自行尝试

如果大家想看一下返回 false 的效果，那么可以将我们配置的两个拦截器中的某一个拦截器的 preHandle() 返回值设置为 false，然后在进行测试，看控制台的效果即可。

异常处理器基于配置的异常处理

SpringMVC 提供了一个处理控制器方法执行过程中所出现的异常的接口：HandlerExceptionResolver

HandlerExceptionResolver 接口的实现类有：DefaultHandlerExceptionResolver 和 SimpleMappingExceptionResolver

SpringMVC 提供了自定义的异常处理器 SimpleMappingExceptionResolver

DefaultHandlerExceptionResolver 说明

默认的异常处理如果出现对应的异常，就会返回一个 ModelAndView 对象，代替我们原本要正常访问的 ModelAndView 对象

我们看到的那些 500、404 之类的报错页面就是它处理的

部分源码：

public class DefaultHandlerExceptionResolver extends AbstractHandlerExceptionResolver {
    @Override
	@Nullable
	protected ModelAndView doResolveException(
			HttpServletRequest request, HttpServletResponse response, @Nullable Object handler, Exception ex) {
		try {
			if (ex instanceof HttpRequestMethodNotSupportedException) {
				return handleHttpRequestMethodNotSupported(
						(HttpRequestMethodNotSupportedException) ex, request, response, handler);
			}
			else if (ex instanceof HttpMediaTypeNotSupportedException) {
				return handleHttpMediaTypeNotSupported(
						(HttpMediaTypeNotSupportedException) ex, request, response, handler);
			}
			else if (ex instanceof HttpMediaTypeNotAcceptableException) {
				return handleHttpMediaTypeNotAcceptable(
						(HttpMediaTypeNotAcceptableException) ex, request, response, handler);
			}
			else if (ex instanceof MissingPathVariableException) {
				return handleMissingPathVariable(
						(MissingPathVariableException) ex, request, response, handler);
			}
			else if (ex instanceof MissingServletRequestParameterException) {
				return handleMissingServletRequestParameter(
						(MissingServletRequestParameterException) ex, request, response, handler);
			}
			else if (ex instanceof ServletRequestBindingException) {
				return handleServletRequestBindingException(
						(ServletRequestBindingException) ex, request, response, handler);
			}
			else if (ex instanceof ConversionNotSupportedException) {
				return handleConversionNotSupported(
						(ConversionNotSupportedException) ex, request, response, handler);
			}
			else if (ex instanceof TypeMismatchException) {
				return handleTypeMismatch(
						(TypeMismatchException) ex, request, response, handler);
			}
			else if (ex instanceof HttpMessageNotReadableException) {
				return handleHttpMessageNotReadable(
						(HttpMessageNotReadableException) ex, request, response, handler);
			}
			else if (ex instanceof HttpMessageNotWritableException) {
				return handleHttpMessageNotWritable(
						(HttpMessageNotWritableException) ex, request, response, handler);
			}
			else if (ex instanceof MethodArgumentNotValidException) {
				return handleMethodArgumentNotValidException(
						(MethodArgumentNotValidException) ex, request, response, handler);
			}
			else if (ex instanceof MissingServletRequestPartException) {
				return handleMissingServletRequestPartException(
						(MissingServletRequestPartException) ex, request, response, handler);
			}
			else if (ex instanceof BindException) {
				return handleBindException((BindException) ex, request, response, handler);
			}
			else if (ex instanceof NoHandlerFoundException) {
				return handleNoHandlerFoundException(
						(NoHandlerFoundException) ex, request, response, handler);
			}
			else if (ex instanceof AsyncRequestTimeoutException) {
				return handleAsyncRequestTimeoutException(
						(AsyncRequestTimeoutException) ex, request, response, handler);
			}
		}
		catch (Exception handlerEx) {
			if (logger.isWarnEnabled()) {
				logger.warn("Failure while trying to resolve exception [" + ex.getClass().getName() + "]", handlerEx);
			}
		}
		return null;
	}
}

SimpleMappingExceptionResolver 说明

自定义异常处理我们可以使用配置文件或注解的方式配置异常处理基于配置文件实现异常处理

在 spring-mvc.xml 文件中配置异常处理

在 index.html 中编写超链接




    
    首页


    首页
    测试自定义异常处理

创建 error.html 页面




    
    错误页面


    页面出现问题了，程序员该加班了！

编写对应的控制器方法

package com.laoyang.mvc.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
public class InterceptorController {
    @RequestMapping("/testException")
    public String testException() {
        // 故意编写一个会导致算术异常的代码
        int i = 10 / 0;
        return "success";
    }
}

启动Tomcat查看效果

获取异常信息

在 spring-mvc.xml 文件的异常处理中在设置一个属性

在 error.html 页面调用这个属性

错误页面

页面出现问题了，程序员该加班了！

测试效果

基于注解实现异常处理

注释掉 spring-mvc.xml 文件中的异常处理

为了确保大家里面的配置没有写错，我这里把完整的代码展示一下

编写一个新的 Controller，并编写对应的方法（使用注解修饰）

package com.laoyang.mvc.controller;

import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;


 //该注解可拆分为 Controller 和 Advice 进行理解
 //可用来实现：捕获全局的异常、进行数据的绑定、全局数据的预处理
@ControllerAdvice
public class ExceptionController {
    
    @ExceptionHandler(value = {ArithmeticException.class, NullPointerException.class})
    public String testExceptionHandler(Exception ex, Model model) {
        model.addAttribute("ex", ex);
        return "error";
    }
}

启动Tomcat查看效果

如果大家想看空指针异常的效果，可以在控制器方法中加入以下代码：
// 空指针异常
String str = null;
System.out.println(str.toString());

注解配置 SpringMVC

使用配置类和注解代替 web.xml 和 spring-mvc.xml 配置文件的功能

创建一个新的工程，导入之前的依赖、创建 webapp 、WEB-INF 、templates 文件夹即可

创建初始化类，代替 web.xml 文件说明

在 Servlet3.0 环境中，容器会在类路径中查找实现 javax.servlet.ServletContainerInitializer 接口的类，如果找到的话就用它来配置 Servlet 容器。Spring 提供了这个接口的实现，名为 SpringServletContainerInitializer，这个类反过来又会查找实现WebApplicationInitializer的类并将配置的任务交给它们来完成。Spring3.2 引入了一个便利的 WebApplicationInitializer 基础实现，名为AbstractAnnotationConfigDispatcherServletInitializer，当我们的类扩展了AbstractAnnotationConfigDispatcherServletInitializer 并将其部署到 Servlet3.0 容器的时候，容器会自动发现它，并用它来配置 Servlet 上下文。实现

在 config 包下创建配置类替代 web.xml 配置文件

package com.laoyang.mvc.config;

import org.springframework.web.filter.CharacterEncodingFilter;
import org.springframework.web.filter.HiddenHttpMethodFilter;
import org.springframework.web.servlet.support.AbstractAnnotationConfigDispatcherServletInitializer;
import javax.servlet.Filter;


public class WebInit extends AbstractAnnotationConfigDispatcherServletInitializer {
    
    @Override
    protected Class[] getRootConfigClasses() {
        return new Class[]{SpringConfig.class};
    }

    
    @Override
    protected Class[] getServletConfigClasses() {
        return new Class[]{SpringMVCConfig.class};
    }

    
    @Override
    protected String[] getServletMappings() {
        return new String[]{"/"};
    }

    
    @Override
    protected Filter[] getServletFilters() {
        // 字符编码过滤器
        CharacterEncodingFilter characterEncodingFilter = new CharacterEncodingFilter();
        characterEncodingFilter.setEncoding("UTF-8");
        characterEncodingFilter.setForceEncoding(true);

        // 处理 put和delete请求的过滤器
        HiddenHttpMethodFilter hiddenHttpMethodFilter = new HiddenHttpMethodFilter();
        return new Filter[]{characterEncodingFilter, hiddenHttpMethodFilter};
    }
}

包别导错了

创建 SpringConfig 配置类，代替 Spring 的配置文件

因为现在是使用 SpringMVC，所以这个配置类也可以不创建，如果创建的话，内容不配置也是可以的（因为现在写的都是SpringMVC的配置）

package com.laoyang.mvc.config;

import org.springframework.context.annotation.Configuration;


@Configuration
public class SpringConfig {

}

创建 SpringMVCConfig 配置类，代替 SpringMVC 的配置文件配置视图解析器

在 config 包下创建配置类代替 spring-mvc.xml 配置文件并配置视图解析器

package com.laoyang.mvc.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.context.ContextLoader;
import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.servlet.ViewResolver;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;
import org.thymeleaf.spring5.SpringTemplateEngine;
import org.thymeleaf.spring5.view.ThymeleafViewResolver;
import org.thymeleaf.templatemode.TemplateMode;
import org.thymeleaf.templateresolver.ITemplateResolver;
import org.thymeleaf.templateresolver.ServletContextTemplateResolver;


// 将当前类标识为一个配置类
@Configuration
// 开启组件扫描
@ComponentScan(value = {"com.laoyang.mvc"})
// 开启 mvc 注解驱动
@EnableWebMvc
public class SpringMVCConfig {
    
    @Bean
    public ITemplateResolver templateResolver() {
        WebApplicationContext webApplicationContext = ContextLoader.getCurrentWebApplicationContext();
        // ServletContextTemplateResolver需要一个ServletContext作为构造参数，可通过 WebApplicationContext 的方法获得
        ServletContextTemplateResolver templateResolver = new ServletContextTemplateResolver(
                webApplicationContext.getServletContext());
        templateResolver.setPrefix("/WEB-INF/templates/");
        templateResolver.setSuffix(".html");
        templateResolver.setCharacterEncoding("UTF-8");
        templateResolver.setTemplateMode(TemplateMode.HTML);
        return templateResolver;
    }

    
    @Bean
    public SpringTemplateEngine templateEngine(ITemplateResolver templateResolver) {
        SpringTemplateEngine templateEngine = new SpringTemplateEngine();
        templateEngine.setTemplateResolver(templateResolver);
        return templateEngine;
    }

    
    @Bean
    public ViewResolver viewResolver(SpringTemplateEngine templateEngine) {
        ThymeleafViewResolver viewResolver = new ThymeleafViewResolver();
        viewResolver.setCharacterEncoding("UTF-8");
        viewResolver.setTemplateEngine(templateEngine);
        return viewResolver;
    }
}

包别导错了，视图解析器基本上都是固定写法

在 templates 目录下创建 index.html 页面

创建对应的控制器

package com.laoyang.mvc.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;


@Controller
public class HelloController {
    @RequestMapping("/")
    public String doIndex() {
        return "index";
    }
}

启动Tomcat查看效果

此时我们启动 Tomcat 就可以访问到首页了

配置拦截器

创建 hello.html 页面




    
    Hello


    Hello World!

在 index.html 中编写超链接




    
    首页


    首页
    测试拦截器

编写对应的控制器方法

package com.laoyang.mvc.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
public class HelloController {
    @RequestMapping("/doHello")
    public String doHello() {
        return "hello";
    }
}

创建拦截器

package com.laoyang.mvc.interceptor;

import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;


public class SpringMvcInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("preHandle 被执行");
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("postHandle 被执行");
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("afterCompletion 被执行");
    }
}

在配置类中配置拦截器

package com.laoyang.mvc.config;

import com.laoyang.mvc.interceptor.SpringMvcInterceptor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.context.ContextLoader;
import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.servlet.ViewResolver;
import org.springframework.web.servlet.config.annotation.*;
import org.thymeleaf.spring5.SpringTemplateEngine;
import org.thymeleaf.spring5.view.ThymeleafViewResolver;
import org.thymeleaf.templatemode.TemplateMode;
import org.thymeleaf.templateresolver.ITemplateResolver;
import org.thymeleaf.templateresolver.ServletContextTemplateResolver;


// 将当前类标识为一个配置类
@Configuration
// 开启组件扫描
@ComponentScan(value = {"com.laoyang.mvc"})
// 开启 mvc 注解驱动
@EnableWebMvc
public class SpringMVCConfig implements WebMvcConfigurer {
    
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        SpringMvcInterceptor interceptor = new SpringMvcInterceptor();
        
        registry.addInterceptor(interceptor).addPathPatterns("
// 将当前类标识为一个配置类
@Configuration
// 开启组件扫描
@ComponentScan(value = {"com.laoyang.mvc"})
// 开启 mvc 注解驱动
@EnableWebMvc
public class SpringMVCConfig implements WebMvcConfigurer {
    
    @Override
    public void addViewControllers(ViewControllerRegistry registry) {
        registry.addViewController("/doHello").setViewName("hello");
    }
}

注释控制器中路径为 /doHello 的方法

package com.laoyang.mvc.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
public class HelloController {
//    @RequestMapping("/doHello")
//    public String doHello() {
//        return "hello";
//    }
}

启动Tomcat查看效果

配置文件上传解析器

导入相关依赖



    4.0.0

    com.laoyang.mvc
    springmvc-demo6
    1.0-SNAPSHOT
    war

    
        
        
            org.springframework
            spring-webmvc
            5.3.1
        

        
        
            ch.qos.logback
            logback-classic
            1.2.3
        

        
        
            javax.servlet
            javax.servlet-api
            3.1.0
            
            provided
        

        
        
            org.thymeleaf
            thymeleaf-spring5
            3.0.12.RELEASE
        

        
        
            commons-fileupload
            commons-fileupload
            1.3.1

需要导入最后那个文件上传的依赖，不然待会会报 500

在配置类中配置文件上传解析器

package com.laoyang.mvc.config;

import com.laoyang.mvc.interceptor.SpringMvcInterceptor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.context.ContextLoader;
import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.multipart.MultipartResolver;
import org.springframework.web.multipart.commons.CommonsMultipartResolver;
import org.springframework.web.servlet.HandlerExceptionResolver;
import org.springframework.web.servlet.ViewResolver;
import org.springframework.web.servlet.config.annotation.*;
import org.springframework.web.servlet.handler.SimpleMappingExceptionResolver;
import org.thymeleaf.spring5.SpringTemplateEngine;
import org.thymeleaf.spring5.view.ThymeleafViewResolver;
import org.thymeleaf.templatemode.TemplateMode;
import org.thymeleaf.templateresolver.ITemplateResolver;
import org.thymeleaf.templateresolver.ServletContextTemplateResolver;
import java.util.List;
import java.util.Properties;


// 将当前类标识为一个配置类
@Configuration
// 开启组件扫描
@ComponentScan(value = {"com.laoyang.mvc"})
// 开启 mvc 注解驱动
@EnableWebMvc
public class SpringMVCConfig implements WebMvcConfigurer {
    
    @Bean
    public CommonsMultipartResolver multipartResolver(){
        return new CommonsMultipartResolver();
    }
}

如果没有什么需要添加的配置，直接返回即可，如果有需要添加的配置，可以在里面创建一个对象，然后设置对应的值即可。

启动Tomcat查看效果

这个 demo4 中有案例代码，大家可自行查看，这里就不给大家演示了，最后的效果都是可以正常实现的（基本上就是在页面创建一个文件域，然后在控制器方法中进行操作）配置异常处理器

编写对应的控制器方法，手动制造异常

package com.laoyang.mvc.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
public class HelloController {
    @RequestMapping("/doHello")
    public String doHello() {
        int i = 10 / 0;
        return "hello";
    }
}

在配置类中配置异常处理器

package com.laoyang.mvc.config;

import com.laoyang.mvc.interceptor.SpringMvcInterceptor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.context.ContextLoader;
import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.multipart.MultipartResolver;
import org.springframework.web.multipart.commons.CommonsMultipartResolver;
import org.springframework.web.servlet.HandlerExceptionResolver;
import org.springframework.web.servlet.ViewResolver;
import org.springframework.web.servlet.config.annotation.*;
import org.springframework.web.servlet.handler.SimpleMappingExceptionResolver;
import org.thymeleaf.spring5.SpringTemplateEngine;
import org.thymeleaf.spring5.view.ThymeleafViewResolver;
import org.thymeleaf.templatemode.TemplateMode;
import org.thymeleaf.templateresolver.ITemplateResolver;
import org.thymeleaf.templateresolver.ServletContextTemplateResolver;
import java.util.List;
import java.util.Properties;


// 将当前类标识为一个配置类
@Configuration
// 开启组件扫描
@ComponentScan(value = {"com.laoyang.mvc"})
// 开启 mvc 注解驱动
@EnableWebMvc
public class SpringMVCConfig implements WebMvcConfigurer {
    
    @Override
    public void configureHandlerExceptionResolvers(List resolvers) {
        SimpleMappingExceptionResolver resolver = new SimpleMappingExceptionResolver();
        Properties properties = new Properties();
        // 出现 ArithmeticException 异常的时候跳转到 error 页面进行处理
        properties.setProperty("java.lang.ArithmeticException", "error");
        resolver.setExceptionMappings(properties);
        // 将异常信息共享到请求域中
        resolver.setExceptionAttribute("ex");
        resolvers.add(resolver);
    }
}

创建 error.html 页面

异常处理

程序存在风险，请谨慎操作！

启动Tomcat查看效果

SpringMVC拦截器与异常处理器（含注解配置SpringMVC）

Java相关栏目本月热门文章