EJB3.1 defines enterprise beans as server-side components that encapsulate business logic. The main types of enterprise beans are session beans, message-driven beans, and entity beans. Session beans are further divided into stateless, stateful, and singleton beans. Enterprise beans provide benefits such as portability, transaction management, and scalability.

1. EJB3.1
S.M. Mahmudul Hasan shohan
Software Engineer
Therap Services LLC

2. What Is an Enterprise Bean
• is a server-side component that encapsulates the business logic of an application.
• Beneits of Enterprise Beans
– EJB container provides system-level services to enterprise beans, the bean
developer can concentrate on solving business problems.
– the beans rather than the clients contain the application’s business logic, the
client developer can focus on the presentation of the client.
– , because enterprise beans are portable components, the application
assembler can build new applications from existing beans.

3. When to Use Enterprise Beans
• The application must be scalable.
• Transactions must ensure data integrity.
• The application will have a variety of clients

4. Types of Enterprise Beans
• Session
– Performs a task for a client; optionally may
implement a web service
– Stateless, Statefull, Singleton
• Message-Driven
– Acts as a listener for a particular messaging
type, such as the Java Message Service API

5. What Is a Session Bean?
• A session bean encapsulates business logic that can be invoked
programmatically by a client over local, remote, or web service client
views.
• In a stateful session bean, the instance variables represent the state of a
unique client/bean session.
• A stateless session bean does not maintain a conversational state with the client.
When a client invokes the methods of a stateless bean, the bean’s instance
variables may contain a state specific to that client but only for the duration of the
invocation.
• A stateless session bean can implement a web service, but a stateful session bean
cannot.
• A singleton session bean is instantiated once per application and exists for the
lifecycle of the application

6. When to Use Session Beans
• Stateful session beans
– The bean’s state represents the interaction between the bean
and a specific client.
– To hold information about the client across method invocations.
• Stateless session bean
– has no data for a specific client.
– performs a generic task for all clients.
– implements a web service.
• Singleton session
– state needs to be shared across the application.
– to be accessed by multiple threads concurrently.
– to perform tasks upon application startup and shutdown.
– implements a web service.

7. Stateful Session Beans
• the instance variables represent the state of a unique client/bean session
• the client interacts with its bean
• often called the conversational state.

8. Life Cycle
• @PostConstruct
– to initialize any resources such as database connection, files etc
required for the bean.
• @PreDestroy
– to release or close any resources used by the bean.
• Rules for @PostConstruct and @PreDestroy
– method signature must return a void and take no arguments.
– method should not throw Checked Exception
– can have access modifiers
– may be FINAL

9. Lifecycle
• Passivation and Activation of Stateful Session Bean
– The transfer from the working set to secondary storage is called instance passivation. In contrast called
activation.
• Conditions for Passivation
– When the instance is not in a transaction.
– with an extended persistence context
– All the entities in the persistence context are serializable.
– The EntityManager is serializable.
• @PrePassivate
– Invoked before the stateful session bean is passivated.
– can be used to release or close any resources used by the bean.
• @PostActivate
– after the stateful session bean is activated.
– to re-initialize any resources such as database connection, files etc which are closed before passivation.
• Rules for @PostActivate and @PrePassivate
– signature must return a void and take no arguments
– can have access modifiers
– cannot be STATIC or FINAL

10. Lifecycle
• The Lifecycle of a Stateless Session Bean
• The Lifecycle of a Message-Driven Bean

11. Lifecycle
• The Lifecycle of a Singleton Bean
– Same as Stateless bean
• Initializing Singleton Session Beans
@Startup
@Singleton
public class StatusBean {
private String status;
@PostConstruct
void init {
status = "Ready";
}
….
}

12. • Managing Concurrent Access in a Singleton
Session Bean
– container-managed concurrency and bean-managed
concurrency.
@Lock(LockType.READ)
@Lock(LockType.WRITE)
@AccessTimeout
• Bean-Managed Concurrency
– is responsible for ensuring that the state of the
singleton is synchronized across all clients

13. Web Service
• annotated either the javax.jws.WebService or
the javax.jws.WebServiceProvider
• must be annotated with javax.jws.WebMethod
• exposed to web service clients must have
JAXB-compatible parameters and return type
• must have a default public constructor.
• must be annotated @Stateless.

14. Timer Service
• Creating Programmatic Timers
– @Schedule or @Schedules
@Schedule(dayOfWeek="Sun", hour="0")
public void cleanupWeekData() { ... }
@Schedules ({
@Schedule(dayOfMonth="Last"),
@Schedule(dayOfWeek="Fri", hour="23")
})
• Canceling and Saving Timers
– Timers can be cancelled by the following events.
– When a single-event timer expires, the EJB container calls the associated timeout
method and then cancels the timer.
– When the bean invokes the cancel method of the Timer interface, the container
cancels the timer.

15. Timers
• Canceling and Saving Timers
– When a single-event timer expires, the EJB
container calls the associated timeout method
and then cancels the timer.
– When the bean invokes the cancel method of the
Timer interface, the container cancels the timer.

16. Message-Driven bean
• An application client that sends several messages to a queue.
• A message-driven bean that asynchronously receives and processes
the messages that are sent to the queue
• The client starts by injecting the connection factory and queue
resources:
• the client creates the connection, session, and message producer:

17. MDB
• The Message-Driven Bean Class
– must be annotated with the @MessageDriven
– must be defined as public
– cannot be defined as abstract or final.
– a public constructor with no arguments.
– must not define the finalize method.
– implement the message listener interface for the message type it supports.
– @MessageDriven annotation typically contains a mappedName element that specifies the
JNDI name of the destination from which the bean will consume messages
• onMessage Method
– onMessage method of the MessageListener interface
– The method must be declared as public.
– The method must not be declared as final or static.
– The return type must be void.
– The method must have a single argument of type javax.jms.Message.