SpringMVC第一天
框架课程
1. 课程计划
第一天
1、SpringMVC介绍
2、入门程序
3、SpringMVC架构讲解
a) 框架结构
b) 组件说明
4、SpringMVC整合MyBatis
5、参数绑定
a) SpringMVC默认支持的参数类型
b) 简单数据类型
c) Pojo类型
d) Pojo包装类型
e) 自定义类型转换器
6、SpringMVC和Struts2的区别（了解）
第二天
1、高级参数绑定
a) 数组类型的参数绑定
b) List类型的绑定
2、@RequestMapping注解的使用
3、Controller方法返回值
4、SpringMVC中异常处理
5、图片上传处理
6、Json数据交互
7、SpringMVC实现RESTful
8、拦截器
2. SpringMVC入门
2.1. SpringMVC是什么？
Spring web MVC和Struts2都属于表现层的框架,它是Spring框架的一部分,我们可以从Spring的整体结构中看得出来：
2.2. SpringMVC处理流程
2.3. 入门程序
需求：使用浏览器显示商品列表
2.3.1. 创建Web工程
SpringMVC是表现层框架，需要搭建web工程开发。
n 新建maven工程
n 选择工程位置
n 配置工程坐标
n 生成web.xml文件
n 效果如下：
n 配置maven工程Java编译版本
<!-- 设置编译版本为1.7 -->
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<configuration>
<source>1.7</source>
<target>1.7</target>
<encoding>UTF-8</encoding>
</configuration>
</plugin>
2.3.2. 引入Jar坐标
<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>4.1.3.RELEASE</version>
</dependency>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>servlet-api</artifactId>
<version>2.5</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>jstl</groupId>
<artifactId>jstl</artifactId>
<version>1.2</version>
</dependency>
</dependencies>
2.3.3. 加入配置文件
在src/main/resources目录下创建配置文件
2.3.3.1. 创建springmvc.xml
在resources目录下创建SpringMVC的核心配置文件springmvc.xml。SpringMVC本身就是Spring的一个子项目，对Spring兼容性很好，所以SpringMVC的Controller扫描使用的就是Spring的<context:component-scan/>标签。
<?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:p="http://www.springframework.org/schema/p"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:mvc="http://www.springframework.org/schema/mvc"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.1.xsd
http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.1.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.1.xsd">
<!-- 配置controller扫描包 -->
<context:component-scan
base-package="com.itheima.springmvc.controller"/>
</beans>
创建包com.itheima.springmvc.controller
2.3.3.2. 配置前端控制器
配置SpringMVC的前端控制器DispatcherServlet
在web.xml中配置
<?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_2_5.xsd"
id="WebApp_ID" version="2.5">
<display-name>springmvc01_quickstart</display-name>
<welcome-file-list>
<welcome-file>index.html</welcome-file>
<welcome-file>index.htm</welcome-file>
<welcome-file>index.jsp</welcome-file>
<welcome-file>default.html</welcome-file>
<welcome-file>default.htm</welcome-file>
<welcome-file>default.jsp</welcome-file>
</welcome-file-list>
<!-- 配置SpringMVC前端控制器 -->
<servlet>
<servlet-name>springmvc01-quickstart</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet
</servlet-class>
<!-- 指定SpringMVC配置文件 -->
<!-- SpringMVC的配置文件的默认路径是/WEB-INF/${servlet-name}-servlet.xml -->
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:springmvc.xml</param-value>
</init-param>
</servlet>
<servlet-mapping>
<servlet-name>springmvc01-quickstart</servlet-name>
<!-- 设置所有以action结尾的请求进入SpringMVC -->
<url-pattern>*.action</url-pattern>
</servlet-mapping>
</web-app>
2.3.4. 加入Jsp页面
把资料中的itemList.jsp复制到工程的/WEB-INF/jsp目录下。
2.3.5. 实现显示商品列表页
2.3.5.1. 创建Pojo
分析页面，查看页面需要的数据
创建商品Pojo
public class Item {
// 构造器
// 商品id
private int id;
// 商品名称
private String name;
// 商品价格
private double price;
// 商品创建时间
private Date createtime;
// 商品描述
private String detail;
创建带参数的构造器
set/get。。。
}
2.3.5.2. 创建ItemController
ItemController是一个普通的java类，不需要实现任何接口。
需要在类上添加@Controller注解，把Controller交由Spring管理
在方法上面添加@RequestMapping注解，里面指定请求的url。其中“.action”可以加也可以不加。
@Controller
public class ItemController {
// @RequestMapping：里面放的是请求的url，和用户请求的url进行匹配
// action可以写也可以不写
@RequestMapping("/itemList.action")
public ModelAndView queryItemList() {
// 创建页面需要显示的商品数据
List<Item> list = new ArrayList<>();
list.add(new Item(1, "1华为 荣耀8", 2399, new Date(), "质量好！1"));
list.add(new Item(2, "2华为 荣耀8", 2399, new Date(), "质量好！2"));
list.add(new Item(3, "3华为 荣耀8", 2399, new Date(), "质量好！3"));
list.add(new Item(4, "4华为 荣耀8", 2399, new Date(), "质量好！4"));
list.add(new Item(5, "5华为 荣耀8", 2399, new Date(), "质量好！5"));
list.add(new Item(6, "6华为 荣耀8", 2399, new Date(), "质量好！6"));
// 创建ModelAndView，用来存放数据和视图
ModelAndView modelAndView = new ModelAndView();
// 设置数据到模型中
modelAndView.addObject("itemList", list);
// 设置视图jsp，需要设置视图的物理地址
modelAndView.setViewName("/WEB-INF/jsp/itemList.jsp");
return modelAndView;
}
}
2.3.6. 启动项目测试
n 添加Tomcat
点击Finish结束
n 发布项目
点击Finish结束后，在新创建的server上右键，选择Add and Remove，如下：
把工程springmvc01_quickstart移动到右侧Configured中，点击Finish结束
选中server，然后启动server
浏览器访问地址
http://127.0.0.1:8080/springmvc01_quickstart/itemList.action
为什么可以用呢？我们需要分析一下SpringMVC的架构图。
3. SpringMVC架构
3.1. 框架结构
3.2. 架构流程
第一步：用户发送请求至前端控制器DispatcherServlet
第二步：DispatcherServlet收到请求调用HandlerMapping处理器映射器 HandlerMapping是map结构 key是url value是对应的controller或者说是handler
第三步：处理器映射器根据请求Url找到具体的Handler（后端控制器），生成处理器对象及处理器拦截器(如果有则生成)一并返回DispatcherServlet
第四步：DispatcherServlet调用HandlerAdapter处理器适配器去调用Handler
第五步：处理器适配器执行Handler
第六步：Handler执行完成给处理器适配器返回ModelAndView
第七步：处理器适配器向前端控制器返回 ModelAndView，ModelAndView 是SpringMVC 框架的一个底层对象，包括 Model 和 View 通过addObject("list",list) 封装模型, 和setviewName("视图路径") 视图
第八步：前端控制器请求视图解析器去进行视图解析
根据逻辑视图名来解析真正的视图。 视图解析器在web.xml中提前配置好前缀和后缀. 无需加上视图的绝对路径. 只需要相对就可以
第九步：视图解析器向前端控制器返回View
第十步：前端控制器进行视图渲染
就是将模型数据（在 ModelAndView 对象中）填充到 request 域
第十一步：前端控制器向用户响应结果
3.3. 组件说明
n DispatcherServlet：前端控制器
接收用户请求，响应结果，相当于中央处理器，DispatcherServlet是整个流程控制的中心，由它调用其它组件完成用户请求的处理。DispatcherServlet的存在降低了组件之间的耦合性。
n HandlerMapping：处理器映射器
HandlerMapping负责根据用户请求的Url找到Handler即处理器，SpringMVC提供了不同的映射器来实现不同的映射方式，例如：实现接口方式，注解方式等。
n Handler：处理器
Handler相对于前端控制器DispatcherServlet来说是后端控制器，执行具体业务处理的，它在DispatcherServlet的控制下处理用户的具体请求。
由于Handler涉及到具体的用户业务请求，所以一般情况需要程序员根据业务需求开发Handler。
n HandlAdapter：处理器适配器
通过HandlerAdapter对Handler处理器进行执行，这是适配器模式的应用。 不论你是啥样是数据统统转成modelAndView
n ViewResolver：视图解析器
ViewResolver进行视图解析，首先根据逻辑视图名解析成物理视图名即具体的页面地址，再生成View视图对象。
n View：视图
SpringMVC框架提供了很多的View视图类型的支持，包括：jsp、freemarkerView等。我们最常用的视图就是jsp。
一般情况下需要通过页面标签或页面模版技术将模型数据通过页面展示给用户，需要由程序员根据业务需求开发具体的页面。
|
说明：在SpringMVC的各个组件中，处理器映射器、处理器适配器、视图解析器称为SpringMVC的三大组件。 需要用户开发的组件有handler、view |
3.4. 框架默认加载组件
我们没有做任何配置，就可以使用这些组件
因为框架已经默认加载这些组件了
# 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
3.5. 注解映射器和注解适配器
3.5.1. 配置注解映射器
注解式处理器映射器，对类中标记了@ResquestMapping的方法进行映射。根据@ResquestMapping定义的url匹配@ResquestMapping标记的方法，匹配成功返回HandlerMethod对象给前端控制器。
HandlerMethod对象中封装url对应的方法Method。
从Spring3.2版本开始，推荐使用RequestMappingHandlerMapping完成注解式处理器映射。
在springmvc.xml配置文件中配置如下：
<!-- 配置处理器映射器 -->
<bean
class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping" />
注解描述：
@RequestMapping：定义请求url到处理器的映射
3.5.2. 配置注解适配器
注解式处理器适配器，对标记@ResquestMapping的方法进行适配。
从spring3.2版本开始，推荐使用RequestMappingHandlerAdapter完成注解式处理器适配。
在springmvc.xml配置文件中配置如下：
<!-- 配置处理器适配器 -->
<bean
class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter" />
3.5.3. 注解驱动
直接配置处理器映射器和处理器适配器比较麻烦，可以使用注解驱动来加载。
SpringMVC使用<mvc:annotation-driven>自动加载RequestMappingHandlerMapping和RequestMappingHandlerAdapter
可以在springmvc.xml配置文件中使用<mvc:annotation-driven>替代注解处理器和适配器的配置。
<!-- 注解驱动 -->
<mvc:annotation-driven />
3.6. 视图解析器
视图解析器使用SpringMVC框架默认的InternalResourceViewResolver，这个视图解析器支持JSP视图解析
在springmvc.xml配置文件中配置如下：
<!-- Example: prefix="/WEB-INF/jsp/", suffix=".jsp", viewname="test" ->
"/WEB-INF/jsp/test.jsp" -->
<!-- 配置视图解析器 -->
<bean
class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<!-- 配置逻辑视图的前缀 -->
<property name="prefix" value="/WEB-INF/jsp/" />
<!-- 配置逻辑视图的后缀 -->
<property name="suffix" value=".jsp" />
</bean>
逻辑视图名需要在Controller中返回ModelAndView指定，比如逻辑视图名为itemList，则最终返回的jsp视图地址：WEB-INF/jsp/itemList.jsp
最终jsp物理地址：前缀+逻辑视图名+后缀
3.6.1. 修改ItemController
修改ItemController中设置视图的代码
// @RequestMapping：里面放的是请求的url，和用户请求的url进行匹配
// action可以写也可以不写
@RequestMapping("/itemList.action")
public ModelAndView queryItemList() {
// 创建页面需要显示的商品数据
List<Item> list = new ArrayList<>();
list.add(new Item(1, "1华为 荣耀8", 2399, new Date(), "质量好！1"));
list.add(new Item(2, "2华为 荣耀8", 2399, new Date(), "质量好！2"));
list.add(new Item(3, "3华为 荣耀8", 2399, new Date(), "质量好！3"));
list.add(new Item(4, "4华为 荣耀8", 2399, new Date(), "质量好！4"));
list.add(new Item(5, "5华为 荣耀8", 2399, new Date(), "质量好！5"));
list.add(new Item(6, "6华为 荣耀8", 2399, new Date(), "质量好！6"));
// 创建ModelAndView，用来存放数据和视图
ModelAndView modelAndView = new ModelAndView();
// 设置数据到模型中
modelAndView.addObject("itemList", list);
// 设置视图jsp，需要设置视图的物理地址
// modelAndView.setViewName("/WEB-INF/jsp/itemList.jsp");
// 配置好视图解析器前缀和后缀，这里只需要设置逻辑视图就可以了。
// 视图解析器根据前缀+逻辑视图名+后缀拼接出来物理路径
modelAndView.setViewName("itemList");
return modelAndView;
}
3.6.2. 效果
效果和之前一样：
4. 整合MyBatis
为了更好的学习 SpringMVC和MyBatis整合开发的方法，需要将SpringMVC和MyBatis进行整合。
整合目标：控制层采用SpringMVC、持久层使用MyBatis实现。
4.1. 创建数据库表
Sql脚本：
创建数据库springmvc，导入到数据库中：
4.2. 整合引入的Jar包
n Log4j日志jar包
n Mysql的数据库驱动jar包
n Mybatis的jar包
n Junit测试jar包
n Spring的jar包（包括SpringMVC）
n Spring+Mybatis的整合包
n 数据库连接池jar包
4.3. 整合思路
Dao层：
1、SqlMapConfig.xml（和Spring整合之后SqlMapConfig.xml不是必需的）
2、applicationContext-dao.xml
a) 数据库连接池
b) SqlSessionFactory对象，需要spring和mybatis整合包下的。
c) 配置mapper文件扫描器。
Service层：
1、applicationContext-service.xml包扫描器，扫描添加了@service注解的类。
2、applicationContext-trans.xml配置事务。
Controller层：
1、Springmvc.xml
a) 包扫描器，扫描添加了@Controller注解的类。
b) 配置注解驱动
c) 配置视图解析器
Web.xml文件：
1、配置spring
2、配置SpringMVC前端控制器。
4.4. 创建工程
新建maven工程，打包方式为war
n 配置Maven工程Java编译版本
<!-- 设置编译版本为1.7 -->
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<configuration>
<source>1.7</source>
<target>1.7</target>
<encoding>UTF-8</encoding>
</configuration>
</plugin>
4.5. 引入Jar坐标
<properties>
<junit.version>4.12</junit.version>
<log4j.version>1.2.17</log4j.version>
<mysql.version>5.1.46</mysql.version>
<mybatis.version>3.2.7</mybatis.version>
<dbcp.version>1.4</dbcp.version>
<mybatis.spring.version>1.2.2</mybatis.spring.version>
<spring.version>4.1.3.RELEASE</spring.version>
<jstl.version>1.2</jstl.version>
<aspectjweaver.version>1.6.8_2</aspectjweaver.version>
</properties>
<dependencies>
<!-- junit测试包 -->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>${junit.version}</version>
<scope>test</scope>
</dependency>
<!-- log4j日志包 -->
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>${log4j.version}</version>
</dependency>
<!--mysql依赖包 -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>${mysql.version}</version>
</dependency>
<!--mybatis依赖包 -->
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>${mybatis.version}</version>
</dependency>
<!--Mybatis+Spring整合 -->
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis-spring</artifactId>
<version>${mybatis.spring.version}</version>
</dependency>
<!-- 数据库连接池 -->
<dependency>
<groupId>commons-dbcp</groupId>
<artifactId>commons-dbcp</artifactId>
<version>${dbcp.version}</version>
</dependency>
<!-- Spring:依赖注入IoC与DI的最基本实现 -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<version>${spring.version}</version>
</dependency>
<!-- Spring:Bean工厂与bean的装配 -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-beans</artifactId>
<version>${spring.version}</version>
</dependency>
<!-- Spring:spring的context上下文即IoC容器 -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>${spring.version}</version>
</dependency>
<!-- Spring:jdbc的支持 -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>${spring.version}</version>
</dependency>
<!-- Spring:test的支持 -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>${spring.version}</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>jstl</groupId>
<artifactId>jstl</artifactId>
<version>${jstl.version}</version>
</dependency>
<dependency>
<groupId>org.apache.geronimo.bundles</groupId>
<artifactId>aspectjweaver</artifactId>
<version>${aspectjweaver.version}</version>
</dependency>
</dependencies>
4.6. 加入配置文件
在src/main/resources文件夹下添加配置文件
4.6.1. log4j.properties
在src/main/resources下创建log4j.properties文件，配置日志信息
# Global logging configuration
log4j.rootLogger=DEBUG, stdout
# Console output...
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%5p [%t] - %m%n
4.6.2. SqlMapConfig.xml（非必需，此处略）
4.6.3. applicationContext-dao.xml
在src/main/resources文件夹下新建spring文件夹，并在spring文件夹下创建
applicationContext-dao.xml文件配置数据源、配置SqlSessionFactory、mapper扫描器
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:context="http://www.springframework.org/schema/context" xmlns:p="http://www.springframework.org/schema/p"
xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.1.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.1.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.1.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.1.xsd
http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.1.xsd">
<!-- 加载配置文件 -->
<context:property-placeholder location="classpath:db.properties"/>
<!-- 数据库连接池 -->
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"
destroy-method="close">
<property name="driverClassName" value="${jdbc.driver}" />
<property name="url" value="${jdbc.url}" />
<property name="username" value="${jdbc.username}" />
<property name="password" value="${jdbc.password}" />
<property name="maxActive" value="10" />
<property name="maxIdle" value="5" />
</bean>
<!-- 配置SqlSessionFactory -->
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
<!-- 数据库连接池 -->
<property name="dataSource" ref="dataSource" />
<property name="typeAliasesPackage" value="com.itheima.ssm.pojo" />
</bean>
<!-- 配置Mapper扫描 -->
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
<!-- 配置Mapper扫描包 -->
<property name="basePackage" value="com.itheima.ssm.mapper" />
</bean>
</beans>
4.6.4. db.properties
在src/main/resources目录下创建db.properties文件，配置数据库连接信息
jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://127.0.0.1:3306/springmvc?characterEncoding=utf-8
jdbc.username=root
jdbc.password=root
4.6.5. applicationContext-service.xml
在spring文件夹下创建applicationContext-service.xml文件，配置service层信息
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:context="http://www.springframework.org/schema/context" xmlns:p="http://www.springframework.org/schema/p"
xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.1.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.1.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.1.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.1.xsd
http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.1.xsd">
<!-- 配置service扫描 -->
<context:component-scan base-package="com.itheima.ssm.service" />
</beans>
4.6.6. applicationContext-trans.xml
在spring文件夹下创建applicationContext-trans.xml文件，配置事务信息
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:context="http://www.springframework.org/schema/context" xmlns:p="http://www.springframework.org/schema/p"
xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.1.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.1.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.1.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.1.xsd
http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.1.xsd">
<!-- 事务管理器 -->
<bean id="transactionManager"
class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<!-- 数据源 -->
<property name="dataSource" ref="dataSource" />
</bean>
<!-- 事务注解驱动 -->
<tx:annotation-driven transaction-manager="transactionManager"/>
</beans>
4.6.7. springmvc.xml
在spring文件夹下创建springmvc.xml文件，内容如下
<?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:p="http://www.springframework.org/schema/p"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:mvc="http://www.springframework.org/schema/mvc"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.1.xsd
http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.1.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.1.xsd">
<!-- 配置controller扫描包 -->
<context:component-scan base-package="com.itheima.ssm.controller" />
<!-- 注解驱动 -->
<mvc:annotation-driven />
<!-- Example: prefix="/WEB-INF/jsp/", suffix=".jsp", viewname="test" ->
"/WEB-INF/jsp/test.jsp" -->
<bean
class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<!-- 配置逻辑视图的前缀 -->
<property name="prefix" value="/WEB-INF/jsp/" />
<!-- 配置逻辑视图的后缀 -->
<property name="suffix" value=".jsp" />
</bean>
</beans>
4.6.8. web.xml
<?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_2_5.xsd"
id="WebApp_ID" version="2.5">
<display-name>springmvc01_ssm</display-name>
<welcome-file-list>
<welcome-file>index.html</welcome-file>
<welcome-file>index.htm</welcome-file>
<welcome-file>index.jsp</welcome-file>
<welcome-file>default.html</welcome-file>
<welcome-file>default.htm</welcome-file>
<welcome-file>default.jsp</welcome-file>
</welcome-file-list>
<!-- 配置spring -->
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>
classpath:spring/applicationContext*.xml
</param-value>
</context-param>
<!-- 使用监听器加载Spring配置文件 -->
<listener>
<listener-class>
org.springframework.web.context.ContextLoaderListener
</listener-class>
</listener>
<!-- 配置SrpingMVC的前端控制器 -->
<servlet>
<servlet-name>springmvc01_ssm</servlet-name>
<servlet-class>
org.springframework.web.servlet.DispatcherServlet
</servlet-class>
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:spring/springmvc.xml</param-value>
</init-param>
</servlet>
<servlet-mapping>
<servlet-name>springmvc01_ssm</servlet-name>
<!-- 配置所有以action结尾的请求进入SpringMVC -->
<url-pattern>*.action</url-pattern>
</servlet-mapping>
</web-app>
5. 实现商品列表显示
5.1. 需求
实现商品查询列表，从mysql数据库查询所有商品信息。
5.2. 加入Jsp页面
复制资料的itemList.jsp和itemEdit.jsp到工程中
5.3. Dao层开发
使用逆向工程，生成代码
注意修改逆向工程的配置文件，参考MyBatis第二天
5.4. ItemService接口
public interface ItemService {
/**
* 查询商品列表
*
* @return
*/
List<Item> queryItemList();
}
5.5. ItemServiceImpl实现类
@Service
public class ItemServiceImpl implements ItemService {
@Autowired
private ItemMapper itemMapper;
@Override
public List<Item> queryItemList() {
// 从数据库查询商品数据
List<Item> list = this.itemMapper.selectByExample(null);
return list;
}
}
5.6. ItemController
@Controller
public class ItemController {
@Autowired
private ItemService itemService;
/**
* 显示商品列表
*
* @return
*/
@RequestMapping("/itemList")
public ModelAndView queryItemList() {
// 获取商品数据
List<Item> list = this.itemService.queryItemList();
ModelAndView modelAndView = new ModelAndView();
// 把商品数据放到模型中
modelAndView.addObject("itemList", list);
// 设置逻辑视图
modelAndView.setViewName("itemList");
return modelAndView;
}
}
5.7. 测试
访问url：http://127.0.0.1:8080/springmvc01_ssm/itemList.action
5.8. Model/ModelMap
5.8.1. Model
除了ModelAndView以外，还可以使用Model来向页面传递数据，Model是一个接口，在参数里直接声明model即可。
如果使用Model则可以不使用ModelAndView对象，Model对象可以向页面传递数据，View对象则可以使用String返回值替代。
不管是Model还是ModelAndView，其本质都是使用Request对象向jsp传递数据。
代码实现：
/**
* 根据id查询商品,使用Model
*
* @param request
* @param model
* @return
*/
@RequestMapping("/itemEdit")
public String queryItemById(HttpServletRequest request, Model model) {
// 从request中获取请求参数
String strId = request.getParameter("id");
Integer id = Integer.valueOf(strId);
// 根据id查询商品数据
Item item = this.itemService.queryItemById(id);
// 把结果传递给页面
// ModelAndView modelAndView = new ModelAndView();
// 把商品数据放在模型中
// modelAndView.addObject("item", item);
// 设置逻辑视图
// modelAndView.setViewName("itemEdit");
// 把商品数据放在模型中
model.addAttribute("item", item);
return "itemEdit";
}
5.8.2. ModelMap
ModelMap是Model接口的实现类，也可以通过ModelMap向页面传递数据
使用Model和ModelMap的效果一样，如果直接使用Model，SpringMVC会实例化ModelMap。
代码实现：
/**
* 根据id查询商品,使用ModelMap
*
* @param request
* @param model
* @return
*/
@RequestMapping("/itemEdit")
public String queryItemById(HttpServletRequest request, ModelMap model) {
// 从request中获取请求参数
String strId = request.getParameter("id");
Integer id = Integer.valueOf(strId);
// 根据id查询商品数据
Item item = this.itemService.queryItemById(id);
// 把结果传递给页面
// ModelAndView modelAndView = new ModelAndView();
// 把商品数据放在模型中
// modelAndView.addObject("item", item);
// 设置逻辑视图
// modelAndView.setViewName("itemEdit");
// 把商品数据放在模型中
model.addAttribute("item", item);
return "itemEdit";
}
6. 参数绑定
6.1. 默认支持的参数类型
6.1.1. 需求
打开商品编辑页面，展示商品信息。
6.1.2. 需求分析
编辑商品信息，首先要显示商品详情
需要根据商品id查询商品信息，然后展示到页面。
请求的url：/itemEdit.action
参数：id（商品id）
响应结果：商品编辑页面，展示商品详细信息。
6.1.3. ItemService接口
6.1.4. ItemServiceImpl实现类
@Override
public Item queryItemById(int id) {
Item item = this.itemMapper.selectByPrimaryKey(id);
return item;
}
6.1.5. ItemController
页面点击修改按钮，发起请求
http://127.0.0.1:8080/springmvc-web/itemEdit.action?id=1
需要从请求的参数中把请求的id取出来。
Id包含在Request对象中。可以从Request对象中取id。
想获得Request对象只需要在Controller方法的形参中添加一个参数即可。Springmvc框架会自动把Request对象传递给方法。
代码实现
/**
* 根据id查询商品
*
* @param request
* @return
*/
@RequestMapping("/itemEdit")
public ModelAndView queryItemById(HttpServletRequest request) {
// 从request中获取请求参数
String strId = request.getParameter("id");
Integer id = Integer.valueOf(strId);
// 根据id查询商品数据
Item item = this.itemService.queryItemById(id);
// 把结果传递给页面
ModelAndView modelAndView = new ModelAndView();
// 把商品数据放在模型中
modelAndView.addObject("item", item);
// 设置逻辑视图
modelAndView.setViewName("itemEdit");
return modelAndView;
}
6.1.6. 默认支持的参数类型
处理器形参中添加如下类型的参数处理适配器会默认识别并进行赋值。
6.1.6.1. HttpServletRequest
通过request对象获取请求信息
6.1.6.2. HttpServletResponse
通过response处理响应信息
6.1.6.3. HttpSession
通过session对象得到session中存放的对象
6.2. 绑定简单类型
当请求的参数名称和处理器形参名称一致时会将请求参数与形参进行绑定。
这样，从Request取参数的方法就可以进一步简化。
/**
* 根据id查询商品,绑定简单数据类型
*
* @param id
* @param model
* @return
*/
@RequestMapping("/itemEdit")
public String queryItemById(int id, ModelMap model) {
// 根据id查询商品数据
Item item = this.itemService.queryItemById(id);
// 把商品数据放在模型中
model.addAttribute("item", item);
return "itemEdit";
}
6.2.1. 支持的数据类型
参数类型推荐使用包装数据类型，因为基础数据类型不可以为null
整型：Integer、int
字符串：String
单精度：Float、float
双精度：Double、double
布尔型：Boolean、boolean
说明：对于布尔类型的参数，请求的参数值为true或false。或者1或0
请求url：
http://127.0.0.1:8080/xxx.action?id=2&status=false
处理器方法：
public String editItem(Model model,Integer id,Boolean status)
6.2.2. @RequestParam
使用@RequestParam常用于处理简单类型的绑定。
value：实际请求的参数名字，如value=“itemId”表示把请求中的参数itemId取出来赋值给形参
required：是否必须，默认是true，表示请求中一定要有相应的参数，否则将报错
TTP Status 400 - Required Integer parameter 'XXXX' is not present，一般情况下，既然使用了@RequestParam注解，那就保持required为true
defaultValue：默认值，表示请求中没有同名参数时的默认值，当定义了defaultValue时，required是true还是false无所谓了，因为都会有值且不会报400错误 一般分页的时候 page当前页需要默认值为1
定义如下：
@RequestMapping("/itemEdit")
public String queryItemById(@RequestParam(value = "itemId", required = true, defaultValue = "1") Integer id,
ModelMap modelMap) {
// 根据id查询商品数据
Item item = this.itemService.queryItemById(id);
// 把商品数据放在模型中
modelMap.addAttribute("item", item);
return "itemEdit";
}
6.3. 绑定Pojo类型
6.3.1. 需求
将页面修改后的商品信息保存到数据库中。
6.3.2. 需求分析
请求的url：/updateItem.action
参数：表单中的数据。
响应内容：更新成功页面
6.3.3. 使用pojo接收表单数据
如果提交的参数很多，或者提交的表单中的内容很多的时候,可以使用简单类型接受数据,也可以使用pojo接收数据。
要求：pojo对象中的属性名和表单中input的name属性一致。
页面定义如下：
Pojo(逆向工程已生成)：
请求的参数名称和pojo的属性名称一致，会自动将请求参数赋值给pojo的属性。
6.3.4. ItemService接口
ItemService里编写接口方法
/**
* 根据id更新商品
*
* @param item
*/
void updateItemById(Item item);
6.3.5. ItemServiceImpl实现类
ItemServiceImpl里实现接口方法
使用updateByPrimaryKeySelective(item)方法，忽略空参数
@Override
public void updateItemById(Item item) {
this.itemMapper.updateByPrimaryKeySelective(item);
}
6.3.6. ItemController
/**
* 更新商品,绑定pojo类型
*
* @param item
* @param model
* @return
*/
@RequestMapping("/updateItem")
public String updateItem(Item item) {
// 调用服务更新商品
this.itemService.updateItemById(item);
// 返回逻辑视图
return "success";
}
注意：
提交的表单中不要有日期类型的数据，否则会报400错误。如果想提交日期类型的数据需要用到后面的自定义参数绑定的内容。
6.3.7. 编写success页面
在WEB-INF/jsp下创建success.jsp页面
页面代码：
<%@ 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>
<h1>商品修改成功！</h1>
</body>
</html>
6.3.8. 解决post乱码问题
提交发现，保存成功，但是保存的是乱码
在web.xml中加入：
<!-- 解决post乱码问题 -->
<filter>
<filter-name>encoding</filter-name>
<filter-class>
org.springframework.web.filter.CharacterEncodingFilter
</filter-class>
<!-- 设置编码参是UTF8 -->
<init-param>
<param-name>encoding</param-name>
<param-value>UTF-8</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>encoding</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
以上可以解决post请求乱码问题。
对于get请求中文参数出现乱码解决方法有两个：
修改tomcat配置文件添加编码与工程编码一致，如下：
<Connector URIEncoding="utf-8" connectionTimeout="20000" port="8080" protocol="HTTP/1.1" redirectPort="8443"/>
另外一种方法对参数进行重新编码：
String userName
= new String(request.getParamter("userName").getBytes("ISO8859-1"),"utf-8")
ISO8859-1是tomcat默认编码，需要将tomcat编码后的内容按utf-8编码
6.4. 绑定Pojo包装对象
6.4.1. 需求
使用Pojo包装对象接收商品信息的查询条件。
6.4.2. 需求分析
包装对象定义如下：
public class QueryVo {
private Item item;
set/get。。。
}
页面定义：
6.4.3. 接收查询条件
// 绑定包装数据类型
@RequestMapping("/queryItem")
public String queryItem(QueryVo queryVo) {
System.out.println(queryVo.getItem().getId());
System.out.println(queryVo.getItem().getName());
return "success";
}
6.5. 自定义类型转换器
6.5.1. 需求
在商品修改页面可以修改商品的生产日期，并且根据业务需求自定义日期格式。
6.5.2. 需求分析
由于日期数据有很多种格式，SpringMVC没办法把字符串转换成日期类型。所以在绑定日期类型时需要做类型转换。
前端控制器接收到请求后，找到注解形式的处理器适配器，对RequestMapping标记的方法进行适配，并对方法中的形参进行参数绑定。可以在SpringMVC处理器适配器上自定义Converter（类型转换器）进行类型转换。
一般使用<mvc:annotation-driven/>注解驱动加载处理器适配器，可以在此标签上进行配置。
6.5.3. 修改jsp页面
修改itemEdit.jsp页面，显示时间
6.5.4. 自定义Converter
//Converter<S, T>
//S:source,需要转换的源的类型
//T:target,需要转换的目标类型
public class DateConverter implements Converter<String, Date> {
@Override
public Date convert(String source) {
try {
// 把字符串转换为日期类型
SimpleDateFormat simpleDateFormat
= new SimpleDateFormat("yyy-MM-dd HH:mm:ss");
Date date = simpleDateFormat.parse(source);
return date;
} catch (ParseException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
// 如果转换异常则返回空
return null;
}
}
6.5.5. 配置Converter
<!-- 配置注解驱动 -->
<mvc:annotation-driven conversion-service="conversionService" />
<!-- 转换器配置 -->
<bean id="conversionService" class="org.springframework.format.support.FormattingConversionServiceFactoryBean">
<property name="converters">
<set>
<bean class="com.itheima.ssm.converter.DateConverter"/>
</set>
</property>
</bean>
6.5.6. 配置方式2（了解）
<!-- 配置处理器映射器 -->
<bean
class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping" />
<!--注解适配器 -->
<bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter">
<property name="webBindingInitializer" ref="customBinder">
</property>
</bean>
<!-- 自定义webBinder -->
<bean id="customBinder" class="org.springframework.web.bind.support.ConfigurableWebBindingInitializer">
<property name="conversionService" ref="conversionService" />
</bean>
<!-- 转换器配置 -->
<bean id="conversionService" class="org.springframework.format.support.FormattingConversionServiceFactoryBean">
<property name="converters">
<set>
<bean class="com.itheima.ssm.converter.DateConverter"/>
</set>
</property>
</bean>
注意：此方法需要独立配置处理器映射器、适配器，
不再使用<mvc:annotation-driven/>
7. SpringMVC与Struts2的区别（了解）
1、 SpringMVC的入口是一个Servlet即前端控制器，而Struts2入口是一个Filter过滤器。
2、 SpringMVC直接将请求参数传递给方法的形参，可以设计为单例或多例(建议单例)；Struts2通过类的属性（成员变量）传参，有线程安全问题，只能设计为多例。
3、 Struts2采用值栈存储请求和响应的数据；SpringMVC将Request请求内容解析，给方法形参赋值，将数据和视图封装成ModelAndView对象，最后又将ModelAndView中的模型数据通过Request域传输到页面。