专栏首页chenchenchenSpring事务与非事务方法相互调用

Spring事务与非事务方法相互调用

事务

1. 事务的4种特性

序号 参数 含义 1 原子性(Atomicity) 事务是数据库的逻辑工作单位,它对数据库的修改要么全部执行,要么全部不执行。 2 一致性(Consistemcy) 事务前后,数据库的状态都满足所有的完整性约束。 3 隔离性(Isolation) 并发执行的事务是隔离的,一个不影响一个。通过设置数据库的隔离级别,可以达到不同的隔离效果 4 持久性(Durability) 在事务完成以后,该事务所对数据库所作的更改便持久的保存在数据库之中,并不会被回滚。

2.Transactional()控制事务传播的配置项目(默认Propagation.REQUIRED)

@Transactional(propagation=Propagation.REQUIRED) //控制事务传播。默认是Propagation.REQUIRED @Transactional(isolation=Isolation.DEFAULT) //控制事务隔离级别。默认跟数据库的隔离级别相同 @Transactional(readOnly=false) //控制事务可读写、只可读。默认可读写 @Transactional(timeout=30) //控制事务的超时时间,单位秒。默认跟数据库的事务控制系统相同 @Transactional(rollbackFor=RuntimeException.class) //控制事务遇到哪些异常会回滚。默认是RuntimeException @Transactional(rollbackForClassName=RuntimeException) //同上 @Transactional(noRollbackFor=NullPointerException.class) //控制事务遇到哪些异常不会回滚。默认遇到RuntimeException回滚 @Transactional(noRollbackForClassName=NullPointerException)//同上

3.事务的7中传播特性

序号 传播行为 含义 1 REQUIRED 如果存在一个事务,则支持当前事务。如果没有事务则开启一个新的事务。 2 SUPPORTS 如果存在一个事务,支持当前事务。如果没有事务,则非事务的执行 3 MANDATORY 如果已经存在一个事务,支持当前事务。如果没有一个活动的事务,则抛出异常。 4 NESTED 如果一个活动的事务存在,则运行在一个嵌套的事务中。如果没有活动事务,则按REQUIRED属性执行 5 NEVER 总是非事务地执行,如果存在一个活动事务,则抛出异常 6 REQUIRES_NEW 总是开启一个新的事务。如果一个事务已经存在,则将这个已经存在的事务挂起 7 NOT_SUPPORTED 总是非事务地执行,并挂起任何存在的事务

Spring事务传播属性: 1.propagation-required: 支持当前事务,如果有就加入当前事务中;如果当前方法没有事务,就新建一个事务; 2.propagation-supports: 支持当前事务,如果有就加入当前事务中;如果当前方法没有事务,就以非事务的方式执行; 3.propagation-mandatory: 支持当前事务,如果有就加入当前事务中;如果当前没有事务,就抛出异常; 4.propagation-requires_new: 新建事务,如果当前存在事务,就把当前事务挂起;如果当前方法没有事务,就新建事务; 5.propagation-not-supported: 以非事务方式执行,如果当前方法存在事务就挂起当前事务;如果当前方法不存在事务,就以非事务方式执行; 6.propagation-never: 以非事务方式执行,如果当前方法存在事务就抛出异常;如果当前方法不存在事务,就以非事务方式执行; 7.propagation-nested: 如果当前方法有事务,则在嵌套事务内执行;如果当前方法没有事务,则与required操作类似; 前六个策略类似于EJB CMT,第七个(PROPAGATION_NESTED)是Spring所提供的一个特殊变量。 它要求事务管理器或者使用JDBC 3.0 Savepoint API提供嵌套事务行为(如Spring的DataSourceTransactionManager) 在同一个类中,一个方法调用另外一个有注解(比如@Async,@Transational)的方法,注解是不会生效的

4. 事务的传播案例:

事务在A类的a()方法中调用B类的b()方法的传播案例

A.a() B.b()的事务配置 a()没有事务的结果 a()有事务的结果 REQUIRED b()创建自己的事务; b()接受a()的事务 SUPPORTS b()不创建自己的事务; b()接受a()的事务 MANDATORY b()报异常 b()接受a()的事务 NESTED b()创建自己的事务; b()接受a()的事务,成为a()嵌套的子事务 NEVER b()不创建自己的事务; b()报异常 REQUIRES_NEW b()创建自己的事务; b()不接受a()的事务,b()先执行,内层事务失败不会影响外层事务 NOT_SUPPORTED b()不创建自己的事务; b()不接受a()的事务,b()先执行

事务不生效的场景

问题一:非事务方法A调用事务方法B,方法B事务不生效

spring默认的是PROPAGATION_REQUIRED机制,如果方法A标注了注解@Transactional 是完全没问题的,执行的时候传播给方法B,因为方法A开启了事务,线程内的connection的属性autoCommit=false,并且执行到方法B时,事务传播依然是生效的,得到的还是方法A的connection,autoCommit还是为false,所以事务生效;反之,如果方法A没有注解@Transactional 时,是不受事务管理的,autoCommit=true,那么传播给方法B的也为true,执行完自动提交,即使B标注了@Transactional ;

在一个Service内部,事务方法之间的嵌套调用,普通方法和事务方法之间的嵌套调用,都不会开启新的事务.是因为spring采用动态代理机制来实现事务控制,而动态代理最终都是要调用原始对象的,而原始对象在去调用方法时,是不会再触发代理了!

所以以上就是为什么在没有标注事务注解的方法A里去调用标注有事务注解的方法B而没有事务滚回的原因;

问题二:在事务方法A中调用另外一个事务方法B,被调用方法B的事务没起作用

产生问题的原因是:spring是通过代理代管理事务的,当在第一个方法insertUser1内直接调用insertUser2的时候 ,insertUser2上的事务是不会起作用的(也就是insertUser2是没有开启事务)

解决方案

开启一下 有关事务 的日志,在 配置文件 中加上下面的配置:

logging.level.org.springframework.jdbc.datasource.DataSourceTransactionManager=debug

1.把方法放到不同的类:

我们需要新建一个接口:

public interface OtherService {
    void insertCodeMonkey();
}

再定义一个类去实现这个接口:

@Service
public class OtherServiceImpl implements OtherService {

    @Autowired
    AccountMapper mapper;

    @Override
    @Transactional(propagation=Propagation.REQUIRES_NEW)
    public void insertCodeMonkey() {
        Account account = new Account();
        account.setAccount("CodeMonkey");
        account.setPassword("CodeMonkey");
        mapper.insert(account);
        int a = 1 / 0;
    }
}

修改原本的实现类:

@Service
public class AccountSerivceImpl implements AccountService {

    @Autowired
    AccountMapper mapper;

    @Autowired
    OtherService otherService;

    @Transactional
    @Override
    public void insertCodeBear() {

        try {
            otherService.insertCodeMonkey();
        } catch (Exception e) {
            e.printStackTrace();
        }

        Account account = new Account();
        account.setAccount("CodeBear");
        account.setPassword("CodeBear");
        mapper.insert(account);
    }
}

运行,查看数据库:

只有一条数据,insertCodeBear方法执行成功了,insertCodeMonkey执行失败,并且回滚了。

让我们再看看控制台的日志:

可以看到是开了两个事务去执行的。

这种解决方案最简单,不需要了解其他东西,但是这种方案需要修改代码结构,本来两个方法都是属于同一个类的,现在需要强行把它们拆开。

2. AopContext:

我们的目标是要在实现类中获取本类的代理对象,Spring提供了Aop上下文,即:AopContext,通过AopContext,可以很方便的获取到代理对象:

@Service
public class AccountSerivceImpl implements AccountService {

    @Autowired
    AccountMapper mapper;

    @Transactional
    @Override
    public void insertCodeBear() {
        try {
            ((AccountService)AopContext.currentProxy()).insertCodeMonkey();
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        Account account = new Account();
        account.setAccount("CodeBear");
        account.setPassword("CodeBear");
        mapper.insert(account);
    }

    @Transactional(propagation = Propagation.REQUIRES_NEW)
    @Override
    public void insertCodeMonkey() {
        Account account = new Account();
        account.setAccount("CodeMonkey");
        account.setPassword("CodeMonkey");
        mapper.insert(account);
        int a = 1 / 0;
    }
}

当写好代码,很愉快的去测试,发现竟然报错了:

翻译下:不能找到当前的代理,需要设置exposeProxy属性为 true使其可以。

expose字面意思就是 暴露。也就是说 我们需要允许暴露代理。

我们需要在Spring Boot启动类上+一个注解:

@EnableAspectJAutoProxy(exposeProxy = true)
@SpringBootApplication
@MapperScan(basePackages = "com.codebear.Dao")
public class SpringbootApplication {
    public static void main(String[] args) throws Exception {
        SpringApplication.run(SpringbootApplication.class, args);
    }
}

再次运行:

确实是开启了两个事务去执行的。

再看看数据库,也没有问题。

3. ApplicationContext:

@Service
public class AccountSerivceImpl implements AccountService {

    @Autowired
    AccountMapper mapper;

    @Autowired
    ApplicationContext context;

    AccountService service;

    @PostConstruct
    private void setSelf() {
        service = context.getBean(AccountService.class);
    }

    @Transactional
    @Override
    public void insertCodeBear() {
        try {
            service.insertCodeMonkey();
        } catch (Exception e) {
            e.printStackTrace();
        }
        Account account = new Account();
        account.setAccount("CodeBear");
        account.setPassword("CodeBear");
        mapper.insert(account);
    }

    @Transactional(propagation = Propagation.REQUIRES_NEW)
    @Override
    public void insertCodeMonkey() {
        Account account = new Account();
        account.setAccount("CodeMonkey");
        account.setPassword("CodeMonkey");
        mapper.insert(account);
        int a = 1 / 0;
    }
}

此方法不适用于prototype

在这里,我用了一个@PostConstruct注解,在初始化的时候,会调用被@PostConstruct标记的方法(注意,仅仅是初始化的时候,才会被调用。以后都不会被调用了,大家可以打个断点试一下),这里这么做的目的就是为了提升一下效率,不用每次都getBean。所以如果这个类是prototype的,就不适用这个方法了。如果是prototype的话,就在insertCodeBear方法中使用getBean方法吧。

上两种方法比较方便,没有新建其他的接口或者是类,但是没有很好的封装获得Aop代理对象的过程,也不是很符合 迪比特法则,也就是最少知识原则。

4. 重写BeanPostProcessor接口:

关于这个接口是做什么的,这里就不详细阐述了,简单的来说这是Spring提供的接口,我们可以通过重写它,在初始化Bean之前或者之后,自定义一些额外的逻辑。 首先,我们需要定义一个接口:

public interface WeavingSelfProxy {
    void setSelfProxy(Object bean);
}

要获得代理对象的类,需要去实现它:

@Service
public class AccountSerivceImpl implements AccountService, WeavingSelfProxy {

    @Autowired
    AccountMapper mapper;

    AccountService service;

    @Override
    public void setSelfProxy(Object bean) {
        System.out.println("进入到setSelfProxy方法");
        service = (AccountService) bean;
    }

    @Transactional
    @Override
    public void insertCodeBear() {
        try {
            service.insertCodeMonkey();
        } catch (Exception e) {
            e.printStackTrace();
        }
        Account account = new Account();
        account.setAccount("CodeBear");
        account.setPassword("CodeBear");
        mapper.insert(account);
    }

    @Transactional(propagation = Propagation.REQUIRES_NEW)
    @Override
    public void insertCodeMonkey() {
        Account account = new Account();
        account.setAccount("CodeMonkey");
        account.setPassword("CodeMonkey");
        mapper.insert(account);
        int a = 1 / 0;
    }
}

重写BeanPostProcessor接口:

@Component
public class SetSelfProxyProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        if(bean instanceof WeavingSelfProxy){
            System.out.println("实现了WeavingSelfProxy接口");
            ((WeavingSelfProxy) bean).setSelfProxy(bean);
        }
        return bean;
    }
}

参考:

@Transactional 同一个类中无事务方法a()内部调用有事务方法b()的问题https://www.cnblogs.com/lukelook/p/11246180.html

被标记为事务的方法互相调用的坑(上):https://www.jianshu.com/p/ba13144dba20?from=timeline&isappinstalled=0

被标记为事务的方法互相调用的坑(下):https://www.jianshu.com/p/b375c52f2a71

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

我来说两句

0 条评论
登录 后参与评论

相关文章

  • 连接数据库报错Unable to load authentication plugin caching_sha2_password

    java.sql.SQLException: Unable to load authentication plugin 'caching_sha2_passwo...

    chenchenchen
  • 查看某个端口占用

    版权声明:本文为博主原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。

    chenchenchen
  • API网关

    假设你正在开发一个电商网站,那么这里会涉及到很多后端的微服务,比如会员、商品、推荐服务等等。

    chenchenchen
  • 3-1 SQL Server 2005的

    所谓事务是用户定义的一个数据库操作序列,这些操作要么全做要么全不做,是一个不可分割的工作单位。SQL Server 2005 提供了几种自动的可以通过编程来完成...

    py3study
  • 必须要讨论的四种分布式事务方案

    分布式事务伴随着微服务被人们一再提起。服务与服务之间的事务怎么处理比较好?到底使用哪种选择方案比较好。相信有人觉得分布式事务实现起来比较困难甚至不可能。也有人觉...

    ImportSource
  • 【面试】Spring事务面试考点整理

    Spring和事务的关系 关系型数据库、某些消息队列等产品或中间件称为事务性资源,因为它们本身支持事务,也能够处理事务。 Spring很显然不是事务性资源,...

    Java团长
  • 面试必会的 MySQL 中的事务问题!

    事务(Transaction) 是并发控制的基本单位。所谓的事务,它是一个操作序列,这些操作要么都 执行,要么都不执行,它是一个不可分割的工作单位。事务是数据库...

    好好学java
  • 【面试】Spring事务面试考点吐血整理(建议珍藏)

    Spring和事务的关系 关系型数据库、某些消息队列等产品或中间件称为事务性资源,因为它们本身支持事务,也能够处理事务。 Spring很显然不是事务性资源,...

    Java3y
  • MySQL基础之事务编程学习笔记

    在学习《MySQL技术内幕:SQL编程》一书,并做了笔记。本博客内容是自己学了《MySQL技术内幕:SQL编程》事务编程一章之后,根据自己的理解做的笔记,内容和...

    用户1208223
  • 可能是最漂亮的 Spring 事务管理详解

    摘要: 原创出处 https://juejin.im/post/5b00c52ef265da0b95276091 「Snailclimb」欢迎转载,保留摘要,谢...

    芋道源码

扫码关注云+社区

领取腾讯云代金券