Skip to main content

TRANSACTIONS in EJB

Transactions


  •      A typical enterprise application accesses and stores information in one or more databases.
           
  •     Because this information is critical for business operations, it must be accurate, current, and reliable.

  •        Data integrity would be lost

  •    if multiple programs were allowed to update the same information simultaneously or
  •     if a system that failed while processing a business transaction were to leave the affected data only partially.

So Software  Transactions Prevent thease two secnarios and ensure data inregrity.
  • Transactions control the concurrent access of data by multiple programs
  • IIn the event of a system failure, transactions make sure that after recovery, the data will be in a consistent state.



Agenda :
■ Transactions in Java EE Applications
■ What Is a Transaction?
■ Container-Managed Transactions
■ Bean-Managed Transactions
■ Transaction Timeouts
■ Updating Multiple Databases
■ Transactions in Web Components
■ Further Information about Transactions

Transactions in Java EE Applications:
In a Java EE application, a transaction is a series of actions that must all complete successfully, or else all the changes in each action are backed out.
Transactions end in either a commit or a rollback.

The Java Transaction API (JTA) allows applications to access transactions in a manner that is independent of specific implementations.
JTA specifies standard Java interfaces between a transaction manager and the parties involved in a distributed transaction system: the transactional application, the Java EE server, and the manager that controls access to the shared resources affected by the transactions.
The JTA 1.2 specification is available at
http://jcp.org/en/jsr/detail?id=907.

What Is a Transaction?
A financial program, for example, might transfer funds from a checking account to a
savings account by using the steps listed in the following pseudocode:
begin transaction
debit checking account
credit savings account
update history log
commit transaction
Either all or none of the three steps must complete. Otherwise, data integrity is lost.
Because the steps within a transaction are a unified whole, a transaction is often
defined as an indivisible unit of work.
A transaction can end in two ways: with a commit or with a rollback.

Container-Managed Transactions
  • In an enterprise bean with container-managed transaction demarcation, the EJBcontainer sets the boundaries of the transactions.
  • We can use container-managed transactions with any type of enterprise bean: session or message-driven.
  • Container-managed transaction simplify development because the enterprise bean code does not explicitly mark the transaction’s boundaries.
  • The code does not include statements that begin and end the transaction.
  • By Defalut enterprise beans use container-managed transaction demarcation.
  •     The container begins a transaction immediately before an enterprise bean   method starts and commits the transaction just before the method exits.
  •       Each method can be associated with a single transaction.
  •       Nested or multiple transactions are not allowed within a method.
  •      Container-managed transactions do not require all methods to be associated with transactions.
  •     When developing a bean, you can set the transaction attributes to specify which of the bean's methods are associated with transactions.
  •      Enterprise beans that use container-managed transaction demarcation must not use any transaction-management methods that interfere with the container's transaction demarcation boundaries.
  •       Examples of such methods are the commit, setAutoCommit,and rollback methods of java.sql.Connection or the commit and rollback methods of javax.jms.Session. If you require control over the transaction demarcation, you must use application-managed transaction demarcation.
  •     Enterprise beans that use container-managed transaction demarcation also must not use the javax.transaction.UserTransaction interface.

Transaction Attributes
<    A transaction attribute controls the scope of a transaction
Figure  illustrates why controlling the scope is important.

In the diagram, method-A begins a transaction and then invokes method-B of Bean-2. When method-B executes, does it run within the scope of the transaction started by method-A, or does it execute with a new transaction? The answer depends on the transaction attribute of method-B.

A transaction attribute can have one of the following values:
  •      Required
  •     RequiresNew
  •     Mandatory
  •      NotSupported
  •      Supports
  •    Never


Required Attribute:
  •      If the client is running within a transaction and invokes the enterprise bean's method, the method executes within the client's transaction.
  •      If the client is not associated with a transaction, the container starts a new transaction before running the method.
The Required attribute is the implicit transaction attribute for all enterprise bean
methods running with container-managed transaction.
The below daigram explains all transaction attributes clearly.



Transaction Attributes and Scope
Transaction Attribute 
Client’s Transaction 
Business Method’s Transaction 
Required
None 
T1 
T2 
T1 
RequiresNew
None 
T1 
T2 
T2 
Mandatory
None 
T1 
Error 
T1 
NotSupported
None 
T1 
None 
None 
Supports
None 
T1 
None 
T1 
Never
None 
T1 
None 
Error 

Setting Transaction Attributes:
  •      Transaction attributes are specified by decorating the enterprise bean class or method with a javax.ejb.TransactionAttribute annotation and setting it to one of the javax.ejb.TransactionAttributeType constants.
  •      If you decorate the enterprise bean class with @TransactionAttribute, the specified TransactionAttributeType is applied to all the business methods in the class.
  •        Decorating a business method with @TransactionAttribute applies the TransactionAttributeType only to that method.
  •       If a @TransactionAttribute annotation decorates both the class and the method, the method TransactionAttributeType overrides the class TransactionAttributeType.




The following code snippet demonstrates how to use the @TransactionAttribute annotation:
@TransactionAttribute(NOT_SUPPORTED)
@Stateful
public class TransactionBean implements Transaction {
...
@TransactionAttribute(REQUIRES_NEW)
public void firstMethod() {...}
@TransactionAttribute(REQUIRED)
public void secondMethod() {...}
public void thirdMethod() {...}
public void fourthMethod() {...}
}
In this example, the TransactionBean class's transaction attribute has been set to
NotSupported, firstMethod has been set to RequiresNew, and secondMethod has
been set to Required. Because a @TransactionAttribute set on a method overrides the
class @TransactionAttribute, calls to firstMethod will create a new transaction, and
calls to secondMethod will either run in the current transaction or start a new
transaction. Calls to thirdMethod or fourthMethod do not take place within a
transaction.

Rolling Back a Container-Managed Transaction
There are two ways to roll back a container-managed transaction.
  •       First, if a system exception is thrown, the container will automatically roll back the transaction.
  •           Second, by invoking the setRollbackOnly method of the EJBContext interface, the bean method instructs the container to roll back the transaction.
  •          If the bean throws an application exception, the rollback is not automatic but can be initiated by a call to setRollbackOnly

Synchronizing a Session Bean's Instance Variables
The SessionSynchronization interface, which is optional, allows stateful session bean
instances to receive transaction synchronization notifications. For example, you could
synchronize the instance variables of an enterprise bean with their corresponding
values in the database. The container invokes the SessionSynchronization methods
(afterBegin, beforeCompletion, and afterCompletion) at each of the main stages of a
transaction.
The afterBegin method informs the instance that a new transaction has begun. The
container invokes afterBegin immediately before it invokes the business method.
The container invokes the beforeCompletion method after the business method has
finished but just before the transaction commits. The beforeCompletion method is the
last opportunity for the session bean to roll back the transaction (by calling
setRollbackOnly).
The afterCompletion method indicates that the transaction has completed. This
method has a single boolean parameter whose value is true if the transaction was
committed and false if it was rolled back.

Methods Not Allowed in Container-Managed Transactions

You should not invoke any method that might interfere with the transaction
boundaries set by the container. The list of prohibited methods follows:
■ The commit, setAutoCommit, and rollback methods of java.sql.Connection
■ The getUserTransaction method of javax.ejb.EJBContext
■ Any method of javax.transaction.UserTransaction
You can, however, use these methods to set boundaries in application-managed
transactions.

Bean-Managed Transactions
In bean-managed transaction demarcation, the code in the session or message-driven
bean explicitly marks the boundaries of the transaction.
Although beans with container-managed transactions require less coding, they have one limitation: When a
method is executing, it can be associated with either a single transaction or no transaction at all.

The following pseudocode illustrates the kind of fine-grained control you can obtain
with application-managed transactions. By checking various conditions, the
pseudocode decides whether to start or stop certain transactions within the business
method:
begin transaction
...
update table-a
...
if (condition-x)
commit transaction
else if (condition-y)
update table-b
commit transaction
else
rollback transaction
begin transaction
update table-c
commit transaction

When coding an application-managed transaction for session or message-driven
beans, you must decide whether to use Java Database Connectivity or JTA
transactions.
JTA Transactions
JTA, or the Java Transaction API, allows you to demarcate transactions in a manner
that is independent of the transaction manager implementation.
example: GlassFish Server implements the transaction manager with the Java Transaction Service (JTS). However, your code doesn't call the JTS methods directly but instead invokes the JTA methods,
which then call the lower-level JTS routines

A JTA transaction is controlled by the Java EE transaction manager.
Adavantages with JTA transaction:
Labels:

Comments

Post a Comment

Popular posts from this blog

Yahoo! Calendar "Add Event" Seed URL Parameters

I can't seem to find any official documentation on this, so here are my notes. Some information gathered from  http://richmarr.wordpress.com/tag/calendar/ Other information gathered through trial and error, and close examination of the "Add Event" form on Yahoo!'s site. Yahoo! Calendar URL Parameters Parameter Required Example Value Notes v Required 60 Must be  60 . Possibly a version number? TITLE Required Event title Line feeds will appear in the confirmation screen, but will not be saved. May not contain HTML. ST Required 20090514T180000Z Event start time in UTC. Will be converted to the user's time zone. 20090514T180000 Event start time in user's local time 20090514 Event start time for an all day event. DUR value is ignored if this form is used. DUR 0200 Duration of the event. Format is HHMM, zero-padded. MM may range up to 99, and is converted into hours appropriately. HH values over 24 hours appear to be modulated by 24. Durations t...
1 comment
Read more

Java literals:

Java literals:           A constant value which can be assigned to a variable is known as Literal.If we are assigning any outside range value for any data type ,we will get a compile time error saying Possible Loss of Precision found int required byte. For the integral data types (int ,byte,short,long) : we are allowed to specify a literal value in any   one of the following three forms. ---> Decimal literal (normal way) --->Octa literal (prefixed with 0 ) --->Hexa decimal (prefixed with 0x ) int x=10 ------------> Decimal int x=010 ------------>Octa int x=0X10 -------------->Hexa In the Hexa decimal notation for the extra digits we are allowed to specify either small or upper case a,b,c or A,B,C ( this is one of the few places where java is not case sensitive ). Example: class Sample { public static void main(String add[]) { int i = 10; int j=010; int k=0x10; System.out.println( i+”….”+j...
Post a Comment
Read more