1. 技术文章
  2. SpringMVC框架笔记01_SpringMVC的使用案例和架构组件_SpringMVC和Mybatis整合_接收参数

SpringMVC框架笔记01_SpringMVC的使用案例和架构组件_SpringMVC和Mybatis整合_接收参数

由 只谈情不闲聊 提交于 2019-12-22 06:50:09

目录

第1章：SpringMVC简介

1.1 什么是SpringMVC

  • SpringMVC和Struts2都属于表现层的框架，它是Spring框架的一个组件。

1.2 SpringMVC的处理流程

第2章：SpringMVC入门程序

2.1 场景描述

  • 在浏览器地址栏中输入list.action 跳转到一个商品列表的页面。

2.2 步骤分析

  1. 创建web工程
  2. 添加jar：springMVC、spring、junit
  3. 在web.xml中添加一个DispatcherServlet[前端控制器]。
  4. DispatcherServlet需要初始化一个springMVC容器，所以需要添加springmvc.xml
  5. 创建一个商品pojo
  6. 创建一个jsp页面
  7. 创建一个商品的Controller
    传统方式：实现一个Controller接口
    注解方式：添加一个@Controller标签
  8. 把Controller配置到springmvc.xml中（传统方式）
    开启包扫描（注解方式）
  9. tomcat测试

2.3 步骤一：创建Web项目

2.4 步骤二：导入jar包

2.5 步骤三：在web.xml中配置DispatcherServlet前端控制器

<servlet>
    <servlet-name>springmvc</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <!-- 
        从源码中可以看到前端控制器DispatcherServlet默认会加载/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>springmvc</servlet-name>
    <!-- /* : 过滤所有请求，包含jsp -->
    <!-- /  : 过滤所有请求，不包含jsp  -->
    <!-- *.action : 过滤以.action结尾的请求 -->
    <url-pattern>*.action</url-pattern>
  </servlet-mapping>

2.6 步骤四：创建springmvc.xml配置文件

  • 在工程下新建一个Source Folder文件夹，在此新建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.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-4.2.xsd">
            
</beans>

2.7 步骤五：新建一个商品POJO

  • package com.itzhouq.springmvc.pojo
public class Items {
    private Integer id;
    private String name;
    private Float price;
    private String pic;
    private Date createtime;
    private String detail;
    //set/get方法
}

2.8 步骤六：创建一个jsp页面

  • /SpringMVC_01/WebContent/jsp/itemList.jsp
<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<%@ taglib uri="http://java.sun.com/jsp/jstl/fmt"  prefix="fmt"%>
<!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>查询商品列表</title>
</head>
<body> 
<form action="${pageContext.request.contextPath }/item/queryitem.action" method="post">
查询条件：
<table width="100%" border=1>
<tr>
<td><input type="submit" value="查询"/></td>
</tr>
</table>
商品列表：
<table width="100%" border=1>
<tr>
    <td>商品名称</td>
    <td>商品价格</td>
    <td>生产日期</td>
    <td>商品描述</td>
    <td>操作</td>
</tr>
<c:forEach items="${itemList }" var="item">
<tr>
    <td>${item.name }</td>
    <td>${item.price }</td>
    <td><fmt:formatDate value="${item.createtime}" pattern="yyyy-MM-dd HH:mm:ss"/></td>
    <td>${item.detail }</td>
    
    <td><a href="${pageContext.request.contextPath }/itemEdit.action?id=${item.id}">修改</a></td>

</tr>
</c:forEach>

</table>
</form>
</body>

</html>

2.9 步骤七：创建商品的Controller

2.9.1 传统方式：实现一个Controller接口

  • com.itzhouq.springmvc.controller.ItemsController
package com.itzhouq.springmvc.controller;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.Controller;

import com.itzhouq.springmvc.pojo.Items;

public class ItemsController implements Controller {

    @Override
    public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
//      模拟商品数据
        List<Items> list =new ArrayList<Items>();
        
        for (int i = 0; i < 10; i++) {
            Items items = new Items();
            items.setId(i);
            items.setCreatetime(new Date());
            items.setName("小米手机"+i);
            items.setDetail("国产");
            items.setPrice((float) (1000*i));
            list.add(items);
        }
        
        ModelAndView modelAndView = new ModelAndView();
        modelAndView.addObject("itemList",list); // 相当于把数据放入了request域中
        
        // ViewName逻辑视图：就是jsp路径
        modelAndView.setViewName("/jsp/itemList.jsp");
        
        return modelAndView;
    }
}

2.9.2 注解方式：添加一个@Controller注解

  • 传统开发方式，Controller类中只能有一个方法。这显然不符合实际开发的需要。所以实际开发采用注解方式。
  • com.itzhouq.springmvc.controller.ItemsController2
package com.itzhouq.springmvc.controller;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;

import com.itzhouq.springmvc.pojo.Items;

@Controller
public class ItemsController2{
    
    @RequestMapping("/list")
    public ModelAndView list(HttpServletRequest request, HttpServletResponse response) throws Exception {
//      模拟商品数据
        List<Items> list =new ArrayList<Items>();
        
        for (int i = 0; i < 10; i++) {
            Items items = new Items();
            items.setId(i);
            items.setCreatetime(new Date());
            items.setName("华为手机"+i);
            items.setDetail("也是国产");
            items.setPrice((float) (1000*i));
            list.add(items);
        }
        
        ModelAndView modelAndView = new ModelAndView();
        modelAndView.addObject("itemList",list); // 相当于把数据放入了request域中
        
        // ViewName逻辑视图：就是jsp路径
        modelAndView.setViewName("/jsp/itemList.jsp");
        
        return modelAndView;
    }
}

2.10 把Controller配置到springmvc.xml中

2.10.1 传统方式：实现一个Controller接口的方式的配置

  • 在springmvc.xml中添加以下配置
 <bean name="/list.action" class="com.itzhouq.springmvc.controller.ItemsController">
    
</bean>
  • 测试：开启服务器，访问http://localhost/SpringMVC_01/list.action

  • 流程描述：当在浏览器中输入http://localhost/SpringMVC_01/list.action的时候，请求会首先经过入口web.xml。该文件中有一个前端控制器DispatcherServlet，里面有配置<url-pattern>*.action</url-pattern>。请求符合*.action，所以请求会进入前端控制器中。前端控制器会初始化一个springMVC容器。根据springMVC容器的配置文件spring.xml的配置。
<bean name="/list.action" class="com.itzhouq.springmvc.controller.ItemsController">

</bean>
  • 可以看到请求list.action和name的值相同，所以请求进入到对应的类ItemsController。执行类中的方法，跳转到类中写明的jsp页面。

2.10.2 注解方式：添加一个@Controller注解

  • 要使用注解开发，必须在springmvc.xml中开启注解扫描器。无需配置<bean>。
<!-- 开启注解扫描器 -->
     <context:component-scan base-package="com.itzhouq.springmvc.controller">
     
     </context:component-scan>
  • 测试：开启服务器，访问http://localhost/SpringMVC_01/list.action

  • 注解方式的优势：可以使用注解@RequestMapping("/list")定位ItemsController类中的不同方法，解决传统开发方式的问题。

第3章：SpringMVC的完整架构

3.1 框架结构

3.2 架构流程

  • 流程图

  • 流程描述
1、 用户发送请求至前端控制器DispatcherServlet

2、 DispatcherServlet收到请求调用HandlerMapping处理器映射器。

3、 处理器映射器根据请求url找到具体的处理器，生成处理器对象及处理器拦截器
    (如果有则生成)一并返回给DispatcherServlet。

4、 DispatcherServlet通过HandlerAdapter处理器适配器调用处理器

5、 执行处理器(Controller，也叫后端控制器)。

6、 Controller执行完成返回ModelAndView

7、 HandlerAdapter将controller执行结果ModelAndView返回给DispatcherServlet

8、 DispatcherServlet将ModelAndView传给ViewReslover视图解析器

9、 ViewReslover解析后返回具体View

10、 DispatcherServlet对View进行渲染视图（即将模型数据填充至视图中）。

11、 DispatcherServlet响应用户

3.3 组件说明

  • DispatcherServlet：前端控制器

    用户请求到达前端控制器，它就相当于mvc模式中的c，dispatcherServlet是整个流程控制的中心，由它调用其它组件处理用户的请求，dispatcherServlet的存在降低了组件之间的耦合性。dispatcherServlet有三大组件。

  1. HandlerMapping：处理器映射器

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

    Handler：处理器

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

  • 配置注解开发方式新版本的处理器映射器的方式：在springmvc.xml文件中
<!--    配置最注解开发方式新版本的处理器映射器 -->
 <bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping"/>
</bean>
  1. HandlAdapter`：处理器适配器

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

  • 配置最注解开发方式新版本的处理器适配器方式：在springmvc.xml文件中
<!--配置最注解开发方式新版本的处理器适配器 -->
 <bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter"/>
</bean>
  • 配置最注解开发方式新版本的处理器映射器和处理器适配器的方式可以简化：
<!--    配置最注解开发方式新版本的处理器映射器 
 <bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping"/>
     配置最注解开发方式新版本的处理器适配器 
 <bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter"/>
 -->
<!--  注解驱动 目的：加载新版本的处理器映射器、处理器适配器-->
 <mvc:annotation-driven/>

  1. View Resolver：视图解析器

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

    View：视图

    springmvc框架提供了很多的View视图类型的支持，包括：jstlView、freemarkerView、pdfView等。我们最常用的视图就是jsp。一般情况下需要通过页面标签或页面模版技术将模型数据通过页面展示给用户，需要由程序员根据业务需求开发具体的页面。

    • 在springmvc.xml文件配置如下:
    <!--  配置视图解析器的前缀和后缀 -->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
    <property name="prefix" value="/WEB-INF/jsp/"></property>
    <property name="suffix" value=".jsp"></property>
</bean>

第4章：SpringMVC和Mybatis整合

  • 需求分析：整合SpringMVC和Mybatis，展示商品的列表。

4.1 整合的思路

  • Dao层：
    • sqlMapConfig.xml：可以为空，可以不需要
    • applicationContext-dao.xml：
      1. 数据库连接池
      2. SqlSessionFactory对象，需要在Spring和mybatis整合包下的。
      3. 配置mapper文件扫描器，用来生成代理对象。
  • Service层：
    • application-service.xml：事务管理、包扫描器【扫描@Service注解】
  • 表现层：
    • 包扫描器，扫描@Controller注解的类
    • 配置注解驱动
    • 视图解析器：前缀和后缀
  • web.xml：
    • 前端控制器
    • 监听器
    • 乱码问题解决

4.2 整合的步骤

  1. 创建数据库
  2. 创建web工程
  3. 添加jar包：mybatis、mybatis扩展包、spring、spring和mybatis整合包、junit、springmvc。
  4. 添加配置文件：
    • applicationContext-dao.xml
    • applicationContext-service.xml
    • jdbc.properties
    • log4j.properties
    • springmvc.xml
  5. 持久层开发
  6. 业务层开发：接口+实现类
  7. 表现层开发：注解开发方式

4.3 开始整合

4.3.1 创建数据库和表

  • 新建数据库springmvc，新建查询springmvc.sql。
SET FOREIGN_KEY_CHECKS=0;

-- ----------------------------
-- Table structure for items
-- ----------------------------
DROP TABLE IF EXISTS `items`;
CREATE TABLE `items` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `name` varchar(32) NOT NULL COMMENT '商品名称',
  `price` float(10,1) NOT NULL COMMENT '商品定价',
  `detail` text COMMENT '商品描述',
  `pic` varchar(64) DEFAULT NULL COMMENT '商品图片',
  `createtime` datetime  NOT NULL COMMENT '生产日期',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8;

-- ----------------------------
-- Records of items
-- ----------------------------
INSERT INTO `items` VALUES ('1', '台式机', '3000.0', '该电脑质量非常好！！！！', null, '2016-02-03 13:22:53');
INSERT INTO `items` VALUES ('2', '笔记本', '6000.0', '笔记本性能好，质量好！！！！！', null, '2015-02-09 13:22:57');
INSERT INTO `items` VALUES ('3', '背包', '200.0', '名牌背包，容量大质量好！！！！', null, '2015-02-06 13:23:02');

4.3.2 创建工程

  • 创建工程，导入jar包。

4.3.3 配置文件

  • web.xml：加载applicationContext-*.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>springmvc-mybatis</display-name>
  
  <!-- 过滤器：解决post方式请求的乱码问题 -->
  <filter>
        <filter-name>CharacterEncodingFilter</filter-name>
        <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
        <init-param>
            <param-name>encoding</param-name>
            <param-value>utf-8</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>CharacterEncodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
  
<!--   前端控制器 -->
 <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>*.action</url-pattern>
 </servlet-mapping>
  
<!--   监听器 -->
 <listener>
  <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
 </listener>
 <context-param>
   <param-name>contextConfigLocation</param-name>
   <param-value>classpath:applicationContext-*.xml</param-value>
 </context-param>
  
</web-app>
  • applicationContext-dao.xml：加载数据库配置文件，将映射文件交给Spring容器管理，配置映射器扫描器
<?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.0.xsd
    http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd
    http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd
    http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.0.xsd">

    <!-- 加载配置文件 -->
    <context:property-placeholder location="classpath:jdbc.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>
    <!-- mapper配置 -->
    <!-- 让spring管理sqlsessionfactory 使用mybatis和spring整合包中的 -->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <!-- 数据库连接池 -->
        <property name="dataSource" ref="dataSource" />
        <property name="typeAliasesPackage" value="com.itzhouq.ssm.pojo"></property>
    </bean>

<!-- mapper扫描器 ：用来产生代理对象-->
     <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
       <property name="basePackage" value="com.itzhouq.ssm.mapper"></property>
     </bean>
</beans>
  • applicationContext-service.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.0.xsd
    http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd
    http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd
    http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.0.xsd">

    <!-- 包扫描器 -->
    <context:component-scan base-package="com.itzhouq.ssm.service"/>
    
    <!-- 声明式的事务管理器 -->
    <bean id="transactionManager"
        class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <!-- 数据源 -->
        <property name="dataSource" ref="dataSource" />
    </bean>
    <!-- 通知 -->
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <tx:attributes>
            <!-- 传播行为 -->
            <tx:method name="save*" propagation="REQUIRED" />
            <tx:method name="insert*" propagation="REQUIRED" />
            <tx:method name="delete*" propagation="REQUIRED" />
            <tx:method name="update*" propagation="REQUIRED" />
            <tx:method name="find*" propagation="SUPPORTS" read-only="true" />
            <tx:method name="get*" propagation="SUPPORTS" read-only="true" />
        </tx:attributes>
    </tx:advice>
    <!-- 切面 -->
    <aop:config>
        <aop:advisor advice-ref="txAdvice"
            pointcut="execution(* com.itzhouq.ssm.service.impl.*.*(..))" />
    </aop:config
</beans>
  • 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.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-4.2.xsd">
  
  <context:component-scan base-package="com.itzhouq.ssm.controller">
  
  </context:component-scan>
<!--  注解驱动 目的：加载新版本的处理器映射器、处理器适配器-->
 <mvc:annotation-driven/>
 
<!--  配置视图解析器的前缀和后缀 -->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
 <property name="prefix" value="/jsp/"></property>
 <property name="suffix" value=".jsp"></property>
</bean>
</beans>
  • jdbc.properties
jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/springmvc?characterEncoding=utf-8
jdbc.username=root
jdbc.password=2626
  • 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.3.4 持久层

  • com.itzhouq.ssm.mapper.ItemsMapper：持久层的接口
package com.itzhouq.ssm.mapper;
import java.util.List;
import com.itzhouq.ssm.pojo.Items;
public interface ItemsMapper {
    List<Items> findAll();
    Items findById(int itemId);
}
  • com/itzhouq/ssm/mapper/ItemsMapper.xml：持久层的映射器
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="com.itzhouq.ssm.mapper.ItemsMapper" >
  <resultMap id="ItemsMap" type="com.itzhouq.ssm.pojo.Items" >
    <id column="id" property="id"  />
    <result column="name" property="name"/>
    <result column="price" property="price"/>
    <result column="pic" property="pic"  />
    <result column="createtime" property="createtime"/>
  </resultMap>
  
  <select id="findAll" resultMap="ItemsMap">
    select * from items
  </select>
  
  <select id="findById" parameterType="int" resultType="com.itzhouq.ssm.pojo.Items">
    select * from items where id = #{id}
  </select>
</mapper>

4.3.4 实体类

  • com.itzhouq.ssm.pojo.Items
package com.itzhouq.ssm.pojo;
import java.util.Date;
import org.springframework.format.annotation.DateTimeFormat;
public class Items {
    private Integer id;
    private String name;
    private Float price;
    private String pic;
    @DateTimeFormat(pattern="yyyy-MM-dd HH:mm:ss")
    private Date createtime;
    private String detail;
    //set/get方法
}

4.3.5 业务层

  • com.itzhouq.ssm.service.ItemService：业务层的接口
package com.itzhouq.ssm.service;
import java.util.List;
import com.itzhouq.ssm.pojo.Items;
public interface ItemService {
    public List<Items> findAll();
    public Items findById(int itemId);
}
  • com.itzhouq.ssm.service.impl.ItemServiceImpl：业务层的实现类
package com.itzhouq.ssm.service.impl;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.itzhouq.ssm.mapper.ItemsMapper;
import com.itzhouq.ssm.pojo.Items;
import com.itzhouq.ssm.service.ItemService;
@Service
public class ItemServiceImpl implements ItemService {
    @Autowired
    private ItemsMapper itemsMapper;    
    public List<Items> findAll() {
        List<Items> list = itemsMapper.findAll();
        return list;
    }
    @Override
    public Items findById(int itemId) {
        Items item = itemsMapper.findById(itemId);
        return item;
    }
}

4.3.6 表现层

  • com.itzhouq.ssm.controller.ItemsController
package com.itzhouq.ssm.controller;
import java.util.List;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.servlet.ModelAndView;
import com.itzhouq.ssm.pojo.Items;
import com.itzhouq.ssm.service.ItemService;

@Controller
public class ItemsController {

    @Autowired
    private ItemService itemService ;
    
    @RequestMapping("/list")
    public String showAllList(Model model){
        List<Items> itemList = itemService.findAll();
        model.addAttribute("itemList",itemList);
        return "itemList";
    }

//  itemEdit.action?id=1
//  展示修改页面
    @RequestMapping("/itemEdit")
    public String itemEdit(@RequestParam(value="id",required=false,defaultValue="1")int itemId,HttpServletRequest request, HttpServletResponse response,Model model){
        Items items = itemService.findById(itemId);
        model.addAttribute("item", items);
//      逻辑视图：jsp的路径
        return "editItem";
    }
}

4.3.7 页面

  • WebContent/jsp/itemList.jsp
<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<%@ taglib uri="http://java.sun.com/jsp/jstl/fmt"  prefix="fmt"%>
<!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>查询商品列表</title>
</head>
<body> 
<form action="${pageContext.request.contextPath }/item/queryitem.action" method="post">
<!-- 查询条件：
<table width="100%" border=1>
<tr>
<td><input type="submit" value="查询"/></td>
</tr>
</table>
商品列表： -->
<table width="100%" border=1>
<tr>
    <td>商品名称</td>
    <td>商品价格</td>
    <td>生产日期</td>
    <td>商品描述</td>
    <td>操作</td>
</tr>
<c:forEach items="${itemList }" var="item">
<tr>
    <td>${item.name }</td>
    <td>${item.price }</td>
    <td><fmt:formatDate value="${item.createtime}" pattern="yyyy-MM-dd HH:mm:ss"/></td>
    <td>${item.detail }</td>
    
    <td><a href="${pageContext.request.contextPath }/itemEdit.action?id=${item.id}">修改</a></td>

</tr>
</c:forEach>

</table>
</form>
</body>

</html>
  • WebContent/jsp/editItem.jsp
<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<%@ taglib uri="http://java.sun.com/jsp/jstl/fmt"  prefix="fmt"%>
<!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>修改商品信息</title>

</head>
<body> 
    <!-- 上传图片是需要指定属性 enctype="multipart/form-data" -->
    <!-- <form id="itemForm" action="" method="post" enctype="multipart/form-data"> -->
    <form id="itemForm" action="${pageContext.request.contextPath }/updateitem.action" method="post">
        <input type="hidden" name="id" value="${item.id }" /> 修改商品信息：
        <table width="100%" border=1>
            <tr>
                <td>商品名称</td>
                <td><input type="text" name="name" value="${item.name }" /></td>
            </tr>
            <tr>
                <td>商品价格</td>
                <td><input type="text" name="price" value="${item.price }" /></td>
            </tr>
            <%-- 
            <tr>
                <td>商品生产日期</td>
                <td><input type="text" name="createtime"
                    value="<fmt:formatDate value="${item.createtime}" pattern="yyyy-MM-dd HH:mm:ss"/>" /></td>
            </tr>
            <tr>
                <td>商品图片</td>
                <td>
                    <c:if test="${item.pic !=null}">
                        <img src="/pic/${item.pic}" width=100 height=100/>
                        <br/>
                    </c:if>
                    <input type="file"  name="pictureFile"/> 
                </td>
            </tr>
             --%>
            <tr>
                <td>商品简介</td>
                <td><textarea rows="3" cols="30" name="detail">${item.detail }</textarea>
                </td>
            </tr>
            <tr>
                <td colspan="2" align="center"><input type="submit" value="提交" />
                </td>
            </tr>
        </table>

    </form>
</body>

</html>

4.3.8 测试

  • 展示商品：发布项目，访问http://localhost/Spring-mybatis-test/list.action

  • 修改商品：点击上图修改按钮进入修改页面

第5章：SpringMVC接收参数

5.1 @RequestParam绑定参数

  • 需求分析：比如在一个商品的编辑页面，需要展示商品的信息。那么在编辑商品信息之前，需要提前根据商品的id查询商品信息，然后展示到页面。这时候的请求是/itemEdit.action?id=5。这里假设id为5。

  • 如果请求中的参数名称和处理器中的形参的名称不一致的时候，就不能自动绑定。需要借助@RequestParam注解来绑定。

5.2 默认支持的参数类型

处理器形参中添加如下类型的参数处理适配器会默认识别并进行赋值。

  • HttpServletRequest request
  • HttpServletResponse response
  • HttpSession session
  • Model model

5.3 绑定POJO类型

  • 需求分析：将页面修改后的商品信息保存到数据库中。这时候请求的url为/updateitem.action。参数是表单中的数据。更新成功后需要跳转页面。如果提交的参数很多，或者表单中的内容很多的时候可以使用pojo接收数据。要求是pojo对象中的属性和表单中input的name属性一致。
  • 页面定义如下：
<input type="text" name="name"/>
<input type="text" name="price"/>
  • pojo定义：

  • 请求的参数和pojo的属性名称一致，会自动请求参数赋值给pojo属性。

  • 注意：此时提交的表单中不要有日期类型的数据，否则会报400错误。如果想提交日期类型的数据需要用到后面的自定义参数绑定的内容。
  • 在数据绑定pojo类型的的过程中有可能会出现乱码问题。

5.4 解决乱码问题

  • 如果请求的方式是POST请求，需要使用过滤器。在web.xml中添加以下配置：
<filter>
        <filter-name>CharacterEncodingFilter</filter-name>
        <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
        <init-param>
            <param-name>encoding</param-name>
            <param-value>utf-8</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>CharacterEncodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
  • 如果请求方式是GET请求，有两种解决办法。
  1. 方式一：修改tomcat服务器配置文件server.xml第64行。

  1. 方式二：对参数进行重新编码
String userName = new String(request.getParamter("userName").getBytes("ISO8859-1"),"utf-8")

5.5 绑定包装POJO

  • 需求分析：使用包装的pojo接收商品信息的查询条件。
  • 包装对象定义如下：

  • 页面定义：

  • Controller方法定义如下:
public String useraddsubmit(Model model,QueryVo queryVo)throws Exception{
System.out.println(queryVo.getItems());
}
  • 接收查询条件：
@RequestMapping("/queryitem")
    public String queryItem(QueryVo queryVo) {
        System.out.println(queryVo.getItems().getName());
        System.out.println(queryVo.getItems().getPrice());
        return null;
    }

5.6 自定义参数绑定

  • 需求分析：在商品修改页面可以修改商品的生产日期，并且根据业务需求自定义日期格式。

  • 自定义Converter转化器
public class DateConverter implements Converter<String, Date> {

    @Override
    public Date convert(String source) {
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        try {
            return simpleDateFormat.parse(source);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return null;
    }
}

  • 定义好转化器之后需要配置转化器，这里有两种配置方式。第二种更简单。

    • 方式一：在springmvc.xml配置文件中添加如下配置：
    <!-- 加载注解驱动 -->
  <mvc:annotation-driven conversion-service="conversionService"/>
  <!-- 转换器配置 -->
  <bean id="conversionService"
      class="org.springframework.format.support.FormattingConversionServiceFactoryBean">
      <property name="converters">
          <set>
              <bean class="cn.itcast.springmvc.convert.DateConverter"/>
          </set>
      </property>
  </bean>
    • 方式二：在pojo类的日期属性上添加如下注解：
    @DateTimeFormat(pattern="yyyy-MM-dd HH:mm:ss")
    private Date createtime;

  • 由于日期数据有很多种格式，所以springmvc没办法把字符串转换成日期类型。所以需要自定义参数绑定。前端控制器接收到请求后，找到注解形式的处理器适配器，对RequestMapping标记的方法进行适配，并对方法中的形参进行参数绑定。在springmvc这可以在处理器适配器上自定义Converter进行参数绑定。如果使用<mvc:annotation-driven/>可以在此标签上进行扩展。

第6章：SpringMVC和Struts2的区别

  1. springmvc的入口是一个servlet即前端控制器，而struts2入口是一个filter过虑器。
  2. springmvc是基于方法开发(一个url对应一个方法)，请求参数传递到方法的形参，可以设计为单例或多例(建议单例)，struts2是基于类开发，传递参数是通过类的属性，只能设计为多例。
  3. Struts采用值栈存储请求和响应的数据，通过OGNL存取数据， springmvc通过参数解析器是将request请求内容解析，并给方法形参赋值，将数据和视图封装成ModelAndView对象，最后又将ModelAndView中的模型数据通过request域传输到页面。Jsp视图解析器默认使用jstl。
标签
springmvc框架
springmvc源码分析
数据库视图
springmvc配置
spring自定义注解
前端架构
springmvc注解
前端框架
开发框架
modelandview
servlet
bean
jsp
schema
易学教程内所有资源均来自网络或用户发布的内容，如有违反法律规定的内容欢迎反馈！
该文章没有解决你所遇到的问题?点击提问,说说你的问题,让更多的人一起探讨吧!