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

单独使用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);
 }
}
(0)

相关推荐

  • 浅谈SSH框架中spring的原理

    在ssh项目中,是有明确分工的,spring的作用就相当于将struts和hibernate连接起来,是将两个没有关系的框架的特性,方法,action都放在spring的配置文件中使他们建立关系.取他门各自所长.而这些做法他们自己不知道,他们是听命于spring调度的,他的的任务只是做好自己的事情. 这样做的好处就是任务结构分明,struts只管理显示与做什么,hibernate只关心怎么做,而spring就相当于领导,所以一切的类都要交给spring的工厂创建,这是一种良好的开发模式,体现了一

  • SSH框架的常见问题和解决方法

    Hibernate工作原理及为什么要用? 原理: 1.读取并解析配置文件 2.读取并解析映射信息,创建SessionFactory 3.打开Sesssion 4.创建事务Transation 5.持久化操作 6.提交事务 7.关闭Session 8.关闭SesstionFactory 为什么要用: 1. 对JDBC访问数据库的代码做了封装,大大简化了数据访问层繁琐的重复性代码. 2. Hibernate是一个基于JDBC的主流持久化框架,是一个优秀的ORM实现.他很大程度的简化DAO层的编码工作

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

    单独使用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

  • 详解Java的MyBatis框架中的事务处理

    一.MyBatis单独使用时,使用SqlSession来处理事务: public class MyBatisTxTest { private static SqlSessionFactory sqlSessionFactory; private static Reader reader; @BeforeClass public static void setUpBeforeClass() throws Exception { try { reader = Resources.getResourc

  • 详解Java的MyBatis框架与Spring框架整合中的映射器注入

    MyBatis-Spring允许你在Service Bean中注入映射器.当使用映射器时,就像调用DAO那样来调用映射器就可以了,但是此时你就不需要进行任何DAO实现的编码,因为MyBatis会为你进行. 使用注入的映射器,你的代码就不会出现任何MyBatis-Spring依赖和MyBatis依赖.在我们的应用中有这样一个简单的映射器.你也应该知道映射器仅仅是一个接口: public interface UserMapper { User getUser(String userId); } 这是

  • 详解Java的MyBatis框架中SQL语句映射部分的编写

    1.resultMap SQL 映射XML 文件是所有sql语句放置的地方.需要定义一个workspace,一般定义为对应的接口类的路径.写好SQL语句映射文件后,需要在MyBAtis配置文件mappers标签中引用,例如: <mappers> <mapper resource="com/liming/manager/data/mappers/UserMapper.xml" /> <mapper resource="com/liming/mana

  • 详解Java的MyBatis框架中动态SQL的基本用法

    有些时候,sql语句where条件中,需要一些安全判断,例如按某一条件查询时如果传入的参数是空,此时查询出的结果很可能是空的,也许我们需要参数为空时,是查出全部的信息.使用Oracle的序列.mysql的函数生成Id.这时我们可以使用动态sql.下文均采用mysql语法和函数(例如字符串链接函数CONCAT). selectKey 标签 在insert语句中,在Oracle经常使用序列.在MySQL中使用函数来自动生成插入表的主键,而且需要方法能返回这个生成主键.使用myBatis的select

  • 详解Java的MyBatis框架中的缓存与缓存的使用改进

    一级缓存与二级缓存 MyBatis将数据缓存设计成两级结构,分为一级缓存.二级缓存: 一级缓存是Session会话级别的缓存,位于表示一次数据库会话的SqlSession对象之中,又被称之为本地缓存.一级缓存是MyBatis内部实现的一个特性,用户不能配置,默认情况下自动支持的缓存,用户没有定制它的权利(不过这也不是绝对的,可以通过开发插件对它进行修改): 二级缓存是Application应用级别的缓存,它的是生命周期很长,跟Application的声明周期一样,也就是说它的作用范围是整个App

  • 详解java基于MyBatis使用示例

    MyBatis的前身叫iBatis,本是apache的一个开源项目, 2010年这个项目由apache software foundation 迁移到了google code,并且改名为MyBatis.MyBatis是支持普通SQL查询,存储过程和高级映射的优秀持久层框架.MyBatis消除了几乎所有的JDBC代码和参数的手工设置以及结果集的检索.MyBatis使用简单的XML或注解用于配置和原始映射,将接口和Java的POJOs(Plan Old Java Objects,普通的Java对象)

  • 详解java WebSocket的实现以及Spring WebSocket

    开始学习WebSocket,准备用它来实现一个在页面实时输出log4j的日志以及控制台的日志. 首先知道一些基础信息: 1.java7 开始支持WebSocket,并且只是做了定义,并未实现 2.tomcat7及以上,jetty 9.1及以上实现了WebSocket,其他容器没有研究 3.spring 4.0及以上增加了WebSocket的支持 4.spring 支持STOMP协议的WebSocket通信 5.WebSocket 作为java的一个扩展,它属于javax包目录下,通常需要手工引入

  • 详解java 中Spring jsonp 跨域请求的实例

    详解java 中Spring jsonp 跨域请求的实例 jsonp介绍 JSONP(JSON with Padding)是JSON的一种"使用模式",可用于解决主流浏览器的跨域数据访问的问题.由于同源策略,一般来说位于 server1.example.com 的网页无法与不是 server1.example.com的服务器沟通,而 HTML 的<script> 元素是一个例外.利用 <script> 元素的这个开放策略,网页可以得到从其他来源动态产生的 JSO

  • 详解JAVA Spring 中的事件机制

    说到事件机制,可能脑海中最先浮现的就是日常使用的各种 listener,listener去监听事件源,如果被监听的事件有变化就会通知listener,从而针对变化做相应的动作.这些listener是怎么实现的呢?说listener之前,我们先从设计模式开始讲起. 观察者模式 观察者模式一般包含以下几个对象: Subject:被观察的对象.它提供一系列方法来增加和删除观察者对象,同时它定义了通知方法notify().目标类可以是接口,也可以是抽象类或具体类. ConcreteSubject:具体的

随机推荐