Spring @Transaction method call by the method within the same class, does not work?

Question

I am new to Spring Transaction. Something that I found really odd, probably I did understand this properly.

I wanted to have a transactional around method level and I have a caller method within the same class and it seems like it does not like that, it has to be called from the separate class. I don't understand how is that possible.

If anyone has an idea how to resolve this issue, I would greatly appreciate. I would like to use the same class to call the annotated transactional method.

Here is the code:

public class UserService {

    @Transactional
    public boolean addUser(String userName, String password) {
        try {
            // call DAO layer and adds to database.
        } catch (Throwable e) {
            TransactionAspectSupport.currentTransactionStatus()
                    .setRollbackOnly();

        }
    }

    public boolean addUsers(List<User> users) {
        for (User user : users) {
            addUser(user.getUserName, user.getPassword);
        }
    } 
}

Inclement

Take a look at the TransactionTemplate approach: https://mcmap.net/q/108321/-does-spring-transactional-attribute-work-on-a-private-method – Bryson

About why self invocation doesn't work, see 8.6 Proxying mechanisms. – Oaken

@Mike, how you discovered that the transaction does not work? An exception is thrown? – Alcestis

Answer 1

It's a limitation of Spring AOP (dynamic objects and cglib).

If you configure Spring to use AspectJ to handle the transactions, your code will work.

The simple and probably best alternative is to refactor your code. For example one class that handles users and one that process each user. Then default transaction handling with Spring AOP will work.

---

Configuration tips for handling transactions with AspectJ

To enable Spring to use AspectJ for transactions, you must set the mode to AspectJ:

<tx:annotation-driven mode="aspectj"/>

If you're using Spring with an older version than 3.0, you must also add this to your Spring configuration:

<bean class="org.springframework.transaction.aspectj
        .AnnotationTransactionAspect" factory-method="aspectOf">
    <property name="transactionManager" ref="transactionManager" />
</bean>

Washroom

Thank you for the information. I refactored the code for now, but could you please send me an example using AspectJ or provide me with some helpful links. Thanks in advance. Mike. – Inclement

Added transaction specific AspectJ configuration in my answer. I hope it helps. – Washroom

That's good! Btw: It would be nice if you can mark my question as the best answer to give me some points. (green checkmark) – Washroom

Spring boot config : @EnableTransactionManagement(mode = AdviceMode.ASPECTJ) – Damselfish

Why AspectJ tis not default for handling transactions? – Cellulosic

@Cellulosic I know this is not a full answer to your question, but I had some very mysterious LazyInitializationExceptions in my codebase after adding the line mentioned by VinyJones, so it does not seem like a pure upgrade that can just be applied thoughtlessly. – Maimaia

Answer 2

In Java 8+ there's a possibility, which I prefer for the reasons given below:

@Service
public class UserService {

    @Autowired
    private TransactionHandler transactionHandler;

    public boolean addUsers(List<User> users) {
        for (User user : users) {
            transactionHandler.runInTransaction(() -> addUser(user.getUsername, user.getPassword));
        }
    }

    private boolean addUser(String username, String password) {
        // TODO call userRepository
    }
}

@Service
public class TransactionHandler {

    @Transactional(propagation = Propagation.REQUIRED)
    public <T> T runInTransaction(Supplier<T> supplier) {
        return supplier.get();
    }

    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public <T> T runInNewTransaction(Supplier<T> supplier) {
        return supplier.get();
    }
}

This approach has the following advantages:

1. It may be applied to private methods. So you don't have to break encapsulation by making a method public just to satisfy Spring limitations.

2. Same method may be called within different transaction propagations and it is up to the caller to choose the suitable one. Compare these 2 lines:

    transactionHandler.runInTransaction(() -> userService.addUser(user.getUserName, user.getPassword));
   
    transactionHandler.runInNewTransaction(() -> userService.addUser(user.getUserName, user.getPassword));
   

3. It is explicit, thus more readable.

Allpowerful

This is great! It avoids all the pitfalls that Spring introduces with its annotation otherwise. Love it! – Spellbound

If I extend TransactionHandler as a subclass, and the subclass calls on these two methods in the TransactionHandler super class, will I still be able to get the benefits of @Transactional as intended? – Pharynx

Sounds wonderful! I wonder whether there are some caveats? – Increate

Excellent. I used this solution too, with a small difference: I named the methods in TransactionHandler runInTransactionSupplier and runInNewTransactionSupplier. This leaves open the possibility for adding later similar but void returning methods in TransactionHandler. – Jallier

@burebista, you do it wrongly, it's possible to define two methods with same name, one of which accepts supplier and return T and other accept runnable and returns void. – Pteridophyte

Spring already has TransactionTemplate which is basically the same thing. – Mariahmariam

not exactly the same thing. transactionTempalte is to make it more manual. (which is not that bad by itself and more flexible) but it's still more verbose than just @Transactional annotation. – Aq

Nice approach, especially since Spring Boot 2.6.x and > wants me to get rid of circular dependencies, which means I can't self-inject services anymore and call other transactional methods in the same service. Question, if one of the methds throws an Exception, I am unable to call it due to "no instance(s) of type variable(s) T exist so that void conforms to T" error. I tried adding a new method that throws, but not working – Nonary

same goes re: my previous comment for transaction methods that return void – Nonary

For what it's worth, the approach does not work in multithreading – Somnus

anyone who wants to use in void returning function, use below. ``` @Transactional(propagation = Propagation.REQUIRED) public void runInTransaction(Runnable runnable) { runnable.run(); } ``` – Vide

@Jarvis: What specific problems do you see with this approach in multithreading? – Mcmurry

Answer 3

The problem here is, that Spring's AOP proxies don't extend but rather wrap your service instance to intercept calls. This has the effect, that any call to "this" from within your service instance is directly invoked on that instance and cannot be intercepted by the wrapping proxy (the proxy is not even aware of any such call). One solutions is already mentioned. Another nifty one would be to simply have Spring inject an instance of the service into the service itself, and call your method on the injected instance, which will be the proxy that handles your transactions. But be aware, that this may have bad side effects too, if your service bean is not a singleton:

<bean id="userService" class="your.package.UserService">
  <property name="self" ref="userService" />
    ...
</bean>

public class UserService {
    private UserService self;

    public void setSelf(UserService self) {
        this.self = self;
    }

    @Transactional
    public boolean addUser(String userName, String password) {
        try {
        // call DAO layer and adds to database.
        } catch (Throwable e) {
            TransactionAspectSupport.currentTransactionStatus()
                .setRollbackOnly();

        }
    }

    public boolean addUsers(List<User> users) {
        for (User user : users) {
            self.addUser(user.getUserName, user.getPassword);
        }
    } 
}

Rainout

If you do choose to go this route (whether this is good design or not is another matter) and don't use constructor injection, make sure you also see this question – Justajustemilieu

What if UserService has singleton scope? What if it is the same object? – Soprano

Answer 4

With Spring 4 it's possible to Self autowired

@Service
@Transactional
public class UserServiceImpl implements UserService{
    @Autowired
    private  UserRepository repository;

    @Autowired
    private UserService userService;

    @Override
    public void update(int id){
       repository.findOne(id).setName("ddd");
    }

    @Override
    public void save(Users user) {
        repository.save(user);
        userService.update(1);
    }
}

Heather

BEST ANSWER !! Thx – Tanguay

Correct me if I'm wrong but such a pattern is really error-prone, although it works. It's more like a showcase of Spring capabilities, right? Someone not familiar with "this bean call" behavior might accidentally remove the self-autowired bean (the methods are available via "this." after all) which might cause issue that are hard to detect at first glance. It could even make it to the prod environment before it was found). – Bumpy

@Bumpy you are right, it's a huge anti pattern and it's not obvious in the first place. So if you can you should avoid it. If you have to use method of the same class then try to use more powerful AOP libraries such as AspectJ – Heather

still looks artificial to me.. – Aq

Defining a class as purely @Transactional can cause some unpredictable errors. Therefore, it should be used carefully. – Paleoecology

I tried this but has no clue how to create the object UserServiceImpl for testing purpose. – Sherronsherry

Answer 5

This is my solution for self invocation:

public class SBMWSBL {
    private SBMWSBL self;

    @Autowired
    private ApplicationContext applicationContext;

    @PostConstruct
    public void postContruct(){
        self = applicationContext.getBean(SBMWSBL.class);
    }

    // ...
}

Trudey

Gives me org.springframework.beans.factory.BeanCurrentlyInCreationException: Error creating bean with name 'xy': Requested bean is currently in creation: Is there an unresolvable circular reference? – Chanterelle

I think it need lazy autowired. – Trudey

Answer 6

You can autowired BeanFactory inside the same class and do a

getBean(YourClazz.class)

It will automatically proxify your class and take into account your @Transactional or other aop annotation.

Edaphic

It is considered as a bad practice. Even injecting the bean recursively into itself is better. Using getBean(clazz) is a tight coupling and strong dependency on spring ApplicationContext classes inside of your code. Also getting bean by class may not work in case of spring wrapping the bean (the class may be changed). – Fatherly

Answer 7

Here is what I do for small projects with only marginal usage of method calls within the same class. In-code documentation is strongly advised, as it may look strange to colleagues. But it works with singletons, is easy to test, simple, quick to achieve and spares me the full blown AspectJ instrumentation. However, for more heavy usage I'd advice the AspectJ solution as described in Espens answer.

@Service
@Scope(proxyMode = ScopedProxyMode.TARGET_CLASS)
class PersonDao {

    private final PersonDao _personDao;

    @Autowired
    public PersonDao(PersonDao personDao) {
        _personDao = personDao;
    }

    @Transactional
    public void addUser(String username, String password) {
        // call database layer
    }

    public void addUsers(List<User> users) {
        for (User user : users) {
            _personDao.addUser(user.getUserName, user.getPassword);
        }
    }
}

Ganny

Answer 8

The issue is related to how spring load classes and proxies. It will not work , untill you write your inner method / transaction in another class or go to other class and then again come to your class and then write the inner nested transcation method.

To summarize, spring proxies does not allow the scenarios which you are facing. you have to write the 2nd transaction method in other class

Klaxon

Answer 9

Tested with Spring 2.5.15, you do a self invocation using @Resource. See the example bellow

@Service
@RequiredArgsConstructor
public class Example {
   private final EntityManager entityManager;
   
   @Resource
   private Example self;


   @Transactional(propagation = Propagation.REQUIRES_NEW)
   public void testSelf(){
      self.transaction();
   }


   @Transactional(propagation = Propagation.SUPPORTS)
   public void transaction(){
       entityManager.persist(new MyEntity(28L));
   }

Test class:

@SpringBootTest
class ExampleTest {
    @Autowired
    private Example example;
    @Autowired
    private EntityManager entityManager;

    @Test
    void testSelf(){
        transactionHandler.testSelf();
        assertNotNull(entityManager.find(Estado.class, 28L));
    }
}

Enounce

Answer 10

just add following annotation on top of the service

@Scope(proxyMode = TARGET_CLASS)

Jinni

Answer 11

There is no point to use AspectJ or Other ways. Just using AOP is sufficient. So, we can add @Transactional to addUsers(List<User> users) to solve current issue.

public class UserService {
    
    private boolean addUser(String userName, String password) {
        try {
            // call DAO layer and adds to database.
        } catch (Throwable e) {
            TransactionAspectSupport.currentTransactionStatus()
                    .setRollbackOnly();

        }
    }

    @Transactional
    public boolean addUsers(List<User> users) {
        for (User user : users) {
            addUser(user.getUserName, user.getPassword);
        }
    } 
}

Cordoba

This changes the original logic! Now adding the whole list of users runs in a single transaction, which is not what the OP intended! – Mcmurry