3.0 mybatis与spring整合

2018-05-22 21:49:58 680 0

 本文介绍了mybatis与spring整合的多种方式,带你一步一步由浅入深的彻底掌握mybatis与spring整合的原理。让你知其然,也知其所以然!堪称史上最全面的mybatis与spring整合教程。

本文总共分为以下10个部分:

  • 整合一:基本依赖

  • 整合二:SqlSessionFactoryBean

  • 整合三:SqlSessionTemplate

  • 整合四:SqlSessionDaoSupport

  • 整合五:MapperFactoryBean

  • 整合六:MapperScannerConfigurer

  • 整合七:@MapperScan

  • 整合八:事务

  • 整合九:springboot

  • 整合十:多数据源 

整合一:基本依赖

mybatis可以单独使用,也可以与spring进行整合。我们在自己的项目中,需要引入相关依赖,如你的项目管理工具使用的是maven,可以在pom.xml中添加以下配置

  <!--spring依赖-->
  <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-jdbc</artifactId>
      <version>4.3.17.RELEASE</version>
  </dependency>
  <dependency>
     <groupId>org.springframework</groupId>
     <artifactId>spring-context</artifactId>
     <version>4.3.17.RELEASE</version>
  </dependency>
  <!--mybatis spring 依赖-->
  <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis-spring</artifactId>
      <version>1.3.0</version>
  </dependency>
  <!--mybatis依赖-->
  <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis</artifactId>
      <version>3.4.0</version>
  </dependency>
  <!--数据库连接池依赖-->
  <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>druid</artifactId>
      <version>1.1.9</version>
  </dependency>
  <!--数据库驱动依赖-->
  <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>5.1.39</version>
  </dependency>

在整合之后,框架的之间的依赖关系如下图所示:

E6D39978-5E6E-4C68-81B7-0D2C1CDEED0B.png

整合二:SqlSessionFactoryBean

    在单独使用mybatis时,我们通过SqlSessionFactoryBuilder 来创建SqlSessionFactory。当mybatis与spring进行整合时,我们使用mybatis-spring提供的SqlSessionFactoryBean 来替代,SqlSessionFactoryBean实现了 Spring 的 FactoryBean 接口,用于创建 SqlSessionFactory 对象实例。

    SqlSessionFactoryBean的配置有2种风格:

  • 保留mybatis的核心配置文件

  • 不保留mybatis的核心配置文件


1、保留mybatis的核心配置文件

我们将绝大部分关于mybatis的配置依然保留在mybatis的核心配置文件mybatis-config文件中,以下是一个示例:

mybatis-config.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>
    <settings>
        <setting name="cacheEnabled" value="true"/>
        <setting name="mapUnderscoreToCamelCase" value="true"/>
        <setting name="defaultExecutorType" value="SIMPLE"/>
    </settings>
    <typeAliases>
        <package name="com.tianshouzhi.mybatis.entity"/>
    </typeAliases>
    <mappers>
        <mapper resource="mybatis/mappers/UserMapper.xml"/>
    </mappers>
</configuration>

细心的读者注意到,在mybatis-config.xml文件中我们并没有通过<environment>的子元素<dataSource>、<transactionManager>来配置数据源和事务管理器。即使配置了,也会被SqlSessionFactoryBean忽略。我们需要显式的为SqlSessionFactoryBean的dataSource属性引用一个数据源配置,如果不指定,在其初始化时就会抛出异常。

此时SqlSessionFactoryBean配置方式如下: 

<!—-SqlSessionFactoryBean-—>
<bean id="sqlSessionFactory" class=“org.mybatis.spring.SqlSessionFactoryBean">
     <!--数据源配置-->
     <property name="dataSource" ref=“dataSource"/>
     <!--通过configLocation属性指定mybatis核心配置文件mybatis-config.xml路径-->
     <property name="configLocation" value="classpath:mybatis/mybatis-config.xml"/>
</bean>
<!--数据源使用阿里巴巴的druid-->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="username" value="root"/>
        <property name="password" value="your password"/>
        <property name="url" value="jdbc:mysql://localhost:3306/mybatis"/>
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <!--其他配置-->
</bean>


2、不保留mybatis的核心配置文件

    从mybatis-spring 1.3.0之后,我们可以移除mybatis-config.xml文件,将所有关于myabtis的配置都通过SqlSessionFactoryBean来指定。

以下配置案例演示了与上述等价的配置: 

<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <property name="typeAliasesPackage" value="com.tianshouzhi.zebracost.entity”/>
        <!--从类路径下加载在mybatis/mappers包和它的子包中所有的 MyBatis 映射器 XML 文件-->
        <property name="mapperLocations" value="classpath*:mybatis/mappers/**/*.xml"></property>
        <property name="configuration">
            <bean class="org.apache.ibatis.session.Configuration">
                <property name="mapUnderscoreToCamelCase" value="true"/>
                <property name="cacheEnabled" value="true"/>
                <property name="defaultExecutorType" value="SIMPLE"/>
            </bean>
        </property>
 </bean>

在mybatis与spring整合后, 通常我们不会再直接使用SqlSessionFactory。mybatis-spring提供了其他更加易于操作的辅助类,如SqlSessionTemplateSqlSessionDaoSupport,当然还有其他更加高级的使用方式,如:MapperFactoryBeanMapperScannerConfigurer

整合三:使用SqlSessionTemplate

     SqlSessionTemplate 是 mybatis-spring 的核心,其实现了SqlSession接口。在使用了SqlSessionTemplate之后,我们不再需要通过SqlSessionFactory.openSession()方法来创建SqlSession实例;使用完成之后,也不要调用SqlSession.close()方法进行关闭。另外,对于事务,SqlSessionTemplate 将会保证使用的 SqlSession 是和当前 Spring 的事务相关的。

SqlSessionTemplate依赖于SqlSessionFactory,其配置方式如下所示: 

<bean id="sqlSessionTemplate" class="org.mybatis.spring.SqlSessionTemplate">
        <constructor-arg index="0" ref="sqlSessionFactory"/>
</bean>
<bean id="userDao" class="com.tianshouzhi.mybatis.dao.UserDao"/>

之后我们可以在UserD类中直接进行注入。SqlSessionTemplate 是线程安全的, 可以被多个 DAO 所共享使用,以下是一个示例:

public class UserDao {
    private static String NAMESPACE = "com.tianshouzhi.zebracost.UserMapper";
    @Autowired
    SqlSessionTemplate sqlSession;
    public User selectById(int id) {
        User user = sqlSession.selectOne(NAMESPACE + ".selectById",id);
        return user;
    }
}

SqlSessionTemplate本质上是一个代理,关于SqlSessionTemplate的源码分析,笔者将在其他文章中分析。

整合四:继承SqlSessionDaoSupport

mybatis提供了抽象类SqlSessionDaoSupport,调用其getSqlSession()方法你会得到一个 SqlSessionTemplate,之后可以用于执行 SQL 方法, 就像下面这样:

public class UserDao extends SqlSessionDaoSupport{
    private static String NAMESPACE = "com.tianshouzhi.zebracost.UserMapper";
    public User selectById(int id) {
        User user = getSqlSession().selectOne(NAMESPACE + ".selectById",id);
        return user;
    }
}

SqlSessionDaoSupport 需要一个 sqlSessionFactory 或 sqlSessionTemplate 属性来设置 。如果两者都被设置了 , 那么SqlSessionFactory是被忽略的。由于我们的UserDao类继承了SqlSessionDaoSupport,所以你可以在UserDao类中进行设置:

<bean id="userDao" class="com.tianshouzhi.zebracost.dao.UserDao">
        <property name="sqlSessionFactory" ref="sqlSessionFactory"/>
 </bean>

 或:

<bean id="userDao" class="com.tianshouzhi.zebracost.dao.UserDao">
     <property name="sqlSessionTemplate" ref="sqlSessionTemplate"/>
</bean>

事实上,如果你提供的是一个SqlSessionFactory,SqlSessionDaoSupport内部也会使用其来构造一个SqlSessionTemplate实例。

整合五:MapperFactoryBean 

无论是使用SqlSessionTemplate,还是继承SqlSessionDaoSupport,我们都需要手工编写DAO类的代码。熟悉mybatis同学知道,SqlSession有一个getMapper()方法,可以让我们通过映射器接口的方式来使用mybatis。

例如有以下UserMapper.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.tianshouzhi.mybatis.mapper.UserMapper">
  <select id="selectById" resultType="Blog">
    select * from user where id = #{id}
  </select>
  <insert id="insert" paramterType="com.tianshouzhi.mybatis.domain.User">
    insert into user(name,age) values(#{name},#{age})
  </insert>
</mapper>

我们可以定义以下UserMapper接口:

package com.tianshouzhi.mybatis.mapper;
import com.tianshouzhi.mybatis.domain.User;
public interface UserMapper {
    public int insert(User user);
    public User selectById(int id);
}

细心的读者注意到:

1、映射文件的namespace属性值”com.tianshouzhi.mybatis.mapper.UserMapper"就是UserMapper接口的全路径

2、映射文件中的<select> 、<insert>元素的id属性值”selectById”、"insert",对应UserMapper接口中的selectById方法和insert方法。

之后,我们调用UserMapper接口中的方法,就会执行UserMapper.xml中对应的sql。 

你甚至可以通过注解的方式直接将sql写到UserMapper接口的方法上,此时你就不再需要UserMapper.xml,如:

package com.tianshouzhi.mybatis.mapper;
import com.tianshouzhi.mybatis.quickstart.domain.User;
import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Select;
public interface UserMapper {
    @Insert("insert into user(name,age) values(#{id},#{name},#{age})")
    public int insert(User user);
    @Select("select * from user where id = #{id}")
    public User selectById(int id);
}

此时我们可以修改mybatis-config.xml中<mapper>元素的resource属性为class属性,指定UserMapper接口的全路径,如下

<mappers>
   <!--<mapper resource="mappers/UserMapper.xml"/>—>
   <!--使用class属性指定UserMapper接口全路径-->
   <mapper class="com.tianshouzhi.mybatis.mapper.UserMapper"/>
</mappers>

之后,我们可以通过以下方式来使用UserMapper接口,更加直观,不容易出错。

SqlSession session = sqlSessionFactory.openSession();
try {
  UserMapper mapper = session.getMapper(UserMapper.class);
  //等价于执行UserMapper中id属性值为”selectById”的<select>元素中的sql,或者selectById方法上注解的sql
  User user = mapper.selectById(1);
} finally {
  session.close();
}

 但是在与spring进行整合时,是否有更加简单的使用方法呢?能够在一个业务Bean中注入UserMapper接口,不需要通过SqlSession的getMapper来创建。我们期望的使用方式如下:

public class UserService {
    @Autowired
    private UserMapper userMapper;
    public void insert(User user){
        System.out.println("create a new user!"+user);
        userMapper.insert(user);
    }
}

     直接这样操作显然是会报错的,因为UserMapper是一个接口,且不是spring管理的bean,因此无法直接注入。 

    这个时候,本节的主角MapperFactoryBean登场了,通过如下配置,MapperFactoryBean会针对UserMapper接口创建一个代理,并将其变成spring的一个bean。MapperFactoryBean继承了SqlSessionDaoSupport类,这也是为什么我们先介绍SqlSessionDaoSupport,再介绍MapperFactoryBean的原因。显然的,你可以想到,我们可以为MapperFactoryBean指定一个SqlSessionTemplate或者SqlSessionFactory,如果两个属性都设置了,那么 SqlSessionFactory 就会被忽略。

    通过以下配置,我们就可以在一个业务bean中直接注入UserMapper接口了:

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

你可能想知道MapperFactoryBean为什么具有这样的魔力,但是这不是本文的重点,本文讲解的是mybatis是如何spring进行整合的。笔者将其会在其他章节分析MapperFactoryBean的源码。

     上述方式,已经是mybatis与spring进行时理想的方式了。但是如果你的业务很复杂,有许多的XxxMapper接口要配置,针对每个接口都配置一个MapperFactoryBean,会使得我们的配置文件很臃肿。关于这一点,mybatis团队提供了MapperScannerConfigurer来帮助你解决这个问题。 

整合六:MapperScannerConfigurer

    通常我们在开发时,会将DAO类放于同一个包下,例如现在我们com.tianshouzhi.mybatis.mappers包下,有两个接口:UserMapper、UserAccountMapper。

    MapperScannerConfigurer可以指定扫描某个包,将这个包下的所有接口,自动的为每个映射器接口都注册一个MapperFactoryBean。配置如下: 

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

    其中:basePackage 属性是让你为映射器接口的包路径。如果的映射器接口位于不同的包下,可以使用分号”;”或者逗号”,”进行分割。如:

<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
  <property name="basePackage" value=“com.tianshouzhi.mybatis.user.mappers;com.tianshouzhi.mybatis.product.mappers" />
</bean>

如果你指定的还包含子包,子包中的映射器接口递归地被搜索到。因此对于上述配置,我们可以通过公共的包名"org.tianshouzhi.mybatis”进行简化。如:

<property name="basePackage" value="org.tianshouzhi.mybatis" />

你可能想到了,如果指定的公共的包名下面还包含了一些其他的接口,这些接口是你作为其他用途使用到的,并不能作为mybatis的映射器接口来使用。此时,你可以通过markerInterface属性或者annotationClass属性来进行过滤。

    对于markerInterface,首先,你需要定义一个标记接口,接口名随意,这个接口中不需要定义任何方法,如: 

public interface MybatisMapperInterface{}

  接着,你需要将你的映射器接口继承MybatisMapperInterface,如:

public interface UserMapper implements MybatisMapperInterface{
   //...映射器方法
}

    此时你可以指定MapperScannerConfigurer中指定,只有继承了MybatisMapperInterface接口的子接口,才为其自动注册MapperFactoryBean,如:

<property name="markerInterface" value=“com.tianshouzhi.mybatis.MybatisMapperInterface"/>

对于annotationClass属性,作用是类似的,根据注解进行过滤。一般我们是映射器接口上添加mybatis提供的@Mapper注解进行过滤,你也可以自定义一个注解。配置如下:

<property name="annotationClass" value="org.apache.ibatis.annotations.Mapper"/>

    如果同时指定了markerInterface和annotationClass属性,那么只有同时满足这两个条件的接口才会被注册为MapperFactoryBean。

 

    细心的读者可能意识到了,到目前,我们还没有为MapperScannerConfigurer指定一个SqlSessionFactory,或者SqlSessionTemplate。前面配置MapperFactoryBean的时候,我们已经看到,我们至少需要为其提供一项。之所以不指定,是因为MapperScannerConfigurer将会spring上下文中自动进行寻找类型为SqlSessionFactory,或者SqlSessionTemplate的bean,然后利用其来创建MapperFactoryBean实例。   

当然你也可以手工的进行指定任意一个,如:

<property name="sqlSessionFactory" ref="sqlSessionFactory"/>
<!--<property name="sqlSessionTemplate" ref="sqlSessionTemplate"/>-->

 然而,sqlSessionFactorysqlSessionTemplate属性已经不建议使用了。原因在于,这两个属性不支持你使用spring提供的PropertyPlaceholderConfigurer的属性替换。例如你配置了SqlSessionFactoryBean来创建SqlSessionFactory实例,前面已经看到必须为其指定一个dataSource属性。很多用户习惯将数据源的配置放到一个独立的配置文件,如jdbc.properties文件中,之后在spring配置中,通过占位符来替换,如:

<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="driverClassName" value="${jdbc.driver}"/>
        <!--其他配置-->
</bean>

    于这样的配置,spring在初始化时会报错,因为MapperScannerConfigurer会在PropertyPlaceholderConfigurer初始化之前,就加载dataSource的配置,而此时PropertyPlaceholderConfigurer还未准备好替换的占位符的内容,所以抛出异常。

    当然,这个问题并不是无解,我们可以使用sqlSessionFactoryBeanNamesqlSessionTemplateBeanName属性来替代sqlSessionFactory和sqlSessionTemplate属性。如下: 

<property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
<!--<property name="sqlSessionTemplateBeanName" value="sqlSessionTemplate"/>-->

此时,你依然可以放心大胆的在你的数据源配置中,使用占位符了。

    事实上,笔者总是建议你,在MapperScannerConfigurer的配置中,显示的指定sqlSessionFactoryBeanName或sqlSessionTemplateBeanName。如果你不指定,MapperScannerConfigurer就会在spring上下文中自动的寻找类型为SqlSessionFactory或者SqlSessionTemplate的bean。如果你的数据源配置中使用了占位符,还是会报错。 

最后,你可能想知道,为什么MapperScannerConfigurer指定一个basePackage属性,就可以为包下的每个接口都注册一个MapperFactoryBean?其内部是如何自动在spring上下文中寻找类型为SqlSessionFactory或者SqlSessionTemplate的bean实例的?以及为什么又做了如此多限制,只有指定sqlSessionFactoryBeanName或sqlSessionTemplateBeanName才能在数据源的配置中使用占位符?

    关于这些问题,笔者将在MapperScannerConfigurer的源码分析中进行解答。 

整合七:@MapperScan

    如果读者习惯使用注解,而不是xml文件的方式进行配置,mybatis-spring提供了@MapperScan注解,其用于取代MapperScannerConfigurer。以下演示了如何通过注解的方式来配置mybatis。 

@Configuration
@MapperScan(basePackages = "com.tianshouzhi.security.mapper”,//等价于basePackage属性
        markerInterface = MybatisMapperInterface.class,//等价于markerInterface属性,默认为null
        annotationClass = MybatisMapper.class,//等价于annotationClass属性,默认为null
        sqlSessionFactoryRef = "sqlSessionFactory")//等价于sqlSessionFactoryBeanName属性,默认为null
public class DatabaseConfig {
    //定义数据源
    @Bean
    public DataSource dataSource() {
        SimpleDriverDataSource dataSource = new SimpleDriverDataSource();
        dataSource.setUsername(“your username");
        dataSource.setPassword(“you password");
        dataSource.setUrl("jdbc:mysql://localhost:3306/mybatis?characterEncoding=UTF-8");
        dataSource.setDriverClass(com.mysql.jdbc.Driver.class);
        return dataSource;
    }
    //定义SqlSessionFactoryBean
    @Autowired
    @Bean("sqlSessionFactory")
    public SqlSessionFactoryBean sqlSessionFactory(DataSource dataSource) throws Exception {
        SqlSessionFactoryBean ssfb = new SqlSessionFactoryBean();
        ssfb.setDataSource(dataSource);
        return ssfb;
    }
}

整合八:事务

    上述所有的配置,还没有涉及到mybatis与spring进行整合另一个核心要点,即事务。整合后,我们需要将事务委派给spring来管理。

    spring使用PlatformTransactionManager接口来表示一个事务管理器。其有2个重要的实现类:

  • DataSourceTransactionManager:用于支持本地事务,简单理解,你可以认为就是操作单个数据库的事务,其内部也是通过操作java.sql.Connection来开启、提交(commit)和回滚(rollback)事务。

  • JtaTransactionManager:用于支持分布式事务,其实现了JTA规范,使用XA协议进行两阶段提交。

    

在本文中,我们主要介绍的是DataSourceTransactionManager,绝大部分情况下, 我们使用的都是这个事务管理器。其配置方式如下: 

<!--spring 事务管理器-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <!--默认事务超时时间-->
        <property name="defaultTimeout" value="30000"/>
        <!--数据源-->
        <property name="dataSource" ref="dataSource" />
        <!--提交失败的话,也进行回滚-->
        <property name="rollbackOnCommitFailure" value="true"/>
    </bean>

关于事务管理器使用方式有2种:声明式事务管理、编程式事务管理

声明式事务管理

1、基于注解

首先,你需要配置事务管理是基于注解驱动的,如下: 

<tx:annotation-driven transaction-manager="transactionManager"/>

之后,在业务bean的方法上添加@Transactional注解,此时这个方法就自动具备了事务的功能,如果出现异常,会自动回滚,没有出现异常则自动交。

@Transactional  
public void transfer(final String out,final String in,final Double money) {  
            accountMapper.outMoney(out, money);  
            int i=1/0;  
            accountMapper.inMoney(in, money);  
    }

基于注解的形式的声明式事务管理器,是最为简单的,也是建议使用的方式。

2、基于切面

    如果你有很多方法,都需要有事务管理,你觉得每个方法都添加@Transactional注解比较麻烦,此时你可以使用以下配置取代<tx:annotation-driven>元素。 

<!-- 1.配置事务通知:(事务的增强) -->  
   <tx:advice id="txAdvice" transaction-manager="transactionManager">  
   <tx:attributes>  
        <tx:method name="transfer"/>  
   </tx:attributes>  
   </tx:advice>  
    
<!-- 2.配置切面 -->  
<aop:config>  
   <!-- 配置切入点 -->  
   <aop:pointcut id="tx_pointcut" expression="execution(*com.tianshouzhi.mybatis.AccountService+.*(..))"/>  
   <!-- 配置切面 -->  
   <aop:advisor pointcut-ref="tx_pointcut" advice-ref="txAdvice" />
</aop:config>

事实上,基于切面的配置,太麻烦了,即使对于一些老鸟,长时间没有编写过类似的配置,可能也无法立即正确的进行配置,没有@Transactional注解来的直观。


编程式事务管理

如果上述两种声明式事务的配置都不是你要想要,那么你可以采取编程式事务。你可以在业务bean中注入事务管理器,然后进行编程式事务的管理,如: 

public class AccountService{
  @Autowired
  private DataSourceTransactionManager transactionManager;
  @Autowired
  private AccountMapper accountMapper;
  public void transfer(final String out,final String in,final Double money){
     DefaultTransactionDefinition def = new DefaultTransactionDefinition();
     def.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED);
    
     TransactionStatus status = transactionManager.getTransaction(def);
     try {
        accountMapper.outMoney(out, money);  
        int i=1/0;  
        accountMapper.inMoney(in, money);  
        transactionManager.commit(status);
     }
     catch (MyException ex) {
        transactionManager.rollback(status);
        throw ex;
     }
   }
}

另外,Spring还提供了一个TransactionTemplate,用于简化编程式事务代码的编写,配置方式如下:

<bean id="transactionTemplate" class="org.springframework.transaction.support.TransactionTemplate">  
    <property name="transactionManager"ref=“transactionManager"/>  
</bean>

使用方式如下:

    public void transfer(final String out,final String in,final Double money) {  
        //在事务模板中执行操作  
        transactionTemplate.execute(new TransactionCallbackWithoutResult(){  
        @Override  
        protected void doInTransactionWithoutResult(TransactionStatustransactionstatus){  
            accountMapper.outMoney(out, money);  
            int i=1/0;  
            accountMapper.inMoney(in, money);  
         }  
        });  
    }

总的来说,编程式事务管理还是显得略微麻烦。

整合九:springboot

     mybatis开发团队为Spring Boot 提供了 mybatis-spring-boot-starter。你需要引入如下依赖: 

<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>1.1.1</version>
</dependency>

使用了该starter之后,只需要定义一个DataSource即可,它会自动利用该DataSource创建需要使用到的SqlSessionFactoryBean、SqlSessionTemplate、以及ClassPathMapperScanner来自动扫描你的映射器接口,并针对每个接口都创建一个MapperFactoryBean,注册到Spring上下文中。

    关于mybatis-spring-boot-starter如何实现自动配置的相关源码,参见:

org.mybatis.spring.boot.autoconfigure.MybatisAutoConfiguration类。

    默认情况下,扫描的basePackage是spring boot的根目录(这里指的是应用启动类Application.java类所在的目录),且只会对添加了@Mapper注解的映射器接口进行注册。

    因此,最简单的情况下,你只需要在application.yml中进行数据源的相关配置即可,以下配置依赖于spring-boot-starter-jdbc: 

spring:
  datasource:
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://localhost:3306/mybatis
    username: root
    password: your password

之后,你就可以直接在你的业务bean中注入映射器接口来使用了。

    需要注意的是,一旦你自己提供了MapperScannerConfigurer,或者配置了MapperFactoryBean,那么mybatis-spring-boot-starter的自动配置功能将会失效。此时所有关于mybatis与spring进行整合的配置,都需要由你自行控制。 

整合十:多数据源

有的时候,应用需要访问多个数据库,假设现在有两个mysql库db_user、db_acount。这个时候我们就需要配置2个数据源,来连接不同的库,如下: 

<bean id="ds_user" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="username" value="root"/>
        <property name="password" value="shxx12151022"/>
        <property name="url" value="jdbc:mysql://192.168.0.1:3306/db_user"/>
        <property name="driverClassName" value="com.mysql.jdbc.Driver”/>
        <!--其他配置-->
</bean>
<bean id="ds_account" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="username" value="root"/>
        <property name="password" value=“your password"/>
        <property name="url" value="jdbc:mysql://192.168.0.2:3306/db_account"/>
        <property name="driverClassName" value="com.mysql.jdbc.Driver”/>
        <!--其他配置-->
</bean>

针对上述的两个数据源ds_user,ds_account我们需要为每个都配置一个SqlSessionFactoryBean,如下:

<bean id=“ssf_user" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="ds_user"/>
        <property name="mapperLocations" value="classpath*:mybatis/mappers/db_user/**/*.xml"/>
</bean>
<bean id=“ssf_account" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="ds_account"/>
        <property name="mapperLocations" value="classpath*:mybatis/mappers/db_account/**/*.xml"/>
</bean>

细心的读者可能已经注意到,这两个SqlSessionFactoryBean分别操作数据源ds_userds_account,且mapperLocations属性值指向的是不同的目录:

  • ssf_user中,指定关于ds_user的映射器xml文件都位于类路径的mybatis/mappers/db_user/目录下

  • ssf_account中,指定关于ds_account的映射器xml文件都位于类路径的mybatis/mappers/db_account/目录下

 如果你是使用映射接口的方式来操作mybatis,那么还应该针对ssf_user和ssf_account两个SqlSessionFactoryBean,各配置一个MapperScannerConfigurer。如下:

<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
  <property name="basePackage" value="com.tianshouzhi.mybatis.mappers.user" />
  <property name="sqlSessionFactoryBeanName" value="ssf_user"/>
</bean>
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
  <property name="basePackage" value="com.tianshouzhi.mybatis.mappers.account" />
  <property name="sqlSessionFactoryBeanName" value=“ssf_account"/>
</bean>

 可以看到,两个MapperScannerConfigurer的basePackage属性是不同的。

  • 将操作db_user库下的映射器XxxMapper接口都放在com.tianshouzhi.mybatis.mappers.user包中,

  • 将操作db_account库下的映射器XxxMapper接口都放在com.tianshouzhi.mybatis.mappers.account包中。

    再次提醒,在使用多数据源时,将操作不同库的xml映射文件、以及对应的映射器接口放到不同的目录下很重要,如果不这样,在使用时你几乎100%会遇到问题,一般都是报出数据库表找不到的错误。

最后,由于你现在有2个数据源,因此你应该配置两个事务管理器,如:

<bean id="userTxManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="ds_user" />
</bean>
<bean id="accountTxManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="ds_account" />
</bean>

    如果你是使用@Transactional注解来进行声明式事务管理,应该要指定你使用的是哪一个事务管理器,如:

@Transactional("accountTxManager")  
public void transfer(final String out,final String in,final Double money) {  
            accountMapper.outMoney(out, money);  
            int i=1/0;  
            accountMapper.inMoney(in, money);  
    }

一个DataSourceTransactionManager类型事务管理器,只能保证操作单个库的事务,例如在这里,accountTxManager只能保证db_account库的事务,证userTxManager只能保证db_user库的事务。

     如果你在一个方法内,想同时操作两个库,并保证事务,使用普通的DataSourceTransactionManager已经无法满足这种需求,这属于分布式事务的范畴。在笔者的另一篇文章atomikos JTA/XA全局事务演示了如何使用atomikos与mybatis、spring进行整合,来进行分布式事务的管理。 


最后,希望本文能对你有所帮助!!!

timg.jpeg