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 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 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 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 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);
    }
}

太原网站制作企业办公室装修设计公司沈阳网站制作公司重庆免费建站公司网站创建方案策划阿里云虚拟主机价格

上一篇：多种方法解决SLF4J: Defaulting to no-operation (NOP) logger implementation的错误

下一篇：nginx部署前端项目时location时root和alias配置