ge_title -->

Enterprise JAVA Bean – IOE Notes

Enterprise JAVA Bean

Enterprise JAVA Bean

  • EJB is a development architecture for
    • Building highly scalable and
    • Robust enterprise level applications,
    • To be deployed on J2EE compliant Application.
  • EJB 3.0 is being a great shift from EJB 2.0 and makes development of EJB based applications quite easy.

What Is an Enterprise Bean?

  • An enterprise bean is a server-side component that encapsulates the business logic of an application.
  • The business logic is the code that fulfills the purpose of the application.
  • In an inventory control application, for example,
    • The enterprise beans might implement the business logic in methods called check Inventory Level and order Product.
    • By invoking these methods, clients can access the inventory services provided by the application.
  • EJBs act as an entry point for presentation-tier technologies like Java Server Faces (JSF) but also for all external services (JMS or web services).
  • An EJB container is a runtime environment that provides services, such as transaction management, concurrency control, pooling, and security authorization.
  • Historically, application servers have added other features such as clustering, load balancing, and failover.
  • EJB developers can then concentrate on implementing business logic while the container deals with all the technical plumbing.


  • Simplified development of large scale enterprise level application.
  • Application Server/ EJB container provides most of the system level services like transaction handling, logging, load balancing, persistence mechanism, exception handling and so on. Developer has to focus only on business logic of the application.
  • EJB container manages life cycle of ejb instances thus developer needs not to worry about when to create/delete ejb objects.


Type Description
Session Bean Session bean stores data of a particular user for a single session. It can be stateful or stateless. It is less resource intensive as compared to entity beans. Session bean gets destroyed as soon as user session terminates.
Entity Bean Entity beans represents persistent data storage. User data can be saved to database via entity beans and later on can be retrieved from the database in the entity bean.
Message Driven Bean Message driven beans are used in context of JMS (Java Messaging Service). Message Driven Beans can consumes JMS messages from external entities and act accordingly.

Session Bean

  • Stateless
    • The session bean contains no conversational state between methods, and any instance can be used for any client. It is used to handle tasks that can be concluded with a single method call.
  • Stateful
    • The session bean contains conversational state, which must be retained across methods for a single user. It is useful for tasks that have to be done in several steps.
  • Singleton
    • A single session bean is shared between clients and supports concurrent access. The container will make sure that only one instance exists for the entire application.

Message-driven beans (MDBs)

  • Is used for integrating with external systems by receiving asynchronous messages using JMS. Even though MDBs are part of the EJB specification.
  • MDBs usually delegate the business logic to session beans

Services Given by the Container

  • Remote client communication:
    • Without writing any complex code, an EJB client (another EJB, a user interface, a batch process, etc.) can invoke methods remotely via standard protocols.
  • Dependency injection:
    • The container can inject several resources into an EJB (JMS destinations and factories, datasources, other EJBs, environment variables, etc.) as well as any POJO thanks to CDI.
  • State management:
    • For stateful session beans, the container manages their state transparently. You can maintain state for a particular client, as if you were developing a desktop application.
  • Pooling:
    • For stateless beans and MDBs, the container creates a pool of instances that can be shared by multiple clients. Once invoked, an EJB returns to the pool to be reused instead of being destroyed.
  • Component life cycle:
    • The container is responsible for managing the life cycle of each component.
  • Messaging:
    • The container allows MDBs to listen to destinations and consume messages without too much JMS plumbing.
  • Transaction management:
    • With declarative transaction management, an EJB can use annotations to inform the container about the transaction policy it should use. The container takes care of the commit or the rollback.
  • Security:
    • Class or method-level access control can be specified on EJBs to enforce user and role authorization.
  • Concurrency support:
    • Except for singletons, where some concurrency declaration is needed, all the other types of EJB are thread-safe by nature. You can develop high-performance applications without worrying about thread issues.
  • Interceptors:
    • Cross-cutting concerns can be put into interceptors, which will be invoked automatically by the container.
  • Asynchronous method invocation:
    • Since EJB 3.1, it’s now possible to have asynchronous calls without involving messaging.

EJBs a set of service cannot create or manage

  • Threads
  • Access files using,
  • Create a ServerSocket,
  • Load a native library, or
  • Use the AWT (Abstract Window Toolkit)or
  • Swing APIs to interact with the user.

EJB Lite

  • The specification defines a minimal subset of the full EJB API known as EJB Lite.
  • It includes a small, powerful selection of EJB features suitable for writing portable transactional and secure business logic.
  • Any EJB Lite application can be deployed on any Java EE product that implementsEJB 3.2.

Comparison Between EJB Lite and Full EJB

Feature EJB Lite Full EJB 3.2
Session beans (stateless, stateful, singleton) Yes Yes
No-interface view Yes Yes
Local interface Yes Yes
Interceptors Yes Yes
Transaction support Yes Yes
Security Yes Yes
Embeddable API Yes Yes
Asynchronous calls No Yes
MDBs No Yes
Remote interface No Yes
JAX-WS web services No Yes
JAX-RS web services No Yes
Timer service No Yes
RMI/IIOP interoperability No Yes

Writing Enterprise Java Beans


public class BookEJB {

  @PersistenceContext(unitName = “YourName”)

  private EntityManager em;

  public Book findBookById(Long id) {

  return em.find(Book.class, id);


  public Book createBook(Book book) {


  return book;



Anatomy of an EJB

  • A bean class:
    • The bean class contains the business method implementation and can implement zero or several business interfaces. The session bean must be annotated with @Stateless, @Stateful, or @Singleton depending on its type.
  • Business interfaces:
    • These interfaces contain the declaration of business methods that are visible to the client and implemented by the bean class. A session bean can have local interfaces, remote interfaces, or no interface at all (a no-interface view with local access only).

Bean class has several types of business interfaces

Bean class has several types of business interfaces
Bean class has several types of business interfaces

Remote, Local, and No-Interface Views

Remote, Local, and No-Interface Views
Remote, Local, and No-Interface Views

EJB – Environment Setup

  • EJB is a framework for Java, so the very first requirement is to have JDK installed in your machine.

Create Project

Create Project
Create Project
Create Project
Create Project
 Create Project
Create Project

EJB – Stateless Bean

  • A stateless session bean is a type of enterprise bean which is normally used to do independent operations.
  • A stateless session bean as per its name does not have any associated client state, 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 lookups/ method calls.

Read Next:

 Steps required to create a stateless EJB

  • Create a remote/local interface exposing the business methods.
  • This interface will be used by the EJB client application.
  • Use @Local annotation if EJB client is in same environment where EJB session bean is to be deployed.
  • Use @Remote annotation if EJB client is in different environment where EJB session bean is to be deployed.
  • Create a stateless session bean implementing the above interface.
  • Use @Stateless annotation to signify it a stateless bean. EJB Container automatically creates the relevant configurations or interfaces required by reading this annotation during deployment.

Remote Interface

import javax.ejb.Remote;


public interface LibrarySessionBeanRemote {

  //add business method declarations


Stateless EJB


public class LibrarySessionBean implements LibrarySessionBeanRemote {

   //implement business method


Enterprise JavaBean Architecture

  • The Enterprise JavaBeans architecture defines a standard model for Java application servers to support “Write Once, Run Anywhere” (WORA) portability
  • EJB technology takes the WORA concept to a new level.
  • EJB completely portable across any vendor’s EJB compliant application server. The EJB environment automatically maps the component to the underlying vendor-specific infrastructure services.

Enterprise JavaBeans

  • The EJB architecture specifies the responsibilities and interactions among EJB entities
    • EJB Servers
    • EJB Containers
    • Enterprise Beans
    • EJB Clients
Enterprise JavaBeans
Enterprise JavaBeans

EJB Server

  • Provides a Runtime Environment
  • The EJB Server provides system services and manages resources
    • Process and thread management
    • System resources management
    • Database connection pooling and caching
    • Management API

EJB Container

  • Provides a Run-time Environment for an Enterprise Bean
  • Hosts the Enterprise JavaBeans
    • Provides services to Enterprise JavaBeans uNaming
    • Life cycle management
    • Persistence (state management)
    • Transaction Management
    • Security
  • Likely provided by server vendor u

Enterprise Java Beans

  • A specialized Java class where the real business logic lives
    • May be developer-written or tool-generated
  • Distributed over a network
  • Transactional
  • Secure
  • Server vendors provide tools that automatically generate distribution, transaction and security behaviour
Enterprise Java Beans
Enterprise Java Beans

EJB Clients

  • Client access is controlled by the container in which the enterprise Bean is deployed
  • Clients locates an Enterprise JavaBean through Java Naming and Directory Interface (JNDI)
  • RMI is the standard method for accessing a bean over a network

What’s Unique About EJB

  • Declarative Programming Model
  • Mandates a container model where common services are declared, not programmed
    • At development and/or deployment time, attributes defining the bean’s transaction and security characteristics are specified
    • At deployment time, the container introspects the Enterprise JavaBean attributes for the runtime services it requires and wraps the bean with the required functionality
    • At runtime, the container intercepts all calls to the object
      • Provides transactional, threading and security behavior required before the method invocation
      • Invokes the method on the object
      • Cleans up after the call

Entity Bean

  • Represents Data
  • Implements javax.ejb.EntityBean interface
  • Maps a data source to a Java class
  • table, view, join or stored procedure in a relational database
  • a set of related records in a database
  • legacy data
  • Each instance of an entity bean is one row of data
  • Each instance of an entity bean is uniquely identified by a primary key
  • An Entity Bean can also have additional methods for business logic, etc.

Comparing Session and Entity Beans

Session Beans Entity Beans
Mandatory for EJB 1.0
Represents a specific client (1 instance per client)
Can be any Java class
May be transactional
Business Logic Beans
Optional for EJB 1.0
Represents underlying data object or context (clients share instance)
Can be a class that maps to persistent data (e.g., database)
Always transactional
Beans which represent data

EJB Persistence

  • Provides Entity Beans the ability to store and retrieve their state
  • Can be implemented by a bean
    • Bean Managed Persistence
  • Can be implemented by a container
    • Container Managed Persistence

Bean Managed Persistence

  • The entity bean is responsible for its persistent behavior
  • EJB developer must implement database access
    • ejbCreate(…), ejbLoad(), ejbStore(), ejbRemove()
  • Not automated, developer manually creates mapping through JDBC calls
  • Not as reusable
    • Hard-code database access within class
  • Advanced features like connection pooling and caching are difficult to support because of reliance on hand written code

Container Managed Persistence

  • The EJB container is responsible for persistence
  • The container provides tools that generate code in the EJB class that maps methods in the bean to a result set
    • Can map to a table, view, join or stored procedure in a database
    • Server provides automated mapping to convert relational data to bean instances
  • Advanced features like connection pooling and caching are easily supported
  • High reuse

Read Next:

Leave a Comment