[关闭]
@MrXiao 2018-03-05T14:25:12.000000Z 字数 11271 阅读 1084

Spring MVC(1)——入门

Spring SpringMVC

原文地址
Spring MVC全称是Spring Web MVC,是spring框架中的一部分，与struts一样是一个表现层框架。

Spring MVC是当前最优秀的MVC框架，自从Spring2.5版本发布后，由于支持注解配置，易用性有了大幅度的提高。Spring3.0更加完善，实现了对Struts2的超越。现在越来越多的开发团队选择了Spring MVC。
<--more-->
此处输入图片的描述

1、Spring MVC与Struts2对比!

  1. 加载机制：SpringMVC入口是servlet,Struts2入口是filter;servlet与filter区别
  2. 性能：SpringMVC优于Struts2
    Struts2基于类设计，每次请求实例化一个action对象，对应一个request上下文；
    SpringMVC基于方法设计，每次请求实例化一个方法对象，每个方法独享request上下文。
  3. 参数传递：
    Struts2使用类变量接收参数，多个方法共享；
    SpringMVC使用请求参数获取，方法独享
  4. 框架继承：spring MVC和Spring是无缝(无缝：无须数据格式转换，直接访问来自数据源数据格式)的。从这个项目的管理和安全上也比Struts2高。
  5. 拦截机制：spring mvc用的是独立的AOP方式实现，而struts2有自己的interceptor机制，这样导致了struts2的配置文件量又比spring mvc大。
  6. Restful架构实现：
    spring mvc用的是独立的AOP方式实现，而struts2有自己的interceptor机制，这样导致了struts2的配置文件量又比spring mvc大；
    spring mvc用的是独立的AOP方式实现，而struts2有自己的interceptor机制，这样导致了struts2的配置文件量又比spring mvc大。

2、SpringMVC运行流程

此处输入图片的描述

  1. 用户发送请求至前端控制器DispatcherServlet
  2. DispatcherServlet收到请求调用HandlerMapping处理器映射器查找Handler。
  3. 处理器映射器根据请求url找到具体的处理器，生成处理器对象及处理器拦截器(如果有则生成)一并返回给DispatcherServlet。
  4. DispatcherServlet通过HandlerAdapter处理器适配器调用处理器
  5. HandlerAdapter调用处理器Handler
  6. Handler执行完成返回ModelAndView
  7. HandlerAdapter将Handler执行结果ModelAndView返回给DispatcherServlet
  8. DispatcherServlet将ModelAndView传给ViewReslover视图解析器，ViewReslover根据逻辑视图名解析View
  9. ViewReslover返回View
  10. DispatcherServlet对View进行渲染视图（即将模型数据填充至request域）。
  11. DispatcherServlet响应用户

从以上流程可以看出几个主要的部件：

  1. 前端控制器DispatcherServlet(SpringMVC提供)
    作用：接收请求，相应结果
    有了前端控制器减少各各组件之间的耦合性，前端控制器相关于中央调度器
  2. 处理器映射器HandlerMapping(SpringMVC提供)
    作用：根据url查找Handler，比如：根据xml配置、注解方式查找Handler
  3. 处理器适配器HandlerAdapter(SpringMVC提供)
    作用：执行Handler
    不同类型的Handler有不同的HandlerAdapter，好处可以通过扩展HandlerAdapter支持更多类型的Handler。
  4. 处理器Handler（由程序员开发）
    作用：业务处理
    实现开发中又称为controller即后端控制器
    Handler的开发按照HandlerAdapter的接口规则去开发。
    Handler处理后的结果是ModelAndView，是springmvc的底层对象，包括Model和view两个部分。view中只包括一个逻辑视图名（为了方便开发起一个简单的视图名称）。
  5. ViewReslover视图解析（springmvc框架提供）
    作用：根据逻辑视图名创建一个View对象（包括真实视图物理地址）
    针对不同类型的view有不同类型的ViewReslover，常用的有jsp视图解析器即jstlView
  6. View视图（由程序员开发）
    作用：将模型数据填充进来(将model数据填充到request域)显示给用户
    view是一个接口，实现类包括：jstlView、freemarkerView，pdfView

3、案例搭建

使用maven构建基本工程结构

3.1 创建web项目

3.2 设置jdk版本及servlet环境

细节参见Maven学习与基本使用

3.3 导入jar包,设置pom

  1. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  2.     xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
  3.     <modelVersion>4.0.0</modelVersion>
  4.     <groupId>com.topvision.maven</groupId>
  5.     <artifactId>ssm</artifactId>
  6.     <packaging>war</packaging>
  7.     <version>0.0.1-SNAPSHOT</version>
  8.     <name>ssm Maven Webapp</name>
  9.     <url>http://maven.apache.org</url>
  11.     <!-- 属性 -->
  12.     <properties>
  13.         <spring.version>4.3.12.RELEASE</spring.version>
  14.         <mybatis.version>3.4.5</mybatis.version>
  15.     </properties>
  17.     <!-- 锁定版本 -->
  18.     <dependencyManagement>
  19.         <dependencies>
  20.             <dependency>
  21.                 <groupId>org.springframework</groupId>
  22.                 <artifactId>spring-context</artifactId>
  23.                 <version>${spring.version}</version>
  24.             </dependency>
  25.             <dependency>
  26.             	<groupId>org.springframework</groupId>
  27.             	<artifactId>spring-aspects</artifactId>
  28.             	<version>${spring.version}</version>
  29.             </dependency>
  30.             <dependency>
  31.                 <groupId>org.springframework</groupId>
  32.                 <artifactId>spring-orm</artifactId>
  33.                 <version>${spring.version}</version>
  34.             </dependency>
  35.             <dependency>
  36.             	<groupId>org.springframework</groupId>
  37.             	<artifactId>spring-test</artifactId>
  38.             	<version>${spring.version}</version>
  39.             </dependency>
  40.             <dependency>
  41.                 <groupId>org.springframework</groupId>
  42.                 <artifactId>spring-web</artifactId>
  43.                 <version>${spring.version}</version>
  44.             </dependency>
  45.             <dependency>
  46.             	<groupId>org.springframework</groupId>
  47.             	<artifactId>spring-webmvc</artifactId>
  48.             	<version>${spring.version}</version>
  49.             </dependency>
  50.             <dependency>
  51.                 <groupId>org.mybatis</groupId>
  52.                 <artifactId>mybatis</artifactId>
  53.                 <version>${mybatis.version}</version>
  54.             </dependency>
  55.         </dependencies>
  56.     </dependencyManagement>
  58.     <dependencies>
  59.         <!-- Spring -->
  60.         <dependency>
  61.             <groupId>org.springframework</groupId>
  62.             <artifactId>spring-test</artifactId>
  63.         </dependency>
  64.         <dependency>
  65.             <groupId>org.springframework</groupId>
  66.             <artifactId>spring-context</artifactId>
  67.         </dependency>
  68.         <dependency>
  69.             <groupId>org.springframework</groupId>
  70.             <artifactId>spring-aspects</artifactId>
  71.         </dependency>
  72.         <dependency>
  73.             <groupId>org.springframework</groupId>
  74.             <artifactId>spring-orm</artifactId>
  75.         </dependency>
  76.         <dependency>
  77.             <groupId>org.springframework</groupId>
  78.             <artifactId>spring-web</artifactId>
  79.         </dependency>
  80.         <dependency>
  81.             <groupId>org.springframework</groupId>
  82.             <artifactId>spring-webmvc</artifactId>
  83.         </dependency>
  84.         <dependency>
  85.             <groupId>junit</groupId>
  86.             <artifactId>junit</artifactId>
  87.             <version>3.8.1</version>
  88.             <scope>test</scope>
  89.         </dependency>
  91.         <!-- mybatis -->
  92.         <dependency>
  93.             <groupId>org.mybatis</groupId>
  94.             <artifactId>mybatis</artifactId>
  95.         </dependency>
  96.         <dependency>
  97.             <groupId>org.mybatis</groupId>
  98.             <artifactId>mybatis-spring</artifactId>
  99.             <version>1.3.1</version>
  100.         </dependency>
  102.         <!-- mysql驱动 -->
  103.         <dependency>
  104.             <groupId>mysql</groupId>
  105.             <artifactId>mysql-connector-java</artifactId>
  106.             <version>5.1.6</version>
  107.             <scope>runtime</scope>
  108.         </dependency>
  110.         <!-- c3p0 -->
  111.         <dependency>
  112.             <groupId>c3p0</groupId>
  113.             <artifactId>c3p0</artifactId>
  114.             <version>0.9.1.2</version>
  115.         </dependency>
  116.         <!-- slf4j -->
  117.         <dependency>
  118.             <groupId>org.slf4j</groupId>
  119.             <artifactId>slf4j-log4j12</artifactId>
  120.             <version>1.7.2</version>
  121.         </dependency>
  122.         <!-- junit -->
  123.         <dependency>
  124.             <groupId>junit</groupId>
  125.             <artifactId>junit</artifactId>
  126.             <version>4.9</version>
  127.             <scope>test</scope>
  128.         </dependency>
  129.         <!-- jstl -->
  130.         <dependency>
  131.             <groupId>javax.servlet</groupId>
  132.             <artifactId>jstl</artifactId>
  133.             <version>1.2</version>
  134.         </dependency>
  136.         <!-- servlet jsp -->
  137.         <dependency>
  138.             <groupId>javax.servlet</groupId>
  139.             <artifactId>servlet-api</artifactId>
  140.             <version>2.5</version>
  141.             <scope>provided</scope>
  142.         </dependency>
  143.         <dependency>
  144.             <groupId>javax.servlet</groupId>
  145.             <artifactId>jsp-api</artifactId>
  146.             <version>2.0</version>
  147.             <scope>provided</scope>
  148.         </dependency>
  149.     </dependencies>
  151.     <build>
  152.         <plugins>
  153.             <plugin>
  154.                 <groupId>org.apache.maven.plugins</groupId>
  155.                 <artifactId>maven-compiler-plugin</artifactId>
  156.                 <configuration>
  157.                     <source>1.8</source>
  158.                     <target>1.8</target>
  159.                     <encoding>UTF-8</encoding>
  160.                 </configuration>
  161.             </plugin>
  162.         </plugins>
  164.         <finalName>ssm</finalName>
  165.     </build>
  166. </project>

3.4 配置前端控制器

关键：在web.xml配置springmvc的前端控制器

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  3.     xmlns="http://java.sun.com/xml/ns/javaee" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
  4.     xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
  5.     id="WebApp_ID" version="2.5">
  8.     <servlet>
  9.         <servlet-name>springDispatcherServlet</servlet-name>
  10.         <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
  11.         <init-param>
  12.             <!--若不配置此项，默认加载/WEB-INF/[servlet的名字]-servlet.xml-->
  13.             <param-name>contextConfigLocation</param-name>
  14.             <param-value>classpath:springmvc.xml</param-value>
  15.         </init-param>
  16.         <load-on-startup>1</load-on-startup>
  17.     </servlet>
  18.     <servlet-mapping>
  19.         <servlet-name>springDispatcherServlet</servlet-name>
  20.         <!--
  21.         *.action或*.do等等，以其结尾的url由springmvc来解析
  22.         / 所有请求都由springmvc解析，单静态资源的请求（html,css,js）由其解析是不对的
  23.         /* 此种配置方式不对，当转到jsp页面，springmvc会去解析jsp页面路径地址，无法解析成功
  24.         -->
  25.         <url-pattern>*.action</url-pattern>
  26.     </servlet-mapping>
  27. </web-app>

3.5 配置处理器映射器

在3.4设置的地址下新建对应的xml文件，一般在classpath下新建springmvc.xml

在springmvc.xml中配置处理器映射器。（有多种）

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:mvc="http://www.springframework.org/schema/mvc"
  4.     xmlns:context="http://www.springframework.org/schema/context"
  5.     xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
  6.     xsi:schemaLocation="http://www.springframework.org/schema/beans 
  7.         http://www.springframework.org/schema/beans/spring-beans-3.0.xsd 
  8.         http://www.springframework.org/schema/mvc 
  9.         http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd 
  10.         http://www.springframework.org/schema/context 
  11.         http://www.springframework.org/schema/context/spring-context-3.0.xsd 
  12.         http://www.springframework.org/schema/aop 
  13.         http://www.springframework.org/schema/aop/spring-aop-3.0.xsd 
  14.         http://www.springframework.org/schema/tx 
  15.         http://www.springframework.org/schema/tx/spring-tx-3.0.xsd">
  17.         <!-- 处理器映射器,选择其中之一即可-->
  18.         <!--根据handel的名字来匹配url-->
  19.         <bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"/>
  21.         <!--升级版-->
  22.         <!--根据handel的id来匹配url-->
  23.         <bean class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
  24.         <property name="mappings">
  25.             <props>
  26.                 <prop key="/ItemsList2.action">itemsController</prop>
  27.                 <prop key="/ItemsList3.action">itemsController</prop>
  28.             </props>
  29.         </property>
  30.     </bean>
  31. </beans>

3.6 配置处理器适配器

开发Handel必须按照处理器适配器接口规则去开发，先要确定使用哪个处理器适配器。
此处使用SimpleControllerHandlerAdapter。

  1. <!-- 处理器适配器 -->
  2. <bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"/>

通过源码分析得出：

  1. public boolean supports(Object handler) {
  2.     return (handler instanceof Controller);
  3. }

只要实现了Controller接口的bean，SimpleControllerHandlerAdapter都可以去执行。

还有一个非注解适配器HttpRequestHandlerAdapter，只要实现HttpRequestHandler接口即可。

3.7 开发及配置Handel

  1. public class ItemsController1 implements Controller {
  3.     @Override
  4.     public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
  5.         // 调用service查询商品信息
  6.         // 这里不调用service使用静态数据模拟
  7.         List<Items> itemsList = new ArrayList<Items>();
  9.         Items items_2 = new Items();
  10.         items_2.setName("苹果手机");
  11.         items_2.setPrice(9688f);
  12.         items_2.setDetail("iphoneX苹果手机！");
  14.         itemsList.add(items_1);
  15.         itemsList.add(items_2);
  17.         ModelAndView modelAndView = new ModelAndView();
  18.         //此方法相当于request.setAttribute(arg0, arg1)
  19.         modelAndView.addObject(itemsList);
  20.         //指定视图地址
  21.         modelAndView.setViewName("/WEB-INF/jsp/itemsList.jsp");
  23.         return modelAndView;
  24.     }
  25. }

3.8 配置视图解析器

使用jsp视图解析器，在springmvc.xml中配置如下：

  1. <!-- ViewResolver -->
  2. <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
  3.     <!--设置统一的前后缀-->
  4.     <property name="prefix" value="/WEB-INF/jsp/"/>
  5.     <property name="suffix" value=".jsp"/>
  6. </bean>

更改Handle代码，使用逻辑视图名:

  1. //指定视图地址
  2. //modelAndView.setViewName("/WEB-INF/jsp/itemsList.jsp");
  3. modelAndView.setViewName("itemList");

3.9 配置jsp视图

在web-inf/jsp下，创建itemList.jsp

4、注解开发

4.1 注解的处理器映射器和适配器

注解的处理器映射器：
spring3.1之前使用org.springframework.web.servlet.mvc.annotation.DefaultAnnotationHandlerMapping
spring3.1之后使用org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping;

注解的处理器适配器：
spring3.1之前使用
org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter
3.1之后使用
org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter

在springmvc.xml中配置：

  1. <!-- 注解的处理器映射器和适配器 -->
  2. <!-- 
  3. <bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping"/>
  4. <bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter" />
  5. -->
  6. <!-- 简写 -->
  7. <mvc:annotation-driven/>

4.2 注解开发Handle

注解处理器映射器和注解处理器适配器要配对使用，对标记@controller注解类中的标记有@RequestMapping方法进行映射和执行。
@controller标记此类是一个控制器
@RequestMapping：对url和Handler中的方法进行映射。

  1. @Controller
  2. public class ItemsController2 {
  4.     @RequestMapping("/itemsList4")
  5.     public ModelAndView itemList4() {
  6.         // 调用service查询商品信息
  7.         // 这里不调用service使用静态数据模拟
  8.         List<Items> itemsList = new ArrayList<Items>();
  10.         Items items_1 = new Items();
  11.         items_1.setName("联想笔记本");
  12.         items_1.setPrice(6000f);
  13.         items_1.setDetail("ThinkPad T430 联想笔记本电脑！");
  15.         Items items_2 = new Items();
  16.         items_2.setName("苹果手机");
  17.         items_2.setPrice(5000f);
  18.         items_2.setDetail("iphone6苹果手机！");
  20.         itemsList.add(items_1);
  21.         itemsList.add(items_2);
  23.         ModelAndView modelAndView = new ModelAndView();
  24.         // 此方法相当于request.setAttribute(arg0, arg1)
  25.         modelAndView.addObject(itemsList);
  26.         // 指定视图地址
  27.         // modelAndView.setViewName("/WEB-INF/jsp/itemsList.jsp");
  28.         modelAndView.setViewName("itemsList");
  30.         return modelAndView;
  31.     }
  32. }

4.3 在spring容器中配置Handle

为方便配置，采用注解扫描的方式。

  1. <!-- 可以扫描标记有@controller、@service、@repository、@component的bean -->
  2. <context:component-scan base-package="com.topvision.ssm"></context:component-scan>
添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注