Spring transaction using AOP

[Anand Sivathanu]

Hi friends,
I have a question regarding spring transaction using AOP.
I can able to declare an transaction advice in spring.xml and able to apply the advice to respective methods using pointcut.


<tx:advice id="txAdvice" transaction-manager="transactionManager"> <tx:attributes> <tx:method name="book*" read-only="false" rollback-for="org.simple.exception.SimpleException"/> </tx:attributes> </tx:advice> <aop:config> <aop:pointcut expression="execution(* org.simple.service.TicketBookingService.*(..))" id="allTicketBookingService"/> <aop:advisor advice-ref="txAdvice" pointcut-ref="allTicketBookingService"/> </aop:config>

Here transactionAdvice(txAdvice) is applied to all methods starting with book present in org.simple.service.TicketBookingService.

class TicketBookingService
{
//Based on the above xml configuration, transaction is set to read-only="false".because tables need to edited as ticket count will decrease,when a ticket is booked.So far so good and its working fine.
	bookBusTicket(){};
	bookTrainTicket(){};
	bookPlaneTicket(){};

	getBusTicket(){};
	getTrainTicket(){};
	getPlaneTicket(){};
}

But,

I would like to use annotation.So what i did is

class TicketBookingService
{
@Transactional(readOnly=false, rollbackFor = {SimpleException.class})
	bookBusTicket(){};

@Transactional(readOnly=false, rollbackFor = {SimpleException.class})
	bookTrainTicket(){};

@Transactional(readOnly=false, rollbackFor = {SimpleException.class})
	bookPlaneTicket(){};

	getBusTicket(){};
	getTrainTicket(){};
	getPlaneTicket(){};
}

This is also working fine.

Now what I feel is,here @Transactional is repeated in all methods which is starting with book.So i would like to put in some common area.
So I did the following,

1.
<aop:aspectj-autoproxy/> in spring.xml,by mentioning this spring will scan for aspect components.

2.
I created a class called TransactionLoggingAspect.

@Aspect
public class TransactionLoggingAspect {


//all methods starting with book present in //org.simple.service.TicketBookingService
	@Pointcut("execution(* org.simple.service.TicketBookingService.book*(..))")

@Transactional(readOnly=false, rollbackFor = {SimpleException.class})

I felt this is wrong place to put @Transactional.But for trial and error
I put and test.its not working.
	public void allTicketBookingService(){}
	
	@Around("allTicketBookingService()")
	public Object myAroundAdvice(ProceedingJoinPoint proceedingJoinPoint){
		Object returnValue = null;
		try 
		{
			System.out.println("before transaction starts");
			returnValue = proceedingJoinPoint.proceed();
			System.out.println("after transaction ends");
		} 
		catch (Throwable e) 
		{
			System.out.println("after transaction throwing exception");
		}		
		return returnValue;
	}
}

<tx:advice id="txAdvice" transaction-manager="transactionManager"> <tx:attributes> <tx:method name="book*" read-only="false" rollback-for="org.simple.exception.SimpleException"/> </tx:attributes> </tx:advice>

My question is,
what is the annotation equivalent of the above "txAdvice"?
In TransactionLoggingAspect.java,Where I can put the annotation equivalent?

In spring tutorial,
http://static.springsource.org/spring/docs/3.0.x/reference/transaction.html
they have mentioned for XML part,which is working fine.
But I am searching for annotation part.But not found.

Please help me in this issue.

Regards,
Anand

[Mark Spritzler]

To use @Transactional Annotations. Your config has to have <tx:annotation-driven/> And you need to have a transactionManager bean. That is all. Now you can put @Transactional on any service method and it will be transactional.

No need for any aop or aspect classes. Everything that you did before in xml is taken care of. That is why using annotations for Transactional methods is so much easier than using xml for it.

Mark

[Anand Sivathanu]

Mark Spritzler wrote:To use @Transactional Annotations. Your config has to have <tx:annotation-driven/> And you need to have a transactionManager bean. That is all. Now you can put @Transactional on any service method and it will be transactional.

No need for any aop or aspect classes. Everything that you did before in xml is taken care of. That is why using annotations for Transactional methods is so much easier than using xml for it.

Mark

Hi Mark Spritzler,
Thanks for your comment. I understood your comment and totally agree with that.
My question here is,
I keep on put @Transactional for any service methods that i needed.I feel lazy to put @Transactional also.
Instead I would like to put in some common area @Transactional and declare that methods starting with book*(bookBusTicket,bookPlaneTicket,bookTrainTicket) present in org.simple.service.TicketBookingService class.
This I can put in xml as
<tx:advice id="txAdvice" transaction-manager="transactionManager"> <tx:attributes> <tx:method name="book*" read-only="false" rollback-for="org.simple.exception.SimpleException"/> </tx:attributes> </tx:advice> <aop:config> <aop:pointcut expression="execution(* org.simple.service.TicketBookingService.*(..))" id="allTicketBookingService"/> <aop:advisor advice-ref="txAdvice" pointcut-ref="allTicketBookingService"/> </aop:config>

But I would like in programmatic way.(@Transactional in common area and declare methods starting with book*(bookBusTicket,bookPlaneTicket,bookTrainTicket) present in org.simple.service.TicketBookingService class)
Is there any programmatic way?(May be annotation or something)
(My question may be wrong.correct me if i am wrong)

Regards,
Anand

[Mark Spritzler]

Well, you can put @Transactional on the class level and then all methods from your interfaces that that class implements are now all transactional.

That is a way to put the annotation in once and get many methods covered.

So one trick it to make sure you put all those methods that start with into a single interface that that class implements. Or just put @Transactional on that interface.

Mark

[Anand Sivathanu]

Mark Spritzler wrote:Well, you can put @Transactional on the class level and then all methods from your interfaces that that class implements are now all transactional.

That is a way to put the annotation in once and get many methods covered.

So one trick it to make sure you put all those methods that start with into a single interface that that class implements. Or just put @Transactional on that interface.

Mark

Oh.
You are telling to put @Transaction in the class level or interface level

1.
class level - flavor 1

@Transactional(readOnly=false, rollbackFor = {SimpleException.class}) 
class TicketBookingService  
{  
//@Transactional(readOnly=false, rollbackFor = {SimpleException.class})  
    bookBusTicket(){};  
  
//@Transactional(readOnly=false, rollbackFor = {SimpleException.class})  
    bookTrainTicket(){};  
  
//@Transactional(readOnly=false, rollbackFor = {SimpleException.class})  
    bookPlaneTicket(){};  
}

2.
interface level - flavor 2

@Transactional(readOnly=false, rollbackFor = {SimpleException.class}) 
public interface BookingService {

void bookBusTicket();

void bookTrainTicket();

void bookPlaneTicket();
}

class TicketBookingService implements BookingService 
{
	bookBusTicket(){}; 
	bookTrainTicket(){}; 
	bookPlaneTicket(){}; 
}

These are the two flavors you are coming to say. Am I right?

Regards,
Anand