Spring与MyBatis的整和方式汇总（详细）

Spring与MyBatis的整和方式汇总（详细）

方式一、继承SqlSessionDaoSupport方式

1、导入相关依赖，依赖的作用看注释

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
   <parent>
       <artifactId>spring-02</artifactId>
       <groupId>com.heyuanhang</groupId>
       <version>1.0-SNAPSHOT</version>
   </parent>
   <modelVersion>4.0.0</modelVersion>

   <artifactId>spring-mybatis01</artifactId>
   <!--   引入相关的依赖-->
   <!--    Spring的相关依赖-->
   
   <dependencies>
    <!--   spring-webmvc依赖包括了spring的基本依赖包，也加入了aop的依赖-->
       <dependency>
           <groupId>org.springframework</groupId>
           <artifactId>spring-webmvc</artifactId>
           <version>5.3.8</version>
       </dependency>
       <!-- spring-jdbc:其中包含了一些操作数据库的封装类-->
       <dependency>
           <groupId>org.springframework</groupId>
           <artifactId>spring-jdbc</artifactId>
           <version>5.3.8</version>
       </dependency>
       <!--        单元测试-->
       <dependency>
           <groupId>junit</groupId>
           <artifactId>junit</artifactId>
           <version>4.12</version>
           <scope>test</scope>
       </dependency>
       <!--        Mybatis相关依赖-->
       <dependency>
           <groupId>org.mybatis</groupId>
           <artifactId>mybatis</artifactId>
           <version>3.5.7</version>
       </dependency>
       <dependency>
           <groupId>org.mybatis</groupId>
           <artifactId>mybatis-spring</artifactId>
           <version>2.0.6</version>
       </dependency>
       <!--        数据库驱动-->
       <dependency>
           <groupId>mysql</groupId>
           <artifactId>mysql-connector-java</artifactId>
           <version>5.1.29</version>
       </dependency>
       <!--        数据源-->
       <dependency>
           <groupId>com.alibaba</groupId>
           <artifactId>druid</artifactId>
           <version>1.1.10</version>
       </dependency>
   </dependencies>
   <!--    静态资源过滤问题，不加这个的话可能导致类路径下的静态资源无法被导出，导致编译器不能加载到配置文件-->
   <build>
       <resources>
           <resource>
               <directory>src/main/java</directory>
               <includes>
                   <include>**/*.properties</include>
                   <include>**/*.xml</include>
               </includes>
               <filtering>false</filtering>
           </resource>
           <resource>
               <directory>src/main/resources</directory>
               <includes>
                   <include>**/*.properties</include>
                   <include>**/*.xml</include>
               </includes>
               <filtering>false</filtering>
           </resource>
       </resources>
   </build>
</project>

除了上述的依赖外，如果还需要其他功能的是实现，就得加入相关依赖

比如要使用aop时，还需要加入:

<!--        AOP联盟的规范包-->
       <dependency>
           <groupId>aopalliance</groupId>
           <artifactId>aopalliance</artifactId>
           <version>1.0</version>
       </dependency>
       <!--        AOP的AspectJ支持-->
       <dependency>
           <groupId>org.aspectj</groupId>
           <artifactId>aspectjweaver</artifactId>
           <version>1.9.6</version>
       </dependency>

注意：通过maven创建的项目时，还需要配置静态资源导出问题的配置，因为由于maven的约定大于配置，可能会导致类路径下的一些自定义配置文件不能正确的读取到，所以在pom.xml中配置了静态资源导出的问题

2、将数据库的连接操作，以及数据源的管理由之前mybatis自己管理，现在交给spring管理

这很好的体现了spring的IOC（控制反转）带来的好处

具体配置如下:
spring-dao.xml(名字自定义，我习惯命名成spring-dao.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:context="http://www.springframework.org/schema/context"
      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.xsd">
   <!--    引入外部配置文件-->
   <context:property-placeholder location="classpath:db.properties"/>
   <!--       配置数据源-->
   <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
       <property name="driverClassName" value="${jdbc.driver}"/>
       <property name="url" value="${jdbc.url}"/>
       <property name="username" value="${jdbc.username}"/>
       <property name="password" value="${jdbc.password}"/>
   </bean>
   <!--    构建一个SqlSessionFactory :由SqlSessionFactoryBean生成（在Mybatis-spring包中）-->
   <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
       <property name="dataSource" ref="dataSource"/>
       <!--        加载Mybatis的主配置文件-->
       <property name="configLocation" value="classpath:mybatis-config.xml"/>
   </bean>
</beans>

对于上述的配置文件，部分说明如下：

1.因为使用自己的java代码与数据库进行连接，这样在数据访问过多时，会给数据库造成一定的压力，当数据访问达到上限时，每次创建连接后，如果忘记关闭，情况严重的情况下，就会导致数据库崩溃。因此这个时候，数据源就显得尤为重要，我们把数据库的连接，以及相关实列的创建，统统交给数据源给我们管理，这个时候，我们就可以自定义初始化连接数，最大连接数等等一系列规则，这样在访问数据库时，就会变得高效，同时也减少了数据库服务器的压力。采用德鲁伊数据源的原因是，因为其稳定、高效的特点。

2.当我们关闭一些连接时，比如，connection.close(),这个时候，并不是关闭了数据源与数据库的真时连接，而是将当前的这个连接又返回了数据库连接池中，在需要连接时，从数据源连接池中取出来即可。

3.我们知道在基础的 MyBatis 用法中，是通过 SqlSessionFactoryBuilder 来创建 SqlSessionFactory
的。 而在 MyBatis-Spring 中，则使用 SqlSessionFactoryBean 来创建。在 MyBatis 中，你可以使用 SqlSessionFactory 来创建 SqlSession 。一旦你获得一个session 之后，你可以使用它来执行映射了的语句，提交或回滚连接，最后，当不再需要它的时候，你可以关闭 session。SqlSessionFactory 有一个唯一的必要属性：用于 JDBC 的 DataSource 。这可以是任意的DataSource 对象，它的配置方法和其它 Spring 数据库连接是一样的。

4.SqlSessionFactoryBean一个常用的属性是 configLocation ，它用来指定 MyBatis 的 XML 配置文件路径。它在需要修改MyBatis 的基础配置非常有用。通常，基础配置指的是 或 元素。需要注意的是，这个配置文件并不需要是一个完整的 MyBatis 配置。确切地说，任何环境配置（ environments>），数据源（Datasource>）和 MyBatis 的事务管理器都会被忽略。 SqlSessionFactoryBean 会创建它自有的 MyBatis环境配置（ Environment ），并按要求设置自定义环境的值。

db.properties:

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://127.0.0.1:3306/jdbc?ServerTimeZone=UTC
jdbc.username=root
jdbc.password=自己的数据库密码

mybatis-config.xml
mybatis的总配置文件，与spring整合后，一般用于配置一些类的别名。开启驼峰命名规则等

<?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>
   <typeAliases>
       <package name="com.heyuanhang.pojo"/>
   </typeAliases>
   <mappers>
       <mapper resource="com/heyuanhang/mapper/UserMapper.xml"></mapper>
   </mappers>
</configuration>

UserMapper.xml
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 namespace="com.heyuanhang.mapper.UserMapper">
   <select id="getAll" resultType="user">
   select * from `user` ;
 </select>
</mapper>

一些类：
UserMapper:

package com.heyuanhang.mapper;

import com.heyuanhang.pojo.User;

import java.util.List;

/**
* @Author 何远航
* @Date: 2021/8/3 23:34
* @Version 1.8
*/
public interface UserMapper {
   //查询所有用户
   public List<User> getAll();
}

userDao

package com.heyuanhang.mapper;

import com.heyuanhang.pojo.User;
import org.apache.ibatis.session.SqlSession;
import org.mybatis.spring.support.SqlSessionDaoSupport;

import java.util.List;

/**
* @Author 何远航
* @Date: 2021/8/4 12:19
* @Version 1.8
*/
//SqlSessionDaoSupport:通过getSession获得SqlSession
public class UserDao extends SqlSessionDaoSupport {

   //调用UserMapper查询方法
   public List<User> getAll() {
       UserMapper userMapper = this.getSqlSession().getMapper(UserMapper.class);
       List<User> userList = userMapper.getAll();
       return userList;
   }
}

为了更好的分层，将一些需要的实例的类的bean统一放在一个配置文件中
我这里放在了spring-service.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"
      xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
  <import resource="spring-dao.xml"/>
   <bean id="user" class="com.heyuanhang.mapper.UserDao">
      <property name="sqlSessionFactory" ref="sqlSessionFactory"/>
  </bean>
</beans>

为什么上述的UserDao在实例化时要注入sqlSessionFactory

因为，UserDao继承了SqlSessionDaoSupport,自然就获得了父类的一些方法与属性，
现在需要父类的getSqlSession()方法获取到SqlSession,那么就得为其中的属性sqlSessionFactory注入spring为我们生产的sqlSessionFactory

import :是导入另外的配置文件

然后将spring-service.xml导入到applicationContext.xml中：
applicationContext.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"
      xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
   <import resource="classpath:spring-service.xml"/>
</beans>

进行测试:

在测试之前，看一下数据表内容:

1.进入mysql服务:

选择数据库，查看表

查看表结构

编写实体类:
User:

package com.heyuanhang.pojo;

/**
 * @Author 何远航
 * @Date: 2021/8/1 22:38
 * @Version 1.8
 */
public class User {
   private Integer id;
   private String name;
   private String email;

   public Integer getId() {
       return id;
   }

   public void setId(Integer id) {
       this.id = id;
   }

   public String getName() {
       return name;
   }

   public void setName(String name) {
       this.name = name;
   }

   public String getEmail() {
       return email;
   }

   public void setEmail(String email) {
       this.email = email;
   }

   @Override
   public String toString() {
       return "User{" +
               "id=" + id +
               ", name='" + name + '\'' +
               ", email='" + email + '\'' +
               '}';
   }
}

只是简单的测试，只进行了部分属性的声明

编写测试类，进行单元测试:

package com.heyuanhang;
import com.heyuanhang.mapper.UserDao;
import com.heyuanhang.pojo.User;
import org.junit.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import java.util.List;
/**
* @Author 何远航
* @Date: 2021/8/4 12:26
* @Version 1.8
*/
public class MyTest {
   @Test
   public void testMybatis() {
       ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
       UserDao user = (UserDao) context.getBean("user");
       List<User> userAll = user.getAll();
       for (User user1 : userAll) {
           System.out.println(user1);
       }
   }
}

测试结果:

方式二，将SqlSession，交给Spring生产

这种方式，和方式一基本类似，只是显示的产生SqlSession

实体类和依赖都和方式是一样，其余的配置也一样，不一样的配置在
spring-dao.xml中，将SqlSession的生产，交给Spring

spring.dao.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:context="http://www.springframework.org/schema/context"
       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.xsd">
    <!--    引入外部配置文件-->
    <context:property-placeholder location="classpath:db.properties"/>
    <!--       配置数据源-->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${jdbc.driver}"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>
    <!--    构建一个SqlSessionFactory :由SqlSessionFactoryBean生成（在Mybatis-spring包中）-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <!--        加载Mybatis的主配置文件-->
        <property name="configLocation" value="classpath:mybatis-config.xml"/>
    </bean>

    <!--    spring生产SqlSession-->
    <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
        <constructor-arg index="0" ref="sqlSessionFactory"/>
    </bean>

    <bean id="userService" class="com.heyuanhang.service.UserService"/>
    <!--    开启注解支持-->
    <context:annotation-config/>
</beans>

新增的类：
UserService：

package com.heyuanhang.service;

import com.heyuanhang.mapper.UserMapper;
import com.heyuanhang.pojo.User;
import org.apache.ibatis.session.SqlSession;
import org.mybatis.spring.SqlSessionTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;

import java.util.List;

/**
* @Author 何远航
* @Date: 2021/8/4 13:48
* @Version 1.8
*/
public class UserService {

   @Autowired//默认按照类类型进行属性注入
   @Qualifier("sqlSession")//按照属性名进行属性注入，不能单独使用
   //定义SqlSession
   private SqlSession sqlSession;
   //查询所有的用户
   public List<User> getAllUser() {
       //底层会进行动态代理生成，动态代理对象
       //会涉及到配置文件的解析之类的
       UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
       return userMapper.getAll();
   }
}

进行单元测试：
（数据表与实体类与方式一致）

@Test
   public void testMybatis01() {
       ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("spring-dao1.xml");
       UserService userService = (UserService) context.getBean("userService");
       List<User> userAll = userService.getAllUser();
       for (User user1 : userAll) {
           System.out.println(user1);
       }
   }

测试结果:

方式三：基于MapperFactoryBean的方式整合Mybatis

通过方式一与方式二的整合，发现步骤有点繁琐，并且会出现很多相同的代码。这样就引出了使用Mybatis提供的另外一种编程方式，，即使用Mapper接口编程。

1、那么MapperFactoryBean是什么？

MapperFactoryBean是Mybatis-spring团队提供的一个根据Mappr接口生成Mapper对象的类(利用反射，进行动态代理)。该类在Spring配置文件中，可以使用的参数有:

(1) mapperInterface：用于指定接口
(2)sqlSessionFactory:(SqlSession构造工厂):用于指定sqlSessionFactory,也可指定SqlSessionTemplate,如果同时指定，只能启用 sqlSessionFactory

2.上整合案例:

引入的依赖以及实体类和方式一一致：

这里再写一遍:

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
   <parent>
       <artifactId>spring-02</artifactId>
       <groupId>com.heyuanhang</groupId>
       <version>1.0-SNAPSHOT</version>
   </parent>
   <modelVersion>4.0.0</modelVersion>

   <artifactId>spring-mybatis01</artifactId>
   <!--   引入相关的依赖-->
   <!--    Spring的相关依赖-->
   <dependencies>
       <dependency>
           <groupId>org.springframework</groupId>
           <artifactId>spring-webmvc</artifactId>
           <version>5.3.8</version>
       </dependency>
       <!-- spring-jdbc:其中包含了一些操作数据库的封装类-->
       <dependency>
           <groupId>org.springframework</groupId>
           <artifactId>spring-jdbc</artifactId>
           <version>5.3.8</version>
       </dependency>
       <!--        单元测试-->
       <dependency>
           <groupId>junit</groupId>
           <artifactId>junit</artifactId>
           <version>4.12</version>
           <scope>test</scope>
       </dependency>
       <!--        Mybatis相关依赖-->
       <dependency>
           <groupId>org.mybatis</groupId>
           <artifactId>mybatis</artifactId>
           <version>3.5.7</version>
       </dependency>
       <dependency>
           <groupId>org.mybatis</groupId>
           <artifactId>mybatis-spring</artifactId>
           <version>2.0.6</version>
       </dependency>
       <!--        数据库驱动-->
       <dependency>
           <groupId>mysql</groupId>
           <artifactId>mysql-connector-java</artifactId>
           <version>5.1.29</version>
       </dependency>
       <!--        数据源-->
       <dependency>
           <groupId>com.alibaba</groupId>
           <artifactId>druid</artifactId>
           <version>1.1.10</version>
       </dependency>
   </dependencies>
   <!--    静态资源过滤问题，不加这个的话可能导致类路径下的静态资源无法被导出，导致编译器不能加载到配置文件-->
   <build>
       <resources>
           <resource>
               <directory>src/main/java</directory>
               <includes>
                   <include>**/*.properties</include>
                   <include>**/*.xml</include>
               </includes>
               <filtering>false</filtering>
           </resource>
           <resource>
               <directory>src/main/resources</directory>
               <includes>
                   <include>**/*.properties</include>
                   <include>**/*.xml</include>
               </includes>
               <filtering>false</filtering>
           </resource>
       </resources>
   </build>
</project>

实体类:User和上述的User一值，只是一个普通的POJO类。

spring配置文件（连接数据库，配置数据源一切操作）
spring-dao2.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:context="http://www.springframework.org/schema/context"
      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.xsd">
   <!--    引入外部配置文件-->
   <context:property-placeholder location="classpath:db.properties"/>
   <!--       配置数据源-->
   <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
       <property name="driverClassName" value="${jdbc.driver}"/>
       <property name="url" value="${jdbc.url}"/>
       <property name="username" value="${jdbc.username}"/>
       <property name="password" value="${jdbc.password}"/>
   </bean>
   <!--    构建一个SqlSessionFactory :由SqlSessionFactoryBean生成（在Mybatis-spring包中）-->
   <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
       <property name="dataSource" ref="dataSource"/>
       <!--        加载Mybatis的主配置文件-->
       <property name="configLocation" value="classpath:mybatis-config.xml"/>
   </bean>

   <!--    spring生产SqlSession-->
   <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
       <constructor-arg index="0" ref="sqlSessionFactory"/>
   </bean>
   <bean id="userMapper1" class="org.mybatis.spring.mapper.MapperFactoryBean">
       <!--接口：底层实现动态代理需要-->
       <property name="mapperInterface" value="com.heyuanhang.mapper.UserMapper1"/>
       <property name="sqlSessionFactory" ref="sqlSessionFactory"/>
   </bean>
</beans>

上述的大部分配置和方式一、二都是一样的，不一样的是，增加了MapperFactoryBean的配置，为这个类的实例注入了UserMapper1,UserMapper1是一个Mapper接口，同时注入了sqlSessionFactory,对注入的两个属性可以简单的理解成，注入Mapper接口就是为了进行动态代理，生成动态代理对象，这样我们就不需要写Mapper层的实现类来具体的操作数据库了。注入sqlSessionFactory是为了得到SqlSession会话对象。

UserMapper1类:

package com.heyuanhang.mapper;

import com.heyuanhang.pojo.User;

import java.util.List;

/**
* @Author 何远航
* @Date: 2021/8/3 23:34
* @Version 1.8
*/
public interface UserMapper1 {
   //查询所有用户
   public List<User> getAll();
}

UserMapper1.xmlSQL映射文件:(和UserMapper1在同一目录下)

<?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.heyuanhang.mapper.UserMapper1">
   <select id="getAll" resultType="user">
   select * from `user` ;
 </select>
</mapper>

单元测试:

   @Test
   public void testMybatis02() {
       ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("spring-dao2.xml");
       //获取UserMapper1的Class对象然后传入
       UserMapper1 userMapper1 = context.getBean(UserMapper1.class);
       List<User> users = userMapper1.getAll();
       for (User user1 : users) {
           System.out.println(user1);
       }
   }

测试结果:

可以看出，Mapper接口编程方式只需要程序猿编写Mapper接口（有些也写成Dao接口），然后由Mybatis框架根据接口的定义创建接口的动态代理对象。
注意
想要实现前面的面向Mapper接口方式编程，必须满足以下条件:
（1）Mapper接口的名称与对应的SQL映射文件Mapper.xml的名称必须一致,比如案例中的UserMapper1与UserMapper1.xml。
（2）Mapper.xml中namespace与Mapper接口的类路径相同，简而言之就是Mapper.xml与Mapper接口要在同一个包中。
（3）Mapper接口中的方法名要和Mapper.xml中定义每一个执行语句的id相同
（4）Mapper接口中的方法传入的参数类型要和Mapper.xml中定义的每个sql的parameterType的类型一致，简而言之就是Mapper接口中每一个方法都会在映射文件Mapper.xml中对应一个要执行的SQL语句块，比如select、update等，如果接口中的方法需要传入参数，那么这些select、update标签就会有parameterType来指定传入的参数类型，这就要求两者指定的参数类型一致，否则将会抛出异常。
（5）Mapper接口中的方法的返回值，要与在Mapper.xml中对应的sql语句标签中的resultType类型一致，否则抛异常。

只要遵循了上述的规范，Mybatis就可以自动生成Mapper接口的代理对象，从而简化开发，如果不遵循就会抛出大量异常。

方式四、基于MapperScannerConfiguer的整合

从方式三可以看出，在一定程度上，简化了开发，但是会发现，当有较多的Mapper接口时，就需要在配置文件中，配置很多的Mapper接口，这不仅会导致工作量增加，同时还会造成spring的配置文件过于臃肿，不便于后期的维护。

为此，Mybatis-spring团队提供了一种自动化扫描的形式来配置Mybatis中的映射器，采用MapperScannerConfiguer

关于MapperScannerConfiguer类在spring配置文件中，常见的属性有:
(1)basePackage：指定了映射接口文件所在的包路径，当需要扫描多个包时，用,分隔，指定包路径后，会扫描根包以及字包下的所有文件（接口等）
(2)annotationClass：指定了要扫描的注解名称，只有被注解标识的类才会被配置成映射器。
(3)SqlSessionFactoryBeanName：指定在Spring中定义的SqlSessionTemplate的Bean名称，如果定义了该属性SqlSessionFactory就不会起作用
(4)markInterface：指定创建映射器的接口

案例体现：

依赖于实体类，依然如上，同样采用方式三的相关类进行测试:

只改变spring-dao2.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:context="http://www.springframework.org/schema/context"
       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.xsd">
    <!--    引入外部配置文件-->
    <context:property-placeholder location="classpath:db.properties"/>
    <!--       配置数据源-->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${jdbc.driver}"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>
    <!--    构建一个SqlSessionFactory :由SqlSessionFactoryBean生成（在Mybatis-spring包中）-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <!--        加载Mybatis的主配置文件-->
        <property name="configLocation" value="classpath:mybatis-config.xml"/>
    </bean>

    <!--    spring生产SqlSession-->
    <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
        <constructor-arg index="0" ref="sqlSessionFactory"/>
    </bean>
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <!--        配置指定要扫描的Mapper接口所在的包-->
        <property name="basePackage" value="com.heyuanhang.mapper"/>
    </bean>
</beans>

单元测试时类:

 @Test
   public void testMybatis03() {
       ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("spring-dao3.xml");
       //Mybatis已经为mapper包下的所有接口自动生成了动态代理对象
       //因此可以直接向IOC容器取，生成的动态代理对象名称默认是接口名首字母小写
       UserMapper1 userMapper1 = (UserMapper1) context.getBean("userMapper1");
       List<User> users = userMapper1.getAll();
       for (User user1 : users) {
           System.out.println(user1);
       }
   }

测试结果:

Spring整合Mybatis成功

由此可看出，方式4是效率最高的，代码量相对较少，显得不臃肿，便于后期的维护~~~~，推荐使用方式4的方式进行spring与Mybatis的整合。