Spring初探之Spring+Spring MVC+MyBatis整合

前言

系统标准的三层架构包括：表现层、业务层、持久层。三层架构在我们的实际开发中使用的非常多，包含：

1、表现层

1）也就是我们常说的web 层。它负责接收客户端请求，向客户端响应结果，通常客户端使用http 协议请求web 层，web 需要接收 http 请求，完成 http 响应。

2）表现层包括展示层和控制层：控制层负责接收请求，展示层负责结果的展示。

3）表现层依赖业务层，接收到客户端请求一般会调用业务层进行业务处理，并将处理结果响应给客户端。

4）表现层的设计一般都使用 MVC 模型。（MVC 是表现层的设计模型，和其他层没有关系）

2、业务层

1）也就是我们常说的 service 层。它负责业务逻辑处理，和我们开发项目的需求息息相关。web 层依赖业务层，但是业务层不依赖 web 层。

2）业务层在业务处理时可能会依赖持久层，如果要对数据持久化需要保证事务一致性。（也就是我们说的， 事务应该放到业务层来控制）

3、持久层

1）也就是我们是常说的 dao 层。负责数据持久化，包括数据层即数据库和数据访问层，数据库是对数据进行持久化的载体，数据访问层是业务层和持久层交互的接口，业务层需要通过数据访问层将数据持久化到数据库中。通俗的讲，持久层就是和数据库交互，对数据库表进行增删改查的。

这里不要把 MVC 设计模式和工程的三层结构混淆，三层结构指的是表现层、业务层、数据持久层。而 MVC 只针对表现层进行设计。

整合

从持久层到业务层、到表现层，我们一步步进行Spring+Spring MVC+MyBatis整合。

步骤1：

新建一个web项目，参考下面博客：IntelliJ IDEA上创建Maven Spring MVC项目

步骤2:

添加pom依赖文件：

<properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.7</maven.compiler.source>
        <maven.compiler.target>1.7</maven.compiler.target>
        <spring.version>5.0.7.RELEASE</spring.version>
    </properties>

    <dependencies>
        <!-- spring ioc组件需要的依赖包 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-expression</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <!-- 基于AspectJ的aop依赖 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>aopalliance</groupId>
            <artifactId>aopalliance</artifactId>
            <version>1.0</version>
        </dependency>
        <!-- spring 事务管理和JDBC依赖包 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <!-- mysql数据库驱动包 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.12</version>
        </dependency>
        <!-- dbcp连接池的依赖包 -->
        <dependency>
            <groupId>commons-dbcp</groupId>
            <artifactId>commons-dbcp</artifactId>
            <version>1.4</version>
        </dependency>
        <!-- mybatis依赖 -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.4.5</version>
        </dependency>
        <!-- mybatis和spring的整合依赖 -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>1.3.2</version>
        </dependency>
        <!-- SpringMVC 相关包 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <!-- jstl -->
        <dependency>
            <groupId>jstl</groupId>
            <artifactId>jstl</artifactId>
            <version>1.2</version>
        </dependency>
        <!-- servlet -->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>servlet-api</artifactId>
            <version>2.5</version>
        </dependency>
        <!-- spring 单元测试组件包 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.0.8.RELEASE</version>
        </dependency>
        <!-- 单元测试Junit -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
    </dependencies>

步骤3:

创建相应到表和插入test数据：

### create table
CREATE TABLE `books` (
  `id` int(11) NOT NULL AUTO_INCREMENT COMMENT '编号',
  `title` varchar(100) NOT NULL COMMENT '书名',
  `price` decimal(10,2) DEFAULT NULL COMMENT '价格',
  `publishDate` timestamp NULL DEFAULT CURRENT_TIMESTAMP COMMENT '出版日期',
  PRIMARY KEY (`id`),
  UNIQUE KEY `title` (`title`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
## insert value
INSERT INTO `books` VALUES ('1', 'Java编程思想', '98.50', '2005-01-02 00:00:00');
INSERT INTO `books` VALUES ('2', 'HeadFirst设计模式', '55.70', '2010-11-09 00:00:00');
INSERT INTO `books` VALUES ('3', '第一行Android代码', '69.90', '2015-06-23 00:00:00');
INSERT INTO `books` VALUES ('4', 'C++编程思想', '88.50', '2004-01-09 00:00:00');
INSERT INTO `books` VALUES ('5', 'HeadFirst Java', '55.70', '2013-12-17 00:00:00');
INSERT INTO `books` VALUES ('6', '疯狂Android', '19.50', '2014-07-31 00:00:00');

实体类

创建与表结构相匹配到实体bean

public class Book {
    private int id;

    private String title;

    private double price;

    private Date publishDate;

    public Book(int id, String title, double price, Date publishDate) {
        this.id = id;
        this.title = title;
        this.price = price;
        this.publishDate = publishDate;
    }
    public Book() {
    }
	//get/set方法省略......
}

实体类有了，接着需要创建创建操作实体类的dao层和与之匹配的MyBatis文件

dao层

public interface BookMapper {
    /**
     * 获得所有图书
     */
    List<Book> getAllBooks();

    /**
     * 根据图书编号获得图书对象
     */
    Book getBookById(@Param("id") int id);

    /**
     * 添加图书
     */
    int add(Book entity);

    /**
     * 根据图书编号删除图书
     */
    int delete(int id);

    /**
     * 更新图书
     */
    int update(Book entity);
}

在resource目录下创建MyBatis映射文件，为方便后续步骤的扫描，路径要与dao层的路径一致

<?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，namespace的值习惯上设置成包名+sql映射文件名，这样就能够保证namespace的值是唯一的-->
<mapper namespace="com.lks.dao.BookMapper">
    <!--获取所有的图书-->
    <select id="getAllBooks" resultType="Book">
        select id,title,price,publishDate from books
    </select>

    <!--获得图书对象通过编号 -->
    <select id="getBookById" resultType="Book">
        select id,title,price,publishDate from books where id=#{id}
    </select>
    <!-- 增加 -->
    <insert id="add">
        insert into books(title,price,publishDate)
        values(#{title},#{price},#{publishDate})
    </insert>
    <!-- 删除 -->
    <delete id="delete">
        delete from books where id=#{id}
    </delete>
    <!-- 更新 -->
    <update id="update">
        update books set title=#{title},price=#{price},publishDate=#{publishDate}
        where id=#{id}
    </update>
</mapper>

MyBatis相应的操作已经做好了，但mybatis的配置文件还没写，而且mybatis如何和Spring相整合呢？

整合Spring + mybatis

同样在resource目录下创建Spring的配置文件：applicationContext.xml文件，在这里实现和mybatis的整合：

<?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:aop="http://www.springframework.org/schema/aop"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context-4.3.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop-4.3.xsd
        http://www.springframework.org/schema/tx
        http://www.springframework.org/schema/tx/spring-tx-4.3.xsd">

    <!--1 引入属性文件，在配置中占位使用 -->
    <context:property-placeholder location="classpath*:db.properties" />

    <!--2 配置jdbc数据源 -->
    <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
        <!--驱动类名 -->
        <property name="driverClassName" value="${jdbc.driver}" />
        <!-- url -->
        <property name="url" value="${jdbc.url}" />
        <!-- 用户名 -->
        <property name="username" value="${jdbc.uid}" />
        <!-- 密码 -->
        <property name="password" value="${jdbc.pwd}" />
    </bean>

    <!--3 会话工厂bean sqlSessionFactoryBean -->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <!-- 数据源 -->
        <property name="dataSource" ref="dataSource"></property>
        <!-- 别名 -->
        <property name="typeAliasesPackage" value="com.lks.entities"></property>
        <!-- sql映射文件路径 -->
        <property name="mapperLocations" value="classpath*:com/lks/dao/BookMapper.xml"></property>
    </bean>

    <!--4 自动扫描对象关系映射 -->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <!--指定会话工厂，如果当前上下文中只定义了一个则该属性可省去 -->
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"></property>
        <!-- 指定要自动扫描接口的基础包，实现接口 -->
        <property name="basePackage" value="com.lks.dao"></property>
    </bean>

    <!--5 声明式事务管理 -->
    <!--定义事物管理器，由spring管理事务 -->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"></property>
    </bean>
    <!--支持注解驱动的事务管理，指定事务管理器 -->
    <tx:annotation-driven transaction-manager="transactionManager"/>

    <!--6 容器自动扫描IOC组件  -->
    <context:component-scan base-package="com.lks"></context:component-scan>

    <!--7 aspectj支持自动代理实现AOP功能 -->
    <aop:aspectj-autoproxy proxy-target-class="true"></aop:aspectj-autoproxy>
</beans>

这里主要有7步：

1 引入属性文件

<context:property-placeholder location="classpath*:db.properties" />

其中db.properties文件直接放在resource目录下：

#mysql jdbc
jdbc.driver= com.mysql.cj.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/spring_demo?useSSL=false
jdbc.uid=root
jdbc.pwd=root

2 配置jdbc数据源

3 配置会话工厂bean

也就是配置SqlSessionFactoryBean，将myBatis中的session交由Spring容器来管理。

4 自动扫描对象关系映射

配置mybatis中的mapper扫描

5 声明式事务管理

这里我们直接使用注解的方式实现事务管理

6 容器自动扫描IOC组件

也就是使用注解的方式管理bean

7 aspectj支持自动代理实现AOP功能

第7处配置并不是必要的，另外关于事务管理也可以选择AOP拦截式事务管理。

到此，持久层相关的功能已经完成了，接下来是service层的操作

Service层

@Service
public class BookService {

    @Resource
    private BookDao bookDao;

    public List<Book> getAllBooks() {
        return bookDao.getAllBooks();
    }

    public Book getBookById(int id) {
        return bookDao.getBookById(id);
    }

    public int add(Book entity) throws Exception {
        if (entity.getTitle() == null || entity.getTitle().equals("")) {
            throw new Exception("书名不能为空");
        }
        return bookDao.add(entity);
    }

    @Transactional
    public int add(Book entity1, Book entityBak) {
        int rows = 0;
        rows = bookDao.add(entity1);
        rows = bookDao.add(entityBak);
        return rows;
    }

    public int delete(int id) {
        return bookDao.delete(id);
    }

    /**
     * 多删除
     */
    public int delete(String[] ids) {
        int rows = 0;
        for (String idStr : ids) {
            int id = Integer.parseInt(idStr);
            rows += delete(id);
        }
        return rows;
    }

    public int update(Book entity) {
        return bookDao.update(entity);
    }
}

service层主要是对持久层做一些操作，这里完成后，就需要用到表现层了。这里先要配置web前端控制器，添加加载Spring容器用的监听器。

配置处理器

<?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"
         version="3.0">

    <welcome-file-list>
        <welcome-file>index.jsp</welcome-file>
    </welcome-file-list>

    <!-- 配置前端控制器 -->
    <servlet>
        <servlet-name>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!-- 设置spring配置文件路径 -->
        <!-- 如果不设置初始化参数，那么DispatcherServlet会读取默认路径下的配置文件,默认配置文件路径：/WEB-INF/springmvc-servlet.xml -->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:applicationContext.xml</param-value>
        </init-param>
        <!-- 指定初始化时机，设置为2，表示Tomcat启动时，DispatcherServlet会跟随着初始化 -->
        <!-- 如果不指定初始化时机，DispatcherServlet就会在第一次被请求的时候，才会初始化 -->
        <load-on-startup>2</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <!-- 为什么url-pattern配置/*会报错？原因是它拦截了jsp请求，但是却不能处理jsp请求，详见图解 -->
        <url-pattern>/</url-pattern>
    </servlet-mapping>
</web-app>

配置完处理器，就可以开始表现层，也就是web层的操作了。

表现层

按前面所说的表现层的主要功能，这里主要是controller和jsp文件的编写：

@Controller
public class BooksController {
    @Resource
    private BookService bookService;

    @RequestMapping(value = "queryBooks")
    public ModelAndView queryBooks() {
        ModelAndView modelAndView = new ModelAndView();
        // 设置数据和视图
        modelAndView.addObject("books", bookService.getAllBooks());
        modelAndView.setViewName("/WEB-INF/views/jsp/bookList.jsp");
        return modelAndView;
    }
}

bookList.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"
         pageEncoding="UTF-8"%>
<%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
<%@taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %>
<!DOCTYPE html>
<html>
<head>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
    <title>图书管理</title>
</head>
<body>
<div class="main">
    <h2 class="title"><span>图书管理</span></h2>
    <form action="BookController.do?act=Deletes" method="post">
        <table border="1" width="100%" class="tab">
            <tr>
                <th><input type="checkbox" id="chbAll"></th>
                <th>编号</th>
                <th>书名</th>
                <th>价格</th>
                <th>出版日期</th>
            </tr>
            <c:forEach var="book" items="${books}">
                <tr>
                    <th><input type="checkbox" name="ids" value="${book.id}"></th>
                    <td>${book.id}</td>
                    <td>${book.title}</td>
                    <td>${book.price}</td>
                    <td><fmt:formatDate value="${book.publishDate}" pattern="yyyy年MM月dd日"/></td>
                </tr>
            </c:forEach>
        </table>
        <p style="color: red">${message}</p>
    </form>
</div>
</body>
</html>

写个简单的jsp展示页，效果：

启动服务

服务的启动我选用的是maven jetty插件方式启动：
idea jetty:run 启动

Demo整合了Mybatis、Spring、Spring MVC的内容，起到了承前启后的作用，巩固前面的知识也可以在此进行扩展，完善其它的几个功能。

项目地址