源代码（所有代码均可直接运行）：https://github.com/KUANG-CHENG/Spring

Spring5.0 — 事物操作管理相关代码

操作环境：IDEA

如果对您有帮助，请点个赞，谢谢支持!

文章目录

1.Spring事务管理基本概念
2.事务管理案例
3.Spring事物操作具体介绍

1.Spring事务管理基本概念

1）事务是数据库操作最基本单元，逻辑上一组操作，要么都成功，如果有一个失败所有操作都失败

2）典型场景：银行转账张三转账 100 元给李四；张三少 100，李四多 100

3） 事物四个特性（ACID）:
（1）原子性 — 不可分割
（2）一致性 — 操作前后总量不变
（3）隔离性 — 多事物操作不产生影响
（4）持久性 — 提交之后，表中数据会发生变化

2.事务管理案例

1）在数据库 userdb 中创建 tb_account 数据表，添加数据

（ lucy 和 mary 每人具有1000元钱）
在这里插入图片描述
2）创建 service，搭建 dao，完成对象创建和注入关系

//（1）service 注入 dao，在 dao 注入 JdbcTemplate，在 JdbcTemplate 注入 DataSource
@Service
public class UserService {
    
    
 //注入 dao
 @Autowired
 private UserDao userDao;
}


@Repository
public class UserDaoImpl implements UserDao {
    
    
 @Autowired
 private JdbcTemplate jdbcTemplate;
}

3）在 dao 创建两个方法：多钱和少钱的方法，在 service 创建方法（转账的方法）

// UserDao接口函数
public interface UserDao {
    
    

    public void addMoney();
    public void reduceMoney();
}

// UserDaoImpl实现类
@Repository
public class UserDaoImpl implements UserDao {
    
    
 @Autowired
 private JdbcTemplate jdbcTemplate;
 	//lucy 转账 100 给 mary
 	//少钱
	 @Override
	 public void reduceMoney() {
    
    
 		String sql = "update t_account set money=money-? where username=?";
 		jdbcTemplate.update(sql,100,"lucy");
 	}
 //多钱
 @Override
 	public void addMoney() {
    
    
 		String sql = "update t_account set money=money+? where username=?";
 		jdbcTemplate.update(sql,100,"mary");
 	}
}


@Service
public class UserService {
    
    
 //注入 dao
 @Autowired
 private UserDao userDao;
 //转账的方法
 public void accountMoney() {
    
    
 //lucy 少 100
 userDao.reduceMoney();
 //mary 多 100
 userDao.addMoney();
 }
}

4）测试结果

测试成功！ lucy 减少 100 元， mary增加 100 元。

TestDemo 测试代码：
5）对于出现异常的考虑

执行到一半，程序报错 — 转账会出现什么结果？？

/**
	上边代码正常执行没有问题，
	但是如果代码执行过程中出现异常，有问题，如下模拟异常！
*/
@Service
public class UserService {
    
    
    //这里执行后将会产生错误（异常），lucy 少 100后，mary不会多 100，这就不对了！！
    private UserDao userDao;
    //转账方法
    public void accountMoney(){
    
    
        userDao.reduceMoney();//lucy 少 100
        int x=10/0;
        userDao.addMoney(); //mary 多 100
    }
}

//解决上边的异常方法——【编程式事务（传统方法）】
//转账的方法
    public void accountMoney() {
    
    
        try {
    
    
            //第一步 开启事务

            //第二步 进行业务操作
            //lucy少100
            userDao.reduceMoney();

            //模拟异常
            int i = 10/0;

            //mary多100
            userDao.addMoney();

            //第三步 没有发生异常，提交事务
        }catch(Exception e) {
    
    
            //第四步 出现异常，事务回滚
        }
    }

3.Spring事物操作具体介绍

1、事务添加到 JavaEE 三层结构里面 Service 层（业务逻辑层）

2、在 Spring 进行事务管理操作；两种方式：编程式事务管理、声明式事务管理（推荐使用）

3、声明式事务管理（1）基于注解方式（推荐使用）（2）基于 xml 配置文件方式

4、在 Spring 进行声明式事务管理，底层使用 AOP 原理

5、Spring 事务管理 API ：提供一个接口，代表事务管理器，这个接口针对不同的框架提供不同的实现类

3.1 声明式事务管理（基于注解方式）

1）Spring 配置文件 — " bean1.xml "

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:util="http://www.springframework.org/schema/util"
       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.xsd
                           http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd
                           http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
                           http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd">

    <!--配置数据库连接池-->
    <bean id="dataSource1" class="com.alibaba.druid.pool.DruidDataSource"
          destroy-method="close">
        <property name="url" value="jdbc:mysql:///userdb" /><!--数据库的地址-->
        <property name="username" value="root" /><!--用户名-->
        <property name="password" value="Kc635908933" /><!--密码-->
        <property name="driverClassName" value="com.mysql.jdbc.Driver" /> <!--驱动名称-->
    </bean>

    <!-- 组件扫描 -->
    <context:component-scan base-package="com.spring"></context:component-scan>

    <!-- JdbcTemplate 对象 -->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <!--注入 dataSource-->
        <!--通过set方法注入-->
        <property name="dataSource" ref="dataSource1"></property><!--set方式注入-->
    </bean>

    <!--事务管理器-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <!--注入数据源-->
        <property name="dataSource" ref="dataSource1"></property>
    </bean>

    <!--开启事务注解-->
    <tx:annotation-driven transaction-manager="transactionManager"></tx:annotation-driven>

</beans>

2）在 UserService 类中添加注解 @Transactional

在 UserService 类上面添加注解@Transactional，在这个注解里面可以配置事务相关参数，代码如下

@Service
@Transactional(propagation = Propagation.REQUIRED,isolation = Isolation.REPEATABLE_READ)
public class UserService {
    
    

    // 注入Dao
    @Autowired
    private UserDao userDao;

    // 转账的方法
    public void accountMoney(){
    
    
        userDao.reduceMoney();
        userDao.addMoney();
    }
}

3.2 声明式事务管理参数配置

事物参数：

1）propagation（事物传播行为）— 只介绍常用的两种

REQUIRED：如果add方法本身有事务，调用update方法后，update使用当前add方法里面的事务；如果add方法本身没有事务，调用update方法后，创建新的事务
REQUIRED_NEW：使用add调用update方法，不论add方法是否有事务，都会创建新的事务。

2）ioslation（事物隔离级别）

事务有特性成为隔离性，多事务操作之间不会产生影响。不考虑隔离性产生很多问题
有三个读问题：脏读、不可重复读、虚（幻）读
脏读：一个未提交事务读取到另一个未提交事务的数据
不可重复读：一个未提交事务读取到另一提交事务修改数据
虚读：一个未提交事务读取到另一提交事务添加数据
解决：通过设置事务隔离级别，解决读问题

@Transactional(propagation = Propagation.REQUIRED,isolation = Isolation.REPEATABLE_READ)

3）timeout（超过时间）
事务需要在一定时间内进行提交，如果不提交进行回滚（2）默认值是 -1（不超时），设置时间以秒单位进行计算

4）readOnly（是否只读）

读：查询操作，写：添加修改删除操作
readOnly 默认值 false，表示可以查询，可以添加修改删除操作
设置 readOnly 值是 true，设置成 true 之后，只能查询

5）rollbackFor（回滚）
设置出现哪些异常进行事务回滚

6）noRollbackFor（不回滚）
设置出现哪些异常进行事务不回滚

3.3 声明式事务管理（基于XML方式）

1）在 Spring配置文件中，进行基于XML文件配置 — “bean2.xml”

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:util="http://www.springframework.org/schema/util"
       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.xsd
                           http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd
                           http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
                           http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd">

    <!--配置数据库连接池-->
    <bean id="dataSource1" class="com.alibaba.druid.pool.DruidDataSource"
          destroy-method="close">
        <property name="url" value="jdbc:mysql:///userdb" /><!--数据库的地址-->
        <property name="username" value="root" /><!--用户名-->
        <property name="password" value="Kc635908933" /><!--密码-->
        <property name="driverClassName" value="com.mysql.jdbc.Driver" /> <!--驱动名称-->
    </bean>

    <!-- 组件扫描 -->
    <context:component-scan base-package="com.spring"></context:component-scan>

    <!-- JdbcTemplate 对象 -->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <!--注入 dataSource-->
        <!--通过set方法注入-->
        <property name="dataSource" ref="dataSource1"></property><!--set方式注入-->
    </bean>

    <!--1 配置事务管理器-->
    <!--事务管理器-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <!--注入数据源-->
        <property name="dataSource" ref="dataSource1"></property>
    </bean>

    <!--2 配置通知-->
    <tx:advice id="txadvice">
        <!--配置事物参数-->
        <tx:attributes>
            <!--指定那种规则的方法上添加事物-->
            <tx:method name="accountMoney" propagation="REQUIRED"/>
        </tx:attributes>
    </tx:advice>

    <!--3 配置切入点和切面-->
    <aop:config>
        <!--配置切入点-->
        <aop:pointcut id="pt" expression="execution(* com.spring.service.UserService.*(..))"/>
        <!--配置切面-->
        <!--事物指向aop操作-->
        <aop:advisor advice-ref="txadvice" pointcut-ref="pt"/>
    </aop:config>

2）TestDemo 测试类

         // 基于xml配置文件方式
        ApplicationContext context =
                new ClassPathXmlApplicationContext("bea2.xml");
        UserService userService = context.getBean("userService", UserService.class);

        userService.accountMoney();

3.4 声明式事务管理（基于完全注解方式）

1）创建一个配置类 TxConfig

/1、创建配置类，使用配置类替代 xml 配置文件
@Configuration //配置类
@ComponentScan(basePackages = "com.spring") //组件扫描
@EnableTransactionManagement //开启事务
public class TxConfig {
    
    
    //创建数据库连接池
    @Bean
    public DruidDataSource getDruidDataSource() {
    
    
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setDriverClassName("com.mysql.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql:///userdb");
        dataSource.setUsername("root");
        dataSource.setPassword("Kc635908933");
        return dataSource;
    }
    //创建 JdbcTemplate 对象
    @Bean
    public JdbcTemplate getJdbcTemplate(DataSource dataSource) {
    
    //从IOC容器中拿到配置注入的数据源
        //到 ioc 容器中根据类型找到 dataSource
        JdbcTemplate jdbcTemplate = new JdbcTemplate();
        //注入 dataSource
        jdbcTemplate.setDataSource(dataSource);
        return jdbcTemplate;
    }
    //创建事务管理器
    @Bean
    public DataSourceTransactionManager
    getDataSourceTransactionManager(DataSource dataSource) {
    
    
        DataSourceTransactionManager transactionManager = new DataSourceTransactionManager();
        transactionManager.setDataSource(dataSource);
        return transactionManager;
    }
}