Spring控制事务回滚

Spring控制事务回滚

  • 1、说明
  • 2、声明式性事务@Transacational
  • 3、@Transactional不适用场景
  • 4、@Transactional注解事务失效的几种场景及原因
    • 4.1、数据库引擎不支持事务
    • 4.2、添加事务的类没有被Spring管理
    • 4.3、@Transactional作用的方法不是public修饰的
    • 4.4、@Transactional的rollbackFor属性设置错误
    • 4.5、@Transactional的propagation属性设置错误
    • 4.6、调用同类的方法,事务失效
    • 4.7、异常被捕获,事务无法回滚
  • 5、spring事务控制手动回滚
  • 6、AOP配置全局事务管理

1、说明

1、Spring中开启事务的方式主要有两种:编程式事务和声明式事务

2、事务是我们开发过程中经常会使用到的,为了在业务执行过程中出现异常时,回滚到原始状态。而事务的回滚在大多数情况下都是靠着 exception(异常)来触发回滚的,当事务机制捕捉到异常,就会开始回滚。

3、但往往也会出现情况:在业务代码中,需要对异常单独进行处理,异常不会抛出,但需要事务回滚的情况,这个时候就需要手动调用回滚

2、声明式性事务@Transacational

@Transactional 声明式事务,是开发过程中最常用的开启事务的方式。
也可以通过切面,对整个业务层的方法进行事务控制

优点:使用方便,而且对代码的侵入性低

这种方式,默认是通过 捕获 RunTimeException 来触发事务回滚,只要是 RuntimeException 以及 它的子类,都可以触发事务回滚。也可以修改触发事务回滚的异常范围,可以通过修改 @Transactional 中的 rollbackFor 属性,修改异常范围。比如:
@Transactional(rollbackFor = Exception.class),修改完成后,只要是 Exception 类的子类,都可以触发事务回滚

3、@Transactional不适用场景

有时候需要对异常进行特殊处理,异常被捕获无法抛出时,声明式事务就失效不可用。

示例:抛出异常被捕获,无法触发事务回滚。

    //业务代码
    try{ 
        //业务处理出现异常
    } catch (Exception e) {
        // 捕获异常,打印异常,或其他处理。但不抛出新的异常
        e.printStackTrace();
        //可以将捕获后的异常,封装为新的业务异常抛出(正常回滚)
        throw new xxxxException(e.getMessage);
    }
    //此时return语句能够执行
    return  xxx;

此处,可以将捕获后的异常,封装为新的业务异常抛出

4、@Transactional注解事务失效的几种场景及原因

在开发过程中,我们需要同时进行多个对数据的操作,这时候需要使用事务去控制多个操作的一致性。
通过声明式事务**@Transactional** 注解修饰方法的形式开启事务,需要注意到以下这些情况会出现事务失效。

4.1、数据库引擎不支持事务

例如我们使用Mysql数据,在 5.5 版本之前,Mysql 默认的数据引擎都是 MyISAM 的,而 MyISAM不支持事务的;在 5.5 版本之后,默认的数据引擎是 InnoDB 的,它是支持事务的。

Spring 对事务的管理实现又是基于数据库的,所以当数据库引擎不支持事务的时候,自然就不会有起作用的事务机制了,所有我们在选择数据库的时候,需要去选择支持事务的数据引擎。

4.2、添加事务的类没有被Spring管理

当添加了注解或者全局事务配置了路径,但是需要用到事务的方法所在的类没有注入到Spring容器中,这样事务也不会生效,通常我们都是添加到业务逻辑处理层,通常都是添加@Service,将当前类注入到Spring中。

4.3、@Transactional作用的方法不是public修饰的

@Transactional注解应用在非public修饰的方法上,Transactional将会失效。这是因为在Spring AOP代理时,事务拦截器只能拦截public方法,而非public方法将直接被执行,不会经过代理。因此,建议将@Transactional注解只应用在public方法上。

4.4、@Transactional的rollbackFor属性设置错误

rollbackFor是@Transactional注解的一个属性,用于指定能够触发事务回滚的异常类型。Spring默认只在遇到未检查unchecked异常(继承自RuntimeException的异常)或者Error时才回滚事务;其他异常不会触发回滚事务。如果想让其他异常也能触发回滚事务,可以在@Transactional注解中加上rollbackFor属性,设置Exception异常就回滚,这样不管是Exception还是RuntimeException,spring都能帮助我们去回滚数据了。

示例:当抛出Exception异常时,想要触发事务回滚,就要设置@Transactional(rollbackFor = Exception.class)

    @Transactional(rollbackFor = Exception.class)
    public void test() {
        // 业务代码
        if(1 == 1) {
            throw new Exception("Exception 异常");
        }
    }

4.5、@Transactional的propagation属性设置错误

设置 @Transactional(propagation = xxxx)可以配置 Spring 的事务传播机制的,当事务传播机制设置为不支持事务是,事务也是不会生效的。propagation参数指定了事务的传播行为,即在一个事务方法中调用另一个事务方法时,两个事务如何关联。

示例:当设置为 propagation = Propagation.NOT_SUPPORTED 时,表示不以事务运行,当前若存在事务则挂起。

    @Transactional(propagation = Propagation.NOT_SUPPORTED)
    public void test1() {
        // 业务代码
    }

propagation有以下几种取值:

  • REQUIRED:如果当前存在事务,则加入该事务;如果当前没有事务,则创建一个新的事务。
  • SUPPORTS:如果当前存在事务,则加入该事务;如果当前没有事务,则以非事务的方式继续运行。
  • MANDATORY:如果当前存在事务,则加入该事务;如果当前没有事务,则抛出异常。
  • REQUIRES_NEW:创建一个新的事务,如果当前存在事务,则把当前事务挂起。
  • NOT_SUPPORTED:以非事务方式运行,如果当前存在事务,则把当前事务挂起。
  • NEVER:以非事务方式运行,如果当前存在事务,则抛出异常。
  • NESTED:如果当前存在事务,则创建一个事务作为当前事务的嵌套事务来运行;如果当前没有事务,则与REQUIRED类似,创建一个新的事务。

propagation的默认值是REQUIRED。

4.6、调用同类的方法,事务失效

调用本类方法导致传播行为失效,同一个 Service 的两个方法之间调用,就会出现这个问题,原因还是在代理对象这里,我们期待的调用是一个代理类的调用,但是我们若是直接在方法中内部调用,不好意思,被调用的方法的事务失效,没有被 AOP 增强。

**示例:**方法addStudents调用本类中的方法addStudent

@Service
public class StudentService {
    @Transactional
    public void addStudent(Student student) {
        // do something
    }

    public void addStudents(List<Student> students) {
        for (Student student : students) {
            // 这里直接调用同类的方法,事务不会生效
            addStudent(student);
        }
    }
}

解决方案一:自己调用自己,自己注入自己。你可能看见过这样的代码,就是为了解决这个问题的。这种解决方案最常见。

    @Transactional(rollbackFor = Exception.class, propagation = Propagation.REQUIRES)
    public void a (){
        service.b();
    }

方案二:还有一种方法可以在同类调用的方法上,通过AOP代理调用,即使用AopContext.currentProxy()方法获取当前类的代理对象,然后通过代理对象调用目标方法,这样就可以执行事务切面,进行事务增强。

@Service
public class StudentService {
    @Transactional
    public void addStudent(Student student) {
        // do something
    }

    public void addStudents(List<Student> students) {
        for (Student student : students) {
            // 这里通过代理对象调用同类的方法,事务会生效
            ((StudentService)AopContext.currentProxy()).addStudent(student);
        }
    }
}

方案三:在同类调用的方法上,使用@Async注解,这样就可以在异步线程中执行目标方法,而不是在当前线程中执行,这样就可以避免事务失效的问题。

@Service
public class StudentService {
    @Transactional
    @Async
    public void addStudent(Student student) {
        // do something
    }

    public void addStudents(List<Student> students) {
        for (Student student : students) {
            // 这里在异步线程中调用同类的方法,事务会生效
            addStudent(student);
        }
    }
}

4.7、异常被捕获,事务无法回滚

事务机制的回滚,是 通过异常来触发事务回滚的。在开发过程中,会出现异常被捕获处理了,而且没有再抛出新的异常,就会导致异常丢失,无法触发回滚。

**示例1:**不会触发回滚的情况

    @Transactional
    public void test1() {
        // 演示直接抛出异常被捕获
        try {
            throw new  RuntimeException();
        } catch (RuntimeException e) {
            // 不做处理,虽然有异常,但异常丢失,无法触发事务回滚
        }
    }

**示例2:**catch 捕获异常后,再抛出

    @Transactional
    public void test1() {
        // test code
        try {
            throw new  RuntimeException();
        } catch (RuntimeException e) {
            // 不做处理,虽然有异常,但异常丢失,无法触发事务回滚
            throw e;
        }
    }

5、spring事务控制手动回滚

Spring事务控制手动回滚是指在某些情况下,我们需要主动触发事务的回滚,而不是依赖于Spring的默认回滚策略。Spring的默认回滚策略是对非检查型异常和运行时异常进行事务回滚,而对检查型异常则不进行回滚操作。有两种常用的方法可以实现手动回滚:

  • 手动抛出一个运行时异常,例如throw new RuntimeException(),这样Spring就会捕获到这个异常,并执行事务回滚。
  • 通过Spring提供的事务切面支持类TransactionAspectSupport,调用其currentTransactionStatus().setRollbackOnly()方法,这样就可以标记当前事务为回滚状态,而不需要抛出异常。

使用手动回滚的方法时,需要注意以下几点:

  • 被回滚的方法必须使用@Transactional注解,否则无法开启事务管理,也就无法回滚。
  • 被回滚的方法不能在同一个类中直接调用,否则无法走代理类,也就无法回滚,需要通过AOP代理调用或者注入自身的bean来调用。
  • 被回滚的方法不能使用try catch来捕获异常,否则无法触发回滚,需要在方法签名上声明throws或者在catch块中重新抛出异常。

**示例:**手动回滚事务

    //假设这是一个service类的片段
    try{ 
        //出现异常
    } catch (Exception e) {
        // 捕获异常,打印异常,或其他处理。但不抛出新的异常
        e.printStackTrace();
        // 手动回滚
        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
    }
    //此时return语句能够执行
    return  xxx;

6、AOP配置全局事务管理

示例:

package com.gd.gd_service.config;

import org.aspectj.lang.annotation.Aspect;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.aop.Advisor;
import org.springframework.aop.aspectj.AspectJExpressionPointcut;
import org.springframework.aop.support.DefaultPointcutAdvisor;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.transaction.TransactionDefinition;
import org.springframework.transaction.TransactionManager;
import org.springframework.transaction.interceptor.*;

import java.util.Collections;
import java.util.HashMap;
import java.util.Map;

/**
 * @Auther: hippoDocker
 * @Date:2021年12月21日20:51:27
 * @Description: TODO 全局事务配置
 */
@Configuration
@Aspect
public class TransactionManagerConfig {
    private static final Logger logger = LoggerFactory.getLogger(TransactionManagerConfig.class);
    /**
     * 配置方法过期时间,默认-1,永不超时,单位秒
     */
    @Value("${spring.application.transactiontimeout}")
    private int AOP_TIME_OUT;
    /**
     * 配置切入点表达式 : 指定哪些包中的类使用事务
     */
    private static final String AOP_POINTCUT_EXPRESSION = "execution(* com.gd.gd_service.service.impl.*.*(..)))";
    //事务管理器
    @Autowired
    private TransactionManager transactionManager;
    /**
     * 全局事务配置
     * REQUIRED :如果当前存在事务,则加入该事务;如果当前没有事务,则创建一个新的事务。
     * SUPPORTS :如果当前存在事务,则加入该事务;如果当前没有事务,则以非事务的方式继续运行。
     * MANDATORY :如果当前存在事务,则加入该事务;如果当前没有事务,则抛出异常。
     * REQUIRES_NEW :创建一个新的事务,如果当前存在事务,则把当前事务挂起。
     * NOT_SUPPORTED :以非事务方式运行,如果当前存在事务,则把当前事务挂起。
     * NEVER :以非事务方式运行,如果当前存在事务,则抛出异常。
     * NESTED :如果当前存在事务,则创建一个事务作为当前事务的嵌套事务来运行;如果当前没有事务,则该取值等价于 REQUIRED 。
     * 指定方法:通过使用 propagation 属性设置,例如:@Transactional(propagation = Propagation.REQUIRED)
     */
    @Bean
    public TransactionInterceptor txAdvice(){
        /**
         * 配置事务管理规则
         * 这里配置只读事务
         * 查询方法, 只读事务,不做更新操作
         */
        RuleBasedTransactionAttribute readOnlyTx = new RuleBasedTransactionAttribute();
        readOnlyTx.setReadOnly(true);
        readOnlyTx.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED);

        /**
         * 增、删、改 需要的事务
         * 必须带事务
         * 当前存在事务就使用当前事务,当前不存在事务,就开启一个新的事务
         */
        RuleBasedTransactionAttribute requiredTx = new RuleBasedTransactionAttribute();
        // 设置回滚规则:什么异常都需要回滚
        requiredTx.setRollbackRules(Collections.singletonList(new RollbackRuleAttribute(Exception.class)));
        // 当前存在事务就使用当前事务,当前不存在事务就创建一个新的事务
        requiredTx.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED);
        // 设置超时时间,超时则抛出异常回滚
        requiredTx.setTimeout(AOP_TIME_OUT);
        System.out.println("=====>>事务超时时间:"+requiredTx.getTimeout());
        /**
         * 无事务地执行,挂起任何存在的事务
         */
        RuleBasedTransactionAttribute noTx = new RuleBasedTransactionAttribute();
        noTx.setPropagationBehavior(TransactionDefinition.PROPAGATION_NOT_SUPPORTED);

        /**
         * 设置方法对应的事务
         */
        Map<String, TransactionAttribute> methodMap = new HashMap<>();
        // 可以提及事务或回滚事务的方法
        //只读事务
        methodMap.put("get*", readOnlyTx);
        methodMap.put("query*", readOnlyTx);
        methodMap.put("find*", readOnlyTx);
        methodMap.put("list*", readOnlyTx);
        methodMap.put("count*", readOnlyTx);
        methodMap.put("exist*", readOnlyTx);
        methodMap.put("search*", readOnlyTx);
        methodMap.put("fetch*", readOnlyTx);
        //写事务
        methodMap.put("add*", requiredTx);
        methodMap.put("save*", requiredTx);
        methodMap.put("insert*", requiredTx);
        methodMap.put("update*", requiredTx);
        methodMap.put("modify*", requiredTx);
        methodMap.put("delete*", requiredTx);
        methodMap.put("creat*", requiredTx);
        methodMap.put("edit*", requiredTx);
        methodMap.put("remove*", requiredTx);
        methodMap.put("repair*", requiredTx);
        methodMap.put("binding*", requiredTx);
        methodMap.put("clean*", requiredTx);
        methodMap.put("upload*",requiredTx);
        //无事务
        methodMap.put("noTx*", noTx);
        // 其他方法无事务,只读
        methodMap.put("*", readOnlyTx);

        //声明一个通过方法名字配置事务属性的对象
        NameMatchTransactionAttributeSource source = new NameMatchTransactionAttributeSource();
        source.setNameMap(methodMap);

        //返回事务拦截器
        TransactionInterceptor txAdvice = new TransactionInterceptor(transactionManager, source);
        return txAdvice;
    }

    @Bean(name = "txAdviceAdvisor")
    public Advisor txAdviceAdvisor(TransactionInterceptor txAdvice) {
        logger.info("=====>>创建txAdviceAdvisor");
        //配置事务切入点表达式
        AspectJExpressionPointcut pointcut = new AspectJExpressionPointcut();
        pointcut.setExpression(AOP_POINTCUT_EXPRESSION);
        //增强事务,关联切入点和事务属性
        return new DefaultPointcutAdvisor(pointcut, txAdvice);
    }
}

你可能感兴趣的:(#,Spring,java,spring,java,mysql)