Spring-3.Spring MVC

MVC

为什么我们强调Spring MVC而不是MVC，因为MVC是一个很广泛的词，不仅有Spring MVC，还有C#的MVC，各种MVC。概念大同小异，而实现方式则千差万别。
M：Model指数据模型以及对数据的处理方式，有对数据的直接访问权限，所以我们写的逻辑包括Service等，都是Model。
V：View指视图，在spring中可以使用Thymeleaf等来做视图。不过现在大都提倡前后端分离，所以V这一块实践上成了分离出去的前端。
C：Controller指控制器，实际上就是调用Model进行数据操作或者查询，返回成一个数据（API）或者组成一个视图返回。

WebApplicationContext

还记得Spring中提供的ApplicationContext，他实现了BeanFactory，是常用的Bean工厂，此外还提供了诸如国际化事件等功能。而WebApplicationContext则是ApplicationContext的子类，在ApplicationContext上又提供的web的功能。

• 允许从相对的Web路径加载文件进行工作，并且保存了ServletContext（可以理解为全局通用的空间），可以使用web应用的上下文。
• 提供了三个新的bean作用域：request，session，globalsession
• 提供了两个参数：
  • HttpServletRequest：请求封装类
  • HttpServletResponse：返回值封装类

servlet和DispatcherServlet

在开始了解spring mvc之前，先了解下servlet。servlet其实只是一种web服务器的规范。规范的意思就是，如果你按照这个规范来编写代码，扔给web服务器，那么他自动会帮你解析成web应用的api。而在tomcat中，servlet 是一个接口

public interface Servlet {
    //初始化
    void init(ServletConfig var1) throws ServletException;
    //获取配置
    ServletConfig getServletConfig();
    //处理客户端请求
    void service(ServletRequest var1, ServletResponse var2) throws ServletException, IOException;

    String getServletInfo();
    //销毁时操作
    void destroy();
}

其中service方法时处理客户端的请求的函数，每当收到Http请求，Servlet容器就会创建一个ServletRequest(包含请求信息)和一个ServletResponse（包含返回信息），并创建一个新的线程调用service方法（Tomcat 8版本使用NIO替代每个请求一个线程）。

在Spring MVC中DispatcherServlet的父类FrameworkServlet实现了servlet接口的service方法，最终调用了this.processRequest，而this.processRequest最终调用了DispatcherServlet的doService方法。而doService则调用了doDispatch方法，doService就是进行控制器匹配的整个方法。

protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        HttpMethod httpMethod = HttpMethod.resolve(request.getMethod());
        if (httpMethod != HttpMethod.PATCH && httpMethod != null) {
            super.service(request, response);
        } else {
            this.processRequest(request, response);
        }

    }

protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
        HttpServletRequest processedRequest = request;
        HandlerExecutionChain mappedHandler = null;
        boolean multipartRequestParsed = false;
        WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);

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

                try {
                    processedRequest = this.checkMultipart(request);
                    multipartRequestParsed = processedRequest != request;
                    //根据请求从HandlerMapping获取执行链，包括拦截器和处理器
                    mappedHandler = this.getHandler(processedRequest);
                    if (mappedHandler == null) {
                        this.noHandlerFound(processedRequest, response);
                        return;
                    }
                    //从适配器中查找适合处理的处理器，一般是Controller类型，
                    HandlerAdapter ha = this.getHandlerAdapter(mappedHandler.getHandler());
                    String method = request.getMethod();
                    //省略代码
                    //执行前拦截器
                    if (!mappedHandler.applyPreHandle(processedRequest, response)) {
                        return;
                    }
                    //执行Controller，并返回ModeView
                    mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
                    if (asyncManager.isConcurrentHandlingStarted()) {
                        return;
                    }
                    //查找视图
                    this.applyDefaultViewName(processedRequest, mv);
                    //执行后拦截器
                    mappedHandler.applyPostHandle(processedRequest, response, mv);
                } catch (Exception var20) {
                    dispatchException = var20;
                } catch (Throwable var21) {
                    dispatchException = new NestedServletException("Handler dispatch failed", var21);
                }
                //执行异常拦截器
                this.processDispatchResult(processedRequest, response, mappedHandler, mv, (Exception)dispatchException);
           //省略代码
    }

生命周期

• 映射处理器（HandlerMapping）返回拦截器和处理器链
  当请求到达DispatcherServlet后，会调用HandlerMapping进行处理找到匹配的拦截器和处理器。根据Request的Url查找相关拦截器和处理器。不过可以配置多个HandlerMapping，也可以自定义HandlerMapping，通过实现接口Order来定义执行的顺序。当按顺序查找到一个适合的处理器，会立即返回而不会继续执行。
• 处理器适配（HandlerAdptor）
  既然HandlerMappring已经返回了拦截器和处理器了，为什么还要一个适配器呢？因为HandlerMapping返回的是一个Object对象，DispatcherServlet并不知道它属于哪个类型。这样解耦了Handler，把是否符合交给HandlerAdapter进行适配。

HandlerAdapter 是一个接口，指提供了三个方法

public interface HandlerAdapter {
    //判断是否支持该处理器
    boolean supports(Object var1);

    //执行处理器的处理方法
    @Nullable
    ModelAndView handle(HttpServletRequest var1, HttpServletResponse var2, Object var3) throws Exception;
    
    //返回给客户端Last-Modified的Http头提供的时间值
    long getLastModified(HttpServletRequest var1, Object var2);
}

进行适配的代码，不过进行了循环验证，可能这里解耦的要求强于对性能的要求吧。不过Handler只有有限的几个，所以估计也不影响性能。一般常用的就是Controller。

 protected HandlerAdapter getHandlerAdapter(Object handler) throws ServletException {
        if (this.handlerAdapters != null) {
            Iterator var2 = this.handlerAdapters.iterator();
            //使用循环
            while(var2.hasNext()) {
                HandlerAdapter ha = (HandlerAdapter)var2.next();
                if (this.logger.isTraceEnabled()) {
                    this.logger.trace("Testing handler adapter [" + ha + "]");
                }
                //在这里调用supports校验是否适配
                if (ha.supports(handler)) {
                    return ha;
                }
            }
        }

        //省略抛出异常
    }

• 解析视图
  在 执行完拦截器，和Handler之后，如果返回的是ViewModel，那么就会根据模板解析，最终返回一个html视图到前端。

拦截器

在上面的过程中，我们讲到拦截器，自定义拦截器非常简单，只要实现HandlerInterceptor接口，并通过配置注册到mvc的拦截器中即可。

public interface HandlerInterceptor {
    //处理器操作前
    default boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        return true;
    }
    //处理器操作后
    default void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, @Nullable ModelAndView modelAndView) throws Exception {
    }
    //整个请求结束之后被调用
    default void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, @Nullable Exception ex) throws Exception {
    }
}

注册拦截器

@Configuration
public class MyWebAppConfigurer 
        extends WebMvcConfigurerAdapter {

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        // 多个拦截器组成一个拦截器链
        // addPathPatterns 用于添加拦截规则
        // excludePathPatterns 用户排除拦截
        registry.addInterceptor(new MyInterceptor1()).addPathPatterns("/**");
        registry.addInterceptor(new MyInterceptor2()).addPathPatterns("/**");
        super.addInterceptors(registry);
    }

}

常用注解

标注类的注解

@Controller：标注类为Controller处理器
@RestController：再@Controller的基础上加上@ResponseBody，所有的方法返回都是数据而不是html视图（API接口）

标注方法的注解

@ResponseBody：标注方法返回的是数据格式（Json或者XML）而不是视图
@GetMapping：标注方法为必须适用get方法调用
@PostMapping：标注方法为必须必须使用Post方法调用
@RequestMapping：标注为可调用的接口，可以使用post和get

标注参数映射的注解

@PathVariable：把url的参数绑定到方法参数，需要在url使用占位符,如：{id}

@RequestMapping("/edit/{id}/{name}")
public String edit(Model model, @PathVariable long id,@PathVariable String name) {
    return page("edit");
    }

@RequestParam：指定值映射到参数，其中required标志是否为必传参数

@ResponseBody
@RequestMapping("/save")
public String saveToken(@RequestParam(value="token", required = false) String token) {
    //.. 
}
 

@RequestHeader：把http的Header的值映射到参数

@RequestMapping(value = "/hello.htm") 
public String hello(@RequestHeader(value="User-Agent") String userAgent) {
    //.. 
}

异常处理:HandlerExceptionResolver

spring mvc 提供了异常处理。我们可以通过实现接口HandlerExceptionResolver并配置为Bean即可

public interface HandlerExceptionResolver {
    @Nullable
    ModelAndView resolveException(HttpServletRequest var1, HttpServletResponse var2, @Nullable Object var3, Exception var4);
}

//异常处理类
@ControllerAdvice
public class GlobalDefaultExceptionHandler {
 
	//如果需要返回值的是view，则方法的返回值是ModelAndView
	//如果需要返回值是String或者Json数据，则需要在方法上添加@ResponseBody
	@ExceptionHandler(value=RuntimeException.class)
	@ResponseBody
	public String defaultExceptionHandler(HttpServletRequest request){
		return "对不起，服务器正忙，请稍后再试";
	}
}

总结：关键四个接口

• HandlerMapping：根据请求（注解和xml配置）返回Handler和拦截器，这里的Handler一般是我们编写的Controller，但是返回类型是Object
• HandlerAdapter：遍历所有的HandlerAdapter，查找适合处理Handler的处理器，一般是Comtroller处理器
• HandlerInterceptor：拦截器，通过实现该接口，并在配置中注册拦截器，可以自定义拦截器
• HandlerExceptionResolver：异常拦截器，当发生异常时，触发的拦截器，可以做全局异常拦截，也可以单独对方法的异常进行拦截，实现异常和逻辑代码的分离