详解Java的MyBatis框架和Spring框架的整合运用

前端技术 2023/09/05 Java

单独使用mybatis是有很多限制的（比如无法实现跨越多个session的事务），而且很多业务系统本来就是使用spring来管理的事务，因此mybatis最好与spring集成起来使用。

版本要求

项目

版本

下载地址

说明

mybatis

3.0及以上

https://github.com/mybatis/mybatis-3/releases

 

spring

3.0及以上

http://projects.spring.io/spring-framework/

 

mybatis-spring

1.0及以上

https://github.com/mybatis/spring/releases

 

spring事务配置

<!-- 自动扫描业务包 --> 
<context:component-scan base-package=\"com.xxx.service\" /> 
 
<!-- 数据源 --> 
<jee:jndi-lookup id=\"jndiDataSource\" jndi-name=\"java:comp/env/jdbc/datasource\" /> 
 
<!-- 配置事务 --> 
<bean id=\"txManager\" 
    class=\"org.springframework.jdbc.datasource.DataSourceTransactionManager\"> 
  <property name=\"dataSource\" ref=\"jndiDataSource\" /> 
</bean> 
<!-- 配置基于注解的事物aop --> 
<tx:annotation-driven transaction-manager=\"txManager\" proxy-target-class=\"true\"/>

单个集成

<!-- 集成mybatis --> 
<bean id=\"sqlSessionFactory\" class=\"org.mybatis.spring.SqlSessionFactoryBean\"> 
  <property name=\"dataSource\" ref=\"jndiDataSource\" /> 
  <property name=\"configLocation\" value=\"classpath:/mybatis/mybatis-config.xml\" /> 
  <!-- 自动配置别名 --> 
  <property name=\"typeAliasesPackage\" value=\"com.xxx.dto\" /> 
</bean> 
 
<!--创建dao bean（只需提供接口不需提供实现类 ）--> 
<bean id=\"userDao\" class=\"org.mybatis.spring.mapper.MapperFactoryBean\"> 
  <property name=\"mapperInterface\" value=\"com.xxx.dao.UserDao\" /> 
  <property name=\"sqlSessionFactory\" ref=\"sqlSessionFactory\" /> 
</bean>

我们不但要明白如何使用，更要明白为什么要这么使用。

SqlSessionFactoryBean是一个工厂bean，它的作用就是解析配置（数据源、别名等）。

MapperFactoryBean是一个工厂bean，在spring容器里，工厂bean是有特殊用途的，当spring将工厂bean注入到其他bean里时，它不是注入工厂bean本身而是调用bean的getObject方法。我们接下来就看看这个getObjec方法干了些什么：

public T getObject() throws Exception { 
 return getSqlSession().getMapper(this.mapperInterface); 
}

看到这里大家应该就很明白了，这个方法和我们之前单独使用Mybatis的方式是一样的，都是先获取一个Sqlsession对象，然后再从Sqlsession里获取Mapper对象（再次强调Mapper是一个代理对象，它代理的是mapperInterface接口，而这个接口是用户提供的dao接口）。自然，最终注入到业务层就是这个Mapper对象。

实际的项目一般来说不止一个Dao，如果你有多个Dao那就按照上面的配置依次配置即可。

如何使用批量更新
前一节讲了如何注入一个mapper对象到业务层， mapper的行为依赖于配置，mybatis默认使用单个更新（即ExecutorType默认为SIMPLE而不是BATCH），当然我们可以通过修改mybatis配置文件来修改默认行为，但如果我们只想让某个或某几个mapper使用批量更新就不得行了。这个时候我们就需要使用模板技术：

<!--通过模板定制mybatis的行为 --> 
lt;bean id=\"sqlSessionTemplateSimple\" class=\"org.mybatis.spring.SqlSessionTemplate\">   
<constructor-arg index=\"0\" ref=\"sqlSessionFactory\" /> 
<!--更新采用单个模式 --> 
<constructor-arg index=\"1\" value=\"SIMPLE\"/> 
</bean> 
   
<!--通过模板定制mybatis的行为 --> 
lt;bean id=\"sqlSessionTemplateBatch\" class=\"org.mybatis.spring.SqlSessionTemplate\">   
<constructor-arg index=\"0\" ref=\"sqlSessionFactory\" /> 
<!--更新采用批量模式 --> 
<constructor-arg index=\"1\" value=\"BATCH\"/> 
</bean>

这里笔者定义了两个模板对象，一个使用单个更新，一个使用批量更新。有了模板之后我们就可以改变mapper的行为方式了：

<bean id=\"userDao\" class=\"org.mybatis.spring.mapper.MapperFactoryBean\"> 
  <property name=\"mapperInterface\" value=\"com.xxx.dao.UserDao\" /> 
  <property name=\"sqlSessionTemplate\" ref=\" sqlSessionTemplateBatch \" /> 
</bean>

 
跟上一节的mapper配置不同的是，这里不需要配置sqlSessionFactory属性，只需要配置sqlSessionTemplate（sqlSessionFactory属性在模板里已经配置好了）。

通过自动扫描简化mapper的配置
前面的章节可以看到，我们的dao需要一个一个的配置在配置文件中，如果有很多个dao的话配置文件就会非常大，这样管理起来就会比较痛苦。幸好mybatis团队也意识到了这点，他们利用spring提供的自动扫描功能封装了一个自动扫描dao的工具类，这样我们就可以使用这个功能简化配置：

<!-- 采用自动扫描方式创建mapper bean(单个更新模式) --> 
<bean class=\"org.mybatis.spring.mapper.MapperScannerConfigurer\"> 
  <property name=\"basePackage\" value=\"com.xxx.dao\" /> 
  <property name=\"sqlSessionTemplateBeanName\" value=\"sqlSessionTemplateSimple\" /> 
  <property name=\"markerInterface\" value=\"com.xxx.dao.SimpleDao\" /> 
</bean> 
    
<!-- 采用自动扫描方式创建mapper bean(批量更新模式) --> 
<bean class=\"org.mybatis.spring.mapper.MapperScannerConfigurer\"> 
  <property name=\"basePackage\" value=\"com.xxx.dao\" /> 
  <property name=\"sqlSessionTemplateBeanName\" value=\"sqlSessionTemplateBatch\" /> 
  <property name=\"markerInterface\" value=\"com.xxx.dao.BatchDao\" /> 
</bean>

MapperScannerConfigurer本身涉及的spring的技术我就不多讲了，感兴趣且对spring原理比较了解的可以去看下它的源码。我们重点看一下它的三个属性：

  • basePackage：扫描器开始扫描的基础包名，支持嵌套扫描；
  • sqlSessionTemplateBeanName：前文提到的模板bean的名称；
  • markerInterface：基于接口的过滤器，实现了该接口的dao才会被扫描器扫描，与basePackage是与的作用。

除了使用接口过滤外，还可使用注解过滤：

<!-- 采用自动扫描方式创建mapper bean(批量更新模式) --> 
<bean class=\"org.mybatis.spring.mapper.MapperScannerConfigurer\"> 
  <property name=\"basePackage\" value=\"com.xxx.dao\" /> 
  <property name=\"sqlSessionTemplateBeanName\" value=\"sqlSessionTemplateBatch\" /> 
  <property name=\"annotationClass\" value=\"com.xxx.dao.BatchAnnotation\" /> 
</bean>

annotationClass：配置了该注解的dao才会被扫描器扫描，与basePackage是与的作用。

需要注意的是，两个过滤条件只能配一个。

实例：事务管理
定义一个实体类:Emp.java

package com.lixing.scm.entity;

public class Emp {
 private String id;
 private String name;
 private String sex;
 private int age;
 private String phone;
 public String getId() {
  return id;
 }
 public void setId(String id) {
  this.id = id;
 }
 public String getName() {
  return name;
 }
 public void setName(String name) {
  this.name = name;
 }
 public String getSex() {
  return sex;
 }
 public void setSex(String sex) {
  this.sex = sex;
 }
 public int getAge() {
  return age;
 }
 public void setAge(int age) {
  this.age = age;
 }
 public String getPhone() {
  return phone;
 }
 public void setPhone(String phone) {
  this.phone = phone;
 }
}

定义实体内操作接口:EmpMapper.java

package com.lixing.scm.test.mapper;

import java.util.List;
import java.util.Map;

import com.lixing.scm.entity.Emp;

public interface EmpMapper {
 void insertEmp(Emp emp);
 List<Emp> getAllEmp();
 Emp getById(String id);
 void deleteEmp(String id);
 void updateEmp(Map<String,Object> map);
}

定义实体类操作接口的映射文件:EmpMapper.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.lixing.scm.test.mapper.EmpMapper\"> 
 <parameterMap type=\"com.lixing.scm.entity.Emp\" id=\"parameterMapEmp\">
  <parameter property=\"id\"/>
  <parameter property=\"name\"/>
  <parameter property=\"sex\"/>
  <parameter property=\"age\"/>
  <parameter property=\"phone\"/>
 </parameterMap>
 
 <resultMap type=\"com.lixing.scm.entity.Emp\" id=\"resultMapEmp\">
  <result property=\"id\" column=\"id\"/>
  <result property=\"name\" column=\"name\"/>
  <result property=\"sex\" column=\"sex\"/>
  <result property=\"age\" column=\"age\"/>
  <result property=\"phone\" column=\"phone\"/>
 </resultMap>
 
 <insert id=\"insertEmp\" parameterMap=\"parameterMapEmp\">
  INSERT INTO emp(id,name,sex,age,phone)
  VALUES(?,?,?,?,?)
 </insert>
 <select id=\"getAllEmp\"  resultMap=\"resultMapEmp\">
  SELECT * FROM emp
 </select>
 <select id=\"getById\" parameterType=\"String\" resultMap=\"resultMapEmp\">
  SELECT * FROM emp
  WHERE id=#{value}
 </select>
 <delete id=\"deleteEmp\" parameterType=\"String\">
  DELETE FROM emp 
  WHERE id=#{value}
 </delete>
 <update id=\"updateEmp\" parameterType=\"java.util.Map\">
  UPDATE emp
  SET name=#{name},sex=#{sex},age=#{age},phone=#{phone}
  WHERE id=#{id}
 </update>
</mapper>
Spring3.0.6定义: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\"
 xmlns:aop=\"http://www.springframework.org/schema/aop\"
 xmlns:tx=\"http://www.springframework.org/schema/tx\"
 xsi:schemaLocation=\"http://www.springframework.org/schema/beans 
     http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
     http://www.springframework.org/schema/context
     http://www.springframework.org/schema/context/spring-context-3.0.xsd
     http://www.springframework.org/schema/tx
     http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
     http://www.springframework.org/schema/aop 
     http://www.springframework.org/schema/aop/spring-aop-3.0.xsd\">

 <!--  -->
 <context:annotation-config />
 <context:component-scan base-package=\"com.lixing.scm.test.*\" />


 <!-- jdbc.propertis Directory -->
 <bean
  class=\"org.springframework.beans.factory.config.PropertyPlaceholderConfigurer\">
  <property name=\"locations\" value=\"classpath:jdbc.properties\" />
 </bean>

 <bean id=\"MyDataSource\" destroy-method=\"close\"
  class=\"org.apache.commons.dbcp.BasicDataSource\">
  <property name=\"driverClassName\" value=\"${jdbc.driverClassName}\" />
  <property name=\"url\" value=\"${jdbc.url}\" />
  <property name=\"username\" value=\"${jdbc.username}\" />
  <property name=\"password\" value=\"${jdbc.password}\" />
 </bean>

 <!-- SqlSessionFactory -->
 <bean id=\"sqlSessionFactory\" class=\"org.mybatis.spring.SqlSessionFactoryBean\">
  <property name=\"dataSource\" ref=\"MyDataSource\" />
 </bean>
 <!-- ScanMapperFiles -->
 <bean class=\"org.mybatis.spring.mapper.MapperScannerConfigurer\">
  <property name=\"basePackage\" value=\"com.lixing.scm.test.mapper\" />
 </bean>



 <!-- ================================事务相关控制=================================================  -->
 <bean name=\"transactionManager\" class=\"org.springframework.jdbc.datasource.DataSourceTransactionManager\">   
     <property name=\"dataSource\" ref=\"MyDataSource\"></property>
  </bean>   
 
 <tx:advice id=\"userTxAdvice\" transaction-manager=\"transactionManager\">
  <tx:attributes>
   <tx:method name=\"delete*\" propagation=\"REQUIRED\" read-only=\"false\" 
              rollback-for=\"java.lang.Exception\" no-rollback-for=\"java.lang.RuntimeException\"/>
   <tx:method name=\"insert*\" propagation=\"REQUIRED\" read-only=\"false\" 
              rollback-for=\"java.lang.RuntimeException\" />
   <tx:method name=\"update*\" propagation=\"REQUIRED\" read-only=\"false\" 
              rollback-for=\"java.lang.Exception\" />
   
   <tx:method name=\"find*\" propagation=\"SUPPORTS\"/>
   <tx:method name=\"get*\" propagation=\"SUPPORTS\"/>
   <tx:method name=\"select*\" propagation=\"SUPPORTS\"/>
  </tx:attributes>
 </tx:advice>
 
 <aop:config>  
  <aop:pointcut id=\"pc\" expression=\"execution(public * com.lixing.scm.test.service.*.*(..))\" /> <!--把事务控制在Service层-->
  <aop:advisor pointcut-ref=\"pc\" advice-ref=\"userTxAdvice\" />
 </aop:config>
 
 
 <!-- 以下为自定义Bean-->
 <bean id=\"empDao\" class=\"com.lixing.scm.test.dao.impl.EmpDaoImpl\"
  autowire=\"byName\" /> 
 <bean id=\"empService\" class=\"com.lixing.scm.test.service.impl.EmpServiceImpl\"  autowire=\"byName\"/>
</beans>

DAO接口:EmpDAO.java

package com.lixing.scm.test.dao;

import java.util.List;
import java.util.Map;

import com.lixing.scm.entity.Emp;

public interface EmpDao {
 void insertEmp(Emp emp);
 List<Emp> getAllEmp();
 Emp getById(String id);
 void deleteEmp(String id);
 void updateEmp(Map<String, Object> map);
}

DAO接口实现类：EmpDaoImpl.java

package com.lixing.scm.test.dao.impl;

import java.util.List;
import java.util.Map;

import com.lixing.scm.entity.Emp;
import com.lixing.scm.test.dao.EmpDao;
import com.lixing.scm.test.mapper.EmpMapper;

public class EmpDaoImpl implements EmpDao {
 private EmpMapper empMapper;  //在此处注入一个empMapper
   //这个empMapper由 Spring自动生成   //不需要我们自己手工去定义
 @Override
 public void insertEmp(Emp emp) {
  this.empMapper.insertEmp(emp);
  throw new RuntimeException(\"Error\");  //测试抛出RuntimeException    //异常查看数据库是否存在记录
 }

 @Override
 public void deleteEmp(String id) {
  this.empMapper.deleteEmp(id);
 }

 @Override
 public List<Emp> getAllEmp() {
  return this.empMapper.getAllEmp();
 }

 @Override
 public Emp getById(String id) {
  return this.empMapper.getById(id);
 }

 @Override
 public void updateEmp(Map<String, Object> map) {
  this.empMapper.updateEmp(map);
 }

 
 public EmpMapper getEmpMapper() {
  return empMapper;
 }

 public void setEmpMapper(EmpMapper empMapper) {
  this.empMapper = empMapper;
 }
}

Service层接口:EmpService.java

package com.lixing.scm.test.service;

import com.lixing.scm.entity.Emp;

public interface EmpService {
 void insertEmp(Emp emp);
}

Service层接口实现类:EmpServiceImpl.java

package com.lixing.scm.test.service.impl;

import com.lixing.scm.entity.Emp;
import com.lixing.scm.test.dao.EmpDao;
import com.lixing.scm.test.service.EmpService;

public class EmpServiceImpl implements EmpService {
 private EmpDao empDao;

 @Override
 public void insertEmp(Emp emp) {
  empDao.insertEmp(emp);

 }

 public EmpDao getEmpDao() {
  return empDao;
 }

 public void setEmpDao(EmpDao empDao) {
  this.empDao = empDao;
 }
}

测试类:TestEmpService.java

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.lixing.scm.entity.Emp;
import com.lixing.scm.test.service.EmpService;


public class TestEmpService {
 @Test
 public void testTrasaction(){
  Emp emp=new Emp();
  emp.setId(\"00000003\");
  emp.setName(\"某某某\");
  emp.setAge(50);
  emp.setSex(\"男\");
  emp.setPhone(\"566666\");
  
  ApplicationContext ctx=new ClassPathXmlApplicationContext(\"classpath:applicationContext.xml\");
  EmpService service=ctx.getBean(EmpService.class);
  service.insertEmp(emp);
 }
}

本文地址：https://www.stayed.cn/item/11924

转载请注明出处。

本站部分内容来源于网络,如侵犯到您的权益,请 联系我

我的博客

人生若只如初见，何事秋风悲画扇。

我的标签

随笔档案