@Transactional transaction methods contain multiple transaction methods of the same kind. These transaction methods themselves are set to fail. There are two solutions

The problem background

1 @Transactional Call similar methods , Different settings @Transactional There are two solutions to failure
2 Pseudo code illustrates the problem

• a,b,c Three methods are in the same class , Call for this method
• a,b,c The transaction settings of the three methods are different
• Similar method calls make a,b Of Transactional Transaction settings are invalid , Unified follow c Method , This is not the result we want

public class TransactionServiceImpl implements TransactionService {
    

    @Transactional(propagation = Propagation.MANDATORY)
    public void a(){
    

    }

    @Transactional(isolation = Isolation.READ_COMMITTED)
    public void b(){
    

    }

    @Transactional
    public void c(){
    
        //1. a,b,c Three methods are in the same class , Call for this method 
        //2. a,b,c The transaction settings of the three methods are different 
        //3.  Similar method calls make a,b Of Transactional Transaction settings are invalid , Unified follow  c  Method , This is not the result we want 
        a();
        b();
    }

}

Solution 1

1 Because the transaction annotation is through spring Of IOC The control inversion of the container is realized , Call this class method directly , Not used spring Dynamic proxy for , So you can change it to other methods to call methods of other classes , Is the dynamic proxy effective

@Service
public class AbServiceImpl implements AbService {
    

    @Transactional(propagation = Propagation.MANDATORY)
    public void a(){
    

    }

    @Transactional(isolation = Isolation.READ_COMMITTED)
    public void b(){
    

    }

}

@Service
public class TransactionServiceImpl implements TransactionService {
    

    // from IOC Get the proxy object in the container , Make dynamic proxy effective 
    @Autowired
    AbService abService; 

    @Transactional
    public void c(){
    
        //a,b,c Three methods in different classes , Use dynamic proxy to call , In this way, three kinds of Transactional The transaction settings take effect 
        abService.a();
        abService.b();
    }

}

Solution 2

1 Use spring The dependency to obtain the dynamic proxy object is provided

        <!--  introduce aop -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
        </dependency>

2 Use... In the startup class @EnableAspectJAutoProxy(exposeProxy = true) annotation , Turn on aspect Dynamic proxy model , Expose proxy objects , You can delegate the current object , send @Asycn and @Transactional take effect , All dynamic agents use aspectj establish , Than JDK More benefits are ： You can proxy without opening the interface
If you don't open this annotation , By default JDK Dynamic proxy for

package com.lanran.transactional;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@EnableAspectJAutoProxy(exposeProxy = true)     // Open the aspect Dynamic proxy model , Expose proxy objects , You can delegate the current object , send @Asycn and @Transactional take effect 
@MapperScan("com.lanran.transactional.dao")
@SpringBootApplication
public class TransactionalApplication {
    

    public static void main(String[] args) {
    
        SpringApplication.run(TransactionalApplication.class, args);
    }

}

3 Get the proxy object and call the method

package com.lanran.transactional.service.impl;

import com.lanran.transactional.service.TransactionService;
import org.springframework.aop.framework.AopContext;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Isolation;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

/** * @Author suolong * @Date 2022/7/21 11:21 * @Version 2.0 */
@Service
public class TransactionServiceImpl implements TransactionService {
    

    @Transactional(propagation = Propagation.MANDATORY)
    public void a() {
    

    }

    @Transactional(isolation = Isolation.READ_COMMITTED)
    public void b() {
    

    }

    @Transactional
    public void c() {
    
        // Get the proxy object from the context 
        TransactionServiceImpl  transactionService = (TransactionServiceImpl) AopContext.currentProxy();
        transactionService.a();
        transactionService.b();
    }

}

summary

This question reminds me of @Async This asynchronous annotation , The principle is the same , The same method calls the method of asynchronous annotation , Asynchrony will fail , Become synchronized , Only call other classes @Async The method works

As a programmer 209 An article , Write one line of lyrics at a time and record , Look at how many songs there are in life ,wahahaha …

Lyric： With the melody of the right hand