在@Transactional方法之前和之后执行代码

Question

We have a Spring based application with a service layer which is annotated with @Transactional. We need to have code run before and after some transactional methods for the following reasons:

1. We need to synchronize access to the method based on a key. The thread needs to block before the start of the transaction.
2. We need to post a message on a queue if the transaction succeeds.

The options seem to be:

1. Create a class with similar methods to the service that can run the @Transactional method in a synchronized block and check for the return then post the message (would need a separate class due to AOP proxy problem). Services calling services, not nice, feels like a work-around.
2. Write an aspect to wrap around the @Transactional AOP which can do the synchronization and message posting. Might work but would rather avoid AOP.
3. Move the transaction down to the domain layer. Not desirable or possibly even feasible with the current implementation due to the way domain methods are reused in different workflows.
4. Code the transaction by hand in the service method and scrap @Transactional.

I would imagine this is a fairly common requirement. Probably I am missing an option 5, which is the obvious one!

Answer 1

I think I'd go with 2 unless you have some specific reasons to avoid AOP. Your problem is a classic example of where AOP can be used and it looks pretty good in the result. Here is a nice example of how to implement that (if you didn't read that already): Advising transactional operations

If AOP is really not an option, I'd go the 'Otherwise' option proposed by @Lawrence McAlpin.

Answer 2

Check out TransactionSynchronization callback interface. Spring can natively inform you what is happening with your transaction.

Answer 3

I would use a TransactionTemplate (your option 4) and programatically control the scope of the transaction in situations like this.

Otherwise, you could move the logic in your method out into a separate service, make that new service @Transactional, remove the @Transactional from the current method, and then surround the call to the new service with your pre- and post-transaction logic. I've taken this approach as well, but I prefer programmatic transaction management for requirements like this, as I think it's cleaner and, as you mentioned, services calling services (that are only ever needed by the first service) just feels like a hackish workaround.

Answer 4

if the key is being passed as part of the method call, then you can use java ReentrantLock to do the job.. its much simpler & cleaner.