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

How to carry out iBATIS DAO transaction analysis, in view of this problem, this article introduces the corresponding analysis and solution in detail, hoping to help more partners who want to solve this problem to find a more simple and feasible method.

Understanding iBATIS DAO transactions starts with the iBATIS DAO framework, which provides a transaction management module. This transaction management can be applied to many situations, including JDBC, Hibernate, JTA, SQLMAP and so on.

Let's take a look at how it implements iBATIS DAO transaction management with the simplest JDBC.

First, let's look at a piece of code:

Public class OrderService {private DaoManager daoManager; private OrderDao orderDao; public OrderService () {daoManager = DaoConfig.getDaoManager (); orderDao = (OrderDao) daoManager.getDao (OrderDao.class);} public void method () {try {/ / a separate transaction orderDao.method1 (); / / * transaction daoManager.startTransaction (); / / start the second transaction orderDao.method1 (); orderDao.method2 (); daoManager.commitTransaction () / / commit the second transaction} finally {daoManager.endTransaction ();}

There are two transactions in the method () method, and if daoManager.startTransaction () is not explicitly called in the method, then a method call to each DAO is a separate transaction.

IBATIS DAO transaction, with two core interfaces DaoTransactionManager and DaoTransaction

Corresponding to different database persistence layer implementations, the two interfaces correspond to different implementations

Looking at the iBATIS code, you can see that these manager implement transactions, that is, to invoke the transaction operation methods of the transaction source.

JdbcDaoTransactionManager public void commitTransaction (DaoTransaction trans) {((JdbcDaoTransaction) trans). Commit ();} JdbcDaoTransaction public JdbcDaoTransaction (DataSource dataSource) {try {connection = dataSource.getConnection (); if (connection = = null) {throw new DaoException ("Could not start transaction.Cause: The DataSource returned a null connection.");} if (connection.getAutoCommit ()) {connection.setAutoCommit (false);} if (connectionLog.isDebugEnabled ()) {connection = ConnectionLogProxy.newInstance (connection) } catch (SQLException e) {throw new DaoException ("Error starting JDBC transaction.Cause:" + e);}} public void commit () {try {try {connection.commit ();} finally {connection.close ();}} catch (SQLException e) {throw new DaoException ("Error committing JDBC transaction.Cause:" + e);}}

So on what basis does DaoTransactionManager handle transactions? DaoTransactionState look at the DaoTransactionState code, very simple, four constants to represent the different states of the transaction

Public static final DaoTransactionState ACTIVE = new DaoTransactionState ()

Public static final DaoTransactionState INACTIVE = new DaoTransactionState ()

Public static final DaoTransactionState COMMITTED = new DaoTransactionState ()

Public static final DaoTransactionState ROLLEDBACK = new DaoTransactionState ()

So how do you control the transaction in the actual program?

In the * code, this is how we get the DAO

OrderDao = (OrderDao) daoManager.getDao (OrderDao.class)

What the actual daoManager returns is not the concrete implementation class of orderDao, it returns the DaoProxy

DaoProxy

Public Object invoke (Object proxy, Method method, Object [] args) throws Throwable {Object result = null; if (PASSTHROUGH_METHODS.contains (method.getName () {try {result = method.invoke (daoImpl.getDaoInstance (), args);} catch (Throwable t) {throw ClassInfo.unwrapThrowable (t);} else {StandardDaoManager daoManager = daoImpl.getDaoManager (); DaoContext context = daoImpl.getDaoContext () If (daoManager.isExplicitTransaction ()) {/ / Just start the transaction (explicit) try {context.startTransaction (); result = method.invoke (daoImpl.getDaoInstance (), args);} catch (Throwable t) {throw ClassInfo.unwrapThrowable (t);}} else {/ / Start, commit and end the transaction (autocommit) try {context.startTransaction (); result = method.invoke (daoImpl.getDaoInstance (), args); context.commitTransaction () } catch (Throwable t) {throw ClassInfo.unwrapThrowable (t);} finally {context.endTransaction ();} return result;}

It is clear when you see this code that every time a method of DAO is called, if daoManager.startTransaction () is not explicitly called, it will become a separate iBATIS DAO transaction. Let's take a look at the template JdbcDaoTemplate provided by iBATIS.

Protected Connection getConnection () {DaoTransaction trans = daoManager.getTransaction (this); if (! (trans instanceof ConnectionDaoTransaction)) {throw new DaoException ("The DAO manager of type" + daoManager.getClass (). GetName () + "cannot supply a JDBC Connection for this template, and is therefore not" + "supported by JdbcDaoTemplate.")} return ((ConnectionDaoTransaction) trans) .getConnection ();}

IBATIS controls the transactions of multiple DAO so that these DAO actually share one DaoTransaction (ThreadLocal) and one Connection.

Here is the case of a transaction source. If you want to complete a global transaction between multiple transaction sources, you should honestly use distributed transaction Management Services (jta).

This is the end of the answer to the question on how to analyze iBATIS DAO transactions. I hope the above content can be of some help to you. If you still have a lot of doubts to solve, you can follow the industry information channel to learn more about it.

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.