Spring整合Mybatis基于XML实现声明式事务管理

什么是事务？

事务（Transaction）是面向关系型数据库企业应用程序的重要组成部分，用来确保数据的完整性和一致性。

---

实现事务管理的方式

• 编程式
  通过编写代码实现事务管理，灵活度较高，但是由于代码实现，难以维护。
• 声明式
  基于AOP技术实现的事务管理，只需要在配置文件中进行相关的规则声明，就可以将事务应用到业务逻辑中。

---

事务的特性

• 原子性：简单来说事务是一个基本的完整的整体，事务中包括的动作要么都做要么都不做。
• 一致性：事务必须保证数据库从一个一致性状态变到另一个一致性状态，一致性和原子性是密切相关的。
• 隔离性：一个事务的执行不能被其它事务干扰，即一个事务内部的操作及使用的数据对并发的其它事务是隔离的，并发执行的各个事务之间不能互相打扰。
• 持久性：指一个事务一旦提交，它对数据库中数据的改变就是永久性的，后面的其它操作和故障都不应该对其有任何影响。

---

Spring基于xml实现事务管理

Spring 实现声明式事务管理主要有 2 种方式：

• 基于 XML 方式的声明式事务管理。
• 通过 Annotation 注解方式的事务管理。

---

代码展示：

能力有限，这里只对xml进行演示。

下面使用idea实现声明式事务管理的演示

下列叙述中各个文件的位置如图所示：

步骤

1. 导入相关jar包
   junit、mybatis、mysql数据库、Spring相关的jar包、aop、mybatis-spring

<dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13</version>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.24</version>
        </dependency>

        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.2</version>
        </dependency>
<!--        spring-webmvc包含了Spring所需要的jar包-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.3.9</version>
        </dependency>
<!--        spring连接数据库需要spring-jdbc-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.3.9</version>
        </dependency>

        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.7</version>
        </dependency>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>2.0.6</version>
        </dependency>
    </dependencies>

2. 编写配置文件

这里的配置文件包含Spring的配置文件和mybatis的核心配置文件，其中， Mybatis配置文件中的数据源注入spring配置文件org.springframework.jdbc.datasource.DriverManagerDataSource 类（实现了javax.sql.DataSource接口，Spring框架自带的数据源），用来构建sqlSessionFactory bean实例，从而构建SqlSession bean实例，简化了sqlsession的创建步骤。

Mybatis的核心配置文件

<?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>
    <environments default="development">
        <!--        环境-->
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
<!--    这里的数据源写在spring配置文件中，用来构建sqlSessionFactory bean实例，从而构建SqlSession bean实例，简化了sqlsession的创建步骤-->
            </dataSource>
        </environment>
    </environments>
<!--    <mappers>-->
<!--        <mapper class="mapper.UserMapper"/>-->
<!--    </mappers>-->
</configuration>

spring的配置文件

<?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:tx="http://www.springframework.org/schema/tx"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/tx
        https://www.springframework.org/schema/tx/spring-tx.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd">
<!--        DataSource：使用Spring的数据源替换Mybatis配置中的数据源
            这里使用Spring提供的JDBC
、-->
    <bean id="DataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/mybatis?useSSL=true&amp;useUnicode=true&amp;characterEncoding=UTF-8"/>
        <property name="username" value="root"/>
        <property name="password" value="251210"/>
    </bean>

<!--        sqlSessionFactory-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="DataSource"/>
<!--        绑定Mybatis配置文件-->
        <property name="configLocation" value="classpath:mybatis-config.xml"/>
        <property name="mapperLocations" value="classpath:mapper/UserMapper.xml"/>
    </bean>

    <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
<!--        没有set方法，使用构造器注入sqlSessionFactory-->
        <constructor-arg index="0" ref="sqlSessionFactory"/>
    </bean>

    <bean id="userMapper" class="mapper.UserMapperImpl">
        <property name="sqlSession" ref="sqlSession"/>
     </bean>

<!--    配置声明式事务-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <constructor-arg ref="DataSource"/>
    </bean>

<!--    结合AOP，实现事务的植入-->
<!--    配置事务的类-->
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
<!--        给哪些方法配置事务-->
        <tx:attributes>
            <tx:method name="addUser"/>
            <tx:method name="deleteUser"/>
        </tx:attributes>
    </tx:advice>

<!--    配置事务的切入-->
    <aop:config>
        <aop:pointcut id="txPoint" expression="execution(* mapper.*.*(..))"/>
        <aop:advisor advice-ref="txAdvice" pointcut-ref="txPoint"/>
    </aop:config>
</beans>

3. 创建一个表名为user的数据库
   
4. 编写实体类User

public class User {
    private int id;
    private String username;
    private String password;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
}

5. 编写一个UserMapper接口，用来实现具体的业务逻辑。

import pojo.User;

import java.util.List;

public interface UserMapper {
    //查询用户
    public List<User> selectUser();

    //添加一个用户
    public void addUser(User user);

    //删除一个用户
    public void deleteUser(int id);
}

6. 编写UserMapperImpl实现接口

import org.mybatis.spring.SqlSessionTemplate;
import pojo.User;

import java.util.List;

public class UserMapperImpl implements UserMapper{
    private SqlSessionTemplate sqlSession;

    public void setSqlSession(SqlSessionTemplate sqlSession) {
        this.sqlSession = sqlSession;
    }

    @Override
    public List<User> selectUser() {
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        return mapper.selectUser();
    }

    @Override
    public void addUser(User user) {
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        mapper.addUser(user);
    }

    @Override
    public void deleteUser(int id) {
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        mapper.deleteUser(id);
    }
}

7. 编写UserMapper.xml核心配置文件绑定UserMapper接口，完成基础的jdbc代码

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!--核心配置文件-->
<mapper namespace="mapper.UserMapper">
    <select id="selectUser" resultType="pojo.User">
        select * from mybatis.user;
    </select>
    
    <insert id="addUser" parameterType="pojo.User">
        insert into mybatis.user(id,username,password) values (#{id},#{username},#{password})
    </insert>

    <delete id="deleteUser" parameterType="int">
        delete from mybatis.user where id =#{id}
    </delete>

</mapper>

8. 测试类Text

import mapper.UserMapper;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import pojo.User;
import java.util.List;

public class MyTest {
    //spring-mybatis实现
    @Test
    public void selectTest(){
        ApplicationContext context = new ClassPathXmlApplicationContext("spring-dao.xml");
        UserMapper userMapper = (UserMapper) context.getBean("userMapper");
        List<User> userList = userMapper.selectUser();
        for (User user : userList) {
            System.out.println(user);
        }
    }
    @Test
    public void addTest(){

        ApplicationContext context = new ClassPathXmlApplicationContext("spring-dao.xml");
        UserMapper userMapper = (UserMapper) context.getBean("userMapper");
        User user = new User();
        user.setId(7);
        user.setUsername("lsl");
        user.setPassword("LZMclaer");
        userMapper.addUser(user);
    }
}

查询结果如下：

---

测试事务管理是否实现

上面的结果仅为查询结果，并不能展示事务在其中所起到的作用

为了直观展现事务的作用，下面对UserMapperImpl代码中的add方法做出改动

改动代码如下：

@Override
    public void addUser(User user) {
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        mapper.addUser(user);
        //添加了下面两行
        int i=1/0;
        mapper.deleteUser(2);
    }

在方法中制造了一个简单的错误来中断deleteUser(n)的运行，在正常情况下，addUser(user);可以运行但deleteUser(12)无法运行，程序出错但是还是对数据库中的数据进行了改动，这就无法保证数据的一致性，添加事务后，整个addUser方法便是一个整体，也就是一个原子，事务中包括的动作要么都做要么都不做，从而保证了数据的一致性。

数据库中最开始的数据为：

运行test文件中的addTest方法

 @Test
    public void addTest(){
        ApplicationContext context = new ClassPathXmlApplicationContext("spring-dao.xml");
        UserMapper userMapper = (UserMapper) context.getBean("userMapper");
        User user = new User();
        user.setId(7);
        user.setUsername("lsl");
        user.setPassword("LZMclaer");
        userMapper.addUser(user);
    }

刷新数据库，此时用户并没有添加进去，id为2的用户也没有被删除

将int i=1/0;注释后运行（等同于代码没有error），结果如下

由图可知：用户lsl添加成功，id为2的用户被删除。

结果成立，至此，Spring整合Mybatis并实现声明式事务已全部展示。