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="https://www.cnblogs.com/paidaxing0623/p/${jdbc.driver}"/>
                   <property name="url" value="https://www.cnblogs.com/paidaxing0623/p/${jdbc.url}"/>
                   <property name="username" value="https://www.cnblogs.com/paidaxing0623/p/${jdbc.username}"/>
                   <property name="password" value="https://www.cnblogs.com/paidaxing0623/p/${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 需要以下版本：

使用 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" >
  <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" >
    <!-- 只能使用構造器注入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" >
    <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" >
       <property name="driverClassName" value="https://www.cnblogs.com/paidaxing0623/p/${jdbc.driver}"/>
       <property name="url" value="https://www.cnblogs.com/paidaxing0623/p/${jdbc.url}"/>
       <property name="username" value="https://www.cnblogs.com/paidaxing0623/p/${jdbc.username}"/>
       <property name="password" value="https://www.cnblogs.com/paidaxing0623/p/${jdbc.password}"/>
   </bean>
   

3. 配置SqlSessionFactory，關聯MyBatis

   <bean id="sqlSessionFactory" >
       <property name="dataSource" ref="dataSource"/>
       <!-- 系結MyBatis組態檔 -->
       <property name="configLocation" value="https://www.cnblogs.com/paidaxing0623/p/classpath:mybatis-config.xml"/>
       <!-- 注冊Mapper檔案 -->
       <property name="mapperLocations" value="https://www.cnblogs.com/paidaxing0623/p/classpath*:com/jh/mapper/*.xml"/>
   </bean>
   

4. 注冊sqlSessionTemplate，關聯sqlSessionFactory；

   <!-- SqlSessionTemplate:就是我們使用的sqlSession -->
   <bean id="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" >
       <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" >
       <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" >
  <property name="mapperInterface" value="https://www.cnblogs.com/paidaxing0623/p/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 >
  <property name="basePackage" value="https://www.cnblogs.com/paidaxing0623/p/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 >
       <property name="sqlSessionFactoryBeanName" value="https://www.cnblogs.com/paidaxing0623/p/sqlSessionFactory"/>
       <!-- 指定掃描的包，即mapper包 -->
       <property name="basePackage" value="https://www.cnblogs.com/paidaxing0623/p/com.jh.mapper"/>
   </bean>
   
   <!-- 注冊UserServiceImpl到Spring -->
   <bean id="userService" >
       <!-- 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的時候還會測驗整合！

標籤：Java

上一篇：虛擬機位元組碼執行引擎 —— 運行時堆疊幀

下一篇：Spring實作宣告式事務