SpringMvc4.x-3（基本配置）

╰半橙微兮° 2022-05-16 06:48 239阅读 0赞

### **静态资源配置：** ###

`Spring ``MVC`的定制配置需要我们的配置类继承一个`WebMvcConfigurerAdapter`类，并在此类使用`@EnableWebMvc`注解，来开启对`Spring` `MVC`的配置支持，这样我们就可以重写这个类的方法，完成我们的常用配置。

我们将前面文章中的`MyMvcConfig`配置类继承`WebMvcConfigurerAdapter`，以后如果不做特别说明，则关于配置的相关内容都在`MyMvcConfig`里面编写。

**程序的静态文件(`js`,`css`,图片)等需要直接访问，这时我们可以在配置里重写`addResourceHandlers`方法来实现。**

### 添加静态资源 ###

在`src/main/resources`下建立`assets/js`目录，并复制一个`jquery.js`放置在该目录下

import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.ComponentScan;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.scheduling.annotation.EnableScheduling;
    import org.springframework.web.servlet.config.annotation.EnableWebMvc;
    import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
    import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;
    import org.springframework.web.servlet.view.InternalResourceViewResolver;
    import org.springframework.web.servlet.view.JstlView;
    
    @Configuration
    @EnableWebMvc// ①
    @ComponentScan("org.light4j.springMvc4")
    public class MyMvcConfig extends WebMvcConfigurerAdapter {// ②
    
        @Bean
        public InternalResourceViewResolver viewResolver() {
            InternalResourceViewResolver viewResolver = new InternalResourceViewResolver();
            viewResolver.setPrefix("/WEB-INF/classes/views/");
            viewResolver.setSuffix(".jsp");
            viewResolver.setViewClass(JstlView.class);
            return viewResolver;
        }
    
        @Override
        public void addResourceHandlers(ResourceHandlerRegistry registry) {
            registry.addResourceHandler("/assets/**").addResourceLocations("classpath:/assets/");// ③
        }
    }

① `@EnableWebMvc`开启`SpringMvc`支持，若无此句，重写`WebMvcConfigurerAdapter`的方法无效。  
② 继承`WebMvcConfigurerAdapter`类，重写其方法可对`Spring ``MVC`进行配置。  
③ `addResourceLocations`指的是文件放置的目录，`addResourceHandler`指的是对外暴露的访问路径。

### [拦截器配置][Link 1]： ###

拦截器(`Interceptor`)实现对每一个请求处理前后进行相关的业务处理，类似于`Servlet`的`Filter`。

可让普通的`Bean`实现`HandlerInterceptor`接口或者继承`HandlerInterceptorAdapter`类来实现自定义拦截器。

通过重写`WebMvcConfigurerAdapter`的`addInterceptors`方法来注册自定义的拦截器，下面演示一个简单的拦截器的开发和配置。业务含义为计算每一次请求的处理时间。

import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    
    import org.springframework.web.servlet.ModelAndView;
    import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;
    
    /**
     * ① 继承HandlerInterceptorAdapter类来实现自定义拦截器。
     * ② 重写preHandle方法，在请求发生前执行。
     * ③ 重写postHandle方法，在请求完成后执行。
     *
     */
    public class DemoInterceptor extends HandlerInterceptorAdapter {//①
    
        @Override
        public boolean preHandle(HttpServletRequest request, //②
                HttpServletResponse response, Object handler) throws Exception {
            long startTime = System.currentTimeMillis();
            request.setAttribute("startTime", startTime);
            return true;
        }
    
        @Override
        public void postHandle(HttpServletRequest request, //③
                HttpServletResponse response, Object handler,
                ModelAndView modelAndView) throws Exception {
            long startTime = (Long) request.getAttribute("startTime");
            request.removeAttribute("startTime");
            long endTime = System.currentTimeMillis();
            System.out.println("本次请求处理时间为:" + new Long(endTime - startTime)+"ms");
            request.setAttribute("handlingTime", endTime - startTime);
        }
    }

**配置：**

/**
    	 * ① 配置拦截器的Bean
    	 * ② 重写addInterceptors方法，注册拦截器。
    	 * @return
    	 */
    	@Bean // ①
    	public DemoInterceptor demoInterceptor() {
    		return new DemoInterceptor();
    	}
    
    	@Override
    	public void addInterceptors(InterceptorRegistry registry) {// ②
    		registry.addInterceptor(demoInterceptor());
    	}

### @ControllerAdvice注解 ###

通过`@ControllerAdvice`。我们可以将对于控制器的全局配置放置在同一个位置，注解了`@ControllerAdvice`的类的方法可以使用`@ExceptionHandler`，`@InitBinder`，`@ModelAttribute`注解到方法上，这对所有注解了`@RequestMapping`的控制器内的方法有效。

1.  `@ExceptionHandler`：用于全局处理控制器里面的异常。
2.  `@InitBinder`：用来设置`WebDataBinder`，`WebDataBinder`用来自动绑定前台请求参数到`Model`中。
3.  `@ModelAttribute`：`@ModelAttribute`本来的作用是绑定键值对到`Model`里，此处是让全局的`@RequestMapping`都能获得在此处设置的键值对。

下面将使用`@ExceptionHandler`处理全局异常，将异常信息更加人性化的输出给用户。

import org.springframework.ui.Model;
    import org.springframework.web.bind.WebDataBinder;
    import org.springframework.web.bind.annotation.ControllerAdvice;
    import org.springframework.web.bind.annotation.ExceptionHandler;
    import org.springframework.web.bind.annotation.InitBinder;
    import org.springframework.web.bind.annotation.ModelAttribute;
    import org.springframework.web.context.request.WebRequest;
    import org.springframework.web.servlet.ModelAndView;
    
    @ControllerAdvice //①
    public class ExceptionHandlerAdvice { 
    
        @ExceptionHandler(value = Exception.class)//②
        public ModelAndView exception(Exception exception, WebRequest request) {
            ModelAndView modelAndView = new ModelAndView("error");// error页面
            modelAndView.addObject("errorMessage", exception.getMessage());
            return modelAndView;
        }
    
        @ModelAttribute //③
        public void addAttributes(Model model) {
            model.addAttribute("msg", "额外信息"); //④
        }
    
        @InitBinder //④
        public void initBinder(WebDataBinder webDataBinder) {
            webDataBinder.setDisallowedFields("id"); //⑤
        }
    }

① `@ControllerAdvice`声明一个控制器建言，`@ControllerAdvice`组合了`@Component`注解，所以自动注册为Spring的`Bean`。  
② `@ExceptionHandler`在此处定义全局处理，通过`@ExceptionHandler`的`value`属性可过滤拦截的条件，在此处可以看出拦截的是所有的`Exception`。  
③ 此处使用`@ModelAttribute`注解将键值对添加到全局，所有注解了`@RequestMapping`的方法可获得此键值对。  
④ 通过`@InitBinder`注解定制`WebDataBinder`

import org.light4j.springMvc4.domain.DemoObj;
    import org.springframework.stereotype.Controller;
    import org.springframework.web.bind.annotation.ModelAttribute;
    import org.springframework.web.bind.annotation.RequestMapping;
    
    @Controller
    public class AdviceController {
        @RequestMapping("/advice")
        public String getSomething(@ModelAttribute("msg") String msg,DemoObj obj){//①
    
            throw new IllegalArgumentException("非常抱歉，参数有误/"+"来自@ModelAttribute:"+ msg);
        }
    }

在`src/main/resources/views`下，新建`error.jsp`，内容如下：

<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
 <%@ page isELIgnored="false" %>
 <%@ page language="java" contentType="text/html; charset=UTF-8"
 pageEncoding="UTF-8"%>
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
 <title>@ControllerAdvice Demo</title>
 </head>
 <body>
 ${errorMessage}
 </body>
 </html>

# [快捷的ViewController][ViewController] #

此处无任何的业务处理，只是简单的页面跳转，写了至少三行有效的代码，在实际的开发中会涉及大量这样的页面转向，若都这样写会特别的麻烦，我们通过在配置类`MyMvcConfig`里通过重写`addViewControllers`来简化配置：

@RequestMapping("/index")//②
        public  String hello(){
    
            return "index";
        }

@Override
    public void addViewControllers(ViewControllerRegistry registry) {
            registry.addViewController("/index").setViewName("/index");
    }

# [路径匹配参数配置][Link 2] #

`Spring ``MVC`中，路径参数如果带”.”的话，”.”后面的值将被忽略，例如，访问`http://localhost/springMvc4.x/anno/pathvar/xxx.yy`，此时，”.”后面的`yy`被忽略；

通过重写`configurePathMatch`方法可实现不忽略”.”后面的参数，在配置类`MyMvcConfig`中增加代码如下：

@Override
    public void configurePathMatch(PathMatchConfigurer configurer) {
        configurer.setUseSuffixPatternMatch(false);
    }

# [Spring Mvc更多配置][Spring Mvc] #

更多配置请查看`WebMvcConfigurerAdater`类的`API`。因其是`WebMvcConfigurerAdater`接口的实现，所以`WebMvcConfigurerAdater`的`API`内的方法也可以用来配置`MVC`。下面列出`WebMvcConfigurerAdater`和`WebMvcConfigurer`的源码供参考。

## 1. WebMvcConfigurerAdater ##

public abstract class WebMvcConfigurerAdapter implements WebMvcConfigurer {
 
 /**
 * {@inheritDoc}
 * This implementation is empty.
 */
 @Override
 public void addFormatters(FormatterRegistry registry) {
 }
 
 /**
 * {@inheritDoc}
 * This implementation is empty.
 */
 @Override
 public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
 }
 
 /**
 * {@inheritDoc}
 * This implementation is empty.
 */
 @Override
 public void extendMessageConverters(List<HttpMessageConverter<?>> converters) {
 }
 
 /**
 * {@inheritDoc}
 * This implementation returns {@code null}
 */
 @Override
 public Validator getValidator() {
 return null;
 }
 
 /**
 * {@inheritDoc}
 * This implementation is empty.
 */
 @Override
 public void configureContentNegotiation(ContentNegotiationConfigurer configurer) {
 }
 
 /**
 * {@inheritDoc}
 * This implementation is empty.
 */
 @Override
 public void configureAsyncSupport(AsyncSupportConfigurer configurer) {
 }
 
 /**
 * {@inheritDoc}
 * This implementation is empty.
 */
 @Override
 public void configurePathMatch(PathMatchConfigurer configurer) {
 }
 
 /**
 * {@inheritDoc}
 * This implementation is empty.
 */
 @Override
 public void addArgumentResolvers(List<HandlerMethodArgumentResolver> argumentResolvers) {
 }
 
 /**
 * {@inheritDoc}
 * This implementation is empty.
 */
 @Override
 public void addReturnValueHandlers(List<HandlerMethodReturnValueHandler> returnValueHandlers) {
 }
 
 /**
 * {@inheritDoc}
 * This implementation is empty.
 */
 @Override
 public void configureHandlerExceptionResolvers(List<HandlerExceptionResolver> exceptionResolvers) {
 }
 
 /**
 * {@inheritDoc}
 * This implementation is empty.
 */
 @Override
 public MessageCodesResolver getMessageCodesResolver() {
 return null;
 }
 
 /**
 * {@inheritDoc}
 * This implementation is empty.
 */
 @Override
 public void addInterceptors(InterceptorRegistry registry) {
 }
 
 /**
 * {@inheritDoc}
 * This implementation is empty.
 */
 @Override
 public void addViewControllers(ViewControllerRegistry registry) {
 }
 
 /**
 * {@inheritDoc}
 * This implementation is empty.
 */
 @Override
 public void configureViewResolvers(ViewResolverRegistry registry) {
 }
 
 /**
 * {@inheritDoc}
 * This implementation is empty.
 */
 @Override
 public void addResourceHandlers(ResourceHandlerRegistry registry) {
 }
 
 /**
 * {@inheritDoc}
 * This implementation is empty.
 */
 @Override
 public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {
 }
 
 }

##  WebMvcConfigurer ##

public interface WebMvcConfigurer {
 
 /**
 * Add {@link Converter}s and {@link Formatter}s in addition to the ones
 * registered by default.
 */
 void addFormatters(FormatterRegistry registry);
 
 /**
 * Configure the {@link HttpMessageConverter}s to use for reading or writing
 * to the body of the request or response. If no converters are added, a
 * default list of converters is registered.
 * Note that adding converters to the list, turns off
 * default converter registration. To simply add a converter without impacting
 * default registration, consider using the method
 * {@link #extendMessageConverters(java.util.List)} instead.
 * @param converters initially an empty list of converters
 */
 void configureMessageConverters(List<HttpMessageConverter<?>> converters);
 
 /**
 * A hook for extending or modifying the list of converters after it has been
 * configured. This may be useful for example to allow default converters to
 * be registered and then insert a custom converter through this method.
 * @param converters the list of configured converters to extend.
 * @since 4.1.3
 */
 void extendMessageConverters(List<HttpMessageConverter<?>> converters);
 
 /**
 * Provide a custom {@link Validator} instead of the one created by default.
 * The default implementation, assuming JSR-303 is on the classpath, is:
 * {@link org.springframework.validation.beanvalidation.OptionalValidatorFactoryBean}.
 * Leave the return value as {@code null} to keep the default.
 */
 Validator getValidator();
 
 /**
 * Configure content negotiation options.
 */
 void configureContentNegotiation(ContentNegotiationConfigurer configurer);
 
 /**
 * Configure asynchronous request handling options.
 */
 void configureAsyncSupport(AsyncSupportConfigurer configurer);
 
 /**
 * Helps with configuring HandlerMappings path matching options such as trailing slash match,
 * suffix registration, path matcher and path helper.
 * Configured path matcher and path helper instances are shared for:
 * <ul>
 * <li>RequestMappings</li>
 * <li>ViewControllerMappings</li>
 * <li>ResourcesMappings</li>
 * </ul>
 * @since 4.0.3
 */
 void configurePathMatch(PathMatchConfigurer configurer);
 
 /**
 * Add resolvers to support custom controller method argument types.
 * This does not override the built-in support for resolving handler
 * method arguments. To customize the built-in support for argument
 * resolution, configure {@link RequestMappingHandlerAdapter} directly.
 * @param argumentResolvers initially an empty list
 */
 void addArgumentResolvers(List<HandlerMethodArgumentResolver> argumentResolvers);
 
 /**
 * Add handlers to support custom controller method return value types.
 * Using this option does not override the built-in support for handling
 * return values. To customize the built-in support for handling return
 * values, configure RequestMappingHandlerAdapter directly.
 * @param returnValueHandlers initially an empty list
 */
 void addReturnValueHandlers(List<HandlerMethodReturnValueHandler> returnValueHandlers);
 
 /**
 * Configure the {@link HandlerExceptionResolver}s to handle unresolved
 * controller exceptions. If no resolvers are added to the list, default
 * exception resolvers are added instead.
 * @param exceptionResolvers initially an empty list
 */
 void configureHandlerExceptionResolvers(List<HandlerExceptionResolver> exceptionResolvers);
 
 /**
 * Add Spring MVC lifecycle interceptors for pre- and post-processing of
 * controller method invocations. Interceptors can be registered to apply
 * to all requests or be limited to a subset of URL patterns.
 * Note that interceptors registered here only apply to
 * controllers and not to resource handler requests. To intercept requests for
 * static resources either declare a
 * {@link org.springframework.web.servlet.handler.MappedInterceptor MappedInterceptor}
 * bean or switch to advanced configuration mode by extending
 * {@link org.springframework.web.servlet.config.annotation.WebMvcConfigurationSupport
 * WebMvcConfigurationSupport} and then override {@code resourceHandlerMapping}.
 */
 void addInterceptors(InterceptorRegistry registry);
 
 /**
 * Provide a custom {@link MessageCodesResolver} for building message codes
 * from data binding and validation error codes. Leave the return value as
 * {@code null} to keep the default.
 */
 MessageCodesResolver getMessageCodesResolver();
 
 /**
 * Configure simple automated controllers pre-configured with the response
 * status code and/or a view to render the response body. This is useful in
 * cases where there is no need for custom controller logic -- e.g. render a
 * home page, perform simple site URL redirects, return a 404 status with
 * HTML content, a 204 with no content, and more.
 */
 void addViewControllers(ViewControllerRegistry registry);
 
 /**
 * Configure view resolvers to translate String-based view names returned from
 * controllers into concrete {@link org.springframework.web.servlet.View}
 * implementations to perform rendering with.
 */
 void configureViewResolvers(ViewResolverRegistry registry);
 
 /**
 * Add handlers to serve static resources such as images, js, and, css
 * files from specific locations under web application root, the classpath,
 * and others.
 */
 void addResourceHandlers(ResourceHandlerRegistry registry);
 
 /**
 * Configure a handler to delegate unhandled requests by forwarding to the
 * Servlet container's "default" servlet. A common use case for this is when
 * the {@link DispatcherServlet} is mapped to "/" thus overriding the
 * Servlet container's default handling of static resources.
 */
 void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer);
 
 }

[Link 1]: http://blog.longjiazuo.com/archives/1434
[ViewController]: http://blog.longjiazuo.com/archives/1458
[Link 2]: http://blog.longjiazuo.com/archives/1462
[Spring Mvc]: http://blog.longjiazuo.com/archives/1467