The Java EE specifications defines a standard mechanism for Java EE applications, which is known as Java EE platform. The platform uses a component based approach to provide a multitiered, distributed, transactional model for enterprise applications. A component is a unit of functionality that is assembled, along with any required resources, and it can communicate with another component inside the Java EE environment or in a networked, multi-machine, distributed environment.
In Simple word Enterprise Java Bean (EJB) is a component that is managed by EJB Container inside Application Server like Websphere, JBoss, Weblogic etc and can be invoked by another component on the same machine or, more typically, somewhere on the network.
These components come in three varieties, each with its own defined role and life cycle:
Session beans - These may be either stateful or stateless, and are primarily used to encapsulate business logic, carry out tasks on behalf of a client, and act as controllers or managers for other beans.
Entity beans - Entity beans represent persistent objects or business concepts that exist beyond a specific application's lifetime; they are typically stored in a relational database. Entity beans can be developed using bean-managed persistence,which is implemented by the developer, or container-managed persistence, implemented by the container.
Message-driven beans - Message-driven beans listen asynchronously for Java Message Service (JMS) messages from any client or component and are used for loosely coupled, typically batch-type, processing.
Session bean
Session beans are reusable components that have conversations or sessions with clients, it can be invoked by local, remote or webservice client and primarily used to encapsulate business logic.
There are 3 types of session bean.
- Stateless Session Bean: It doesn't maintain state of a client between multiple method calls.
- Stateful Session Bean: It maintains state of a client across multiple requests.
- Singleton Session Bean: One instance per application, it is shared between clients and supports concurrent access.
Stateless Session Bean
Stateless session beans do not maintain conversational state and remember nothing from previous client interaction, but it may preserve its instance state. EJB Container normally creates a
pool of few stateless bean's objects and use these objects to process
client's request. Because of pool, instance variable values are not
guaranteed to be same across method calls.
There are only two milestones in a stateless session bean's life cycle: Does Not Exist and Ready. EJB Container creates and maintains a pool of session bean first. It injects the dependency if any, then calls the @PostConstruct method if any. Now actual business logic method is invoked by the client. Then, container calls @PreDestory method if any. Now bean is ready for garbage collection.
Example of Stateless Session Bean
Remote Interfaceimport javax.ejb.Remote;
@Remote
public interface HotelSessionBeanRemote {
void bookRoom(Integer roomNo, String custName);
}
Stateless EJB
@Stateless
public class HotelSessionBean implements HotelSessionBeanRemote {
Map room = new HashMap();
void bookRoom(Integer roomNo, String custName){
room.put(roomNo, custName);
}
Stateful Session Bean
Stateful session beans are called "stateful" because they maintain a
conversational state with the client. In other words, they have state
or instance fields that can be initialized and changed by the client
with each method invocation. The bean can use the conversational state
as it process business methods invoked by the client.
Example of Stateful Session Bean
Remote Interfaceimport javax.ejb.Remote;
@Remote
public interface BankSessionBeanRemote {
void bookRoom(Integer roomNo, String custName);
}
Stateful EJB
@Stateless
public class BankSessionBean implements HotelSessionBeanRemote {
Map room = new HashMap();
void bookRoom(Integer roomNo, String custName){
room.put(roomNo, custName);
}
Posts
