Spring整合MyBatis

1、整合之前的环境准备

1. 导入相关的jar包

   • Junit测试

     <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.2</version>
     </dependency>
     

   • MySQL数据库

     <dependency>
         <groupId>mysql</groupId>
         <artifactId>mysql-connector-java</artifactId>
         <version>5.1.47</version>
     </dependency>
     

   • Spring相关

     <dependency>
         <groupId>org.springframework</groupId>
         <artifactId>spring-webmvc</artifactId>
         <version>5.3.3</version>
     </dependency>
     <dependency>
         <groupId>org.springframework</groupId>
         <artifactId>spring-jdbc</artifactId>
         <version>5.3.3</version>
     </dependency>
     

   • aspectJ AOP 织入器

     <dependency>
         <groupId>org.aspectj</groupId>
         <artifactId>aspectjweaver</artifactId>
         <version>1.9.6</version>
     </dependency>
     

   • mybatis-spring整合包 【重点】

     <dependency>
         <groupId>org.mybatis</groupId>
         <artifactId>mybatis-spring</artifactId>
         <version>2.0.5</version>
     </dependency>
     

2. 配置Maven静态资源过滤问题！

   <build>
      <resources>
          <resource>
              <directory>src/main/java</directory>
              <includes>
                  <include>**/*.properties</include>
                  <include>**/*.xml</include>
              </includes>
              <filtering>true</filtering>
          </resource>
      </resources>
   </build>
   

2、回忆MyBatis

1. 编写一个实体类User

   public class User {
       private Integer id;
       private String name;
       private String pwd;
       // getter and setter
       // 有参和无参
       // toString
   }
   

2. 编写MyBatis核心配置文件

   jdbc.driver=com.mysql.jdbc.Driver
   jdbc.url=jdbc:mysql://localhost:3306/mybatis?useUnicode=true&characterEncoding=utf8&autoReconnect=true&failOverReadOnly=false
   jdbc.username=root
   jdbc.password=123456
   

   <?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>
       <properties resource="jdbc.properties"/>
       <environments default="development">
           <environment id="development">
               <transactionManager type="JDBC"/>
               <dataSource type="POOLED">
                   <property name="driver" value="${jdbc.driver}"/>
                   <property name="url" value="${jdbc.url}"/>
                   <property name="username" value="${jdbc.username}"/>
                   <property name="password" value="${jdbc.password}"/>
               </dataSource>
           </environment>
       </environments>
   </configuration>
   

3. 编写UserMapper接口

   public interface UserMapper {
       List<User> userList();
   }
   

4. 编写接口对应的Mapper.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.jh.mapper.UserMapper">
       <select id="userList" resultType="com.jh.domain.User">
           select * from mybatis.user
       </select>
   </mapper>
   

5. 注册Mapper.xml文件

   <mappers>
       <mapper resource="com/jh/mapper/UserMapper.xml"/>
   </mappers>
   

6. 编写测试类

   @Test
   public void userList() throws IOException {
       String resource = "mybatis-config.xml";
       InputStream stream = Resources.getResourceAsStream(resource);
       SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(stream);
       
       SqlSession sqlSession = sqlSessionFactory.openSession(true);
       UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
       
       List<User> userList = userMapper.userList();
       userList.forEach(System.out::println);
       
       sqlSession.close();
   }
   

7. 输出结果

   User{id=1, name='小王', pwd='123456'}
   User{id=2, name='张三', pwd='123456'}
   User{id=3, name='李四', pwd='123456'}
   

3、MyBatis-Spring学习

引入Spring之前需要了解mybatis-spring包中的一些重要类；

MyBatis-Spring中文官网：https://mybatis.org/spring/zh/index.html

什么是 MyBatis-Spring？

MyBatis-Spring 会帮助你将 MyBatis 代码无缝地整合到 Spring 中。

知识基础

在开始使用 MyBatis-Spring 之前，你需要先熟悉 Spring 和 MyBatis 这两个框架和有关它们的术语。这很重要

MyBatis-Spring 需要以下版本：

MyBatis-Spring	MyBatis	Spring Framework	Spring Batch	Java
2.0	3.5+	5.0+	4.0+	Java 8+
1.3	3.4+	3.2.2+	2.1+	Java 6+

使用 Maven 作为构建工具，仅需要在 pom.xml 中加入以下代码即可：

<dependency>
  <groupId>org.mybatis</groupId>
  <artifactId>mybatis-spring</artifactId>
  <version>2.0.6</version>
</dependency>

和 Spring 一起使用 MyBatis，需要在 Spring 应用上下文中定义至少两样东西：一个 SqlSessionFactory 和至少一个数据映射器类。

在 MyBatis-Spring 中，可使用 SqlSessionFactoryBean来创建 SqlSessionFactory。 要配置这个工厂 bean，只需要把下面代码放在 Spring 的 XML 配置文件中：

<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
  <property name="dataSource" ref="dataSource" />
</bean>

注意：SqlSessionFactory 需要一个 DataSource（数据源）。这可以是任意的 DataSource，只需要和配置其它 Spring 数据库连接一样配置它就可以了。常用第三方数据源：dbcp，c3p，druid

在基础的 MyBatis 用法中，是通过 SqlSessionFactoryBuilder 来创建 SqlSessionFactory 的。而在 MyBatis-Spring 中，则使用 SqlSessionFactoryBean 来创建。

在 MyBatis 中，你可以使用 SqlSessionFactory 来创建 SqlSession。一旦你获得一个 session 之后，你可以使用它来执行映射了的语句，提交或回滚连接，最后，当不再需要它的时候，你可以关闭 session。

SqlSessionFactory有一个唯一的必要属性：用于 JDBC 的 DataSource。这可以是任意的 DataSource 对象，它的配置方法和其它 Spring 数据库连接是一样的。

一个常用的属性是 configLocation，它用来指定 MyBatis 的 XML 配置文件路径。它在需要修改 MyBatis 的基础配置非常有用。通常，基础配置指的是 < settings> 或 < typeAliases>元素。

需要注意的是，这个配置文件并不需要是一个完整的 MyBatis 配置。确切地说，任何环境配置（），数据源（）和 MyBatis 的事务管理器（）都会被忽略。SqlSessionFactoryBean 会创建它自有的 MyBatis 环境配置（Environment），并按要求设置自定义环境的值。

SqlSessionTemplate 是 MyBatis-Spring 的核心。作为 SqlSession 的一个实现，这意味着可以使用它无缝代替你代码中已经在使用的 SqlSession。

模板可以参与到 Spring 的事务管理中，并且由于其是线程安全的，可以供多个映射器类使用，你应该总是用 SqlSessionTemplate 来替换 MyBatis 默认的 DefaultSqlSession 实现。在同一应用程序中的不同类之间混杂使用可能会引起数据一致性的问题。

可以使用 SqlSessionFactory 作为构造方法的参数来创建 SqlSessionTemplate 对象。

<bean id="sqlSessionTemplate" class="org.mybatis.spring.SqlSessionTemplate">
    <!-- 只能使用构造器注入sqLSessionFactory，因为它没有set方法- -->
    <constructor-arg name="sqlSessionFactory" ref="sqlSessionFactory"/>
</bean>

现在，这个 bean 就可以直接注入到你的 DAO bean 中了。你需要在你的 bean 中添加一个SqlSessionTemplate 属性，就像下面这样：

public class UserMapperImpl implements UserMapper {
    private SqlSessionTemplate sessionTemplate;

    public void setSessionTemplate(SqlSessionTemplate sessionTemplate) {
        this.sessionTemplate = sessionTemplate;
    }

    @Override
    public List<User> userList() {
        UserMapper mapper = sessionTemplate.getMapper(UserMapper.class);
        return mapper.userList();
    }
}

按下面这样，注入 SqlSessionTemplate：

<bean id="userMapper" class="com.jh.mapper.UserMapperImpl">
    <property name="sessionTemplate" ref="sqlSessionTemplate"/>
</bean>

4、实现整合方式一

1. 编写Spring配置文件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"
          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 
          https://www.springframework.org/schema/context/spring-context.xsd">
   </beans>
   

2. 配置数据源替换mybaits的数据源

   jdbc.driver=com.mysql.jdbc.Driver
   jdbc.url=jdbc:mysql://127.0.0.1:3306/mybatis?useUnicode=true&characterEncoding=utf8&autoReconnect=true&failOverReadOnly=false
   jdbc.username=root
   jdbc.password=123456
   

   <!-- 导入数据库连接信息 -->
   <context:property-placeholder location="classpath*:jdbc.properties"/>
   <!-- 数据源：DataSource;使用Spring的数据源替换Mybatis的配置  c3p，dbcp druid spring-->
   <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
       <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>
   

3. 配置SqlSessionFactory，关联MyBatis

   <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
       <property name="dataSource" ref="dataSource"/>
       <!-- 绑定MyBatis配置文件 -->
       <property name="configLocation" value="classpath:mybatis-config.xml"/>
       <!-- 注册Mapper文件 -->
       <property name="mapperLocations" value="classpath*:com/jh/mapper/*.xml"/>
   </bean>
   

4. 注册sqlSessionTemplate，关联sqlSessionFactory；

   <!-- SqlSessionTemplate:就是我们使用的sqlSession -->
   <bean id="sqlSessionTemplate" class="org.mybatis.spring.SqlSessionTemplate">
       <!-- 只能使用构造器注入sqLSessionFactory，因为它没有set方法- -->
       <constructor-arg name="sqlSessionFactory" ref="sqlSessionFactory"/>
   </bean>
   

5. 增加Dao接口的实现类；私有化sqlSessionTemplate

   public class UserMapperImpl implements UserMapper {
       private SqlSessionTemplate sessionTemplate;
   
       public void setSessionTemplate(SqlSessionTemplate sessionTemplate) {
           this.sessionTemplate = sessionTemplate;
       }
   
       @Override
       public List<User> userList() {
           UserMapper mapper = sessionTemplate.getMapper(UserMapper.class);
           return mapper.userList();
       }
   }
   

6. 注册bean实现；

   <!-- 注册UserMapperImpl到Spring -->
   <bean id="userMapper" class="com.jh.mapper.UserMapperImpl">
       <property name="sessionTemplate" ref="sqlSessionTemplate"/>
   </bean>
   

7. 测试；

   @Test
   public void userList() throws IOException {
       ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
       UserMapper userMapper = context.getBean("userMapper", UserMapper.class);
       List<User> userList = userMapper.userList();
       userList.forEach(System.out::println);
   }
   

结果成功输出！现在我们的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>

</configuration>

4、实现整合方式二

mybatis-spring1.2.3版以上的才有这个。

官方文档截图：

dao继承Support类，直接利用 getSqlSession() 获得，然后直接注入SqlSessionFactory。比起方式1，不需要管理SqlSessionTemplate，而且对事务的支持更加友好。可跟踪源码查看

具体实现：

1. 修改上面写的UserMapperImpl

   public class UserMapperImpl extends SqlSessionDaoSupport implements UserMapper {
       @Override
       public List<User> userList() {
           return super.getSqlSession().getMapper(UserMapper.class).userList();
       }
   }
   

2. 修改applicationContext.xml的配置

   <bean id="userMapper" class="com.jh.mapper.UserMapperImpl">
       <property name="sqlSessionFactory" ref="sqlSessionFactory"/>
   </bean>
   

3. 测试

   @Test
   public void userList() throws IOException {
       ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
       UserMapper userMapper = context.getBean("userMapper", UserMapper.class);
       List<User> userList = userMapper.userList();
       userList.forEach(System.out::println);
   }
   

5、实现整合方式三

为了代替手工使用SqlSessionDaoSupport或SqlSessionTemplate编写数据访问对象(DAO)的代码，使用动态代理实现，MapperFactoryBean出现了。

这个类 可以让你直接注入数据映射器接口到你的 service 层 bean 中。当使用映射器时,你仅仅如调用你的DAO一样调用它们就可以了,但是你不需要编写任何 DAO 实现的代码,因为 MyBatis-Spring 将会为你创建代理。

先查看官网的配置：

<bean id="userMapper" class="org.mybatis.spring.mapper.MapperFactoryBean">
  <property name="mapperInterface" value="org.mybatis.spring.sample.mapper.UserMapper" />
  <property name="sqlSessionFactory" ref="sqlSessionFactory" />
</bean>

org.mybatis.spring.sample.mapper.UserMapper是一个接口，我们创建一个MapperFactoryBean实例，然后注入这个接口和sqlSessionFactory（mybatis中提供的SqlSessionFactory接口，MapperFactoryBean会使用SqlSessionFactory创建SqlSession）这两个属性。

之后想使用这个UserMapper接口的话，直接通过spring注入这个bean，然后就可以直接使用了，spring内部会创建一个这个接口的动态代理。

当发现要使用多个MapperFactoryBean的时候，一个一个定义肯定非常麻烦，于是mybatis-spring提供了MapperScannerConfigurer这个类,它将会查找类路径下的映射器并自动将它们创建成MapperFactoryBean。

<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
  <property name="basePackage" value="org.mybatis.spring.sample.mapper" />
</bean>

这段配置会扫描org.mybatis.spring.sample.mapper下的所有接口，然后创建各自接口的动态代理类。

具体代码实现：

1. 编写Mapper接口

   public interface UserMapper {
       List<User> userList();
   }
   

2. 编写Service方法和对应实现类

   public interface UserService {
       List<User> userList();
   }
   

   public class UserServiceImpl implements UserService {
       private UserMapper userMapper;
   
       public void setUserMapper(UserMapper userMapper) {
           this.userMapper = userMapper;
       }
   
       @Override
       public List<User> userList() {
           return null;
       }
   }
   

3. 编写spring配置文件

   <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
       <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
       <!-- 指定扫描的包，即mapper包 -->
       <property name="basePackage" value="com.jh.mapper"/>
   </bean>
   
   <!-- 注册UserServiceImpl到Spring -->
   <bean id="userService" class="com.jh.service.impl.UserServiceImpl">
       <!-- userMapper由MapperScannerConfigurer自动创建，并注入到UserServiceImpl -->
       <property name="userMapper" ref="userMapper"/>
   </bean>
   

4. 测试

   @Test
   public void userList() throws IOException {
       ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
       UserService userService = context.getBean("userService", UserService.class);
       List<User> userList = userService.userList();
       userList.forEach(System.out::println);
   }
   

【总结】 :整合到spring以后可以完全不要mybatis的配置文件，除了这些方式可以实现整合之外，我们还可以使用注解来实现，这个等我们后面学习SpringBoot的时候还会测试整合！