Shulou(Shulou.com)06/02 Report--

This article mainly explains "what is the Hibernate transaction management mechanism". Interested friends may wish to have a look at it. The method introduced in this paper is simple, fast and practical. Let's let the editor take you to learn "what is the Hibernate transaction management mechanism"?

JTA provides transaction management capabilities across Session. This is the difference from JDBC Transaction. JDBC transactions are managed by Connnection, that is, transaction management is actually implemented in JDBC Connection. The transaction cycle is limited to the life cycle of the Connection, and so on. Similarly, for the Hibernate transaction management mechanism based on JDBC Transaction, transaction management is implemented in JDBC Connection, which Session relies on, and the transaction cycle is limited to the life cycle of Session.

JTA transaction management is implemented by the JTA container. The JTA container schedules many Connection that currently join the transaction to achieve its transactional requirements. The transaction cycle of JTA can span multiple JDBC Connection lifecycles. Also for Hibernate based on JTA transactions, JTA transactions span multiple Session. JTA transactions are maintained by JTA Container, and the Connection participating in the transaction does not need to interfere with transaction management. That is to say, if we use JTA Transaction, we should no longer invoke the HibernateTransaction function.

Based on the correct code for JDBC Transaction above, the problem arises here:

Public class ClassA {public void saveUser (User user) {session = sessionFactory.openSession (); Transaction tx = session.beginTransaction (); session.save (user); tx.commit (); session.close ();}} public class ClassB {public void saveOrder (Order order) {session = sessionFactory.openSession (); Transaction tx = session.beginTransaction (); session.save (order); tx.commit (); session.close ();}} public class ClassC {public void save () {. UserTransaction tx = new InitialContext () .lookup (".") ; ClassA.save (user); ClassB.save (order); tx.commit (); … }}

There are two classes, ClassA and ClassB, which provide two methods, saveUsersaveOrder, for storing user information and order information. In ClassC, we call the ClassA.saveUser method and the ClassB.saveOrder method one after another, and introduce UserTransaction in JTA to achieve the transactionality in the ClassC.save method. The problem is that the Transaction function of Hibernate is called in ClassA and ClassB, respectively. In the JTA wrapper of Hibernate, Session.beginTransaction also executes the InitialContext.lookup method to get the UserTransaction instance, and the Transaction.commit method also calls the UserTransaction.commit method.

In effect, this results in two nested JTA Transaction:ClassC declaring a transaction, and during the ClassC transaction cycle, ClassA and ClassB also attempt to declare their own transactions, which results in run-time errors. Therefore, if you decide to adopt JTA Transaction, you should avoid repeatedly calling Hibernate's Transaction function, and the above code is modified as follows:

Public class ClassA {public void save (TUser user) {session = sessionFactory.openSession (); session.save (user); session.close ();}. } public class ClassB {public void save (Order order) {session = sessionFactory.openSession (); session.save (order); session.close ();}. } public class ClassC {public void save () {. UserTransaction tx = new InitialContext () .lookup (".") ; classA.save (user); classB.save (order); tx.commit (); … }}

The ClassC.save method in the above code can also be changed to this:

Public class ClassC {public void save () {. Session = sessionFactory.openSession (); Transaction tx = session.beginTransaction (); classA.save (user); classB.save (order); tx.commit (); … }}

In fact, this uses Hibernate to launch and submit UserTransaction, but this consumes more resources than the original practice of getting UserTransaction directly through InitialContext, and the loss outweighs the gain.

It is undoubtedly the easiest to use JTA Transaction in EJB. We only need to configure the save method to support JTA transactions without explicitly declaring any transactions. Here is a save method of Session Bean whose transaction attribute is declared as "Required". The EJB container will automatically maintain transactions during the execution of this method:

/ * * @ ejb.interface-method * view-type= "remote" * @ ejb.transaction type= "Required" * * / public void save () {/ / EJB environment, transaction declaration can be achieved through deployment configuration without explicitly calling transaction classA.save (user); classB.save (log) When the method ends, if no exception occurs, the transaction is automatically committed by the EJB container. At this point, I believe you have a deeper understanding of "what is the Hibernate transaction management mechanism". You might as well do it in practice. Here is the website, more related content can enter the relevant channels to inquire, follow us, continue to learn!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.