5.Spring事务

最新推荐文章于 2024-08-16 20:21:37 发布

小马Mark

最新推荐文章于 2024-08-16 20:21:37 发布

阅读量107

点赞数

分类专栏： Spring 文章标签： spring java 事务

原文链接：https://www.bilibili.com/

版权

Spring 专栏收录该内容

6 篇文章 0 订阅

订阅专栏

Spring事务管理

事务原本是数据库中的概念，在 Dao 层。但一般情况下，需要将事务提升到业务层，即 Service 层。这样做是为了能够使用事务的特性来管理具体的业务。

在 Spring 中通常可以通过以下两种方式来实现对事务的管理：

使用 Spring 的事务注解管理事务
使用 AspectJ 的 AOP 配置管理事务

Spring事务管理API

Spring 的事务管理，主要用到两个事务相关的接口。

事务管理器接口

事务管理器是 PlatformTransactionManager 接口对象。其主要用于完成事务的提交、回滚，及获取事务的状态信息。

void commit(TransactionStatus status)

TransactionStatus getTransaction(TransactionDefinition definition)

void rollback(TransactionStatus status)

PlatformTransactionManager接口的常用实现类：

DataSourceTransactionManager：使用 JDBC 或 MyBatis 进行数据库操作时使用。
HibernateTransactionManager：使用 Hibernate 进行持久化数据时使用。

Spring回滚方式

Spring 事务的默认回滚方式是：发生运行时异常和 error 时回滚，发生受查(编译)异常时提交。不过，对于受查异常，程序员也可以手工设置其回滚方式。

事务定义接口

事务定义接口 TransactionDefinition 中定义了事务描述相关的三类常量：事务隔离级别、事务传播行为、事务默认超时时限，及对它们的操作。

事务隔离级别

定义了五个事务隔离级别常量

这些常量均是以 ISOLATION_开头。即形如 ISOLATION_XXX。

DEFAULT：采用 DB 默认的事务隔离级别。MySql 的默认为 REPEATABLE_READ； Oracle默认为 READ_COMMITTED。
READ_UNCOMMITTED：读未提交（就是一个事务可以读取另一个未提交事务的数据）。未解决任何并发问题。
READ_COMMITTED：读已提交（就是一个事务要等另一个事务提交后才能读取数据）。解决脏读，存在不可重复读与幻读。
REPEATABLE_READ：可重复读（就是在开始读取数据（事务开启）时，不再允许修改操作）。解决脏读、不可重复读，存在幻读
SERIALIZABLE：串行化。不存在并发问题。最高的事务隔离级别，在该级别下，事务串行化顺序执行，可以避免脏读、不可重复读与幻读。但是这种事务隔离级别效率低下，比较耗数据库性能，一般不使用。

static int	ISOLATION_DEFAULT

static int	ISOLATION_READ_COMMITTED

static int	ISOLATION_READ_UNCOMMITTED

static int	ISOLATION_REPEATABLE_READ

static int	ISOLATION_SERIALIZABLE

事务超时时限

定义了默认事务超时时限

常量 TIMEOUT_DEFAULT 定义了事务底层默认的超时时限，sql 语句的执行时长。

注意：事务的超时时限起作用的条件比较多，且超时的时间计算点较复杂。所以，该值一般就使用默认值即可。

static int	TIMEOUT_DEFAULT

事务传播行为

定义了七个事务传播行为常量

事务传播行为：处于不同事务中的方法在相互调用时，执行期间事务的维护情况。如，A 事务中的方法 doSome()调用 B 事务中的方法 doOther()，在调用执行期间事务的维护情况，就称为事务传播行为。

事务传播行为是加在方法上的。

事务传播行为常量都是以 PROPAGATION_ 开头，形如 PROPAGATION_XXX。

PROPAGATION_REQUIRED
PROPAGATION_REQUIRES_NEW
PROPAGATION_SUPPORTS

PROPAGATION_MANDATORY
PROPAGATION_NESTED
PROPAGATION_NEVER
PROPAGATION_NOT_SUPPORTED

static int	PROPAGATION_REQUIRED

static int	PROPAGATION_REQUIRES_NEW

static int	PROPAGATION_SUPPORTS
    
static int	PROPAGATION_MANDATORY

static int	PROPAGATION_NESTED

static int	PROPAGATION_NEVER

static int	PROPAGATION_NOT_SUPPORTED

PROPAGATION_REQUIRED

指定的方法必须在事务内执行。
若当前存在事务，就加入到当前事务中；若当前没有事务，则创建一个新事务。这种传播行为是最常见的选择，也是 Spring 默认的事务传播行为。
例如：该传播行为加在 doOther()方法上。若 doSome()方法在调用 doOther()方法时就是在事务内运行的，则 doOther()方法的执行也加入到该事务内执行。若 doSome()方法在调用doOther()方法时没有在事务内执行，则 doOther()方法会创建一个事务，并在其中执行。

PRPAGATION_SUPPORTS

指定的方法支持当前事务，但若当前没有事务，也可以以非事务方式执行。

PROPAGATION_REQUIRES_NEW

总是新建一个事务，若当前存在事务，就将当前事务挂起，直到新事务执行完毕。

事务提交事务，回滚事务的时机

当你的业务方法，执行成功，没有异常抛出，当方法执行完毕，spring在方法执行后提交事务。调用事务管理器commit
当你的业务方法抛出运行时异常，spring执行回滚，调用事务管理器的rollback。

运行时异常：RuntimeException及其子类都是运行时异常，例如NUllPointException，NumberFormatException
当你的业务方法抛出非运行时异常，主要是受查异常时，默认提交事务。

受查异常：在写代码中必须处理的异常，例如：IOException、SQLException

Spring使用事务

Spring框架中提供的事务处理方案：

适合中小型项目中使用的，注解方案，spring自己提供的
使用 AspectJ 的 AOP 配置管理事务（适合大型项目）

使用 Spring 的事务注解管理事务

通过@Transactional 注解方式，可将事务织入到相应 public 方法中，实现事务管理。

可以给注解的属性赋值，表示具体的隔离级别，传播行为，异常信息等等

@Transactional 的所有可选属性如下所示：

1.propagation：用于设置事务传播属性。该属性类型为 Propagation 枚举，默认值为Propagation.REQUIRED。
    
2.isolation：用于设置事务的隔离级别。该属性类型为 Isolation 枚举，默认值为Isolation.DEFAULT。
    
3.readOnly：用于设置该方法对数据库的操作是否是只读的。该属性为 boolean，默认值为 false。
    
4.timeout：用于设置本操作与数据库连接的超时时限。单位为秒，类型为 int，默认值为-1，即没有时限。
    
5.rollbackFor：指定需要回滚的异常类。类型为 Class[]，默认值为空数组。当然，若只有一个异常类时，可以不使用数组。
    
6.rollbackForClassName：指定需要回滚的异常类类名。类型为 String[]，默认值为空数组。当然，若只有一个异常类时，可以不使用数组。
    
7.noRollbackFor：指定不需要回滚的异常类。类型为 Class[]，默认值为空数组。当然，若只有一个异常类时，可以不使用数组。
    
8.noRollbackForClassName：指定不需要回滚的异常类类名。类型为 String[]，默认值为空数组。当然，若只有一个异常类时，可以不使用数组。

注意：

@Transactional 若用在方法上，只能用于 public 方法上。对于其他非 public方法，如果加上了注解@Transactional，虽然 Spring 不会报错，但不会将指定事务织入到该方法中。因为 Spring 会忽略掉所有非 public 方法上的@Transaction 注解。
若@Transactional 注解在类上，则表示该类上所有的方法均将在执行时织入事务。

使用步骤

声明事务管理器对象


<!--声明数据源DateSource，作用是连接数据库-->
<bean id="myDateSource" class="com.alibaba.druid.pool.DruidDataSource"
      init-method="init" destroy-method="close">
    <!-- set注入给DruidDataSource 提供连接数据库信息 -->
    <property name="url" value="${jdbc.url}" />
    <property name="username" value="${jdbc.username}" />
    <property name="password" value="${jdbc.password}" />
    <property name="maxActive" value="${jdbc.maxActive}" />  <!--最大连接数-->
</bean>
......................................................................................


<!--使用事务管理器-->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <!--指定连接的数据库，指定数据源-->
    <property name="dataSource" ref="myDateSource" />
</bean>

开启事务注解驱动
- 告诉spring框架，我要使用注解的方式管理驱动。
- spring使用aop机制，创建@Transactional所在的类代理对象，给方法加入事务的功能。
- 原理：在业务方法之前开启事务，在执行业务方法之后提交事务或回滚事务，使用aop的环绕通知。
```


<tx:annotation-driven transaction-manager="transactionManager" />
```
说明：transaction-manager：事务管理器 bean 的 id
在需要的添加的事务的方法上加注解@Transactional

只写个注解，不写属性，那么注解的属性全是默认的。

例如：

package com.maj.service.impl;

import com.maj.dao.GoodsDao;
import com.maj.dao.SaleDao;
import com.maj.domain.Goods;
import com.maj.domain.Sale;
import com.maj.excep.NotEnoughException;
import com.maj.service.BuyGoodsService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Isolation;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;


@Component
public class BuyGoodsServiceImpl implements BuyGoodsService {
    @Autowired
    @Qualifier("goodsDao")
    private GoodsDao goodsDao = null;

    @Autowired
    @Qualifier("saleDao")
    private SaleDao saleDao = null;


    @Transactional(
            propagation = Propagation.REQUIRED,
            isolation = Isolation.DEFAULT,
            readOnly = false,
            rollbackFor = {
                    NotEnoughException.class,
                    NullPointerException.class
            }
    )
    @Override
    public void buy(Integer goodsId, Integer nums) {
        // 销售添加
        Sale sale = new Sale();
        sale.setGid(goodsId);
        sale.setNums(nums);
        int count0 = saleDao.insertSale(sale);

        // 更新库存
        Goods goods = goodsDao.selectGoods(goodsId);
        if (goods == null){
            throw new NullPointerException("编号："+goodsId + "商品不存在");
        }else if (goods.getAmount() < nums){
            throw new NotEnoughException("编号："+goodsId + "商品库存不足");
        }else{
            // 修改库存了
            Goods goods1 = new Goods();
            goods1.setId(goodsId);
            goods1.setAmount(nums);
            int count1 = goodsDao.updateGoods(goods1);

        }
    }
}

使用 AspectJ 的 AOP 配置管理事务

使用 XML 配置事务代理的方式的不足是，每个目标类都需要配置事务代理。当目标类较多，配置文件会变得非常臃肿。

使用 XML 配置顾问方式可以自动为每个符合切入点表达式的类生成事务代理。

使用步骤

加入maven依赖

<!-- AspectJ依赖 -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aspects</artifactId>
    <version>5.2.5.RELEASE</version>
</dependency>

声明事务管理器对象

    <!--声明式事务处理-->
    <!--声明事务管理器对象-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="myDateSource"/>
    </bean>

配置事务通知

为事务通知设置相关属性。用于指定要将事务以什么方式织入给哪些方法

    <!--声明业务方法的事务属性（隔离级别，传播行为，超时时间）-->
    <!--
        <tx:advice>的属性id = 自定义名称，表示这个标签的
                    属性transaction-manager = 事务管理器对象的id
		约束文件：http://www.springframework.org/schema/tx/spring-tx.xsd
    -->
    <tx:advice id="myAdvice" transaction-manager="transactionManager">
        <!-- <tx:attributes>配置事务的属性 -->
        <tx:attributes>
            <!-- tx:method是给具体的方法配置事务属性，method可以有多个，给不同的方法设置事务属性
                    属性name = 方法名称
                        （1）完整的方法名称，不带有包和类
                        （2）方法可以使用通配符 * ，表示任意字符
                    属性propagation = 传播行为，枚举值
                    isolation = 隔离级别
                    rollback-for = 指定的异常类名，全限定类名。异常时发生回滚
                    no-rollback-for = 异常时不回滚的异常类
                    read-only = 是否只读
                    timeout = 超时时间
             -->
            <tx:method name="buy" propagation="REQUIRED" isolation="DEFAULT"
                       rollback-for="java.lang.NullPointerException,com.maj.excep.NotEnoughException" />
        </tx:attributes>
    </tx:advice>

配置增强器

指定将配置好的事务通知，织入给谁。

<!-- 配置aop，可以指定哪些类，使用事务-->
    <aop:config>
        <!--
            配置切入点表达式：指定哪些包中的类，要使用事务
            id = 指定切入点表达式名称
            expression = 切入点表达式，指定哪些类要使用事务，aspectJ会创建代理对象
        -->
        <aop:pointcut id="servicePt" expression="execution(* *..service..*.*(..))"/>

        <!--配置增强器：关联advice和pointcut-->
        <aop:advisor advice-ref="myAdvice" pointcut-ref="servicePt" />
    </aop:config>

小马Mark

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
5.Spring事务

Spring事务管理事务原本是数据库中的概念，在 Dao 层。但一般情况下，需要将事务提升到业务层，即 Service 层。这样做是为了能够使用事务的特性来管理具体的业务。在 Spring 中通常可以通过以下两种方式来实现对事务的管理：使用 Spring 的事务注解管理事务使用 AspectJ 的 AOP 配置管理事务Spring事务管理APISpring 的事务管理，主要用到两个事务相关的接口。事务管理器接口事务管理器是 PlatformTransactionManager 接口对象。
复制链接

扫一扫

专栏目录