4.1 Spring MVC 介绍

那个时候时间过得很慢，

慢到只用一种技术规范，

就可以...

开发 Web 应用一辈子。

MVVM：Model-View-ViewModel 的简写，它本质上就是 MVC 的改进版。

@ComponentScan(excludeFilters = { @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
		@Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
public @interface SpringBootApplication {
	...
}

• value， method：
  • value： 指定请求的实际地址，指定的地址可以是 URI Template 模式；
  • method： 指定请求的 method 类型，例如 GET、POST、PUT、DELETE等；
• consumes，produces：
  • consumes：指定处理请求的提交内容类型（Content-Type），例如 application/json, text/html;
  • produces: 指定返回的内容类型，仅当 request 请求头中的（Accept）类型中包含该指定类型才返回；
• params，headers：
  • params： 指定 request 中必须包含某些参数值是，才让该方法处理；
  • headers： 指定 request 中必须包含某些指定的 header 值，才能让该方法处理请求。

@Controller  
public class TestController {  
     @RequestMapping(value="/product/{productId}",method = RequestMethod.GET)  
     public String getProduct(@PathVariable("productId") String productId){  
           System.out.println("Product Id : " + productId);  
           return "hello";  
     }  
  
     @RequestMapping(value="/javabeat/{regexp1:[a-z-]+}", method = RequestMethod.GET) 
     public String getRegExp(@PathVariable("regexp1") String regexp1){  
           System.out.println("URI Part 1 : " + regexp1);  
           return "hello";  
     }  
}

@RequestMapping("genUsers")
public String genUsers(@RequestParam int count) {
    //public String genUsers(int count) {
    for (int i=2; i<count+2; i++) {
        String str = UUID.randomUUID().toString().substring(16);
        User user = new User();
        user.setId(i);
        user.setUserName(str);
        user.setRealName(str);
        user.setPassWord(str);
        userService.saveUser(user);
    }
    return "生成了" + count + "个用户。";
}

返回的数据不是 HTML 页面，而是其他某种格式的数据时（如JSON、XML等）使用。

public ModelAndView handleRequestInternal(HttpServletRequest request,  
                                          HttpServletResponse response)throws Exception{  
    ...  
        Map<String,Object> model = new HashMap<String,Object>();  
    if(courtName != null){  
        model.put("courtName",courtName);  
        model.put("reservations",reservationService.query(courtName));  
    }  
    return new ModelAndView("reservationQuery",model);  
}  

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Controller
@ResponseBody
public @interface RestController {
	/**
	 * The value may indicate a suggestion for a logical component name,
	 * to be turned into a Spring bean in case of an autodetected component.
	 * @return the suggested component name, if any (or empty String otherwise)
	 * @since 4.0.1
	 */
	@AliasFor(annotation = Controller.class)
	String value() default "";
}

从依赖倒置原则来讲，@Service 组件绝对不应该依赖 @Controller 组件。

@RestController
@RequestMapping("/user")
public class UserController {
 
    @Autowired
    private UserService userService;
 
    @RequestMapping("get/{id}")
    public String getUser(@PathVariable int id){
        return userService.selectUser(id).toString();
    }
...

@SuppressWarnings("serial")
public class DispatcherServlet extends FrameworkServlet {
...
	/** List of HandlerMappings used by this servlet. */
	@Nullable
	private List<HandlerMapping> handlerMappings;
...

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);
            // Determine handler for the current request.
            mappedHandler = getHandler(processedRequest);
            if (mappedHandler == null) {
                noHandlerFound(processedRequest, response);
                return;
            }
            // Determine handler adapter for the current request.
            HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());
            // Process last-modified header, if supported by the handler.
            String method = request.getMethod();
            boolean isGet = "GET".equals(method);
            if (isGet || "HEAD".equals(method)) {
                long lastModified = ha.getLastModified(request, mappedHandler.getHandler());
                if (new ServletWebRequest(request, response).checkNotModified(lastModified) && isGet) {
                    return;
                }
            }
            if (!mappedHandler.applyPreHandle(processedRequest, response)) {
                return;
            }
            // Actually invoke the handler.
            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) {
            // As of 4.3, we're processing Errors thrown from handler methods as well,
            // making them available for @ExceptionHandler methods and other scenarios.
            dispatchException = new NestedServletException("Handler dispatch failed", err);
        }
        processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
    }
    catch (Exception ex) {
        triggerAfterCompletion(processedRequest, response, mappedHandler, ex);
    }
    catch (Throwable err) {
        triggerAfterCompletion(processedRequest, response, mappedHandler,
                               new NestedServletException("Handler processing failed", err));
    }
    finally {
        if (asyncManager.isConcurrentHandlingStarted()) {
            // Instead of postHandle and afterCompletion
            if (mappedHandler != null) {
                mappedHandler.applyAfterConcurrentHandlingStarted(processedRequest, response);
            }
        }
        else {
            // Clean up any resources used by a multipart request.
            if (multipartRequestParsed) {
                cleanupMultipart(processedRequest);
            }
        }
    }
}

控制器方法（处理器）一般完成前端数据的准备封装工作，然后调用服务层方法完成特定的业务逻辑功能处理。

@RequestMapping("get/{id}")
public String getUser(@PathVariable int id){
    return userService.selectUser(id).toString();
}

public InternalResourceViewResolver(String prefix, String suffix) {
    this();
    setPrefix(prefix);
    setSuffix(suffix);
}

<!-- 这个类用于Spring MVC视图解析 -->
<beans:bean id="viewResolver"
            class="org.springframework.web.servlet.view.InternalResourceViewResolver">
    <beans:property name="prefix" value="/WEB-INF/views/" />
    <beans:property name="suffix" value=".jsp" />
</beans:bean>

<servlet>
    <servlet-name>dispatcherServlet</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <init-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:META-INF/spring/springmvc-context.xml</param-value>
    </init-param>
    <load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
    <servlet-name>dispatcherServlet</servlet-name>
    <url-pattern>/</url-pattern>
</servlet-mapping>

<mvc:resources mapping="/images/**" location="/images/" />  

0. 在Web容器启动时，Spring MVC 的 Spring 容器及前端分发器加载 SpringMVC.xml 配置文件，完成 Spring MVC 的初始化；
1. 浏览器发起一个 http 请求（Request），被 DispatcherServlet 拦截到；
2. DispatcherServlet 查询 handlerMappings 匹配一个handler；
3. 调用 handler；
4. handler 调用服务层对应的方法，完成业务逻辑处理；
5. 业务逻辑返回的结果被 handler 包装到一个ModelAndView中；
6. DispatcherServlet 通过 ViewResolver 获取解析视图；
7. 将 Model 上的数据加载到 View 上；
8. View（JSP 页面）向浏览器返回 http 响应（Response）。

在本示例中，使用 8.5 版本的 Tomcat。

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.2.1.RELEASE</version>
</dependency>

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns="http://java.sun.com/xml/ns/javaee"
	xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
	id="WebApp_ID" version="3.0">
	<display-name>spring-mvc-jsp</display-name>
	<servlet>
		<servlet-name>SpringMVC</servlet-name>
		<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
		<init-param>
			<param-name>contextConfigLocation</param-name>
			<param-value>classpath:spring-context.xml</param-value>
		</init-param>
		<load-on-startup>1</load-on-startup>
	</servlet>
	<servlet-mapping>
		<servlet-name>SpringMVC</servlet-name>
		<url-pattern>/</url-pattern>
	</servlet-mapping>
	<welcome-file-list>
		<welcome-file>index.jsp</welcome-file>
	</welcome-file-list>
</web-app>

<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:mvc="http://www.springframework.org/schema/mvc"
	xmlns:context="http://www.springframework.org/schema/context"
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
        http://www.springframework.org/schema/beans/spring-beans.xsd 
        http://www.springframework.org/schema/mvc 
        http://www.springframework.org/schema/mvc/spring-mvc.xsd 
        http://www.springframework.org/schema/context 
        http://www.springframework.org/schema/context/spring-context.xsd">
	<context:component-scan base-package="com.example"/>
	<mvc:annotation-driven/>
	<mvc:resources location="/images/" mapping="/images/**"/>
	<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
		<property name="prefix" value="/WEB-INF/views"></property>
		<property name="suffix" value=".jsp"></property>
	</bean>
</beans>

• Model 中存储了模拟服务层返回的 sayHello + who + "." 内容，其键值为 sayHello；
• View 指定为 /hello，根据视图解析器配置换算成真实文件为 /WEB-INF/views/hello.jsp。

package com.example.controller;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;
@Controller
public class HelloController {
	@RequestMapping("/sayHello")
	public ModelAndView sayHello(String who) {
		ModelAndView mv = new ModelAndView();
		//模拟调用Service方法，返回问候语sayHello
		String sayHello = "Greeting! Hello ";
		mv.addObject("sayHello", sayHello + who + ".");
		mv.setViewName("/hello");
		return mv;
	}
}

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Say Hello to WHO.</title>
</head>
<body>
	<img src="<%=request.getContextPath()%>/images/RoyElephant.png" width="128" height="128" />
	${sayHello}
</body>
</html>