EJB vs. Spring

Transaction management

EJB

• must use a JTA transaction manager.
• supports transactions that span remote method calls.

Spring

• supports multiple transaction environments through its PlatformTransactionManager interface, including JTA, Hibernate, JDO, and JDBC.
• does not natively support distributed transactions—it must be used with a JTA transaction manager.

Declarative transaction support

EJB

• can define transactions declaratively through the deployment descriptor.
• can define transaction behavior per method or per class by using the wildcard character *.
• cannot declaratively define rollback behavior—this must be done programmatically.

Spring

• can define transactions declaratively through the Spring configuration file or through class metadata.
• can define which methods to apply transaction behavior explicitly or by using regular expressions.
• can declaratively define rollback behavior per method and per exception type.

Persistence

EJB

• supports programmatic bean-managed persistence and declarative container managed persistence.

Spring

• provides a framework for integrating with several persistence technologies, including JDBC, Hibernate, JDO, and iBATIS.

Declarative security

EJB

• supports declarative security through users and roles. The management and implementation of users and roles is container specific. 
• Declarative security is configured in the deployment descriptor.

Spring

• No security implementation out-of-the box.
• Acegi, an open source security framework built on top of Spring, provides declarative security through the Spring configuration file or class metadata.

Distributed computing

EJB

• provides container-managed remote method calls.

Spring

• provides proxying for remote calls via RMI, JAX-RPC, and web services.

EJB vs. RMI

Both of them are java solution for distributed computing.

RMI offers remote access to an object running in another JVM and no other services.

But EJB offers far more services than RMI apart from remote method calling.

EJB leverages this remote-object feature of RMI and ORB (RMI-IIOP) which can be called by any COBRA client, but also provides other services such as :

• Persistence
• Transaction management
• Security
• Resource management
• Object pooling
• Messaging

What are transaction isolation levels in EJB ?

1. Transaction_read_uncommitted

Allows a method to read uncommitted data from a DB (fast but not wise).

2. Transaction_read_committed

Guarantees that the data you are getting has been committed.

3. Transaction_repeatable_read

Guarantees that all reads of the database will be the same during the transaction (good for read and update operations).

4. Transaction_serializable

All the transactions for resource are performed serial.

What are transaction attributes ?

The transaction attribute specifies how the Container must manage transactions for a method when a client invokes the method via the enterprise bean’s home or component interface or when the method is invoked as the result of the arrival of a JMS message.

Below is a list of transactional attributes : 

1. NotSupported

Transaction context is unspecified.

2. Required

Bean's method invocation is made within a transactional context.

If a client is not associated with a transaction, a new transaction is invoked automatically.

3. Supports

If a transactional context exists, a Container acts like the transaction attribute is Required, else - like NotSupported.

4. RequiresNew

A method is invoked in a new transaction context.

5. Mandatory

If a transactional context exists, a Container acts like the transaction attribute is Required,

else it throws a javax.ejb.TransactionRequiredException.

6. Never

A method executes only if no transaction context is specified.

Scenario : How do you check whether the session is active in Stateful session bean

In Stateful session bean session is not itself a separate entity.

It is contained in the bean itself.

So in order to check that we need the check whether the Stateful session bean is present or not which is done by just invoking the home interface with the JNDI.

Session context vs. Entity context

Since EnterpriseBeans live in a managed container, the container is free to call your EJB components methods at its leisure.

The container houses the information like current status of bean, security credentials of the user currently accessing the bean in one object is called EJBContext Object.

EJBContext is an interface that is implemented by the container, and itis also a part of the bean-container contract.

Entity beans use a subclass of EJBContext called EntityContext.

Session beans use a subclass called SessionContext.

These EJBContext objects provide the bean class with information about its container, the client using the bean and the bean itself.

A context represents a way for beans to perform callbacks and modify their current status :

• Session context is EJB context for session bean
• Entity context is EJB context for entity bean
• Message driven context is EJB context for message driven bean

What is re-entrant ? Is session beans reentrant. Is entity beans reentrant ?

Re-entrant means where Bean A calls methods of Bean B and then Bean B turns around and calls methods of Bean A.

The above all within a single thread of control. This is also called as loopback.

Entity beans are the only one bean that is reentrant.

Neither Session bean nor Message Driven Bean are reentrant.

When Entity bean, we have to declare in the deployment descriptor whether it is reentrant ( true or false).

1. If reentrant is defined as true in the entity bean deployment descriptor, multiple clients can connect to the Entity bean and execute methods within the entity bean concurrently and J2ee Container takes care of synchronization.

2. If reentrant is defined as false in the entity bean deployment descriptor, and many clients tries to connect to Entity Bean concurrently to execute a method, exception is thrown.

Container-Managed Persistent (CMP) beans vs. Bean-Managed Persistent (BMP) beans

Container-managed persistence beans are the simplest for the bean developer to create and the most difficult for the EJB server to support. This is because all the logic for synchronizing the bean's state with the database is handled automatically by the container.

This means that the bean developer doesn't need to write any data access logic, while the EJB server is supposed to take care of all the persistence needs automatically.

With CMP, the container manages the persistence of the entity bean.

A CMP bean developer doesn't need to worry about JDBC code and transactions, because the Container performs database calls and transaction management instead of the programmer.

Vendor tools are used to map the entity fields to the database and absolutely no database access code is written in the bean class.

All table mapping is specified in the deployment descriptor.

Otherwise, a BMP bean developer takes the load of linking an application and a database on his shoulders.

The bean-managed persistence (BMP) enterprise bean manages synchronizing its state with the database as directed by the container.

The bean uses a database API to read and write its fields to the database, but the container tells it when to do each synchronization operation and manages the transactions for the bean automatically.

Bean-managed persistence gives the bean developer the flexibility to perform persistence operations that are too complicated for the container or to use a data source that is not supported by the container. BMP beans are not 100% database-independent, because they may contain database-specific code, but CMP beans are unable to perform complicated DML (data manipulation language) statements.

EJB 2.0 specification introduced some new ways of querying database (by using the EJB QL - query language).

When ejbStore() and ejbLoad() is called ?

• ejbStore() will be called before ejbPassivate() and is used to store the object to persistent database.

• ejbLoad() will be called before ejbActivate() and is used to retrieve the object from persistence datastore.

ejbCreate() vs. ejbPostCreate()

The purpose of ejbPostCreate() is to perform clean-up database operations after SQL INSERTs [ which occur when ejbCreate() is called ] when working with CMP entity beans. ejbCreate() is called before database INSERT operations.

You need to use ejbPostCreate() to define operations, like set a flag, after INSERT completes successfully.

When working with BMP entity beans, this is not necessary. You have full control over the entire process, so you can place all the necessary logic surrounding your INSERT statement directly in the ejbCreate() method.

Even if you are creating BMP entity beans, the recommendation would still be to include an empty ejbPostCreate() method.

Although some application servers will not enforce it, the spec indicates that this placeholder should be there.

What are the callback methods in Entity beans ?

The callback methods are defined in the javax.ejb.EntityBean interface that is implemented by all entity beans.

public interface javax.ejb.EntityBean {  

   public void setEntityContext();

   public void unsetEntityContext();

   public void ejbLoad();

   public void ejbStore();

   public void ejbActivate();

   public void ejbPassivate();

   public void ejbRemove();

}

setEntityContext()

Provides the bean with an interface to the container called the EntityContext.

The EntityContext interface contains methods for obtaining information about the context under which the bean is operating at any particular moment.

The EntityContext interface is used to access security information about the caller; to determine the status of the current transaction or to force a transaction rollback; or to get a reference to the bean itself, its home, or its primary key.

The EntityContext is set only once in the life of an entity bean instance, so its reference should be put into one of the bean instance's fields if it will be needed later.

unsetEntityContext()

Used at the end of the bean's life cycle before the instance is evicted from memory to dereference the EntityContext and perform any last-minute clean-up.

ejbLoad() , ejbStore()

invoked when the entity bean's state is being synchronized with the database.

The ejbLoad() is invoked just after the container has refreshed the bean container-managed fields with its state from the database.

The ejbStore() method is invoked just before the container is about to write the bean container-managed fields to the database.

These methods are used to modify data as it's being synchronized.

This is common when the data stored in the database is different than the data used in the bean fields.

ejbPassivate() , ejbActivate()

invoked on the bean by the container just before the bean is passivated and just after the bean is activated, respectively.

Passivation in entity beans means that the bean instance is disassociated with its remote reference so that the container can evict it from memory or reuse it.

It's a resource conservation measure the container employs to reduce the number of instances in memory.

A bean might be passivated if it hasn't been used for a while or as a normal operation performed by the container to maximize reuse of resources.

Some containers will evict beans from memory, while others will reuse instances for other more active remote references.

The ejbPassivate() and ejbActivate() methods provide the bean with a notification as to when it's about to be passivated (disassociated with the remote reference) or activated (associated with a remote reference).