Enterprise Bean (EJB) programming tutorials

Enterprise Beans Tutorial

Home| Forums | Join Google Group | Join Yahoo Group | Jobs

Earn Money
Trading Forex Online
  Paramount Airways
  Free Data Recovery
Cargo
Job Portal
  HSBC Investment
Management
Cheap Web Hosting
  Make Trip
  Cheap Air Travel
Leisure Hotel
  Free Air Travel
  Mutual Fund Informations
Cheapest Cellular Plan
Free Sexy Indians
  Call Center Software
  Hot Indian

Enterprise Beans Tutorial

22 commit transaction When coding a bean-managed transaction, you must decide whether to use JDBC or JTA transactions. The
sections that follow discuss the techniques and merits of both approaches. JDBC Transactions A JDBC transaction is controlled by the transaction manager of the DBMS.
You may want to use JDBC transactions when wrapping legacy code inside a session bean.
To code a JDBC transaction, you invoke the commit and rollback methods of the javax.sql.Connection interface. The beginning of a transaction is implicit. A transaction begins with the first SQL statement that follows the most recent commit, rollback, or connect statement. (This rule is generally true, but may vary with
DBMS vendor.) The following code is from the WarehouseEJB example, a session bean that uses the Connection interface's methods to delimit bean-managed transactions. The ship method starts
by invoking setAutoCommit on the Connection object con. This invocation tells the DBMS
not to automatically commit every SQL statement. Next, the ship method calls routines that
update the order_item and inventory database tables. If the updates succeed, the transaction is
committed. But if an exception is thrown, the transaction is rolled back. public void ship (String productId, String orderId, int quantity) {

try {
con.setAutoCommit(false);
updateOrderItem(productId, orderId);
updateInventory(productId, quantity);
con.commit();
} catch (Exception ex) {
try {
con.rollback();
throw new EJBException("Transaction failed: " +
ex.getMessage());
} catch (SQLException sqx) {
throw new EJBException("Rollback failed: " +
sqx.getMessage());
}
}
} JTA Transactions · JTA is the abbreviation for the Java Transaction API. This API allows you to demarcate transactions in
a manner that is independent of the transaction manager implementation. · The J2EE SDK implements the transaction manager with the Java Transaction Service (JTS). But your
code doesn't call the JTS methods directly. Instead, it invokes the JTA methods, which then call the
lower-level JTS routines. · A JTA transaction is controlled by the J2EE transaction manager. You may want to use a JTA
transaction because it can span updates to multiple databases from different vendors. A particular
DBMS's transaction manager may not work with heterogenous databases. However, the J2EE
transaction manager does have one limitation-- it does not support nested transactions. (It cannot start a
transaction for an instance until the previous transaction has ended.) · To demarcate a JTA transaction, you invoke the begin, commit, and rollback methods of the
UserTransaction interface.