Hello,
I'm making a case for my design team regarding the use of Aspect Oriented Programming (AOP) and Hibernate. It would seem to me that these two technologies are quite compatible, since you can design an AOP pointcut to "wrap" your hibernate-aware methods inbetween sessionFactory.openSession() and session.close().

I'm trying to find out if this is being done by others? Are there any users here using this approach? Any pros/cons to mention?

Thanks,
George.

This has several problems.

Firstly, you are inventing your own declarative transaction management solution. AOP is a good tool to use for this, but there are containers which do this for you already, and probably more robustly and correctly.

Second, full-on AOP is not usually necessary. It is enough to use more coarse grained interception, such as a servlet filter and avoid introducing AOP dependencies.

Thirdly, wrapping each method or even dao class in its own session prevents multiple daos from collaborating using the same session, which is often useful.

Look into the Thread Local Session pattern and the HibernateUtil class. Unless you have a container managing your transactions, this is almost certainly the best and simplest way to solve this common problem.

Some comments:



Agree.


It very much depends on the granularity he wants to obtain. Introducing aop dependencies is like introducing any other dependency so this is not wrong from the beginning.
Moreover, there have been benchmarks driven for comparing proxy-based vs bytecode aop solutions where the later are performing better.



This is definitely true. Most probably the aspects that would solve correctly this would be perthread, but I am not aware of a bytecode aop solution having this option (it has been removed in previous versions).

Concluding: as a theoretical demo, this is one of the best ideas, but recreating the wheel for production it's not.

take care,
:alex |.::the_mindstorm::.|

OK these comments are useful to me. Although, on the second point; I wouldn't be introducing AOP soley for this purpose; our project will use it for logging and tracing already.
Anyone else want to weigh in?

Relying on AOP for providing proper Hibernate environment ( session availability, transaction propagation and error handling) is very convenient and robust approach. I have used it on production for couple of years already.

And that is exactly what Spring is doing with Hibernate interceptor,
http://static.springframework.org/sprin ... eptor.html
same thing easily could be done with other AOP frameworks like HiveMind - see HiveTranse utilities
http://hivetranse.sourceforge.net/
or AspectWerks/AspectJ.

See also my AOP frameworks comparison http://kgionline.com/presentations/aop_test.jsp

No need for you to write it, its all be done already, and works fantistically well. Never again will you have to worry about opening or closing sessions, or messign aroudn with transactions:

http://www.springframework.org/docs/wik ... rnate.html

I've seen loads of posts that involve openign and closing sessions, and with Spring that is all handled for you, and you can get on with your business logic, as using Spring and Hibernate otgether makes your DB access easy peasy !