SpringBoot（2）SpringMVC

2017-04-07

一、Spring MVC原理

Servlet–>EJB–>Struts–>SpringMVC–>SpringBoot

Servlet

Servlet的本质：

Servlet就是一个Java接口，这个接口定义了一套处理网络请求的规范，包含了init、destroy这两个生命周期的方法，和一个处理请求的service方法。
所有实现servlet接口的类，或者说，所有想要处理网络请求的类，都需要回答这三个问题：你初始化时要做什么？你销毁时要做什么？你接受到请求时要做什么？
实现Servlet类并不能直接处理请求，servlet不会和客户端打交道，需要servlet容器来实现。常见的如tomcat，里面包含servlet接口和实现。tomcat监听客户端端口，根据请求信息，将请求交给对应的servlet处理，调用servlet的service方法，返回response对象，再返回给客户端。

Servlet和JSP的区别：

JSP就是在html里面写Java代码，Servlet就是在Java里面写html代码。其实JSP会转换为servlet代码，然后编译成类文件，供JVM运行。
Servlet能够很好地组织业务逻辑代码，但是在Java源文件中通过字符串拼接的方式生成动态HTML内容会导致代码维护困难、可读性差。
JSP虽然规避了Servlet在生成HTML内容方面的劣势，但是在HTML中混入大量、复杂的业务逻辑同样也是不可取的。

因此通过MVC模型，Controller层负责servlet，View层负责JSP，提高代码可读性和可维护性。

DispatcherServlet（前端控制器）

DispatcherServlet是整个流程控制的中心，由它调用其它组件处理用户的请求，DispatcherServlet的存在降低了组件之间的耦合性。

DispatcherServlet继承自Servlet。HttpServletBean抽象类仍然是spring提供，而HttpServlet抽象类、Servlet接口都是servlet容器（如tomcat）等提供。

HandlerMapping（处理器映射器）

HandlerMapping负责根据用户请求找到Handler即处理器，springmvc提供了不同的映射器实现不同的映射方式，例如：配置文件方式，实现接口方式，注解方式等，推荐使用注解开发。

Handler（处理器）

Handler 是继DispatcherServlet前端控制器的后端控制器，在DispatcherServlet的控制下Handler对具体的用户请求进行处理。由于Handler涉及到具体的用户业务请求，所以一般情况需要程序员根据业务需求开发Handler。

HandlerAdapter（处理器适配器）

通过HandlerAdapter对处理器进行执行，这是适配器模式的应用，通过扩展适配器可以对更多类型的处理器进行执行。

ViewResolver（视图解析器）

View Resolver负责将处理结果生成View视图，View Resolver首先根据逻辑视图名解析成物理视图名即具体的页面地址，再生成View视图对象，最后对View进行渲染将处理结果通过页面展示给用户。

二、Spring MVC核心源码

1、所有的源头从Servlet接口的service方法开始。

1
2
3

public interface Servlet {
    void service(ServletRequest var1, ServletResponse var2) throws ServletException, IOException;
}

2、FrameworkServlet类有service的方法的实现

public abstract class FrameworkServlet extends HttpServletBean implements ApplicationContextAware {
    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); // 关键代码，调用父类service方法
        } else {
            this.processRequest(request, response);
        }

    }
}

3、父类HttpServlet的service方法

public abstract class HttpServlet extends GenericServlet {
	protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
		String method = req.getMethod();
		long lastModified;
		if (method.equals("GET")) {
			lastModified = this.getLastModified(req);
			if (lastModified == -1L) {
				this.doGet(req, resp); //关键代码，是get方法调用doGet
			} 
			...
		} 
	}
}

4、回到FrameworkServlet的doGet和processRequest方法

public abstract class FrameworkServlet extends HttpServletBean implements ApplicationContextAware {
    protected final void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        this.processRequest(request, response);
    }

	protected final void processRequest(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		...
        asyncManager.registerCallableInterceptor(FrameworkServlet.class.getName(), new FrameworkServlet.RequestBindingInterceptor());
        this.initContextHolders(request, localeContext, requestAttributes);
        try {
            this.doService(request, response); //关键代码，调用doService
        }
    }

	protected abstract void doService(HttpServletRequest var1, HttpServletResponse var2) throws Exception; //doService是个抽象方法，被子类DispatcherServlet重写
}

5、DispatcherServlet的最核心SpringMVC源码

public class DispatcherServlet extends FrameworkServlet {
	@Nullable
    private List<HandlerMapping> handlerMappings;
    @Nullable
    private List<HandlerAdapter> handlerAdapters;

	protected void doService(HttpServletRequest request, HttpServletResponse response) throws Exception {
		...
        try {
            this.doDispatch(request, response); //关键代码，调用doDispatch，进入mvc核心源码
        }
    }

	//SpringMVC核心源码
	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); //检查是否是multipart请求
                    multipartRequestParsed = processedRequest != request; 
                    mappedHandler = this.getHandler(processedRequest); //图上的2、3步，调用处理器映射器HandlerMapper
                    if (mappedHandler == null) {
                        this.noHandlerFound(processedRequest, response);
                        return;
                    }
					
                    HandlerAdapter ha = this.getHandlerAdapter(mappedHandler.getHandler());//获取处理器适配器
                    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;
                    }
					//返回处理器对象后，会走图上第4、5、6步，通过处理器适配器HandlerAdapter调用controller的方法
                    mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
                    if (asyncManager.isConcurrentHandlingStarted()) {
                        return;
                    }
					//图上8、9、10步骤，渲染ModelAndView
                    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);
            } catch (Exception var22) {
                this.triggerAfterCompletion(processedRequest, response, mappedHandler, var22);
            } catch (Throwable var23) {
                this.triggerAfterCompletion(processedRequest, response, mappedHandler, new NestedServletException("Handler processing failed", var23));
            }

        } finally {
            if (asyncManager.isConcurrentHandlingStarted()) {
                if (mappedHandler != null) {
                    mappedHandler.applyAfterConcurrentHandlingStarted(processedRequest, response);
                }
            } else if (multipartRequestParsed) {
                this.cleanupMultipart(processedRequest);
            }

        }
    }

	//获取处理器映射器HandlerMapping，相关配置在spring-webmvc-x.x.x.RELEASE.jar!\org\springframework\web\servlet\DispatcherServlet.properties
	@Nullable
    protected HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
        if (this.handlerMappings != null) { 
			// handlerMappings是个数组，是spring启动时已初始化
			// {RequestMappingHandlerMapping@6887}匹配Controller中@Requestmapping注解指定的URL。
			// {BeanNameUrlHandlerMapping@7378}匹配beanID作为url，必须以/开头，由继承AbstractController的Controller来处理该url。 
			// {RouterFunctionMapping@7379}
			// {SimpleUrlHandlerMapping@7380}根据url进行统一映射管理，比如会映射到ResourceHttpRequestHandler来处理静态资源映射。
			// {WelcomePageHandlerMapping@7381}欢迎页面/或/index的映射 
            Iterator var2 = this.handlerMappings.iterator();

            while(var2.hasNext()) {
                HandlerMapping mapping = (HandlerMapping)var2.next(); //如是controller自定义路径，会定位到RequestMappingHandlerMapping
                HandlerExecutionChain handler = mapping.getHandler(request);
                if (handler != null) { //handler会返回处理器对象。com.herr.springboot.base.Controller.HelloController#index()
                    return handler;
                }
            }
        }

        return null;
    }
	//获取处理器适配器HandlerAdapter
	protected HandlerAdapter getHandlerAdapter(Object handler) throws ServletException {
        if (this.handlerAdapters != null) {
			// handlerAdapters同样是个数组，在spring启动时已初始化。根据映射器的不同，会有不同的适配器
			// {RequestMappingHandlerAdapter@7109} 
			// {HandlerFunctionAdapter@7469} 
			// {HttpRequestHandlerAdapter@7470} 
			// {SimpleControllerHandlerAdapter@7471} 
            Iterator var2 = this.handlerAdapters.iterator();

            while(var2.hasNext()) {
                HandlerAdapter adapter = (HandlerAdapter)var2.next();
                if (adapter.supports(handler)) {
                    return adapter;
                }
            }
        }
    }
}

三、Spring Boot的Web开发

Spring Boot提供了springboot-starter-web为Web开发予以支持。提供了嵌入的Tomcat以及Spring MVC的依赖。Web相关的自动配置存储在spring-boot-autoconfigure.jar的org.springframework.boot.autoconfigure.web下。
jsp在内嵌的Servlet的容器中有问题，tomcat和jetty不支持以jar形式运行jsp，undertow不支持jsp，因此Spring Boot提供了大量模板引擎，有Freemarker、Thymeleaf、Groovy、Velocity（springboot2.0已弃用）等。

JSP

<!DOCTYPE html>
<%--声明要引用的标签库--%>
<%@ taglib prefix="spring" uri="http://www.springframework.org/tags"%>

<!-- HTML注释，客户端可显示 -->
<%-- JSP注释，发送到服务端，客户端无法显示--%>
<html lang="en">

<body>

<%-- JSP声明语句用于声明变量和方法 --%>
<%!
    public int a=1;            //声明整型变量a
    public String print(){    //声明方法print
        return "JSP method";
    }
%>
<p>
    Message: ${message}
</p>


<%-- JJSPScriptlet是一段Java代码 --%>
<p>
    <%
        String name="herr";
        out.print("hello "+name);
    %>
</p>

<%-- JSP表达式 --%>
<p>
    <%=a%>
</p>
</body>

</html>

Freemarker

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="utf-8"/>
    <title>FreeMarker</title>
</head>
<body>
	<#-- 注释不会输出到html -->
	<h1>hello world ftl</h1>
	<h1 style="color: red">${name}</h1> <#-- 插值 -->
	<h1 style="color: red">${sex!'男'}</h1> <#-- 如为null的默认值 -->

	<#assign age = 20 /> <#-- 定义变量 -->
	<#if age == 18>
		<p> age = 18</p>
	<#else>
		<p> age != 18</p>
	</#if>

	<#list list as item> <#-- List集合取值 -->
		${item!}<br/>
	</#list>

	<#list map?keys as key> <#-- Map集合取值 -->
		${key}:${map[key]}
	</#list>

	<br/>
	${htmlstr?html} <#-- 转义HTML内容 -->

	<br/>
	${htmlstr}  <#-- 不转义HTML内容，直接以html展示 -->
</body>
</html>

Thymeleaf

Thymeleaf『官网传送门』是一个java类库，是xml/xhtml/html5的模板引擎，作为MVC的Web应用的View层。

@Controller
public class TestController {

	@RequestMapping("/index")
	public ModelAndView index(){
		ModelAndView mv = new ModelAndView();
		mv.addObject("name","hello herr");
		mv.setViewName("/index.html");
		Person p1 = new Person("iherr", 18, "male");
		Person p2 = new Person("zhangsan", 20, "famale");
		ArrayList<Person> list = new ArrayList<>();
		list.add(p1);
		list.add(p2);
		mv.addObject("plist",list);
		mv.addObject("person",p1);
		return mv;
	}
}

<!doctype html>
<html lang="en">
<!--引入Thymeleaf。后续需要处理的动态内容都需要加上"th:"前缀。-->
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <meta name="viewport"
          content="width=device-width, user-scalable=no, initial-scale=1.0, maximum-scale=1.0, minimum-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>thymeleaf</title>
    <!-- 通过"@{}"引入静态文件，默认原则，文件放在src/main/resources/static下 -->
    <link rel="stylesheet" type="text/css" th:href="@{css/a.css}" />
    <script th:src="@{js/a.js}"></script>

    <!-- 在JavaScript中访问model，使用 "[[dollar{}]]" 格式。且需要在script标签设置th:inline="javascript"才可实现访问。 -->
    <script th:inline="javascript">
        var single = [[${person}]];
        console.log(single.name+"/"+single.age)
    </script>

</head>
<body>
    <!-- 通过dollar{}访问model中的属性 -->
    <p th:text="${name}"></p>
    <p th:text="${person.name}"></p>
    <!-- list数据判断和迭代 -->
    <div th:if="not ${#lists.isEmpty(plist)}">
        <ul class="list-group">
            <li th:each="person:${plist}">
                <span th:text="${person.name}"></span>
                <span th:text="${person.age}"></span>
            </li>
        </ul>
    </div>
</body>
</html>

四、Web相关配置

Spring Boot提供的自动配置，通过WebMvcConfiguration及WebMvcProperties来设置。

1、自动配置的ViewResolver

ContentNegotiatingViewResolver，特殊，最高级，代理给不同的ViewResolver来处理不同的View
BeanNameViewResolver，根据控制器返回的字符串来查找Bean名称相同的视图
InternaleResourceViewResolver，通过设置前后缀和控制器返回视图名的字符串来获得实际页面

2、自动配置的静态资源

通过自动配置类的addResourceHandlers方法来定义以下静态资源的自动配置。

类路径文件（/static、/public、/resources、/META-INF/resources）文件夹下的静态文件直接映射为/* * ，可通过http://localhost:8080/* * 来访问。
webjar，把webjar的/META-INF/resources/webjars下的静态文件映射为/webjars/* * ，可通过http://localhost:8080/webjars/* * 来访问。

3、自动配置的Formatter和Converter
在WebMvcAutoConfiguration的方法addFormatters中，配置了Converter、GenericConverter和Formatter接口的实现类的Bean，并自动注册到Spring MVC中。

4、自动配置的HttpMessageConverters
定义了ByteArray、BufferedImage、Resource、Jackson、Gson等HttpMessageConverters。

接管Spring Boot的mvc配置

新建配置类，注解Configuration，重写WebMvcConfigurerAdapter的addViewControllers方法，不是覆盖，和自动配置同时生效。

@Configuration
public class NewWebMvcConfig  extends WebMvcConfigurerAdapter {
    @Override
    public void addViewControllers(ViewControllerRegistry registry) {
        registry.addViewController("/herr").setViewName("/herr");
    }

}

tomcat替换为jetty或undertow

<dependencies>
	<dependency>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-web</artifactId>
		<exclusions>
			<exclusion>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-starter-tomcat</artifactId>
			</exclusion>
		</exclusions>
	</dependency>
	<dependency>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-jetty</artifactId>
	</dependency>
	<dependency>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-undertow</artifactId>
	</dependency>
</dependencies>

SSL配置

使用keytool生成p12文件，并安装到服务器。p12文件放到src/main/resources路径下。

1	$ keytool -genkey -alias tomcat -dname "CN=Andy,OU=kfit,O=kfit,L=HaiDian,ST=BeiJing,C=CN" -storetype PKCS12 -keyalg RSA -keysize 2048 -keystore keystore.p12 -validity 365

properties文件配置

server.port = 8443
server.ssl.key-store = classpath:keystore.p12
server.ssl.key-store-password= 123456
server.ssl.keyStoreType= PKCS12
server.ssl.keyAlias= tomcat

设置http8080自动跳转(springboot2版本)

@Bean
   public TomcatServletWebServerFactory servletContainer() {

       TomcatServletWebServerFactory tomcat = new TomcatServletWebServerFactory() {

           @Override
           protected void postProcessContext(Context context) {

               SecurityConstraint securityConstraint = new SecurityConstraint();
               securityConstraint.setUserConstraint("CONFIDENTIAL");
               SecurityCollection collection = new SecurityCollection();
               collection.addPattern("/*");
               securityConstraint.addCollection(collection);
               context.addConstraint(securityConstraint);
           }
       };
       tomcat.addAdditionalTomcatConnectors(initiateHttpConnector());
       return tomcat;
   }

   private Connector initiateHttpConnector() {
       Connector connector = new Connector("org.apache.coyote.http11.Http11NioProtocol");
       connector.setScheme("http");
       connector.setPort(8080);
       connector.setSecure(false);
       connector.setRedirectPort(8443);
       return connector;
   }

favicon配置

禁用favicon

1	spring.mvc.favicon.enabled=false

设置favicon：将favicon.ico放到到静态路径下即可。