Spring 与 MyBatis 的整合

1.整合思路

  思路：将MyBatis框架中使用到的核心组件配置到Spring容器中，交给Spring来创建和管理。
  具体来说是将需要自行编码通过SqlSessionFactoryBuilder读取配置文件、构建SqlSessionFactory,进而获得SqlSession实例，满足业务逻辑对象对于数据访问的需要的工作交由Spring来完成，发挥Spring框架Bean容器的作用，接管组件的创建工作，管理组件的生命周期，并对组件之间的依赖关系进行解耦合管理。

2、整和前准备

步骤：1、添加相应的 jar 包。
2、建立开发目录结构，创建实体类。
3、创建数据访问接口。
4、配置 SQL 映射文件。
5、配置 MyBatis 配置文件。

第一步：添加相应的依赖：

  整合时项目中只需要包含mybaits-spring:2.0.0就可以了，由于在整合中还会用到Spring的数据源支持以及事务支持，因此还需要在项目中加入 spring-jdbc:5.0.0.RELEASE 和
spring-tx:5.0.0：RELEASE 两个文件。
第二步：建立开发目录结构，创建实体类.

第三步：创建数据访问接口

第四步：配置 SQL 映射文件

<?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文件-->
<mapper namespace="com.kgc.dao.UserMapper">
    <select id="getUserList" resultType="User">
        select u.* , r.roleName from smbms_user u,smbms_role r where u.userRole = r.id
       
            <if test="userName !=null || userName!=''">
                and u.userName like concat("%",#{userName},"%")
            </if>
            <if test="userRole !=null || userRole!=''">
                and u.userRole = #{userRole} 
            </if>
    </select>
</mapper>

第五步：配置MyBatis配置文件
  和Spring整合的MyBaits配置文件要简单一些，可以将之前一些mybaits文件的配置工作交给spring完成
如：数据源的配置，加载Mapper.xml文件等工作

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <!--和Spring整合的MyBaits配置文件要简单一些，可以将之前一些mybaits文件的配置工作交给spring完成
    如：数据源的配置，加载Mapper.xml文件等工作-->
    <typeAliases>
        <package name="main.java.cn.kgc.pojo"/>
    </typeAliases>
</configuration>

3.实现 Spring 对 MyBatis 的整合

3.1 配置DataSource

  对于任何持久化方案，数据库谅解都是首先要解决的问题。在 Spring 中，数据源作为一个重要的组件可以单独进行配置和维护。
  在 Spring 中配置数据源，首先要选择一种具体的数据源实现技术。目前流行的数据源实现有 dbcp、c3p0、Proxool。他们都实现了连接池功能。下面是对他们的一些介绍：

  DBCP （DataBase connection pool）数据库连接池。是 Apache 上的一个 Java 连接池项目，也是 tomcat 使用的连接池组件。单独使用DBCP需要2个包：commons-dbcp.jar和commons-pool.jar。由于建立数据库连接是一种非常耗时、耗资源的行为，所以通过连接池预先同数据库建立一些连接，放在内存中，应用程序需要建立数据库连接时直接到连接池中申请一个就行，使用完毕后再归还到连接池中。
  C3P0 是一个开源的JDBC连接池，它实现了数据源和JNDI绑定，支持JDBC3规范和JDBC2的标准扩展。目前使用它的开源项目有Hibernate，Spring等。
  Proxool 是一种Java数据库连接池技术。sourceforge下的一个开源项目,这个项目提供一个健壮、易用的连接池，最为关键的是这个连接池提供监控的功能，方便易用，便于发现连接泄漏的情况。
  *目前是和DBCP以及C3P0一起，最为常见的三种JDBC连接池技术。
  *日前，Hibernate官方宣布由于Bug太多不再支持DBCP，而推荐使用 Proxool或C3P0。

 这里我们使用dbcp，使用前需要引入两个 jar 包：commons-dbcp.jar 和 commons-pool.jar

  建立Spring配置文件 applicationContext-mybatis.xml,需要配置数据源的代码示例如下：

 <!--配置数据源的Bean-->
    <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://locathost:3306/smbms?userUnicode=true&amp;characterEncoding=UTF-8"/>
        <property name="username" value="root"/>
        <property name="password" value="121127"/>
    </bean>

Tip:因为 url 属性的值包含特殊符号 “&” ,所以赋值时使用了 “&amp ;”,也可以使用 <![CDATA[]]标记来替换。

3.2 配置SqlSessionFactoryBean

  配置完数据源，就可以在此基础上集合 SQL 映射文件信息以及 MyBatis 配置文件中的其他信息，创建 SqlSessionFactory 实例。
  在 MyBatis 中，SqlSessionFactory 的实例需要使用 SqlSessionFactoryBuilder 穿件，而在集成环境中，则可以用 MyBatis-Spring 整合保重的 SqlSessionFactoryBean来代替。SqlSessionFactoryBean封装了 SqlSessionFactoryBuilder 创建 SqlSessionFactory 对象的过程， 我们可以在 Spring 中以配置文件的形式，通过配置 SqoSessionFactoryBean 获得 SqlSessionFactory实例。
如下示例：

   <!--配置SqlSessionFactoryBean-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
       
        <!--引用数据源组件-->
        <property name="dataSource" ref="dataSource"/>
       
        <!--引用 MyBatis 配置文件中的配置-->
        <property name="configLocation" value="applicationContext-mybatis.xml"/>
    
        <!--配置映射文件信息-->
        <property name="mapperLocations">
            <list>
                <value>classpath:UserMapper.xml</value>
            </list>
        </property>
    </bean>

  除了数据源和 SQL 映射信息，其他的 MyBatis 配置信息也可以转移至 Spring 配置文件中进行维护，只需要通过 SqlSessionFactoryBean 的对应属性进行赋值即可。

3.3. SqlSessionTemplate 进行持久化操作

  对于 MyBatis 而言，得到 SqlSessionFactory 实例，就可以进一步获取 SqlSession 实例进行数据库操作了。而在集成环境中，为了更好的使用 Spring 框架提供的服务， MyBatis-Spring 整合包提供了 SqlSessionTemplate 类。

  SqlSessionTemplate 类实现了 MyBatis 的 SqlSession 接口，可以替换 MyBatis 中原有的SqlSession 实现类来提供数据库的访问操作。使用SqlSessionTemplate 可以更好的与Spring 服务融合饼干简化部分流程化的工作，还可以保证和当前 Spring 事务相关联、自动管理会话的生命周期，包括必要的关闭、提交和回滚操作。
  配置 SqlSessionTempalte 并在 UserMapper 实现类中使用，示例如下：

package com.kgc.dao.impl;

import com.kgc.dao.UserMapper;
import main.java.com.kgc.pojo.User;
import org.mybatis.spring.SqlSessionTemplate;

import java.util.List;

/**
 * @description:
 * @author:
 * @date: 2019-07-06 12:12
 */
public class UserMapperImpl implements UserMapper {

    private SqlSessionTemplate sqlSessionTemplate;


    @Override
    public List<User> getUserList(User user) {

        //调用SqlSessionTemplate 对象的 getMapper()方法执行 SQL查询 并返回结果
        return sqlSessionTemplate.getMapper(UserMapper.class).getUserList(user);
    }

    public SqlSessionTemplate getSqlSessionTemplate() {
        return sqlSessionTemplate;
    }

    public void setSqlSessionTemplate(SqlSessionTemplate sqlSessionTemplate) {
        this.sqlSessionTemplate = sqlSessionTemplate;
    }
}

Spring 配置文件的代码如下：

    <!--配置SqlSessionTemplate-->
    <bean id="sqlSessionTemplate" class="org.mybatis.spring.SqlSessionTemplate" >
  
        <!--配置SqlSessionTemplate需要引用 SqlSessionFactoryBean 组件作为参数-->
        <constructor-arg name="sqlSessionFactory" ref="sqlSessionFactory"/>
    </bean>
     
    <!--配置 DAO 组件并注入 SqlSessionTemplate 实例-->
    <bean id="userMapper" class="com.kgc.dao.impl.UserMapperImpl">
        <property name="sqlSessionTemplate" ref="sqlSessionTemplate"/>
    </bean>

注意： 1、创建 SqlSessionTemplate实例时，需要通过其构造方法注入 SqlSessionFactory 的实例。
  2、与 MyBatis 中默认的 SqlSession 实现不同， SqlSessionTemplate 是线程安全的，可以以单例模式配置并被多个 DAO 对象公用，而不必为每一个 DAO 单独配置一个 SqlSessionTemplate 实例。

3.4 完善代码并测试

业务层代码如下：

/**
 * @description:
 * @author:
 * @date: 2019-07-06 13:19
 */
public class UserServiceImpl implements UserService {
    private UserMapper userMapper;
    @Override
    public List<User> getUserList(User user) {
        return userMapper.getUserList(user);
    }
}

Spring 中配置Service层的代码如下：

   <bean id="userService" class="java.cn.kgc.service.impl.UserServiceImpl" p:userMapper-ref="userMapper"/>

测试类代码：

* @author: 
 * @date: 2019-07-06 14:35
 */
public class TestUserMapper {
Logger log = Logger.getLogger(TestUserMapper.class);
    /**
     * 获取所有用户信息
     */
    @Test
    public void getUser(){
        ApplicationContext context = new ClassPathXmlApplicationContext("ApplicationContext-mybatis.xml");
       UserService userService = (UserService) context.getBean("userService");
        User user = new User();
        user.setUserName("韩");
        List<User> userList = userService.getUserList(user);
        for(User u:userList){
            log.info(u.getUserName());
        }
    }

 小结：利用Spring框架和MyBatis-Spring整合资源包提供的组件，能够以配置的方式得到数据源、SqlSessionFactoryBean、SqlSessionTemplate等组件，并在此基础上完成DAO 模块和业务模块的开发和装配，简化了开发过程且便于维护。

 扩展：
  MyBatis-Spring 提供了 SqlSessionDaoSupport 类来简化 SqlSessionTemplate的配置和获取。SqlSessionDaoSupport 类提供了 **setSqlSessionFactory()**方法用来注入 SqlSessionFactory实例并创建 SqlSessionTemplate 实例，同时提供了 getSqlSession() 方法用来返回创建好的SqlSessionTemplate 实例。

4.注入映射器的两种方式

  在 DAO 的实现类中使用 SqlSessionTemplate 的方法，都是采用字符来指定映射项，这种方式比较容易产生错误。并且 SqlSessionTemplate 对于映射器的方法功能实现都是通过 getMapper() 等方法来使先的。这并非最佳选择。
  利用MyBatis_spring 提供的组件，可以不必每次都调用 getMapper()方法，而是通过配置的方式直接为业务对象注入映射器实现，不需要额外代码。

4.1 MapperFactoryBean 的用法

  如果如果仅适用 SqlSessionTemplate 执行基本的数据访问操作，而不包含替他非 MyBatis的工作，可以不必手工编码使用 SqlSessionTemplate 或 SqlSessionDaoSupport 来实现此类 DAO.。 MyBatis_spring 提供了 MapperFactoryBean，能够以配置的方式生成映射器实现并注入到业务组件。

用法示例如下（先注释 上述示例中 UserMapper 的实现类 UserMapperImpl ）：

   <!--配置数据源-->
    <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/smbms?useUnicode=true&amp;characterEncoding=UTF-8&amp;useSSL=false"/>
        <property name="username" value="root"/>
        <property name="password" value="121127"/>
    </bean>

    <!--配置SqlSessioinFactoryBean-->
    <bean id="sqlSessionFactoryBean" class="org.mybatis.spring.SqlSessionFactoryBean">
        <!--引入数据源组件-->
        <property name="dataSource" ref="dataSource"/>
        <!--引入mybatis配置文件-->
        <property name="configLocation" value="mybatis-config.xml"/>
        <!--映入映射文件-->
        <property name="mapperLocations">
            <list>
                <value>UserMapper.xml</value>
            </list>
        </property>
    </bean>
    
    <!--配置 DAO-->
    <bean id="userMapper" class="org.mybatis.spring.mapper.MapperFactoryBean">
        <property name="mapperInterface" value="main.java.cn.kgc.dao.UserMapper"/>
        <property name="sqlSessionFactory" ref="sqlSessionFactoryBean"/>
    </bean>
    <!--业务层配置-->
      <bean id="userService" class="java.cn.kgc.service.impl.UserServiceImpl" p:userMapper-ref="userMapper"/>

注意：
    1、配置 DAO 组件 userMapper 时， class 属性不是某个实现类，而是 MapperFactoryBean.
    2、通过 mapperInterface 属性指定映射器，只能是接口类型，不能是某个实现类。
    3、 MapperFactoryBean 是 SqlSessionDaoSupport 的子类，需要通过 setSqlSessinFactory()方法注入 SqlSessionFactory 实例以创建SqlSessionTemplate实例。
    4、如果映射器对应的 SQL 映射文件与映射器的类路径相同，该映射文件可以自动被 MapperFactoryBean解析。在此情况下，配置SqlSessionFacotryBean是可以不必指定SQL映射文件的位置。反之，如果映射器与映射文件的类路径不同，则需要再配置SqlSessionFactoryBean是明确指定映射文件的位置。

4.2 MapperScannerConfigurer 的用法

  MyBatis-Spring 中提供了 MapperScannerConfigurer,他可以用来扫描指定标准的接口并将它们直接注册为MapperFactoryBean.以解决因为映射器过多而导致配置过多的问题。
MapperConfigurer 的配置方法如下：

   <!--配置 DAO -->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="main.java.cn.kgc.dao"/>
    </bean>

说明：
 basePackage 属性指定了扫描的基准包，MapperConfigure将递归扫描 基准包下及其子包下的所有接口。如果它们已经在 SQL 映射文件中定义过，则将它们动态注册为MapperFacotryBean,如此即可批量产生映射器实现类。

注意：
  1、basePackage 属性中可以包含多个包名，多个包名之间用逗号或者分号隔开。
  2、MapperScannerConfigurer 会为所有由它创建的映射器实现类开启自动装配。也就是说，MapperScannerConfigurer 创建的所有映射器实现都会被自动注入SqlSessionFactory 实例。因此在上述示例中装配DAO组件是无需显式注入 SqlSessionFactory 实例。
  3、若环境中出于不同目的配置了多个SqlSessionFactory 实例。将无法进行自动装配，此时应显式地指定所以啦的 SqlSessionFactory 实例。配置示例如下：

 <!--配置 DAO -->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
       <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>   
        <property name="basePackage" value="main.java.cn.kgc.dao"/>
    </bean>

  需要注意的是这里使用的是 sqlSessionFactoryBeanName 属性而不是 sqlSessionFactory属性。正如该属性名所表达的，这个属性关注的是Bean的名称，所以为其赋值使用的是 value 而不是 ref。

映射器的命名问题：
  通过配置 MapperScannerConfigurer 可以批量生成映射器实现，这些映射器被注册到 Spring 的容器是，Spring 会根据其接口名称为其命名，默认规则是首字母小写的非完全限定类名。如： UserMapper 类型的组件会被 默认注册为 userMapper。在业务层中依然可以通过该命名为其注入映射器，也可以通过使用 @Autowired 或 @Resources 注解来实现对业务层的组件的依赖注入。

小结：
 &emsp**;MapperScannerConfigurer** 与 @Autowired 注解 或 @Resource 注解配合使用，自动创建映射器实现并注入给业务组件，能够最大限度的减少 DAO 组件与业务组件的编码和配置工作。

5. 添加声明式事务

  Spring 提供了声明式事务处理机制，它基于AOP实现，无需编写任何事务管理代码，所有的工作全在配置文件中完成。这意味着与业务代码完全分离，配置即可用，降低了开发和维护的难度。

5.1 声明式事务的 XML 配置方式

  这里以添加用户的功能为例，介绍如何实现声明式事务处理。首先在UserMapper 和 UserMapper.xml 中添加相关的方法和 SQL 映射。示例代码如下：

UserMapper中的代码：

 public interface UserMapper {
        public int addUser(User user);
    }

UserMapper.xml中的代码:

  <insert id="addUser" parameterType="User">
        insert into smbms_user (userCode,userName,userPassword,gender,birthday,phone,address,userRole)
        values(#{userCode},#{userName},#{userPassword},#{gender},#{birthday},#{phone},#{address},#{userRole})
    </insert>

业务层的代码：

 public int addUser(User user) throws RuntimeException{
        int i = 0;

        try{
           i = userMapper.addUser(user);
        }catch(RuntimeException e){
            System.out.println("发生异常！");

            throw e;
        }
        return i;
    }

  接下来为业务层配置事务切面。首先要引入 tx 和 aop 两个命名空间，

<?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:aop="http://www.springframework.org/schema/aop"
       xmlns:util="http://www.springframework.org/schema/util"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:tx="http://www.springframework.org/schema/tx"

       xmlns:p="http://www.springframework.org/schema/p"
       xsi:schemaLocation="http://www.springframework.org/schema/beans  http://www.springframework.org/schema/beans/spring-beans-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/util  http://www.springframework.org/schema/util/spring-util-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/tx  http://www.springframework.org/schema/tx/spring-tx-4.0.xsd

        http://www.springframework.org/schema/p  http://www.springframework.org/schema/p/spring-p-4.0.xsd">
</beans>

  接下来需要配置一下事务管理器组件，他提供对事物处理的全面支持和统一管理，在切面中相当于增强处理的角色。可以使用 DataSourceTranSactionManager 来实现。其配置方式如下：

 <!--定义事务管理器-->
    <bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <!--需要引入之前配置好的数据源-->
        <property name="dataSource" ref="dataSource"/>
    </bean>

  事务管理器还可以进一步的配置，以便更好地适应具体的事务规则。示例代码如下：

  <!--定义属性声明事务规则-->
        <tx:attributes>
            <tx:method name="find*" propagation="SUPPORTS"/>
            <tx:method name="add*" propagation="REQUIRED"/>
            <tx:method name="del*" propagation="REQUIRED"/>
            <tx:method name="update*" propagation="REQUIRED"/>
            <tx:method name="*" propagation="REQUIRED"/>
        </tx:attributes>

  在<tx:advice>标签内可以设置id 属性和 transaction-manager 属性。 其中 transaction-manager 属性医用一个事务管理器 Bean。
  除了上述两个属性外，还可以通过 <tx:attributes> 子标签定制事务属性。事务属性通过<tx:method >标签进行设置。Spring 支持对不同的方法设置不同的事务属性，所以可以为一个 <tx:advice> 设置多个<tx:method>。
  <tx:method>标签中的 name 属性时必须的，用于指定匹配的方法。这里需要对方法名进行约定，可以使用通配符（*）。其他属性均为可选，用于指定具体的事务规则，这些属性的解释如下：

1、propagration:事务传播机制。该属性的可选值如下：

属性可选值	说明
REQUIRED	默认值，表示如果存在一个事务，则支持当前事务；如果当前没有事务，则开启一个新的事务。
REQUIRES_NEW	表示总是开启一个新的事务，如果一个事务已经存在，则将这个存在的事务挂起，开启新事物执行该方法。
MANDATORY	表示如果存在一个事务，则支持当前事务；如果当前没有一个活动弄的事务，则抛出异常
NESTED	表示如果当前存在一个活动的事务，则创建一个事务座位当前事物的签到事务运行；如果当前没有事务该取值与REQUIRE相同
SUPPORTS	表示如果存在一个事务，则支持当前事务；如果当前没有事务，则按非事务方式执行。
NOT_SUPPORTED	表示总是以非事务方式执行。如果一个事务已经存在，则将这个存在的事务挂起，然后执行该方法。
NEVER	表示总是以非事务方式执行。如果当前存在一个活动的食物，则抛出异常。

2、isolation:事务隔离登记。即挡墙事务和其他事务的隔离程度，在并发事务处理的情况下需要考虑他的设置。该属性的可选值如下：

属性可选值	说明
DEFAULT	默认值，表示使用数据库默认的事务隔离级别。
READ_UNCOMMITTED	未提交阅读
READ_COMMITTED	提交阅读
REPEATABLE_READ	可重复阅读
SERIALIZABLE	串行读

3、timeout:事务超时时间。允许事务运行的最长时间，以秒为单位。
4、read-only：事务是否为只读，默认你只为 false 。对于只执行查询功能的事务，把它设置为 true ,能提高事务处理的性能。
5、rollback-for:设定能够触发回滚的异常类型。
6、no-rollback-for:设定不触发回滚的异常类型。

 设置完事务规则，最后还要定义切面，将事务规则应用到指定的方法上。示例代码如下：

  <!--定义切面-->
    <aop:config>
    <!--定义切入点-->
        <aop:pointcut id="txPointCut" expression="execution(* service.*.*(..))"/>

        <!--引入事务管理的增强处理,引入切入点-->
        <aop:advisor advice-ref="txAdvice" pointcut-ref="txPointCut"/>
    </aop:config>

总结Spring声明事务的步骤：
1、导入tx 和 aop 的命名空间。
2、定义事务管理器 Bean ,并为其注入 数据源Bean。
3、通过 <ts:advice>配置事务增强，绑定事务管理器并针对不同方法定义事务规则。
4、配置切面，僵尸舞增强与方法切入点结合。

5.2 声明式事务的注解添加方式

  Spring 还支持使用注解装配声明式事务，所使用的注解是 @Transacional。

    @Transactional(propagation = Propagation.SUPPORTS)
    public int addUser(User user) throws RuntimeException{
        int i = 0;

        try{
           i = userMapper.addUser(user);
        }catch(RuntimeException e){
            System.out.println("发生异常！");

            throw e;
        }
        return i;
    }

  如上述示例在一个业务的实现类上添加@Transactional 注解即可为该类的所有业务方法统一添加事务处理。如果某一业务方法需要采用不同的事务规则，可以在该业务方法上添加@Transactional注解进行单独设置。

@Transactional 注解也可以设置事务属性的值，默认的@Transactional 设置如下，
1、事务传播设置是 PROPAGATION_REQUIRED.
2、事务隔离级别是 ISOLATION_DEFAULT。
3、食物是读/写
4、事务超时默认是依赖于事务系统的，或者不支持事务超时。
5、任何RuntimeException 将触发事务回滚，但是任何 checked Exception 不会触发事务回滚。

这些属性也是可以改变的，@Transactional 注解的个属性如下：

属性	类型	说明
propagation	枚举型：Propagation	可选的传播性设置。使用列举：@Transaciontal (propagation = Propagation.REQUIRES_NEW)
isolation	枚举型：Isolaction	可选的隔离级别。使用举例：@Transacional(propagation = Isolation.READ_COMMITTED)
readOnly	布尔型	是否为只读事务。使用列举：@Transacional (readOnly = true)
timeout	int 型（以秒为单位）	事务超时。使用列举 @Transacioinal(timeout=10)
roolbackFor	一组Class类是的实例；必须是Throwable 的子类	一组异常类@Transacional(roollbackFor={SQLException.class}),多个异常可以用英文逗号隔开
rollbackFoClassName	一组Class类是的实例必须是Throwable 的子类	一组异常类名，遇到时必须进行回滚。使用举例：@Transactional(rolbackForClassName={“SQLException”}),多个异常用英文逗号隔开
noRollBackFor	一组Class类是的实例必须是Throwable 的子类	一组异常类，遇到时不必进行回滚
noRollbackForClassName	一组Class类是的实例必须是Throwable 的子类	一组异常类名称，遇到时不必进行回滚

总结：

  1、MyBatis-Spring 提供了 SqlSessionTemplate 模板类操作数据库，常用的方法有 selectList()、 insert()、update() 、等，使用 getMapper(ClassType) 可以直接访问接口实例，能够减少错误的发生， 另外不用写 DAO 的实现类。
  2、 使用 MapperFactoryBean 能够以配置的方式得到映射器实现，简化DAO 开发。前提是保证映射命名空间名和接口名称相同，以及映射元素的 id 和接口方法相同。
  3、使用 MapperScannerConfigurer 可以递归扫描 basePackage 所指定的包下的所有接口类， 在 Service 中可以使用 @Autowired 或 @Resource 注解注入这些映射接口的 Bean。
  4、Spring 和 MyBatis 整合可以采用 Spring 的事务管理，包括使用 xml 和注解配置事务管理。