Spring的事务管理详细介绍

最新推荐文章于 2024-03-13 11:02:03 发布

你不懂、、、

最新推荐文章于 2024-03-13 11:02:03 发布

阅读量81

点赞数

分类专栏： Java

本文链接：https://blog.csdn.net/zhangzhanbin/article/details/115681644

版权

Java 专栏收录该内容

65 篇文章 1 订阅

订阅专栏

理解事务、锁和并发的关系

事务：为了能够在执行数据更新中出现异常，能够回滚到更新之前。
锁：为了解决数据更新中，出现并发操作导致数据混乱问题。
并发：查询是不需要上锁的，可是查询会产生并发问题的，就后面说的脏读、幻读、不可重复读。

为什么需要使用事务管理？

这里我们以取钱的例子来讲解：比如你去ATM机取1000块钱，大体有两个步骤：第一步输入密码金额，银行卡扣掉1000元钱；第二步从ATM出1000元钱。这两个步骤必须是要么都执行要么都不执行。如果银行卡扣除了1000块但是ATM出钱失败的话，你将会损失1000元；如果银行卡扣钱失败但是ATM却出了1000块，那么银行将损失1000元。
如何保证这两个步骤不会出现一个出现异常了，而另一个执行成功呢？事务就是用来解决这样的问题。事务是一系列的动作，它们综合在一起才是一个完整的工作单元，这些动作必须全部完成，如果有一个失败的话，那么事务就会回滚到最开始的状态，仿佛什么都没发生过一样。
在企业级应用程序开发中，事务管理是必不可少的技术，用来确保数据的完整性和一致性。

什么是事务？

事务（Transaction），一般是指要做的或所做的事情。在计算机中事务是数据库的最小单元的操作，这些操作作为一个整体一起向系统提交，要么都执行、要么都不执行；事务是一组不可再分割的操作集合。

补充：既然是操作集合，说明可以多个操作，在多个操作中，如A启动了一个事务对Atbl表进行了添加数据操作并没有提交，此时B也启动了一个事务，对同一张Atbl表进行统计操作。此时两者操作的都是一张表，但是各自启动事务后，都会产生一个当前表全部信息的虚拟表进行操作，其实A添加了数据，没提交事务，但是A接着查表时，查出来的数据是有刚刚插入的数据行的。而B查询，则无法查到A未提交的数据。只有提交了才会真正的写入物理表（物理存储器）中。谨慎：== 别把物理表和虚拟表搞混了。==

事务的最大优势（作用）：可以在发生异常的时候，进行回滚。

注意：事务和（并发）锁并没有直接关系。增删改会启动锁（加锁）。事务的提交和回滚会触发解锁。启动事务可以防止并发的产生，而并不是事务的功劳，是锁的功劳。

事务 -> A(原子性)C(一致性)I(隔离性)D(持久性)

并发 -> 多个会话同时访问(读写)同一资源

隔离 -> 脏读幻读不可重复读 -> 读并发

	工作原理:执行INSERT UPDATE DELETE 先上锁（能上锁在执行） 执行完成后解锁

	 开启事务(不涉及上锁)|  提交回滚事务(解锁)

Mysql锁的相关信息说明

以事务相关概念理论

一、众所周知，事务有四大特征（ACID）

原子性（Atomicity）：不可分割
一致性（Consistency）：事务完成时，必须是所有的数据都保持一致状态。
隔离性（Isolation）：并发事务执行之间不影响，在一个事务内部的操作对其他事务是不产生影响，这需要通过事务隔离级别来指定隔离性。
持久性（Durability）：一旦事务完成，数据库的改变必须是持久化的。

二、事务管理器

Spring并不直接管理事务，通过这个接口，Spring为各个平台如JDBC、Hibernate等都提供了对应的事务管理器，也就是将事务管理的职责委托给Hibernate或者JTA等持久化机制所提供的相关平台框架的事务来实现。

三、传播行为：当事务方法被另一个事务方法调用时，必须指定事务应该如何传播。

Spring 定义了如下七中传播行为，这里以A业务和B业务之间如何传播事务为例说明：

①、PROPAGATION_REQUIRED ：required , 必须。默认值，A如果有事务，B将使用该事务；如果A没有事务，B将创建一个新的事务。

②、PROPAGATION_SUPPORTS：supports ，支持。A如果有事务，B将使用该事务；如果A没有事务，B将以非事务执行。

③、PROPAGATION_MANDATORY：mandatory ，强制。A如果有事务，B将使用该事务；如果A没有事务，B将抛异常。

④、PROPAGATION_REQUIRES_NEW ：requires_new，必须新的。如果A有事务，将A的事务挂起，B创建一个新的事务；如果A没有事务，B创建一个新的事务。

⑤、PROPAGATION_NOT_SUPPORTED ：not_supported ,不支持。如果A有事务，将A的事务挂起，B将以非事务执行；如果A没有事务，B将以非事务执行。

⑥、PROPAGATION_NEVER ：never，从不。如果A有事务，B将抛异常；如果A没有事务，B将以非事务执行。

⑦、PROPAGATION_NESTED ：nested ，嵌套。A和B底层采用保存点机制，形成嵌套事务。

四、隔离级别：定义了一个事务可能受其他并发事务影响的程度。

并发事务引起的问题：

在典型的应用程序中，多个事务并发运行，经常会操作相同的数据来完成各自的任务。并发虽然是必须的，但可能会导致以下的问题（结合虚拟表概念分析）。

①、脏读（Dirty reads）——脏读发生在一个事务读取了另一个事务改写但尚未提交的数据时。如果改写在稍后被回滚了，那么第一个事务获取的数据就是无效的。

②、不可重复读（Nonrepeatable read）——不可重复读发生在一个事务执行相同的查询两次或两次以上，但是每次都得到不同的数据时。这通常是因为另一个并发事务在两次查询期间进行了更新。

③、幻读（Phantom read）——幻读与不可重复读类似。它发生在一个事务（T1）读取了几行数据，接着另一个并发事务（T2）插入了一些数据时。在随后的查询中，第一个事务（T1）就会发现多了一些原本不存在的记录。

注意：不可重复读重点是修改，而幻读重点是新增或删除。

在 Spring 事务管理中，为我们定义了如下的隔离级别：

①、ISOLATION_DEFAULT（默认）：使用后端数据库默认的隔离级别

②、ISOLATION_READ_UNCOMMITTED（读未提交）：最低的隔离级别，允许读取尚未提交的数据变更，可能会导致脏读、幻读或不可重复读

③、ISOLATION_READ_COMMITTED（读已提交）：允许读取并发事务已经提交的数据，可以阻止脏读，但是幻读或不可重复读仍有可能发生

④、ISOLATION_REPEATABLE_READ（可重复读）：对同一字段的多次读取结果都是一致的，除非数据是被本身事务自己所修改，可以阻止脏读和不可重复读，但幻读仍有可能发生

⑤、ISOLATION_SERIALIZABLE（可串行化）：最高的隔离级别，完全服从ACID的隔离级别，确保阻止脏读、不可重复读以及幻读，也是最慢的事务隔离级别，因为它通常是通过完全锁定事务相关的数据库表来实现的

Spring事务管理使用

基于AOP的 xml 配置
我们在 applicationContext.xml 文件中配置 aop 自动生成代理，进行事务管理：

①、配置管理器

②、配置事务详情

③、配置 aop

<?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.xsd
                           http://www.springframework.org/schema/aop
                           http://www.springframework.org/schema/aop/spring-aop.xsd
                           http://www.springframework.org/schema/context
                           http://www.springframework.org/schema/context/spring-context.xsd
                           http://www.springframework.org/schema/tx
                           http://www.springframework.org/schema/tx/spring-tx.xsd">
    <!--start  准备工作：整合Mybatis -->                       
    <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
        <property name="url" value="jdbc:mysql://localhost:3306/test?characterEncoding=utf8"></property>
        <property name="username" value="root"></property>
        <property name="password" value="123456"></property>
    </bean>
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"></property>
        <property name="mapperLocations" value="classpath:mappers/*Mapper.xml"></property>
    </bean>
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <!--<property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"></property>-->
        <property name="basePackage" value="com.uplooking.dao"></property>
    </bean>
    <!--end   整合Mybatis -->
    
    <!-- 1 事务管理器 -->
    <bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"></property>
    </bean>
     
    <!-- 2 事务详情（事务通知）  ， 在aop筛选基础上，比如对ABC三个确定使用什么样的事务。例如：AC读写、B只读 等
        <tx:attributes> 用于配置事务详情（属性属性）
            <tx:method name=""/> 详情具体配置
                propagation 传播行为 ， REQUIRED：必须；REQUIRES_NEW:必须是新的
                isolation 隔离级别
    -->
    <tx:advice id="txAdvice" transaction-manager="txManager">
        <tx:attributes>
            <tx:method name="transfer" propagation="REQUIRED" isolation="DEFAULT"/>
        </tx:attributes>
    </tx:advice>
     
    <!-- 3 AOP编程，利用切入点表达式从目标类方法中 确定增强的连接器，从而获得切入点 -->
    <aop:config>
        <aop:advisor advice-ref="txAdvice" pointcut="execution(* com.ys.service..*.*(..))"/>
    </aop:config>
</beans>

基于AOP的注解配置
分为如下两步：

①、在applicationContext.xml 配置事务管理器，将并事务管理器交予spring

②、在目标类或目标方法添加注解即可 @Transactional

首先在 applicationContext.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:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:jdbc="http://www.springframework.org/schema/jdbc"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       http://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
       http://www.springframework.org/schema/jdbc 
       http://www.springframework.org/schema/jdbc/spring-jdbc.xsd">
    <!-- 准备工作：注解扫描范围  base-package 填写需要扫描的包 -->
    <context:component-scan base-package="com.gtq.service"></context:component-scan>
    <!-- 准备工作：启动注解 自动代理 -->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
    <!-- 1 事务管理器 -->
    <!-- 设置事务管理  aop面向切面编程，切面就是切入点和通知组合-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
    </bean>
    <!-- 启动事务管理 -->
    <!-- 2 将管理器交予spring
        * transaction-manager 配置事务管理器
    -->
    <tx:annotation-driven transaction-manager="transactionManager"/>
    <jdbc:embedded-database id="dataSource"/>
</beans>

其次在目标类或者方法添加注解@Transactional。如果在类上添加，则说明类中的所有方法都添加事务，如果在方法上添加，则只有该方法具有事务。

package com.ys.service.impl;
 
import javax.annotation.Resource;
 
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Isolation;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
 
import com.ys.dao.AccountDao;
import com.ys.service.AccountService;
 
@Transactional(propagation=Propagation.REQUIRED , isolation = Isolation.DEFAULT)
@Service("accountService")
public class AccountServiceImpl implements AccountService{
    @Resource(name="accountDao")
    private AccountDao accountDao;
     
    public void setAccountDao(AccountDao accountDao) {
        this.accountDao = accountDao;
    }
    @Override
    //@Transactional(propagation=Propagation.REQUIRED , isolation = Isolation.DEFAULT)
    public void transfer(String outer, String inner, int money) {
        accountDao.out(outer, money);
        //int i = 1/0;
        accountDao.in(inner, money);
    }
 
}

你不懂、、、

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
打赏
1
评论
Spring的事务管理详细介绍

为什么需要使用事务管理？在业务层中，如为了完成一个注册的业务，此时，需要进行用户名和密码的验证，并且写入数据库中，成功后还需要完成日志信息的保存，表示xxx什么时间注册了系统的账号。这个时候注册的操作就需要完成两次数据插入操作，如第一次数据插入成功并提交了，可是第二次的日志信息插入时，出现了异常插入失败，这是就造成了数据的混乱，为了解决这个问题，事务管理的技术如此生成。什么是事务？事务是数据库的最小单元的操作，这些操作作为一个整体一起向系统提交，要么都执行、要么都不执行；事务是一组不可再分割的操作集合
复制链接

扫一扫