SpringMVC实现原理及详解

1、什么是 SpringMVC ?

　　在介绍什么是 SpringMVC 之前，我们先看看 Spring 的基本架构。如下图：

　　

　　我们可以看到，在 Spring 的基本架构中，红色圈起来的 Spring Web MVC ，也就是本系列的主角 SpringMVC，它是属于Spring基本架构里面的一个组成部分，属于SpringFrameWork的后续产品，已经融合在Spring Web Flow里面，所以我们在后期和 Spring 进行整合的时候，几乎不需要别的什么配置。

　　SpringMVC 是类似于 Struts2 的一个 MVC 框架，在实际开发中，接收浏览器的请求响应，对数据进行处理，然后返回页面进行显示，但是上手难度却比 Struts2 简单多了。而且由于 Struts2 所暴露出来的安全问题，SpringMVC 已经成为了大多数企业优先选择的框架。

　　那么多的不说，我们直接通过一个实例来看看 SpringMVC 的魔力。

2、创建 web 工程，并导入相应的 jar 包。

　　

　　这里我们加入了 Spring 3.2 的所有 jar 包，正好也佐证了上面所说的 SpringMVC 是 Spring 架构的一部分，注意：一定要包括红色椭圆圈起来的 spring-webmvc-3.2.0.RELEASE.jar

3、新建 SpringMVC 全局配置文件

　　在 src 目录下新建 springmvc.xml 文件，并添加如下代码：

　　

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
<?xml version="1.0" encoding="UTF-8"?>
<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"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans-4.2.xsd
        http://www.springframework.org/schema/mvc
        http://www.springframework.org/schema/mvc/spring-mvc-4.2.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop-4.2.xsd
        http://www.springframework.org/schema/tx
        http://www.springframework.org/schema/tx/spring-tx.xsd">
 
 
</beans>

 

 4、在 web.xml 文件中配置前端过滤器　

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
<?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>SpringMVC_01</display-name>
  <!-- 配置前端控制器DispatcherServlet -->
  <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:springmvc.xml</param-value>
    </init-param>
  </servlet>
 
  <servlet-mapping>
    <servlet-name>springmvc</servlet-name>
    <url-pattern>*.do</url-pattern>
  </servlet-mapping>
</web-app>

 

5、编写处理器 Handler

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
package com.ys.controller;
 
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
 
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.Controller;
 
public class HelloController implements Controller{
 
    @Override
    public ModelAndView handleRequest(HttpServletRequest request,
            HttpServletResponse response) throws Exception {
        ModelAndView modelView = new ModelAndView();
        //类似于 request.setAttribute()
        modelView.addObject("name","张三");
        modelView.setViewName("/WEB-INF/view/index.jsp");
        return modelView;
    }
 
}

　

6、在 springmvc.xml 文件中配置 Handler,处理器映射器，处理器适配器，以及视图解析器　　

　　在 springmvc.xml 文件中添加如下代码：

1
2
3
4
5
6
7
8
9
10
11
<!-- 配置Handler -->   
<bean name="/hello.do" class="com.ys.controller.HelloController" />
   <!-- 配置处理器映射器
    将bean的name作为url进行查找，需要在配置Handler时指定bean name（就是url）-->
<bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping" />
   <!-- 配置处理器适配器，所有适配器都得实现 HandlerAdapter接口 -->
   <bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter" />
 
<!-- 配置视图解析器
    进行jsp解析，默认使用jstl标签，classpath下得有jstl的包-->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" />

　

 7、在  /WEB-INF/view 目录下创建 index.jsp 文件

　　

1
2
3
4
5
6
7
8
9
10
11
12
<%@ 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>Insert title here</title>
</head>
<body>
hello:${name}
</body>
</html>

　

8、在浏览器输入 http://localhost:8080/SpringMVC_01/hello.do

 　　

1、SpringMVC 详细介绍

　　通过入门实例，我们大概知道 SpringMVC 的作用，那么它到底是什么呢？

　　Spring Web MVC是一种基于Java的实现了Web MVC设计模式的请求驱动类型的轻量级Web框架，即使用了MVC架构模式的思想，将web层进行职责解耦，基于请求驱动指的就是使用请求-响应模型，框架的目的就是帮助我们简化开发，Spring Web MVC也是要简化我们日常Web开发的。

　　与之相反的是基于组件的、事件驱动的Web框架，如Tapestry、JSF等，在此就不介绍了。

　　Spring Web MVC也是服务到工作者模式的实现，但进行可优化。前端控制器是DispatcherServlet；应用控制器其实拆为处理器映射器(Handler Mapping)进行处理器管理和视图解析器(View Resolver)进行视图管理；页面控制器/动作/处理器为Controller接口（仅包含ModelAndView handleRequest(request, response) 方法）的实现（也可以是任何的POJO类）；支持本地化（Locale）解析、主题（Theme）解析及文件上传等；提供了非常灵活的数据验证、格式化和数据绑定机制；提供了强大的约定大于配置（惯例优先原则）的契约式编程支持。

2、SpringMVC 处理请求流程

第一步：用户发送请求到前端控制器（DispatcherServlet）。

第二步：前端控制器请求 HandlerMapping 查找 Handler，可以根据 xml 配置、注解进行查找。

第三步： 处理器映射器 HandlerMapping 向前端控制器返回 Handler

第四步：前端控制器调用处理器适配器去执行 Handler

第五步：处理器适配器执行 Handler

第六步：Handler 执行完成后给适配器返回 ModelAndView

第七步：处理器适配器向前端控制器返回 ModelAndView

　　　　ModelAndView 是SpringMVC 框架的一个底层对象，包括 Model 和 View

第八步：前端控制器请求试图解析器去进行视图解析

　　　　根据逻辑视图名来解析真正的视图。

第九步：试图解析器向前端控制器返回 view

第十步：前端控制器进行视图渲染

　　　　就是将模型数据（在 ModelAndView 对象中）填充到 request 域

第十一步：前端控制器向用户响应结果

 

下面我们对上面出现的一些组件进行解释：

1
2
3
4
5
6
7
8
9
10
11
12
13
1、前端控制器DispatcherServlet（不需要程序员开发）。
　　作用：接收请求，响应结果，相当于转发器，中央处理器。有了DispatcherServlet减少了其它组件之间的耦合度。
2、处理器映射器HandlerMapping（不需要程序员开发）。
　　作用：根据请求的url查找Handler。
3、处理器适配器HandlerAdapter（不需要程序员开发）。
　　作用：按照特定规则（HandlerAdapter要求的规则）去执行Handler。
4、处理器Handler（需要程序员开发）。
　　注意：编写Handler时按照HandlerAdapter的要求去做，这样适配器才可以去正确执行Handler
5、视图解析器ViewResolver（不需要程序员开发）。
　　作用：进行视图解析，根据逻辑视图名解析成真正的视图（view）
6、视图View（需要程序员开发jsp）。
　　注意：View是一个接口，实现类支持不同的View类型（jsp、freemarker、pdf…）
ps:不需要程序员开发的，需要程序员自己做一下配置即可。

　　可以总结出：需要我们开发的工作只有处理器 Handler 的编写以及视图比如JSP页面的编写。可能你还对诸如前端控制器、处理器映射器等等名词不太理解，那么接下来我们对其进行详细的介绍。

3、配置前端控制器

　　在 web.xml 文件中进行如下配置：

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
<?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>SpringMVC_01</display-name>
  <!-- 配置前端控制器DispatcherServlet -->
  <servlet>
    <servlet-name>springmvc</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <!--springmvc.xml 是自己创建的SpringMVC全局配置文件，用contextConfigLocation作为参数名来加载
        如果不配置 contextConfigLocation，那么默认加载的是/WEB-INF/servlet名称-servlet.xml，在这里也就是 springmvc-servlet.xml
      -->
    <init-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:springmvc.xml</param-value>
    </init-param>
  </servlet>
 
  <servlet-mapping>
    <servlet-name>springmvc</servlet-name>
    <!--第一种配置：*.do,还可以写*.action等等，表示以.do结尾的或者以.action结尾的URL都由前端控制器DispatcherServlet来解析
        第二种配置：/,所有访问的 URL 都由DispatcherServlet来解析，但是这里最好配置静态文件不由DispatcherServlet来解析
        错误配置：/*,注意这里是不能这样配置的，应为如果这样写，最后转发到 jsp 页面的时候，仍然会由DispatcherServlet进行解析，
                    而这时候会找不到对应的Handler，从而报错！！！
      -->
    <url-pattern>*.do</url-pattern>
  </servlet-mapping>
</web-app>

　

4、配置处理器适配器

　　在 springmvc.xml 文件中配置。用来约束我们所需要编码的 Handler类。

　　第一种配置：编写 Handler 时必须要实现 Controller

1
2
<!-- 配置处理器适配器，所有适配器都得实现 HandlerAdapter接口 -->
<bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter" />

　　我们可以查看源码：　

 

 　　第二种配置：编写 Handler 时必须要实现 HttpRequestHandler

1
2
<!-- 配置处理器适配器第二种方法，所有适配器都得实现 HandlerAdapter接口 ，这样配置所有Handler都得实现 HttpRequestHandler接口-->
<bean class="org.springframework.web.servlet.mvc.HttpRequestHandlerAdapter" />

　　

5、编写 Handler

　　在 springmvc.xml 文件中配置。通俗来讲，就是请求的 URL 到我们这里所编写的 Handler 类的某个方法进行一些业务逻辑处理。

　　我们在上面讲解了两个处理器适配器来约束 Handler，那么我们就通过上面两种配置分别编写两个 Handler

　　第一种：实现Controller 接口

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
package com.ys.controller;
 
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
 
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.Controller;
 
public class HelloController implements Controller{
 
    @Override
    public ModelAndView handleRequest(HttpServletRequest request,
            HttpServletResponse response) throws Exception {
        ModelAndView modelView = new ModelAndView();
        //类似于 request.setAttribute()
        modelView.addObject("name","张三");
        modelView.setViewName("/WEB-INF/view/index.jsp");
        return modelView;
    }
 
}

　　第二种：实现 HttpRequestHandler 接口

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
package com.ys.controller;
 
import java.io.IOException;
 
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
 
import org.springframework.web.HttpRequestHandler;
 
public class HelloController2 implements HttpRequestHandler{
 
    @Override
    public void handleRequest(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        request.setAttribute("name", "张三");
        request.getRequestDispatcher("/WEB-INF/view/index.jsp").forward(request, response);
    }
 
}

　　总结：通常我们使用第一种方式来编写 Handler ，但是第二种没有返回值，我们可以通过 response 修改相应内容，比如返回 json 数据。

1
2
3
response.setCharacterEncoding("utf-8");
response.setContentType("application/json;charset=utf-8");
response.getWriter().write("json字符串");

　　所以具体使用哪一种根据实际情况来判断。

5、配置处理器映射器

　　在 springmvc.xml 文件中配置。通俗来讲就是请求的 URL 怎么能被 SpringMVC 识别，从而去执行我们上一步所编写好的 Handler

 　　第一种方法：

1
2
3
4
5
6
<!-- 配置Handler -->   
<bean name="/hello.do" class="com.ys.controller.HelloController2" />
 
<!-- 配置处理器映射器
    将bean的name作为url进行查找，需要在配置Handler时指定bean name（就是url）-->
<bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping" />

　　这样配置的话，那么请求的 URL，必须为 http://localhost:8080/项目名/hello.do

　　

　　第二种方法：

1
2
3
4
5
6
7
8
9
10
11
12
<!-- 配置Handler -->   
<bean id="hello1" class="com.ys.controller.HelloController" />
<bean id="hello2" class="com.ys.controller.HelloController" />
<!-- 第二种方法：简单URL配置处理器映射器 -->
<bean class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
    <property name="mappings">
        <props>
            <prop key="/hello1.do">hello1</prop>
            <prop key="/hello2.do">hello2</prop>
        </props>
    </property>
</bean>

　　这种配置请求的 URL可以为 http://localhost:8080/项目名/hello1.do，或者http://localhost:8080/项目名/hello2.do

 

 总结：上面两种处理器映射器配置可以并存，前端控制器会正确的去判断 url 用哪个 Handler 去处理。

 

6、配置视图解析器

　　第一种配置:

1
2
3
<!-- 配置视图解析器
    进行jsp解析，默认使用jstl标签，classpath下得有jstl的包-->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" />

　如果这样配，那么在 Handler 中返回的必须是路径+jsp页面名称+".jsp"　

 　　第二种配置：

1
2
3
4
5
6
7
<!--配置视图解析器  -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <!-- 返回视图页面的前缀 -->
        <property name="prefix" value="/WEB-INF/view"></property>
        <!-- 返回页面的后缀 -->
        <property name="suffix" value=".jsp"></property>
    </bean>

　　如果这样配，那么在 Handler 中只需要返回在 view 文件夹下的jsp 页面名就可以了。

7、DispatcherServlet.properties

　　上面我们讲解了各种配置，可能有人会问这么多配置，万一少配置了一样，那不就不能运行了，那我们能不能不配置呢？答案是肯定的，SpringMVC 给我们提供了一个 DispatcherServlet.properties 文件。系统会首先加载这里面的配置，如果我们没有配置，那么就默认使用这个文件的配置；如果我们配置了，那么就优先使用我们手动配置的。

　　

　　在 SpringMVC 运行之前，会首先加载 DispatcherServlet.properties 文件里面的内容，那么我们来看看这里面都是什么。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
# Default implementation classes for DispatcherServlet's strategy interfaces.
# Used as fallback when no matching beans are found in the DispatcherServlet context.
# Not meant to be customized by application developers.
 
org.springframework.web.servlet.LocaleResolver=org.springframework.web.servlet.i18n.AcceptHeaderLocaleResolver
 
org.springframework.web.servlet.ThemeResolver=org.springframework.web.servlet.theme.FixedThemeResolver
 
org.springframework.web.servlet.HandlerMapping=org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping,\
    org.springframework.web.servlet.mvc.annotation.DefaultAnnotationHandlerMapping
 
org.springframework.web.servlet.HandlerAdapter=org.springframework.web.servlet.mvc.HttpRequestHandlerAdapter,\
    org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter,\
    org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter
 
org.springframework.web.servlet.HandlerExceptionResolver=org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerExceptionResolver,\
    org.springframework.web.servlet.mvc.annotation.ResponseStatusExceptionResolver,\
    org.springframework.web.servlet.mvc.support.DefaultHandlerExceptionResolver
 
org.springframework.web.servlet.RequestToViewNameTranslator=org.springframework.web.servlet.view.DefaultRequestToViewNameTranslator
 
org.springframework.web.servlet.ViewResolver=org.springframework.web.servlet.view.InternalResourceViewResolver
 
org.springframework.web.servlet.FlashMapManager=org.springframework.web.servlet.support.SessionFlashMapManager

　　我们可以从上面得出，如果我们不手动进行各种配置，那么也有会默认的

　　①、处理器适配器默认：org.springframework.web.servlet.mvc.HttpRequestHandlerAdapter

　　②、处理器映射器默认：org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping

　　③、视图解析器默认：org.springframework.web.servlet.view.InternalResourceViewResolver

 

前两篇博客我们讲解了基于XML 的入门实例，以及SpringMVC运行的详细流程。但是我们发现基于 XML 的配置还是比较麻烦的，而且，每个 Handler 类只能有一个方法，在实际开发中肯定是不可能这样来进行开发的。那么这篇博客我们就讲解实际开发中用的最多的基于注解配置的SpringMVC配置。

　　本篇博客源码下载链接：http://pan.baidu.com/s/1dESLgv3 密码：vkuy

　　项目结构为：

　　

1、在 web.xml 文件中配置前端处理器

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
<?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>SpringMVC_01</display-name>
  <!-- 配置前端控制器DispatcherServlet -->
  <servlet>
    <servlet-name>springmvc</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <!--springmvc.xml 是自己创建的SpringMVC全局配置文件，用contextConfigLocation作为参数名来加载
        如果不配置 contextConfigLocation，那么默认加载的是/WEB-INF/servlet名称-servlet.xml，在这里也就是 springmvc-servlet.xml
      -->
    <init-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:springmvc.xml</param-value>
    </init-param>
  </servlet>
 
  <servlet-mapping>
    <servlet-name>springmvc</servlet-name>
    <!--第一种配置：*.do,还可以写*.action等等，表示以.do结尾的或者以.action结尾的URL都由前端控制器DispatcherServlet来解析
        第二种配置：/,所有访问的 URL 都由DispatcherServlet来解析，但是这里最好配置静态文件不由DispatcherServlet来解析
        错误配置：/*,注意这里是不能这样配置的，应为如果这样写，最后转发到 jsp 页面的时候，仍然会由DispatcherServlet进行解析，
                    而这时候会找不到对应的Handler，从而报错！！！
      -->
    <url-pattern>/</url-pattern>
  </servlet-mapping>
</web-app>

 

2、在 springmvc.xml 文件中配置处理器映射器，处理器适配器，视图解析器

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
<?xml version="1.0" encoding="UTF-8"?>
<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"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans-4.2.xsd
        http://www.springframework.org/schema/mvc
        http://www.springframework.org/schema/mvc/spring-mvc-4.2.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop-4.2.xsd
        http://www.springframework.org/schema/tx
        http://www.springframework.org/schema/tx/spring-tx.xsd">
    <!--注解处理器映射器  -->   
    <bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping"></bean>
     
    <!--注解处理器适配器  -->   
    <bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter"></bean>  
 
    <!--使用mvc:annotation-driven可以代替上面的映射器和适配器
        这里面会默认加载很多参数绑定方法，比如json转换解析器就默认加载，所以优先使用下面的配置
      -->
    <!-- <mvc:annotation-driven></mvc:annotation-driven> -->
 
 
    <!--单个配置Handler  -->
    <!-- <bean class="com.ys.controller.HelloController"></bean> -->
     
    <!--批量配置Handler,指定扫描的包全称  -->
    <context:component-scan base-package="com.ys.controller"></context:component-scan>
     
 
    <!--配置视图解析器  -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <!-- 返回视图页面的前缀 -->
        <property name="prefix" value="/WEB-INF/view/"></property>
        <!-- 返回页面的后缀 -->
        <property name="suffix" value=".jsp"></property>
    </bean>
</beans>

3、编写 Handler

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
package com.ys.controller;
 
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;
 
//使用@Controller注解表示这个类是一个Handler
@Controller
public class HelloController {
 
    //@RequestMapping注解括号里面的表示访问的URL
    @RequestMapping("hello")
    public ModelAndView hello(){
        ModelAndView modelView = new ModelAndView();
        //类似于 request.setAttribute()
        modelView.addObject("name","张三");
        //配置返回的视图名，由于我们在springmvc.xml中配置了前缀和后缀，这里直接写视图名就好
        modelView.setViewName("index");
        //modelView.setViewName("/WEB-INF/view/index.jsp");
        return modelView;
    }
 
}

　　注意@Controller注解和@RequestMapping注解的用法

4、编写 视图 index.jsp

1
2
3
4
5
6
7
8
9
10
11
12
<%@ 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>Insert title here</title>
</head>
<body>
hello:${name}
</body>
</html>

1、Spring mvc介绍

SpringMVC框架是以请求为驱动，围绕Servlet设计，将请求发给控制器，然后通过模型对象，分派器来展示请求结果视图。其中核心类是DispatcherServlet，它是一个Servlet，顶层是实现的Servlet接口。

2、SpringMVC使用

需要在web.xml中配置DispatcherServlet。并且需要配置spring监听器ContextLoaderListener

<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<servlet>
<servlet-name>springmvc</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<!-- 如果不设置init-param标签，则必须在/WEB-INF/下创建xxx-servlet.xml文件，其中xxx是servlet-name中配置的名称。 -->
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:spring/springmvc-servlet.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>
3、SpringMVC运行原理

如图所示：

 

 

 

 

 

流程说明：

（1）客户端（浏览器）发送请求，直接请求到DispatcherServlet。

（2）DispatcherServlet根据请求信息调用HandlerMapping，解析请求对应的Handler。

（3）解析到对应的Handler后，开始由HandlerAdapter适配器处理。

（4）HandlerAdapter会根据Handler来调用真正的处理器开处理请求，并处理相应的业务逻辑。

（5）处理器处理完业务后，会返回一个ModelAndView对象，Model是返回的数据对象，View是个逻辑上的View。

（6）ViewResolver会根据逻辑View查找实际的View。

（7）DispaterServlet把返回的Model传给View。

（8）通过View返回给请求者（浏览器）

4、DispatcherServlet详细解析

首先看下源码：

package org.springframework.web.servlet;

@SuppressWarnings("serial")
public class DispatcherServlet extends FrameworkServlet {

public static final String MULTIPART_RESOLVER_BEAN_NAME = "multipartResolver";
public static final String LOCALE_RESOLVER_BEAN_NAME = "localeResolver";
public static final String THEME_RESOLVER_BEAN_NAME = "themeResolver";
public static final String HANDLER_MAPPING_BEAN_NAME = "handlerMapping";
public static final String HANDLER_ADAPTER_BEAN_NAME = "handlerAdapter";
public static final String HANDLER_EXCEPTION_RESOLVER_BEAN_NAME = "handlerExceptionResolver";
public static final String REQUEST_TO_VIEW_NAME_TRANSLATOR_BEAN_NAME = "viewNameTranslator";
public static final String VIEW_RESOLVER_BEAN_NAME = "viewResolver";
public static final String FLASH_MAP_MANAGER_BEAN_NAME = "flashMapManager";
public static final String WEB_APPLICATION_CONTEXT_ATTRIBUTE = DispatcherServlet.class.getName() + ".CONTEXT";
public static final String LOCALE_RESOLVER_ATTRIBUTE = DispatcherServlet.class.getName() + ".LOCALE_RESOLVER";
public static final String THEME_RESOLVER_ATTRIBUTE = DispatcherServlet.class.getName() + ".THEME_RESOLVER";
public static final String THEME_SOURCE_ATTRIBUTE = DispatcherServlet.class.getName() + ".THEME_SOURCE";
public static final String INPUT_FLASH_MAP_ATTRIBUTE = DispatcherServlet.class.getName() + ".INPUT_FLASH_MAP";
public static final String OUTPUT_FLASH_MAP_ATTRIBUTE = DispatcherServlet.class.getName() + ".OUTPUT_FLASH_MAP";
public static final String FLASH_MAP_MANAGER_ATTRIBUTE = DispatcherServlet.class.getName() + ".FLASH_MAP_MANAGER";
public static final String EXCEPTION_ATTRIBUTE = DispatcherServlet.class.getName() + ".EXCEPTION";
public static final String PAGE_NOT_FOUND_LOG_CATEGORY = "org.springframework.web.servlet.PageNotFound";
private static final String DEFAULT_STRATEGIES_PATH = "DispatcherServlet.properties";
protected static final Log pageNotFoundLogger = LogFactory.getLog(PAGE_NOT_FOUND_LOG_CATEGORY);
private static final Properties defaultStrategies;
static {
try {
ClassPathResource resource = new ClassPathResource(DEFAULT_STRATEGIES_PATH, DispatcherServlet.class);
defaultStrategies = PropertiesLoaderUtils.loadProperties(resource);
}
catch (IOException ex) {
throw new IllegalStateException("Could not load 'DispatcherServlet.properties': " + ex.getMessage());
}
}

/** Detect all HandlerMappings or just expect "handlerMapping" bean? */
private boolean detectAllHandlerMappings = true;

/** Detect all HandlerAdapters or just expect "handlerAdapter" bean? */
private boolean detectAllHandlerAdapters = true;

/** Detect all HandlerExceptionResolvers or just expect "handlerExceptionResolver" bean? */
private boolean detectAllHandlerExceptionResolvers = true;

/** Detect all ViewResolvers or just expect "viewResolver" bean? */
private boolean detectAllViewResolvers = true;

/** Throw a NoHandlerFoundException if no Handler was found to process this request? **/
private boolean throwExceptionIfNoHandlerFound = false;

/** Perform cleanup of request attributes after include request? */
private boolean cleanupAfterInclude = true;

/** MultipartResolver used by this servlet */
private MultipartResolver multipartResolver;

/** LocaleResolver used by this servlet */
private LocaleResolver localeResolver;

/** ThemeResolver used by this servlet */
private ThemeResolver themeResolver;

/** List of HandlerMappings used by this servlet */
private List<HandlerMapping> handlerMappings;

/** List of HandlerAdapters used by this servlet */
private List<HandlerAdapter> handlerAdapters;

/** List of HandlerExceptionResolvers used by this servlet */
private List<HandlerExceptionResolver> handlerExceptionResolvers;

/** RequestToViewNameTranslator used by this servlet */
private RequestToViewNameTranslator viewNameTranslator;

private FlashMapManager flashMapManager;

/** List of ViewResolvers used by this servlet */
private List<ViewResolver> viewResolvers;

public DispatcherServlet() {
super();
}

public DispatcherServlet(WebApplicationContext webApplicationContext) {
super(webApplicationContext);
}

@Override
protected void onRefresh(ApplicationContext context) {
initStrategies(context);
}

protected void initStrategies(ApplicationContext context) {
initMultipartResolver(context);
initLocaleResolver(context);
initThemeResolver(context);
initHandlerMappings(context);
initHandlerAdapters(context);
initHandlerExceptionResolvers(context);
initRequestToViewNameTranslator(context);
initViewResolvers(context);
initFlashMapManager(context);
}
}
DispatcherServlet类中的属性beans：

HandlerMapping：用于handlers映射请求和一系列的对于拦截器的前处理和后处理，大部分用@Controller注解。

HandlerAdapter：帮助DispatcherServlet处理映射请求处理程序的适配器，而不用考虑实际调用的是 哪个处理程序。

HandlerExceptionResolver：处理映射异常。

ViewResolver：根据实际配置解析实际的View类型。

LocaleResolver：解决客户正在使用的区域设置以及可能的时区，以便能够提供国际化视野。

ThemeResolver：解决Web应用程序可以使用的主题，例如提供个性化布局。

MultipartResolver：解析多部分请求，以支持从HTML表单上传文件。

FlashMapManager：存储并检索可用于将一个请求属性传递到另一个请求的input和output的FlashMap，通常用于重定向。

在Web MVC框架中，每个DispatcherServlet都拥自己的WebApplicationContext，它继承了ApplicationContext。WebApplicationContext包含了其上下文和Servlet实例之间共享的所有的基础框架beans。

 

HandlerMapping：


HandlerMapping接口处理请求的映射

HandlerMapping接口的实现类：

SimpleUrlHandlerMapping类通过配置文件把URL映射到Controller类。

DefaultAnnotationHandlerMapping类通过注解把URL映射到Controller类。

 

HandlerAdapter：


HandlerAdapter接口-处理请求映射

AnnotationMethodHandlerAdapter：通过注解，把请求URL映射到Controller类的方法上。

HandlerExceptionResolver：


HandlerExceptionResolver接口-异常处理接口

SimpleMappingExceptionResolver通过配置文件进行异常处理。

AnnotationMethodHandlerExceptionResolver：通过注解进行异常处理。

ViewResolver：


ViewResolver接口解析View视图。

UrlBasedViewResolver类 通过配置文件，把一个视图名交给到一个View来处理。

SpringMVC 注解详解

spring mvc 中有很多的注解，每个注解都有自己的功能，下面我们就对spring mvc中的注解一一作出介绍。关于spring的注解还没有总结，请等待后续blog更新。

@controller

org.springframework.stereotype.Controller注解类型用于指示当前类是一个控制器。 Spring使用扫描机制查找应用程序中所有基于注解的控制器类，分发器会扫描使用该注解类的方法，并检测方法是否使用了@RequestMapping注解，只用使用了@RequestMapping注解的方法才能用来处理请求。

为了保证spring能找到控制器，需要完成两件事情：

  • 在spring mvc的配置文件的头文件中引入spring-context。
  • 在spring mvc 的配置文件中使用context:component-scan/，该元素的功能是启动包扫描功能，以便注册有@Controller、@Service、@Repository、@Component等注解的类成为spring的bean。
<context:component-scan base-package = "com.chris.controller"/>

@RequestMapping

该注解类型指示spring用哪一个类或方法来处理请求动作，可以用于类或方法。

@Controller
// RequestMapping可以用来注释一个控制器类，此时，所有方法都将映射为相对于类级别的请求, 
// 表示该控制器处理所有的请求都被映射到 user属性所指示的路径下
@RequestMapping(value="/user")
public class UserController{
    // 映射请求 user/register
    @RequestMapping(value="/register",method=RequestMethod.GET)
	 public String registerForm() {
		 // 跳转到注册页面
	     return "registerForm";
	 }
     // 映射请求 user/login
     @RequestMapping("/login")
	 public String login( Model model) {
	     return "loginForm";
	 }
}

@RequestMapping可以指定一些属性

  • value：用来映射一个请求和一个方法，是其默认属性，如果在使用@RequestMapping时只有这个属性，则可以省略关键字value.
  • method：该属性用来指定该方法仅仅处理哪些HTTP请求的处理方式，例如GET、POST。
  • consumes：用来指定处理请求提交内容的类型。
  • produces：用来指定返回的内容类型，返回的内容类型必须是request请求头（Accept）中包含的类型。
  • params：指明request中必须包含哪些参数时，才让该方法处理。例如下面的代码指明方法只处理其中名为"myParam"，值为"myValue"的请求。
@RequestMapping(value="/hello", method = RequestMethod.POST,
 params = "myParam = myValue")
  • headers 指明request中必须包含某些header值，才能让该方法处理请求，例如
@RequestMapping(value="/hello", method = RequestMethod.POST,
 header = "bolgID = http://www.cnblogs.com/arax/")

在使用@RequestMapping指定的方法中，如果要访问HttpServletRequest或HttpSession，可以将其直接作为参数，Spring会将对象传递给方法。

@RequestMapping("/hello")
public String login(HttpSession session) {
    return "hello";
}

@RequestParam

该注解将指定的请求参数赋值给方法中的形参。

@RequestMapping("/hello") {
    public String login(
        @RequestParam("loginName") String loginName,
        @RequestParam("password") String password
    ) {
        return "login";
    }
}

在执行上面函数时，springmvc 会将Request中的loginName,password从参数中取出来赋值给函数的形参。
@RequestParam中的属性如下：

  • name：绑定参数在Request中的名称。
  • value：name属性的别名。
  • required：参数是否必须绑定。
  • defaultValue：如果没有传递参数而使用的默认值。
@RequestParam(value="loginname",required=true,defaultValue="admin")

@PathVariable

@PathVariable只支持一个属性value，类型为String，表示绑定的名称，如果省略则表示绑定同名参数。

@RequestMapping("path/{userId}")
public String login(@PathVariable Integer userId) {
    return "login";
}

加入请求url为http://localhost:8080/path/3，则上述函数在执行时会自动将userId值映射为3。

@RequestHeader

将请求头信息区书记映射到处理方法上。其主要有如下属性

  • name：指定请求头绑定的名称。
  • value：name属性的别名。
  • required：参数是否必须绑定。
  • defaultValue：如果没有传递参数而使用的默认值。

和@PathVariable的属性相同。下面给出用法实例

@RequestMapping("/hello") {
    public String login(
        @RequestHeader("User-Agent") String userAgent,
        @RequestHeader(value="Accept") String[] accepts
    ) {
        return "login";
    }
}

@CookieValue

将请求的Cookie书记映射到功能处理方法参数上。其支持的属性如下：

  • name：指定请求头绑定的名称。
  • value：name属性的别名。
  • required：参数是否必须绑定。
  • defaultValue：如果没有传递参数而使用的默认值。
    用法和@RequestParam相同，这里不再赘述。

@SessionAttribute

该注解允许我们有选择的将指定Model中的哪些属性转存到HttpSession对象中。其只能声明在类上。他包含3个属性。

使用如下

@Controller
// 将Model中的属性名为user的放入HttpSession对象当中
@SessionAttributes("user")
public class SessionAttributesController{

	@RequestMapping(value="/{formName}")
	 public String loginForm(@PathVariable String formName){
		// 动态跳转页面
		return formName;
	}

	@RequestMapping(value="/login")
	 public String login(
			 @RequestParam("loginname") String loginname,
			 @RequestParam("password") String password,
			 Model model ) {
		 User user = new User();
		 user.setLoginname(loginname);
		 user.setPassword(password);
		 user.setUsername("admin");
		 model.addAttribute("user",user);
		 return "welcome";
	 }
}

@ModelAttribute

@ModelAttribute只有一个属性value，类型为String，表示绑定数据类型的名称。其使用方法以及表现形式比较多变，容我娓娓道来。@ModelAttribute主要用来修饰方法，被其修饰的方法会在Controller中每个方法执行前被执行，因此在一个Controller类要映射多个URL时，要谨慎使用。
我个人理解被@ModelAttribute修饰的方法，是在执行映射方法前对Model的预处理。

注解返回具体类的方法

@Controller
public class ModelAttribute1Controller{

    // 使用@ModelAttribute注释的value属性，
    // 来指定model属性的名称,model属性对象就是方法的返回值
	@ModelAttribute("loginname")
	public String userModel( 
			@RequestParam("loginname") String loginname){
		return loginname;
	}

	@RequestMapping(value="/login1")
	 public String login() {
		 return "result1";
	 }
}

userModel会先于login执行，并在Model中以loginname为属性名称，userModel返回值为属性值，在Model中放入了一个属性。

注解无返回值的方法

@Controller
public class ModelAttribute2Controller{

	// model属性名称和model属性对象由model.addAttribute()实现，
    // 前提是要在方法中加入一个Model类型的参数。
	// 注意：当URL或者post中不包含对应的参数时，程序会抛出异常。
	@ModelAttribute
	public void userModel( 
			@RequestParam("loginname") String loginname,
			@RequestParam("password") String password,
			 Model model){
		model.addAttribute("loginname", loginname);
		model.addAttribute("password", password);
	}

	@RequestMapping(value="/login2")
	 public String login() {
		 return "result2";
	 }
}

在这个例子中userModel先于login执行，相当于将一段对model的预处理逻辑单独放到一个函数中。

注解返回具体类的方法

@Controller
public class ModelAttribute3Controller{

    // model属性的名称没有指定，它由返回类型隐含表示，
    // 如这个方法返回User类型，那么这个model属性的名称是user。
    // 这个例子中model属性名称由返回对象类型隐含表示，
    // model属性对象就是方法的返回值。它不需要指定特定的参数。
	@ModelAttribute
	public User userModel3( 
			@RequestParam("loginname") String loginname,
			@RequestParam("password") String password){
		return new UserUpperCase(loginname, password);
	}

	@RequestMapping(value="/login3")
	 public String login3() {
		 return "result3";
	 }
}

例子中@ModelAttribue没有参数，修饰的函数的返回值为User的对象，这时会以类名的首字母小写为属性名，返回值为属性值，在Model中放入一个属性。

@ModelAttribute和@RequestMapping同时注解同一个方法

@Controller
public class ModelAttribute4Controller{
	
    // 这时这个方法的返回值并不是表示一个视图名称，而是model属性的值，
     //视图名称是@RequestMapping的value值。
    // Model属性名称由@ModelAttribute(value="")指定，相当于在request中封装了
    //username（key）=admin（value）。
	@RequestMapping(value="/login")
	@ModelAttribute(value="username")
	 public String login() {
		 return "admin";
	 }
}

此时login方法的返回值不在是一个视图的名称，而是model属性的值，视图的名称仍然是@RequestMapping的value值"/login"。处理结束后页面继续跳转到login.jsp。

注释一个方法的参数

@Controller
public class ModelAttribute5Controller{
    @RequestMapping(value="/login")
    public String login(@ModelAttribute("user") User user) {
    user.setUsername("管理员");
        return "result";
    }
}

 

posted @ 2022-02-15 20:22  hanease  阅读(1689)  评论(0)  编辑  收藏  举报