单独使用MyBatis对事务进行管理

前面MyBatis的文章有写过相关内容，这里继续写一个最简单的Demo，算是复习一下之前MyBatis的内容吧，先是建表，建立一个简单的Student表：

1
2
3
4
5
6
create table student
(
    student_id    int            auto_increment,
    student_name  varchar(20)    not null,
    primary key(student_id)
)

建立实体类Student.java：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
public class Student
{
    private int        studentId;
    private String    studentName;
 
    public int getStudentId()
    {
        return studentId;
    }
 
    public void setStudentId(int studentId)
    {
        this.studentId = studentId;
    }
 
    public String getStudentName()
    {
        return studentName;
    }
 
    public void setStudentName(String studentName)
    {
        this.studentName = studentName;
    }
 
    public String toString()
    {
        return "Student{[studentId:" + studentId + "], [studentName:" + studentName + "]}";
    }
}

多说一句，对实体类重写toString()方法，打印其中每一个（或者说是关键属性）是一个推荐的做法。接着是config.xml，里面是jdbc基本配置：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
<?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>
    <typeAliases>
        <typeAlias alias="Student" type="org.xrq.domain.Student" />
    </typeAliases>
 
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/test"/>
                <property name="username" value="root"/>
                <property name="password" value="root"/>
            </dataSource>
        </environment>
    </environments>
 
    <mappers>
        <mapper resource="student_mapper.xml"/>
    </mappers>
</configuration>

然后是student_mapper.xml，主要是具体的sql语句：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
<mapper namespace="StudentMapper">
    <resultMap type="Student" id="StudentMap">
        <id column="student_id" property="studentId" jdbcType="INTEGER" />
        <result column="student_name" property="studentName" jdbcType="VARCHAR" />
    </resultMap>
 
    <select id="selectAllStudents" resultMap="StudentMap">
        select student_id, student_name from student;
    </select>
 
    <insert id="insertStudent" useGeneratedKeys="true" keyProperty="studentId" parameterType="Student">
        insert into student(student_id, student_name) values(#{studentId, jdbcType=INTEGER}, #{studentName, jdbcType=VARCHAR});
    </insert>
</mapper>

建立一个MyBatisUtil.java，用于建立一些MyBatis基本元素的，后面的类都继承这个类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public class MyBatisUtil
{
    protected static SqlSessionFactory ssf;
    protected static Reader reader;
 
    static
    {
        try
        {
            reader = Resources.getResourceAsReader("config.xml");
            ssf = new SqlSessionFactoryBuilder().build(reader);
        }
        catch (IOException e)
        {
            e.printStackTrace();
        }
    }
 
    protected SqlSession getSqlSession()
    {
        return ssf.openSession();
    }
}

企业级开发讲求：

1、定义和实现分开

2、分层开发，通常情况下为Dao–>Service–>Controller，不排除根据具体情况多一层/几层或少一层

所以，先写一个StudentDao.java接口：

1
2
3
4
5
public interface StudentDao
{
    public List<Student> selectAllStudents();
    public int insertStudent(Student student);
}

最后写一个StudentDaoImpl.java实现这个接口，注意要继承MyBatisUtil.java类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public class StudentDaoImpl extends MyBatisUtil implements StudentDao
{
    private static final String NAMESPACE = "StudentMapper.";
 
    public List<Student> selectAllStudents()
    {
        SqlSession ss = getSqlSession();
        List<Student> list = ss.selectList(NAMESPACE + "selectAllStudents");
        ss.close();
        return list;
    }
 
    public int insertStudent(Student student)
    {
        SqlSession ss = getSqlSession();
        int i = ss.insert(NAMESPACE + "insertStudent", student);
        // ss.commit();
        ss.close();
        return i;
    }
}

写一个测试类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class StudentTest
{
    public static void main(String[] args)
    {
        StudentDao studentDao = new StudentDaoImpl();
 
        Student student = new Student();
        student.setStudentName("Jack");
 
        studentDao.insertStudent(student);
        System.out.println("插入的主键为：" + student.getStudentId());
 
        System.out.println("-----Display students------");
        List<Student> studentList = studentDao.selectAllStudents();
        for (int i = 0, length = studentList.size(); i < length; i++)
            System.out.println(studentList.get(i));
    }
}

结果一定是空。

我说过这个例子既是作为复习，也是作为一个引子引入我们今天的内容，空的原因是，insert操作已经做了，但是MyBatis并不会帮我们自动提交事物，所以展示出来的自然是空的。这种时候就必须手动通过SqlSession的commit()方法提交事务，即打开StudentDaoImpl.java类第17行的注释就可以了。

多说一句，这个例子除了基本的MyBatis插入操作之外，在插入的基础上还有返回插入的主键id的功能。

接下来，就利用Spring管理MyBatis事务，这也是企业级开发中最常用的事务管理做法。

使用Spring管理MyBatis事务

关于这块，网上有很多文章讲解，我搜索了很多，但是要么就是相互复制黏贴，要么就是没有把整个例子讲清楚的，通过这一部分，我尽量讲清楚如何使用Spring管理MyBatis事务。

使用Spring管理MyBatis事务，除了Spring必要的模块beans、context、core、expression、commons-logging之外，还需要以下内容：

（1）MyBatis-Spring-1.x.0.jar，这个是Spring集成MyBatis必要的jar包

（2）数据库连接池，dbcp、c3p0都可以使用，我这里使用的是阿里的druid

（3）jdbc、tx、aop，jdbc是基本的不多说，用到tx和aop是因为Spring对MyBatis事务管理的支持是通过aop来实现的

（4）aopalliance.jar，这个是使用Spring AOP必要的一个jar包

上面的jar包会使用Maven的可以使用Maven下载，没用过Maven的可以去CSDN上下载，一搜索就有的。

MyBatis的配置文件config.xml里面，关于jdbc连接的部分可以都去掉，只保留typeAliases的部分：

1
2
3
4
5
6
7
8
9
<?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>
    <typeAliases>
        <typeAlias alias="Student" type="org.xrq.domain.Student" />
    </typeAliases>
</configuration>

多提一句，MyBatis另外一个配置文件student_mapper.xml不需要改动。接着，写Spring的配置文件，我起名字叫做spring.xml：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns="http://www.springframework.org/schema/beans"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xsi:schemaLocation="
    http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.2.xsd
    http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.2.xsd 
    http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc-4.2.xsd
    http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.2.xsd 
    http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.2.xsd">
 
    <!-- 注解配置 -->
    <tx:annotation-driven transaction-manager="transactionManager" />
    <context:annotation-config />   
    <context:component-scan base-package="org.xrq" />
 
    <!-- 数据库连接池,这里使用alibaba的Druid -->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" init-method="init" destroy-method="close">
        <property name="url" value="jdbc:mysql://localhost:3306/test" /> 
        <property name="username" value="root" /> 
        <property name="password" value="root" /> 
    </bean>
 
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="configLocation" value="classpath:config.xml" />
        <property name="mapperLocations" value="classpath:*_mapper.xml" />
        <property name="dataSource" ref="dataSource" />
    </bean>
 
    <!-- 事务管理器 --> 
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"> 
        <property name="dataSource" ref="dataSource" /> 
    </bean>
 
</beans>

这里面主要就是事务管理器和数据库连接池两部分的内容。

另外我们看到有一个SqlSessionFactory，使用过MyBatis的朋友们一定对这个类不陌生，它是用于配置MyBatis环境的，SqlSessionFactory里面有两个属性configLocation、mapperLocations，顾名思义分别代表配置文件的位置和映射文件的位置，这里只要路径配置正确，Spring便会自动去加载这两个配置文件了。

然后要修改的是Dao的实现类，此时不再继承之前的MyBatisUtil这个类，而是继承MyBatis-Spring-1.x.0.jar自带的SqlSessionDaoSupport.java，具体代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
@Repository
public class StudentDaoImpl extends SqlSessionDaoSupport implements StudentDao
{
    private static final String NAMESPACE = "StudentMapper.";
 
    @Resource
    public void setSqlSessionFactory(SqlSessionFactory sqlSessionFactory)
    {
        super.setSqlSessionFactory(sqlSessionFactory);
    }
 
    public List<Student> selectAllStudents()
    {
        return getSqlSession().selectList(NAMESPACE + "selectAllStudents");
    }
 
    public int insertStudent(Student student)
    {
        return getSqlSession().insert(NAMESPACE + "insertStudent", student);
    }
}

这里用到了两个注解，分别说一下。

（1）@Repository，这个注解和@Component、@Controller和我们最常见的@Service注解是一个作用，都可以将一个类声明为一个Spring的Bean。它们的区别到不在于具体的语义上，更多的是在于注解的定位上。之前说过，企业级应用注重分层开发的概念，因此，对这四个相似的注解应当有以下的理解：

  • @Repository注解，对应的是持久层即Dao层，其作用是直接和数据库交互，通常来说一个方法对应一条具体的Sql语句
  • @Service注解，对应的是服务层即Service层，其作用是对单条/多条Sql语句进行组合处理，当然如果简单的话就直接调用Dao层的某个方法了
  • @Controller注解，对应的是控制层即MVC设计模式中的控制层，其作用是接收用户请求，根据请求调用不同的Service取数据，并根据需求对数据进行组合、包装返回给前端
  • @Component注解，这个更多对应的是一个组件的概念，如果一个Bean不知道属于拿个层，可以使用@Component注解标注

这也体现了注解的其中一个优点：见名知意，即看到这个注解就大致知道这个类的作用即它在整个项目中的定位。

（2）@Resource，这个注解和@Autowired注解是一个意思，都可以自动注入属性属性。由于SqlSessionFactory是MyBatis的核心，它在spring.xml中又进行过了声明，因此这里通过@Resource注解将id为”sqlSessionFactory”的Bean给注入进来，之后就可以通过getSqlSession()方法获取到SqlSession并进行数据的增、删、改、查了。

最后无非就是写一个测试类测试一下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class StudentTest
{
    public static void main(String[] args)
    {
        ApplicationContext ac = new ClassPathXmlApplicationContext("spring.xml");
        StudentDao studentDao = (StudentDao)ac.getBean("studentDaoImpl");
 
        Student student = new Student();
        student.setStudentName("Lucy");
 
        int j = studentDao.insertStudent(student);
        System.out.println("j = " + j + "\n");
 
        System.out.println("-----Display students------");
        List<Student> studentList = studentDao.selectAllStudents();
        for (int i = 0, length = studentList.size(); i < length; i++)
            System.out.println(studentList.get(i));
    }
}

由于StudentDaoImpl.java类使用了@Repository注解且没有指定别名，因此StudentDaoImpl.java在Spring容器中的名字为”首字母小写+剩余字母“即”studentDaoImpl”。

运行一下程序，可以看见控制台上遍历出了new出来的Student，即该Student直接被插入了数据库中，整个过程中没有任何的commit、rollback，全部都是由Spring帮助我们实现的，这就是利用Spring对MyBatis进行事务管理。

后记

本文复习了MyBatis的基本使用与使用Spring对MyBatis进行事务管理，给出了比较详细的代码例子，有需要的朋友们可以照着代码研究一下。在本文的基础上，后面还会写一篇文章，讲解一下多数据在单表和多表之间的事务管理实现，这种需求也是属于企业及应用中比较常见的需求。

MyBatis（5）：MyBatis集成Spring事务管理（上）的更多相关文章

  1. MyBatis6：MyBatis集成Spring事务管理（下篇）

    前言 前一篇文章<MyBatis5:MyBatis集成Spring事务管理(上篇)>复习了MyBatis的基本使用以及使用Spring管理MyBatis的事务的做法,本文的目的是在这个的基 ...

  2. MyBatis（6）：MyBatis集成Spring事务管理（下）

    前一篇文章复习了MyBatis的基本使用以及使用Spring管理MyBatis的事务的做法,本文的目的是在这个的基础上稍微做一点点的进阶:多数据的事务处理.文章内容主要包含两方面: 1.单表多数据的事 ...

  3. MyBatis5：MyBatis集成Spring事务管理（上篇）

    前言 有些日子没写博客了,主要原因一个是工作,另一个就是健身,因为我们不仅需要努力工作,也需要有健康的身体嘛. 那有看LZ博客的网友朋友们放心,LZ博客还是会继续保持更新,只是最近两三个月LZ写博客相 ...

  4. MyBatis6：MyBatis集成Spring事物管理（下篇）

    前言 前一篇文章<MyBatis5:MyBatis集成Spring事物管理(上篇)>复习了MyBatis的基本使用以及使用Spring管理MyBatis的事物的做法,本文的目的是在这个的基 ...

  5. SSM(spring mvc+spring+mybatis)学习路径——1-2、spring事务管理

    目录 1-2 Spring事务管理 概念介绍 事务回顾 事务的API介绍 Spring 事务管理 转账案例 编程式事务管理 声明式事务管理 使用XML配置声明式事务 基于tx/aop 使用注解配置声明 ...

  6. Spring事务管理--多个ORM框架在使用时的情况分析

    公司的项目已经接近尾声了,总结一下项目中用到的技术,我发现项目中的有些东西还是挺模糊的,只是知道这么用就行了.并不清楚其中的原理.由于公司的项目比较老,是7年前的一个项目了,中间一直有人在维护,也是在 ...

  7. Spring事务管理总结

    本文是对慕课网上"搞定SSM开发"路径的系列课程的总结,详细的项目文档和课程总结放在github上了.点击查看 本文对应慕课网上课程Spring事务管理,详情可查看:点我 1: 概 ...

  8. （转）Spring事务管理详解

    背景:之前一直在学习数据库中的相关事务,而忽略了spring中的事务配置,在阿里面试时候基本是惨败,这里做一个总结. 可能是最漂亮的Spring事务管理详解 https://github.com/Sn ...

  9. 转 可能是最漂亮的Spring事务管理

    Snailclimb 2018年05月21日阅读 4246 可能是最漂亮的Spring事务管理详解 Java面试通关手册(Java学习指南):github.com/Snailclimb/… 微信阅读地 ...

随机推荐

  1. GIT学习（一）-->Git产生的历史原因

    首先要说:Git是目前世界上最先进的分布式版本控制系统(没有之一). git的作者:Linus,林纳斯(下图就是,先膜拜一下,因为成就可不止这一点) 他是为何要写git的呢?话说 Linus虽然创建了 ...

  2. CSS基本知识介绍

    CSS (Cascading Style Sheet)叠层样式表.用于控制网页样式并允许将样式信息与网页内容分离的一种标记性语言. 样式的几种控制方法: 1.行内样式         <div ...

  3. Struts1 中实现Action跳转地址栏变化的方法

    Action进行跳转,有时候地址栏不变化,如果重复刷新就会重复提交, 这里一般需要进行重定向: 1.在xml里面进行配置 <action path="/checkCdconfirmEn ...

  4. (转)一步一步学习PHP(3)——函数

    相信每个人在学习PHP之前至少都有着一定的C语言,或者是C++/Java/C#等其他语言的基础,所以在这里也不从头开始说起,只是来谈谈PHP方法的独特之处. 1. 方法概述 首先,写一个最简单的函数, ...

  5. 控制器View的加载过程

    1.控制器内部的view是延迟加载 1> 用到时再加载2> 加载完毕后会调用控制器的viewDidLoad方法 2.创建控制器的方式 1> 直接通过代码创建OneViewContro ...

  6. ASP.NET菜鸟之路之Seesion小例子

    背景 我是一个ASP.NET菜鸟,暂时开始学习ASP.NET,在此记录下我个人敲的代码,没有多少参考价值,请看到的盆友们为我点个赞支持我一下,多谢了. Session介绍 Session保存特定用户相 ...

  7. 【USACO 1.1.1】你的飞碟在这儿

    [问题描述] 一个众所周知的事实,在每一慧星后面是一个不明飞行物UFO. 这些不明飞行物时常来收集来自在地球上忠诚的支持者. 不幸地,他们的空间在每次旅行只能带上一群支持者. 他们要做的是用一种聪明的 ...

  8. Thinkphp 表单验证

    在服务器端通过tp框架实现表单验证 用户名.密码.重复密码.邮箱.qq.手机号码.爱好.学历 具体步骤: 制作表单 表单form数据通过create()方法收集(验证功能要求我们必须通过create( ...

  9. python模块之json序列化

    31.序列化:      1.json实现序列化,json.dumps()和json.loads().           >>> s1 = {'k1':'v1','k2':'v2' ...

  10. mongod的主要参数有

    ------------------------------------基本配置----------------------   --quiet # 安静输出 --port arg # 指定服务端口号 ...