Spring详细解读事务管理

2024-04-02 19:55

短信预约 -IT技能 免费直播动态提醒

什么是事务

事务就是对数据库若干操作组成的一个单元

我们在开发企业应用时，对于业务人员的一个操作实际是对数据读写的多步操作的结合。由于数据操作在顺序执行的过程中，任何一步操作都有可能发生异常，异常会导致后续操作无法完成，此时由于业务逻辑并未正确的完成，之前成功操作数据的并不可靠，需要在这种情况下进行回退

事务的作用就是为了保证用户的每一个操作都是可靠的，事务中的每一步操作都必须成功执行，只要有发生异常就回退到事务开始未进行操作的状态,这些操作要么都完成，要么都取消，从而保证数据满足一致性的要求

如何理解呢 ?

例如 : A现在要转账给B 那么转账是几个方法呢? 两个 : 方法1: A 减钱方法2: B加钱

如果A方法成功执行后 , B方法中执行时出现了异常, 就等于A钱扣了却没有给B加钱, 那么这样的行为肯定是不允许的, 所以我们引入事务的概念 , 事务一般也是对于数据库而言的

Spring事务配置

Spring事务管理又分为编程式事务和声明式事务

编程式事务在项目中很少使用 , 这种方式需要注入一个事务管理对象 TransactionTemplate ,然后在我们代码中需要提交事务或回滚事务时自己写代码实现

声明式事务管理建立在 AOP 基础上，本质是对方法前后进行拦截，所以声明式事务是方法级别的。

为什么说是基于AOP呢? 因为在通过xml文件配置中我们是这样来做的

<aop:config> 
<aop:pointcut expression="execution(* com.ff.spring.service.UserService.*(..))" id="allmethod"/> 
<aop:advisor advice-ref="txadvice" pointcut-ref="allmethod"/> 
</aop:config>

基于注解的方式直接帮我们省略了这个过程, 更为方便

这里我们主要介绍声明式事务

首先在db.xml中配置spring事务管理类

<!--配置spring事务管理类-->
    <bean id="sourceTransactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="druidDataSource"/>
    </bean>

这里我们直接介绍基于注解方式的spring事务管理

开启注解扫描

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

我们使用@Transactiona 这样一个注解标签来声明事务, 它可以作用于方法,表明这个方法支持事务, 也可以作用于类, 表明这个类中的所有方法支持事务

public class UserDao {
    @Autowired
    JdbcTemplate jdbcTemplate;
    @Transactional(propagation= Propagation.REQUIRED)
    public void saveUser(){
        jdbcTemplate.update("insert into admin(account,pass_word,sex) values (?,?,?)","li","111","男");
        int i=108/0;  //出现异常
        jdbcTemplate.update("insert into admin(account,pass_word,sex) values (?,?,?)","qw","111","男");
    }
}

在上述代码中, 第一条sql 语句虽然成功执行, 但后面出现了异常, 所以这个方法的事务并没有提交, 是不会向数据库提交数据的

Spring事务传播行为

即然是传播，那么至少有两个东西，才可以发生传播。单体不存在传播这个行为。事务传播行为（propagation behavior）指的就是当一个事务方法被另一个事务方法调用时，这个事务方法应该如何进行。事务传播行为是 Spring 框架独有的事务增强特性，他不属于的事务实际提供方数据库行为.

是不是有点懵, 说啥呢这是, 接着来解释

试想 , 有两个方法 A 和 B , 它们都有事务, 那么我在 A 方法中去调用 B 方法, 那么B方法此时

应该怎样去执行呢? 是将B 方法加入到 A 方法组成一个事务,还是它们都是一个独立的事务呢 ?

Spring定义了 7种事务传播行为, 我们下面主要介绍其中三种,都会举例说明

传播行为一般是对于B方法(被调用的方法而言的)

1. PROPAGATION_REQUIRED

指定的方法必须在事务内执行,若当前存在事务,加入到当前事务中,若当前没有事务,则创建一个新事务,这种传播行为是最常见的,也是 spring 默认的传播行为

A 方法调用 B方法(PROPAGATION_REQUIRED) , 如果A方法是存在事务的, 那么直接将B方

法加入到 A事务中,组成一个事务. 如果 A 方法是没有事务的, 那么B就是一个单独的事务

这么说可能有点绕 , 我们再次请出李雷, 算了, 这次就放过李雷, 换成张三吧

就是说呢 , 我和李雷现在都要去吃饭, 然后我说呢,李雷咱俩一起吧(A调用B,我叫李雷去吃饭) , 不出意外的话(事务顺利执行提交), 我们两吃饭作为一个整体, 最终都吃了饭(AB都存在事务就作为一个整体事务) , 但是还有一种情况, 我叫李雷去吃饭, 但是我却没有去(A调用B, 但是A没有事务),那么这时候李雷肯定单独去吃饭(B单独开启一个事务)

@Transactional(propagation = Propagation.REQUIRED)
    public void saveDept(){   //A调用B
        deptDao.saveDept();
        commonService.saveLog(); //B
    }

@Transactional(propagation = Propagation.REQUIRED)
    public void saveLog(){
        commonDao.saveLog();
        int a = 10/0; //异常
    }

此时 A 调用 B , 它们都有事务, B中出了异常, 那么此时AB最终都不会去和数据库交互

//@Transactional(propagation = Propagation.REQUIRED)
    public void saveDept(){   //A调用B
        deptDao.saveDept();
        commonService.saveLog(); //B
    }

@Transactional(propagation = Propagation.REQUIRED)
    public void saveLog(){
        commonDao.saveLog();
        int a = 10/0; //异常
    }

第二种方式 , 我们将异常加到A 中, 注释掉注解(取消A的事务), 那么此时B是单独的一个事务, B里面出了异常, 不会去和数据库交互, 则A会去和数据库交互

2. PROPAGATION_SUPPORTS

支持当前事务，如果当前没有事务，就以非事务方式执行

A方法调用B方法(PROPAGATION_SUPPORTS), 如果A是存在事务的,那么直接将B方

法加入到 A事务中,组成一个事务. 如果 A 没有事务, 那么B也没有事务

我叫李雷去吃饭 , 如果我一定要去吃饭(A调用B), 那么最终我吃饭和李雷吃饭就总共作为一个事务,就和上面第一个例子是一样的, 作为整体的一个事务. 但是第二种情况就是, 我虽然叫了李雷去吃饭, 但是我最终没有去(A没有事务) , 这时候李雷说, 那我也不去吃饭了(B也没有事务)

@Transactional(propagation = Propagation.REQUIRED)
    public void saveDept(){   //A调用B
        deptDao.saveDept();
        commonService.saveLog(); //B
    }

@Transactional(propagation = Propagation.SUPPORTS)
    public void saveLog(){
        commonDao.saveLog();
        int a = 10/0; //异常
    }

此时 A调用 B , AB都有事务, 那么B 中出现异常, 最终都不会和数据库交互,就和上述第一种情况

一样

//@Transactional(propagation = Propagation.REQUIRED)
    public void saveDept(){   //A调用B
        deptDao.saveDept();
        commonService.saveLog(); //B
    }

取消掉A 的事务 , 那么此时B 会以非事务执行 , 这时候AB都会和数据库去交互,因为非事务

3. PROPAGATION_REQUIRES_NEW

总是新建一个事务，如果当前存在事务，把当前事务挂起,直到新建的事务结束。

A方法调用B方法(PROPAGATION_REQUIRES_NEW), 如果A存在事务, 那么B此时会先把A事务挂起, 然后为自己新建一个事务, 先执行完B事务, 才会去执行 A 事务 . 如果A 没有事务, 那么B自己单独新建一个事务执行

这里就是, 我虽然叫李雷去吃饭(A调用B) , 李雷都会先自己去吃饭, 不等我(B自己新建一个事务, A有事务先将A挂起)

@Transactional(propagation = Propagation.REQUIRED)
    public void saveDept(){   //A调用B
        deptDao.saveDept();
        commonService.saveLog(); //B
    }

@Transactional(propagation = Propagation.REQUIRES_NEW)
    public void saveLog(){
        commonDao.saveLog();
        int a = 10/0; //异常
    }

A 调用 B , A支持事务 , 此时B将A事务挂起, 单独开启一个事务,里面出现异常,此时AB都不会和数据库交互

//@Transactional(propagation = Propagation.REQUIRED)
    public void saveDept(){   //A调用B
        deptDao.saveDept();
        commonService.saveLog(); //B
    }

取消A的事务, 但此时B事务是独立的, 出现异常, 所以B不会和数据库交互,但是A和数据库交互