【SpringBoot】使用WebMvcConfigurer配置SpringMVC

文章目录

• • 一.前言
  • 二.使用方式
  • • 2.1.过时方式
    • 2.2.新版本方式
  • 三.WebMvcConfigurer接口常用方法
  • • addInterceptors：拦截器
    • addCorsMappings：跨域
    • configureContentNegotiation:默认内容协商配置
    • addViewControllers：跳转指定页面
    • resourceViewResolver：视图解析器
    • configureMessageConverters：信息转换器
    • extendMessageConverters：信息转换器
    • • 1.使用
      • 2.HttpMessageConverter接口
      • 3.HttpMessageConverter请求信息转换器执行流程
      • 4.自定义HttpMessageConverter
      • 5.总结
    • addResourceHandlers：静态资源
    • addFormatters:格式转换
    • 错误页面配置

一.前言

WebMvcConfigurer配置类是使用Java代码代替传统的xml配置文件,对SpirngMvc进行配置的一种方式，需要创建一个配置类@Configuration并实现WebMvcConfigurer 接口（推荐）

二.使用方式

2.1.过时方式

• 在Spring Boot 1.5版本以前都是继承WebMvcConfigurerAdapter类来实现代码配置的。 SpringBoot 2.0 后，WebMvcConfigurerAdapter类被@Deprecated（弃用）

配置类继承WebMvcConfigurerAdapter类

@Configuration
public class WebMvcConfg extends WebMvcConfigurerAdapter{}
1
2

2.2.新版本方式

• 官方推荐使用实现WebMvcConfigurer接口(推荐)或者继承WebMvcConfigurationSupport类来实现代码配置

1.配置类实现WebMvcConfigurer接口

@Configuration
public class WebMvcConfg implements WebMvcConfigurer {}
1
2

2.配置类继承WebMvcConfigurationSupport

@Configuration
public class WebMvcConfg extends WebMvcConfigurationSupport {}
1
2

三.WebMvcConfigurer接口常用方法

addInterceptors：拦截器

• addInterceptor：需要一个实现HandlerInterceptor接口的拦截器实例

• addPathPatterns：用于设置拦截器的过滤路径规则；- addPathPatterns(“/**”)对所有请求都拦截

• excludePathPatterns：用于设置不需要拦截的过滤规则

• 拦截器主要用途：进行用户登录状态的拦截，日志的拦截等。

  @Override
  public void addInterceptors(InterceptorRegistry registry) {
  super.addInterceptors(registry);
  registry.addInterceptor(new TestInterceptor()).addPathPatterns(“/**”);
  }

addCorsMappings：跨域

    @Override
    public void addCorsMappings(CorsRegistry registry) {
        registry.addMapping("/**")
                .allowedOrigins("*")  //浏览器允许所有的域访问 / 注意 * 不能满足带有cookie的访问,Origin 必须是全匹配
                .allowCredentials(true)   // 允许带cookie访问
                .allowedMethods("GET", "POST", "PUT", "DELETE", "OPTIONS")
                 .allowedHeaders("token")
                .maxAge(3600);
    }
1
2
3
4
5
6
7
8
9

configureContentNegotiation:默认内容协商配置

内容协商:在 HTTP 协议中，内容协商是这样一种机制，通过为同一 URI 指向的资源提供不同的展现形式，可以使用户代理选择与用户需求相适应的最佳匹配

• 一个请求路径返回多种数据格式

  @Override
  public void configureContentNegotiation(ContentNegotiationConfigurer configurer) {
  /* 是否通过请求Url的扩展名来决定media type /
  configurer.favorPathExtension(true)
  / 不检查Accept请求头 /
  .ignoreAcceptHeader(true)
  .parameterName(“mediaType”)
  / 设置默认的media yype /
  .defaultContentType(MediaType.TEXT_HTML)
  / 请求以.html结尾的会被当成MediaType.TEXT_HTML*/
  .mediaType(“html”, MediaType.TEXT_HTML)
  /* 请求以.json结尾的会被当成MediaType.APPLICATION_JSON*/
  .mediaType(“json”, MediaType.APPLICATION_JSON);
  }

上面代码说白了就是告诉系统什么类型用什么来标识

addViewControllers：跳转指定页面

以前写SpringMVC的时候，如果需要访问一个页面，必须要写Controller类，然后再写一个方法跳转到页面，感觉好麻烦，其实重写WebMvcConfigurer中的addViewControllers方法即可达到效果了

@Override
 public void addViewControllers(ViewControllerRegistry registry) {
     super.addViewControllers(registry);
     registry.addViewController("/").setViewName("/index");
     //实现一个请求到视图的映射，而无需书写controller
     registry.addViewController("/login").setViewName("forward:/index.html");  
}
1
2
3
4
5
6
7

resourceViewResolver：视图解析器

/**
 * 视图配置
 * @param registry
 */
@Override
public void configureViewResolvers(ViewResolverRegistry registry) {
	super.configureViewResolvers(registry);
	registry.viewResolver(resourceViewResolver());
	/*registry.jsp("/WEB-INF/jsp/",".jsp");*/
}

/**
 * 配置请求视图映射
 * @return
 */
@Bean
public InternalResourceViewResolver resourceViewResolver()
{
	InternalResourceViewResolver internalResourceViewResolver = new InternalResourceViewResolver();
	//请求视图文件的前缀地址
	internalResourceViewResolver.setPrefix("/WEB-INF/jsp/");
	//请求视图文件的后缀
	internalResourceViewResolver.setSuffix(".jsp");
	return internalResourceViewResolver;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

configureMessageConverters：信息转换器

配置在接收request (请求)和返回response (响应)时的数据转换器，最常用到的就是fastJson的转换，配置如下所示：

• 该方法会替换所有默认的MessageConverters，使用自定义添加converters，在实际项目中应用比例也比较小；

       /**
   * 消息内容转换配置
   */
  @Override
  public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
      //StringHttpMessageConverter默认使用的字符集是ISO-8859-1,改为输出的JSON字符串为UTF-8字符集
      converters.add(new StringHttpMessageConverter(StandardCharsets.UTF_8));
      
      //添加fastjson消息转换器
      converters.add(fastJsonHttpMessageConverters());
  }
  
  /**
   * 引入Fastjson解析json，不使用默认的jackson,必须在pom.xml引入fastjson的jar包，并且版必须大于1.2.10
   *
   * @return
   */
  @Bean
  public FastJsonHttpMessageConverter fastJsonHttpMessageConverters() {
      //1、定义一个convert转换消息的对象
      FastJsonHttpMessageConverter fastConverter = new FastJsonHttpMessageConverter();
  
      //2、添加fastjson的配置信息
      FastJsonConfig fastJsonConfig = new FastJsonConfig();
  
      SerializerFeature[] serializerFeatures = new SerializerFeature[]{
              //    输出key是包含双引号
              //SerializerFeature.QuoteFieldNames,
              //    是否输出为null的字段,若为null 则显示该字段
              SerializerFeature.WriteMapNullValue,
              //    数值字段如果为null，则输出为0
              SerializerFeature.WriteNullNumberAsZero,
              //     List字段如果为null,输出为[],而非null
              SerializerFeature.WriteNullListAsEmpty,
              //    字符类型字段如果为null,输出为"",而非null
              SerializerFeature.WriteNullStringAsEmpty,
              //    Boolean字段如果为null,输出为false,而非null
              SerializerFeature.WriteNullBooleanAsFalse,
              //    Date的日期转换器
              SerializerFeature.WriteDateUseDateFormat,
              //    循环引用（如果不配置有可能会进入死循环）
              SerializerFeature.DisableCircularReferenceDetect,
              //    格式化JSON
              SerializerFeature.PrettyFormat
      };
  
  
      fastJsonConfig.setSerializerFeatures(serializerFeatures);
      fastJsonConfig.setCharset(Charset.forName("UTF-8"));
  
  
      //3.解决乱码问题。定义响应的MIME类型，设置响应的content-type为application/json;charset=UTF-8
      List<MediaType> fastMediaType = new ArrayList<>();
      fastMediaType.add(MediaType.valueOf(MediaType.APPLICATION_JSON_VALUE));
  
      //4.converter消息转换器添加配置信息
      fastConverter.setSupportedMediaTypes(fastMediaType);
  
      //5、在convert中添加配置信息
      fastConverter.setFastJsonConfig(fastJsonConfig);
  
      return fastConverter;
  }
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20
  21
  22
  23
  24
  25
  26
  27
  28
  29
  30
  31
  32
  33
  34
  35
  36
  37
  38
  39
  40
  41
  42
  43
  44
  45
  46
  47
  48
  49
  50
  51
  52
  53
  54
  55
  56
  57
  58
  59
  60
  61
  62
  63

extendMessageConverters：信息转换器

1.使用

springboot2.0版本以后推荐使用extendMessageConverters来进行web配置，这个方法不会覆盖springmvc已默认添加的HttpMessageConverter

• 即:在默认加载的消息转换器基础上继续添加自定义的converters实例

  @Override
  public void extendMessageConverters(List<HttpMessageConverter<?>> converters) {
      converters.add(customerMappingJackson2HttpMessageConverter());
      converters.add(stringHttpMessageConverter());
      converters.add(fastJsonHttpMessageConverters());
  
  }
  
  @Bean
  public MappingJackson2HttpMessageConverter customerMappingJackson2HttpMessageConverter(){
      MappingJackson2HttpMessageConverter messageConverter = new MappingJackson2HttpMessageConverter();
      //设置日期格式
      ObjectMapper objectMapper = new ObjectMapper();
      SimpleDateFormat smt = new SimpleDateFormat("yyyy-MM-dd");
      objectMapper.setDateFormat(smt);
      messageConverter.setObjectMapper(objectMapper);
      
      //设置中文编码格式
      List<MediaType> list = new ArrayList<MediaType>();
      list.add(MediaType.APPLICATION_JSON);
      messageConverter.setSupportedMediaTypes(list);
      return messageConverter;
  }
  
  @Bean
  public StringHttpMessageConverter stringHttpMessageConverter(){
      StringHttpMessageConverter stringConvert = new StringHttpMessageConverter();
      List<MediaType> stringMediaTypes = new ArrayList<MediaType>(){{
          add(new MediaType("text","plain",Charset.forName("UTF-8")));
      }};
      stringConvert.setSupportedMediaTypes(stringMediaTypes);
      return stringConvert;
  }
  
    /**
   * 引入Fastjson解析json，不使用默认的jackson,必须在pom.xml引入fastjson的jar包，并且版必须大于1.2.10
   *
   * @return
   */
  @Bean
  public FastJsonHttpMessageConverter fastJsonHttpMessageConverters() {
      //1、定义一个convert转换消息的对象
      FastJsonHttpMessageConverter fastConverter = new FastJsonHttpMessageConverter();
  
      //2、添加fastjson的配置信息
      FastJsonConfig fastJsonConfig = new FastJsonConfig();
  
      SerializerFeature[] serializerFeatures = new SerializerFeature[]{
              //    输出key是包含双引号
              //SerializerFeature.QuoteFieldNames,
              //    是否输出为null的字段,若为null 则显示该字段
              SerializerFeature.WriteMapNullValue,
              //    数值字段如果为null，则输出为0
              SerializerFeature.WriteNullNumberAsZero,
              //     List字段如果为null,输出为[],而非null
              SerializerFeature.WriteNullListAsEmpty,
              //    字符类型字段如果为null,输出为"",而非null
              SerializerFeature.WriteNullStringAsEmpty,
              //    Boolean字段如果为null,输出为false,而非null
              SerializerFeature.WriteNullBooleanAsFalse,
              //    Date的日期转换器
              SerializerFeature.WriteDateUseDateFormat,
              //    循环引用（如果不配置有可能会进入死循环）
              SerializerFeature.DisableCircularReferenceDetect,
              //    格式化JSON
              SerializerFeature.PrettyFormat
      };
  
  
      fastJsonConfig.setSerializerFeatures(serializerFeatures);
      fastJsonConfig.setCharset(Charset.forName("UTF-8"));
  
  
      //3.解决乱码问题。定义响应的MIME类型，设置响应的content-type为application/json;charset=UTF-8
      List<MediaType> fastMediaType = new ArrayList<>();
      fastMediaType.add(MediaType.valueOf(MediaType.APPLICATION_JSON_VALUE));
  
      //4.converter消息转换器添加配置信息
      fastConverter.setSupportedMediaTypes(fastMediaType);
  
      //5、在convert中添加配置信息
      fastConverter.setFastJsonConfig(fastJsonConfig);
  
      return fastConverter;
  }
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20
  21
  22
  23
  24
  25
  26
  27
  28
  29
  30
  31
  32
  33
  34
  35
  36
  37
  38
  39
  40
  41
  42
  43
  44
  45
  46
  47
  48
  49
  50
  51
  52
  53
  54
  55
  56
  57
  58
  59
  60
  61
  62
  63
  64
  65
  66
  67
  68
  69
  70
  71
  72
  73
  74
  75
  76
  77
  78
  79
  80
  81
  82
  83
  84
  85

应用场景

空值处理

• 请求和返回的数据有很多空值，这些值有时候并没有实际意义，我们可以过滤掉和不返回，或设置成默认值。比如通过重写getObjectMapper方法，将返回结果的空值不进行序列化：

converters.add(0, new MappingJackson2HttpMessageConverter(){
    @Override
    public ObjectMapper getObjectMapper() {
        super.getObjectMapper().setSerializationInclusion(JsonInclude.Include.NON_NULL);
                return super.getObjectMapper();
    }
}
1
2
3
4
5
6
7

XSS 脚本攻击
为了保证输入的数据更安全，防止 XSS 脚本攻击，我们可以添加自定义反序列化器

//对应无法直接返回String类型
converters.add(0, new MappingJackson2HttpMessageConverter(){
    @Override
    public ObjectMapper getObjectMapper() {
        super.getObjectMapper().setSerializationInclusion(JsonInclude.Include.NON_NULL);

                // XSS 脚本过滤
        SimpleModule simpleModule = new SimpleModule();
        simpleModule.addDeserializer(String.class, new StringXssDeserializer());
        super.getObjectMapper().registerModule(simpleModule);

        return super.getObjectMapper();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

2.HttpMessageConverter接口

• Http请求响应报文其实都是字符串，当请求报文到java程序会被封装为一个ServletInputStream流，供开发人员读取请求报文，响应报文则通过ServletOutputStream流，来输出响应报文。
  从流中只能读取到原始的字符串报文，同样输出流也是。
• 那么在报文SpringMVC 输入和输出都存在一个字符串到java对象的转化问题。这一过程，在SpringMVC是通过HttpMessageConverter来解决的。
• 在SpringMVC的处理过程中，一次请求报文和一次响应报文，分别被抽象为一个请求消息HttpInputMessage和一个响应消息HttpOutputMessage。处理请求时，由合适的消息转换器将请求报文绑定为方法中的形参对象，在这里同一个对象就有可能出现多种不同的消息形式，如json、xml。同样响应请求也是同样道理。

（1）HttpInputMessage 将请求的信息先转为 InputStream 对象，InputStream 再由 HttpMessageConverter 转换为 SpringMVC 需要的java对象；
（2）SpringMVC 返回一个 java 对象， 并通过 HttpMessageConverter 转为响应信息，接着 HttpOutputMessage 将响应的信息转换为OutputStream，接着给出响应。

HttpMessageConverter接口源码：

简单说就是 HTTP request (请求)和response (响应)数据的转换器

public interface HttpMessageConverter<T> {
 	//该方法指定转换器可以读取的对象类型，即转换器可将请求信息转换为clazz 类型的对象，同时指定支持的MIME类型（text/html、application/json）
 	//用于判断接受什么类型的数据且
    boolean canRead(Class<?> clazz, MediaType mediaType);
 	
 	//该方法指定类型转换器可以将clazz类型的对象写到相应流当中，响应流支持的媒体类型在mediaType中定义
    boolean canWrite(Class<?> clazz, MediaType mediaType);
 	
 	//该方法返回当前转换器支持的媒体类型
    List<MediaType> getSupportedMediaTypes();
 	
 	//该方法将请求信息流转换为T类型的对象
    T read(Class<? extends T> clazz, HttpInputMessage inputMessage) throws IOException, HttpMessageNotReadableException;
 	
 	//该方法将T类型的对象写到响应流当中，同时指定响应的媒体类型为contentType
    void write(T t, MediaType contentType, HttpOutputMessage outputMessage) throws IOException, HttpMessageNotWritableException;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

通常实现HttpMessageConverter接口的转换器有以下几种：

• ByteArrayHttpMessageConverter: 负责读取二进制格式的数据和写出二进制格式的数据；
• StringHttpMessageConverter： 负责读取字符串格式的数据和写出二进制格式的数据；
• ResourceHttpMessageConverter：负责读取资源文件和写出资源文件数据；
• FormHttpMessageConverter： 负责读取form提交的数据（能读取的数据格式为 application/x-www-form-urlencoded，不能读取multipart/form-data格式数据）；负责写入application/x-www-from-urlencoded和multipart/form-data格式的数据；
• MappingJacksonHttpMessageConverter: 负责读取和写入json格式的数据；
• SourceHttpMessageConverter： 负责读取和写入 xml 中javax.xml.transform.Source定义的数据；
• Jaxb2RootElementHttpMessageConverter: 负责读取和写入xml 标签格式的数据；
• AtomFeedHttpMessageConverter: 负责读取和写入Atom格式的数据；
• RssChannelHttpMessageConverter: 负责读取和写入RSS格式的数据

在SpringMVC / SpringBoot中@ResponseBody这类注解默认使用的是jackson来解析json

3.HttpMessageConverter请求信息转换器执行流程

当用户发送请求后，@Requestbody 注解会读取请求body中的数据，默认的请求转换器HttpMessageConverter通过获取请求头Header中的Content-Type来确认请求头的数据格式，从而来为请求数据适配合适的转换器。

• 例如contentType=applicatin/json，那么转换器会适配MappingJacksonHttpMessageConverter
• 响应时候的时候同理，@Responsebody注解会启用HttpMessageConverter，通过检测Header中Accept属性来适配的响应的转换器。

4.自定义HttpMessageConverter

1.自定义HttpMessageConverter

@Data
@AllArgsConstructor
public class UserEntity {
    private String name;
    private String address;
}


public class MyMessageConverter extends AbstractHttpMessageConverter<UserEntity> {
    /**
     * 当前消息转换器处理的 消息类型为 application/oyjp
     */
    public MyMessageConverter() {
        // 新建一个我们自定义的媒体类型application/oyjp
        super(new MediaType("application", "oyjp", Charset.forName("UTF-8")));

    }

    @Override
    protected boolean supports(Class<?> clazz) {
        // 表明只处理UserEntity类型的参数。
        return UserEntity.class.isAssignableFrom(clazz);
    }

    /**
     * 重写readlntenal 方法，处理请求的数据。代码表明我们处理由“-”隔开的数据，并转成 UserEntity类型的对象。
     */
    @Override
    protected UserEntity readInternal(Class<? extends UserEntity> clazz,
            HttpInputMessage inputMessage) throws IOException,
            HttpMessageNotReadableException {
        String temp = StreamUtils.copyToString(inputMessage.getBody(), Charset.forName("UTF-8"));
        String[] tempArr = temp.split("-");

        return new UserEntity(tempArr[0],tempArr[1]);
    }

    /**
     * 重写writeInternal ，处理如何输出数据到response。
     */
    @Override
    protected void writeInternal(UserEntity userEntity,
            HttpOutputMessage outputMessage)
            throws IOException, HttpMessageNotWritableException {
        String out = "hello: " + userEntity.getName() + "-" + userEntity.getAddress();
        outputMessage.getBody().write(out.getBytes());
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

2.配置类中添加自定义的HttpMessageConverter

    @Override
    public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
        System.out.println(converters.size());
        converters.add(myConverter());
    }
    
   @Bean
    public MyMessageConverter myConverter() {
        return new MyMessageConverter();
    }
1
2
3
4
5
6
7
8
9
10

3.控制器使用

    @RequestMapping(method = RequestMethod.POST, value = "/convert", produces = {"application/oyjp"})
    public @ResponseBody UserEntity converter(@RequestBody UserEntity user) {
        return user;
    }
1
2
3
4

4.postman请求

1. Content-Type设置为application/oyjp
2. Controller方法使用@RequestBody修饰,表明以对象方式接受指定类型的数据
3. postman设置请求参数
   
4. 查看postman响应
   

5.总结

当在使用SpringMVC做服务器数据接收时，尤其是在做Ajax请求的时候，尤其要注意contentType属性，和accepte 属性的设置，在springmvc配置好相应的转换器。

HttpMessageConverter是这样转换数据的
类型转换HttpMessageConverter

addResourceHandlers：静态资源

• addResoureHandler：请求静态资源的路径

• addResourceLocations：静态资源存放位置,可以配置多个,按先后顺序查找

  @Override
  public void addResourceHandlers(ResourceHandlerRegistry registry) {
      //添加对swagger-ui的处理
      registry.addResourceHandler("/**").addResourceLocations("classpath:/static/");
      //registry.addResourceHandler("/static/**").addResourceLocations("classpath:/static/static/");
      registry.addResourceHandler("swagger-ui.html").addResourceLocations("classpath:/META-INF/resources/");
      registry.addResourceHandler("/webjars/**").addResourceLocations("classpath:/META-INF/resources/webjars/");
  }
  1
  2
  3
  4
  5
  6
  7
  8

addFormatters:格式转换

• 可以把时间转化成你需要时区或者格式。
• 可以自定义转化器和你数据库做交互，比如传进来userId，经过转化可以拿到user对象。
• 需要传入Convert,GenericConvert和Formatter接口的实现类的Bean

以下配置代码用于使用LocalDate，LocalTime ,LocalDateTime属性接收前端传来的标准时间字符串，并返回指定的时间格式，LocalDate对应 yyyy-MM-dd，LocalDateTime对应yyyy-MM-dd HH:mm:dd，LocalTime对应 HH:mm:dd，不论参数的形式传递如body、pathVariable、requestParam里，只要时间字符串满足格式要求都可以转为对应的时间日期属性。

 @Override
    public void addFormatters(FormatterRegistry registry) {
        registry.addConverter(localDateTimeConverter());
        registry.addConverter(localDateConverter());
        registry.addConverter(localTimeConverter());
    }

    /**
     * LocalDate转换器，用于转换RequestParam和PathVariable参数
     */
    private Converter<String, LocalDate> localDateConverter() {
        return new Converter<String, LocalDate>() {
            @Override
            public LocalDate convert(String source) {
                if(!ObjectUtils.isEmpty(source)){
                    return LocalDate.parse(source, DateTimeFormatter.ofPattern(DateUtil.DATE_FORMAT_yyyy_MM_dd));
                }
                return null ;

            }
        };
    }

    /**
     * LocalDateTime转换器，用于转换RequestParam和PathVariable参数
     */
    private Converter<String, LocalDateTime> localDateTimeConverter() {
        return new Converter<String, LocalDateTime>() {
            @Override
            public LocalDateTime convert(String source) {
                if(!ObjectUtils.isEmpty(source)) {
                    return LocalDateTime.parse(source, DateTimeFormatter.ofPattern(DateUtil.DATE_FORMAT_yyyy_MM_dd_HH_mm_ss));
                }
                return null ;
            }
        };
    }

    /**
     * LocalTime转换器，用于转换RequestParam和PathVariable参数
     */
    private Converter<String, LocalTime> localTimeConverter() {
        return new Converter<String, LocalTime>() {
            @Override
            public LocalTime convert(String source) {
                if(!ObjectUtils.isEmpty(source)) {
                    return LocalTime.parse(source, DateTimeFormatter.ofPattern(DateUtil.DATE_FORMAT_HH_mm_ss));
                }
                return null;
            }
        };
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

错误页面配置

如果想为某个状态码展示一个自定义的HTML错误页面，你需要将文件添加到/error文件夹下。错误页面既可以是静态HTML，也可以是使用模板构建的，文件名必须是状态码或一系列标签。

例如，映射404到一个静态HTML文件，你的目录结构可能如下：

src/
      main/
          java/
          resources/
              public/
                  error/
                     404.html
      test/
1
2
3
4
5
6
7
8

使用FreeMarker模板映射所有5xx错误，你需要如下的目录结构：

src/
     main/
      	 java/
         resources/
            templates/
                error/
                   5xx.ftl
     test/
1
2
3
4
5
6
7
8

对于更复杂的映射，你可以添加实现ErrorViewResolver接口的beans：

public class MyErrorViewResolver implements ErrorViewResolver {

    @Override
    public ModelAndView resolveErrorView(HttpServletRequest request,
            HttpStatus status, Map<String, Object> model) {
        // Use the request or status to optionally return a ModelAndView
        return ...
    }
}
1
2
3
4
5
6
7
8
9

也可以使用@ExceptionHandler方法和@ControllerAdvice的ErrorController将处理所有未处理的异常。

测试请求SpringBoot项目发生返回404状态时跳转到404页面

404页面

随便乱发起一个不存在的请求

测试请求SpringBoot项目发生返回500状态时跳转到500页面

500页面

请求一个报错接口