T.Y.I.

T SEM-V Enterprise Java

Enterprise Java Beans(EJB)

What are Java Beans?

 JavaBeans is a portable, platform-independent model written in Java

Programming Language. Its components are referred to as beans
 In simple terms, JavaBeans are classes which encapsulate several objects
into a single object. It helps in accessing these object from multiple places.
JavaBeans contains several elements like Constructors, Getter/Setter Methods and
much more.

Following are the unique characteristics that distinguish a JavaBean from other Java classes −
 It provides a default, no-argument constructor.
 It should be serializable and that which can implement the Serializable interface.
 It may have a number of properties which can be read or written.
 It may have a number of "getter" and "setter" methods for the properties.

JavaBeans Properties

A JavaBean property is a named attribute that can be accessed by the user of the object . The attribute
can be of any Java data type, including the classes that you define.
A JavaBean property may be read, write, read only, or write only. JavaBean properties are accessed
through two methods in the JavaBean's implementation class −
S.No Method & Description
.

1
getPropertyName()
For example, if property name is firstName, your method name
would be getFirstName() to read that property. This method is
called accessor.
2
setPropertyName()
For example, if property name is firstName, your method name
would be setFirstName() to write that property. This method is
called mutator.

INTRODUCTION TO EJB

● EJB is defined as an architecture for the development and

deployment of component-based, robust, highly scalable
business applications. By using EJB, you can write scalable,
 T.Y.I.T SEM-V Enterprise Java

reliable, and secure applications without writing your own

complex distributed component framework.
● EJB is about rapid application development for the server side.
You can quickly and easily construct server-side components in
Java. This can be done by leveraging a prewritten distributed
infrastructure provided by the industry.
● EJB is designed to support application portability and reusability
across Enterprise middleware services of any vendor

BENEFITS OF EJB

• Component portability - The EJB architecture provides a simple,

elegant component container model. Java server components
can be developed once and deployed in any EJB-compliant
server.
• Architecture independence - The EJB architecture is
independent of any specific platform, proprietary protocol, or
middleware infrastructure. Applications developed for one
platform can be redeployed on other platforms.
• Developer productivity - The EJB architecture improves the
productivity of application developers by standardizing and
automating the use of complex infrastructure services such as
transaction management and security checking. Developers can
create complex applications by focusing on business logic
rather than environmental and transactional issues.
• Customization - Enterprise bean applications can be customized
without access to the source code. Application behavior and
runtime settings are defined through attributes that can be
changed when the enterprise bean is deployed.
• Multitier technology - The EJB architecture overlays existing
infrastructure services.
• Versatility and scalability - The EJB architecture can be used for
small-scale or large-scale business transactions. As processing
requirements grow, the enterprise beans can be migrated to
more powerful operating environments.

DIFFERENCE BETWEEN JAVABEANS AND

ENTERPRISE JAVABEANS

Enterprise JavaBeans JavaBeans

1. They are non-visible remote 1. They can be either visible or
objects. non-visible.
2. They are remotely executable 2. They are intended to be local
components deployed on the to a single process on the client
server. side.
3. They use the Deployment 3. They use BeanInfo classes,
Descriptor to describe and Property Editors. And they
themselves. customize to describe
themselves.
4. They cannot be deployed as 4. They can also be deployed as
ActiveX control, since OCXs run ActiveX controls.
on desktop.
T.Y.I.T SEM-V ITCS CLASSES For BSc(I.T) & BSc(C.S) Enterprise Java

Enterprise JavaBeans can be used while:

● developing the reusable business logic component in enterprise

application
● developing a fast growing distributed application, which is
scalable
● application supports transaction management to ensure the
integrity of the database
● application deals with variety of clients and session
management for thousands of clients

J2EE ARCHITECTURE OVERVIEW

The aim of the Java EE 5 platform is to provide developers a

powerful set of APIs. This is in order to:
● reduce development time
● reduce application complexity
● improve application performance

1ST FLOOR HINDUSTAN BLDG, T.P STREET, OPP. TO AKBAR PEERBHOY COLLEGE, M.S ROAD ABOVE
JAVED HOTEL GRANT ROAD(E) MUMBAI-03 Mob. 7977-079-435
T.Y.I.T SEM-V ITCS CLASSES For BSc(I.T) & BSc(C.S) Enterprise Java

The Java EE platform uses a distributed Multi-Tiered

application model for Enterprise applications. The application logic
is divided to form components according to the function. The
various application components that make up a Java EE application
are installed on different machines. This installation depends on
the tier in the multi-tiered Java EE environment to which the
application component belongs.

Java EE applications are divided in the tiers described in the

following list:
● Client-Tier components run on the Client machine
● Web-Tier components run on the Java EE server
● Business-Tier components run on the Java EE server
● Enterprise Information System (EIS)-Tier software run on the
EIS server

A Java EE application can consist of three or four tiers.

However, Java EE Multi-Tiered applications are generally
considered to be Three-Tiered applications because they are
distributed over three locations:
1. the Client machines
2. the Java EE server machine
3. the database or legacy machines at the back end

The Three-Tiered applications that run in this manner extend

the standard Two-Tiered “Client and Server” model by placing a
“Multi-threaded application server” between the “Client application”
and the “back-end storage”.

JEE APPLICATION COMPONENTS:

Java EE applications are made up of components. A Java EE

component is a self-contained functional software unit.
● The Java EE component is assembled in a Java EE application
with its related classes and files.
● The Java EE component communicates with other components,
as well.

The Java EE specification defines the following Java EE

components:
1. Application clients and applets: They are components that run
on the client.
2. Java Servlet, JavaServer Faces, and JavaServer Pages
technology components: They are web components that run on
the server.
3. Enterprise JavaBeans (EJB) components (Enterprise beans):
They are business components that run on the server.

Java EE components are written in the Java programming

language and are compiled in the same way as any program in the
language. However, the difference between Java EE components
and standard Java classes is that Java EE components are
assembled in a Java EE application. Here they are verified to be

1ST FLOOR HINDUSTAN BLDG, T.P STREET, OPP. TO AKBAR PEERBHOY COLLEGE, M.S ROAD ABOVE
JAVED HOTEL GRANT ROAD(E) MUMBAI-03 Mob. 7977-079-435
T.Y.I.T SEM-V ITCS CLASSES For BSc(I.T) & BSc(C.S) Enterprise Java

well formed and in compliance with the Java EE specification. Then

they are deployed to production, where they are run and managed
by the Java EE server.

JAVA EE CLIENTS:

Web Clients:
A web client consists of two parts:
i. dynamic web pages that contain various types of markup
languages (HTML, XML, and so on), which are generated by
web components running in the web tier, and
ii. a web browser, which renders the pages received from the
server

A web client is sometimes called a “thin client”. Thin clients

usually do not query databases, execute complex business rules,
or connect to legacy applications. When you use a “thin client”,
such heavyweight operations are off-loaded to Enterprise beans
executing on the Java EE server. Therein they can leverage the
security, speed, services, and reliability of Java EE server-side
technologies.

Applets:
A web page received from the web tier can include an
“embedded applet”. An applet is a small client application written in
the Java programming language that executes in the Java Virtual
Machine installed in the web browser. However, client systems will
likely need the Java Plug-in, and possibly a security policy file, for
the applet to successfully execute in the web browser.

Web components are the preferred API for creating a web

client program because no plug-ins or security policy files are
required on the client systems. The web components enable a
cleaner and more modular application design, as well. This is
because the web components provide a method to separate
“applications programming” from “web page design”. Thus the
personnel involved in web page design do not need to understand
Java programming language syntax to do their jobs.

Application Clients:
An application client runs on a client machine. The
application client provides a better method for users to handle
tasks, which require a richer user interface than can be provided by
a markup language. The application client typically has a graphical
user interface (GUI) created from the Swing or the Abstract Window
Toolkit (AWT) API. However, a command-line interface is certainly
possible.

Application clients directly access Enterprise beans that run

in the “business tier”. However, if application requirements warrant
it, an application client can open an HTTP connection to establish
communication with a servlet running in the “web tier”. Application
clients written in languages other than Java can interact with Java
EE 5 servers. This provision enables the Java EE 5 platform to

1ST FLOOR HINDUSTAN BLDG, T.P STREET, OPP. TO AKBAR PEERBHOY COLLEGE, M.S ROAD ABOVE
JAVED HOTEL GRANT ROAD(E) MUMBAI-03 Mob. 7977-079-435
T.Y.I.T SEM-V ITCS CLASSES For BSc(I.T) & BSc(C.S) Enterprise Java

interoperate with legacy systems, clients, and non-Java languages.

UNIT END EXERCISE

1) What is EJB? State the benefits of EJB?
2) State the difference between JavaBeans and Enterprise
JavaBeans?
3) Explain the JEE Architecture?
4) Describe the JEE Application Components?
5) State and explain Java EE clients?
TYPES OF EJB’S
Unit Structure:
 Objectives
 Types of Enterprise JavaBeans
 Session Beans
 Message-driven Bean
 Deciding on Remote or Local Access
 Method Parameters and Access
 Summary
 Unit end exercise
 Further Reading

OBJECTIVES

The objective of this chapter is to learn and understand the

types of EJB’s. Here we will learn about the session beans,
message beans and two types of access – Remote and Local.

TYPES OF ENTERPRISE JAVABEANS:

There are THREE kinds of Enterprise Beans:

 Session Beans
 Entity Beans
 Message-driven Beans

• Session Beans:
A Session Bean represents a transient conversation with a
client. When the Client completes its execution, the Session Bean
and it’s data are gone.

Entity Bean:
 An entity bean is a remote object that manages persistent
data, performs complex business logic, potentially uses
several dependent Java objects, and can be uniquely
identified by a primary key.
 Entity beans are normally coarse-grained persistent objects,
in that they utilize persistent data stored within several fine-
grained persistent Java objects.

• Message-driven Beans:
A Message-driven Bean combines features of a session
bean and a message listener, allowing a business component to

1ST FLOOR HINDUSTAN BLDG, T.P STREET, OPP. TO AKBAR PEERBHOY COLLEGE, M.S ROAD ABOVE
JAVED HOTEL GRANT ROAD(E) MUMBAI-03 Mob. 7977-079-435
T.Y.I.T SEM-V ITCS CLASSES For BSc(I.T) & BSc(C.S) Enterprise Java

asynchronously receive messages. Commonly, these are known as

Java Message Service (JMS) messages. In Java EE 5, the Entity
Beans have been replaced by Java Persistence API entities. An
Entity represents persistent data stored in one row of a database
table. If the Client terminates, or if the Server shuts down, the
Persistence Manager ensures that the entity data is saved.

SESSION BEANS:

A Session Bean represents a single Client inside the Application

Server.
• Session Beans are reusable components that contain logic for
business processes.
• For example: A Session Bean can perform price quoting, order
entry, video compression, banking transactions, stock trades,
database operations, complex calculations and more.
• To access an application that is deployed on the Server, the
Client invokes the methods of the Session Bean.
• The Session Bean performs work for its Client, thus shielding
the Client from complexity by executing business tasks inside
the Server.
• As it’s name suggests, a Session Bean is similar to an
interactive session. However, a Session Bean is not shared.
• A Session Bean can have only one client, in the same manner
as an interactive session can have only one user.
• Like an interactive session, a Session bean is not persistent.
When the client terminates, it’s Session Bean terminates and is
no longer associated with the client.

Session Beans Types:

Based on the “span of conversation” between the Client and
the Bean, there are three types of Session Beans:
1. Stateless Session Bean
2. Stateful Session Bean
3. Singleton Session Bean

All Enterprise Beans hold conversations at some level. A

“conversation” is an interaction between a Bean and a Client. It
comprises of a number of “method calls” between the Client and
the Bean.
Stateless Session Bean - Life Cycle:

1ST FLOOR HINDUSTAN BLDG, T.P STREET, OPP. TO AKBAR PEERBHOY COLLEGE, M.S ROAD ABOVE
JAVED HOTEL GRANT ROAD(E) MUMBAI-03 Mob. 7977-079-435
T.Y.I.T SEM-V ITCS CLASSES For BSc(I.T) & BSc(C.S) Enterprise Java

1. Does Not Exist to Ready: The client initiates the life cycle by
obtaining a reference to a Stateless Session Bean. The container
performs any dependency injection, and then invokes the method
annotated @PostConstruct, if any. The client can now invoke the
business methods of the bean.

2. Ready to Does Not Exist: At the end of the session bean life
cycle, the EJB container calls the method annotated @PreDestroy,
if any. The Bean instance is then ready for garbage collection.

Callback Methods:
• @PostConstruct: The container invokes this method on newly
constructed Bean instances after all dependency injections are
completed, and before the first business method is invoked on
the Enterprise Bean.
• @PreDestroy: These methods are invoked after any method
annotated @Remove is completed, and before the container
removes the Enterprise Bean instance

Stateful Session Bean - Life Cycle:

1. Does Not Exist to Ready: The Client initiates the life cycle by
obtaining a reference to a Stateful Session Bean. Dependency
injection is performed by container, and then invokes the
method annotated @PostConstruct, if any. The client can now
invoke the business methods of the bean.
2. Ready to Passive: In the Ready state, the EJB container may

1ST FLOOR HINDUSTAN BLDG, T.P STREET, OPP. TO AKBAR PEERBHOY COLLEGE, M.S ROAD ABOVE
JAVED HOTEL GRANT ROAD(E) MUMBAI-03 Mob. 7977-079-435
T.Y.I.T SEM-V ITCS CLASSES For BSc(I.T) & BSc(C.S) Enterprise Java

decide to passivate the Bean by moving it from the memory to

the secondary storage.
3. Passive to Ready: If there is any @PrePassivate annotated
method, container invokes it immediately before passivating the
Bean. If a Client invokes a business method on the Bean while it
is in the Passive state, the EJB container activates the Bean.
The container then calls the method annotated with
@PostActivate and moves it to the Ready state.
4. Ready to Does Not Exist: At the end, the client calls a method
annotated with @Remove, and the EJB container calls the
method annotated with @PreDestroy. The Bean’s instance is
then ready for garbage collection. Only the method annotated
with @Remove can be controlled with your code.

Callback methods:
Given below are the annotations with the help of which you can
declare Bean Class methods as Life Cycle Callback methods:
• javax.annotation.PostConstruct
• javax.annotation.PreDestroy
• javax.ejb.PostActivate
• javax.ejb.PrePassivat
1. @PostConstruct: The container calls these methods on newly
constructed Bean instances after all dependency injections are
completed and before the first business method is invoked on
the Enterprise Bean.
2. @PreDestroy: These methods are called after any method
annotated with @Remove has completed its execution, and
before the container removes the Enterprise Bean instance.
3. @PostActivate: The container calls these methods after it moves
the Bean from secondary storage to the memory, i.e. Active
state.
4. @PrePassivate: The container calls these methods before it
passivates the Enterprise Bean. This means before the
container shifts the bean from memory to secondary storage.

Stateless Session Beans Stateful Session Beans

1. They do not possess Internal 1. They possess Internal state.
state.
2. They cannot be passivated. 2. They can undergo
Passivation and Activation.
3. They can serve for multiple 3. They are specific to a single
client. client.
4. They create Network Traffic. 4. Stateful Beans hurt scalability.

When to use Session Beans?

1. Generally Session Beans are used in the following
circumstances:
• When there is only one client accessing the bean instance at a
given time.
• When the bean is not persistent, that is when the bean is going
to exist no longer.
• The bean is implementing the web services.

2. Stateful Session Beans are useful in the following circumstances:

1ST FLOOR HINDUSTAN BLDG, T.P STREET, OPP. TO AKBAR PEERBHOY COLLEGE, M.S ROAD ABOVE
JAVED HOTEL GRANT ROAD(E) MUMBAI-03 Mob. 7977-079-435
T.Y.I.T SEM-V ITCS CLASSES For BSc(I.T) & BSc(C.S) Enterprise Java

• What information the bean wants to hold about the client across
method invocation.
• When the bean works as the mediator between the client and
the other component of the application.
• When the bean has to manage the work flow of several other
enterprise beans

1ST FLOOR HINDUSTAN BLDG, T.P STREET, OPP. TO AKBAR PEERBHOY COLLEGE, M.S ROAD ABOVE
JAVED HOTEL GRANT ROAD(E) MUMBAI-03 Mob. 7977-079-435
T.Y.I.T SEM-V ITCS CLASSES For BSc(I.T) & BSc(C.S) Enterprise Java

3. Stateless Session Beans are appropriate in the

circumstances
illustrated below:
• If the bean does not contain the data for a specific client.
• If there is only one method invocation among all the clients to
perform the generic task.

MESSAGE-DRIVEN BEAN:

• A Message-driven Bean is an Enterprise Bean that allows Java

EE applications to asynchronously process messages. It normally
acts as a “JMS Message Listener”, which is similar to an “event
listener” except that it receives “JMS messages” instead of
“events”.

• The messages can be sent by any Java EE component (an

Application Client, another Enterprise Bean, or a web component),
by a JMS application, or by a system that does not use Java EE
technology.

• Message-driven Beans can process JMS messages or other kinds

of messages.

• A Message-driven Bean resembles a Stateless Session Bean:

• A Message-driven Bean instances do not retain data or
conversational state for a specific Client.
• All instances of a Message-driven Bean are equivalent.
• A single Message-driven Bean can process messages from
multiple clients

Following are the characteristics of a Message-driven Bean (MDB):

• MDBs execute upon receipt of a single Client message.
• MDBs are asynchronously invoked.
• MDBs are relatively short-lived.
• MDBs do not represent the directly shared data in the
database. However, they can access and update this data.
• MDBs can be transaction-aware.
• MDBs are stateless
When to use Message Driven Bean:
• Session Beans allow sending JMS messages. However, they
allow synchronous receiving of JMS messages, and not
asynchronous.
• To avoid tying up server resources, do not use blocking
synchronous receives in a server-side component. In general,
do not send or receive JMS messages in a “synchronous”
manner.
• To “asynchronously” receive messages, use a Message-driven
Bean.

JMS Concept:
• What is Message?
Message is a unit of information or data which can be sent from
one processing computer/application to other/same
computer/applications.

1ST FLOOR HINDUSTAN BLDG, T.P STREET, OPP. TO AKBAR PEERBHOY COLLEGE, M.S ROAD ABOVE
JAVED HOTEL GRANT ROAD(E) MUMBAI-03 Mob. 7977-079-435
T.Y.I.T SEM-V ITCS CLASSES For BSc(I.T) & BSc(C.S) Enterprise Java

• What is Messaging?
Messaging is a method of communication between software
components or applications.

• How Messaging works?

A messaging system is a peer-to-peer facility. A messaging client
can send messages to, and receive messages from, any other
client. Each client connects to a messaging agent that provides
facilities for creating, sending, receiving, and reading messages.

• What is JMS?
The Java Message service is a client-side API for accessing
messaging systems.

JMS Messaging models:

JMS communicates in synchronous or in asynchronous mode by
using “point-to-point” and the “publish-subscribe” models
respectively. Point-to-Point and Publish/Subscribe are the two most
commonly used models. These two models conclude the following
concepts:
• Producer: The client, responsible for sending the message to
the destination is known as the “producer”.
• Consumer: The client, responsible for receiving the message is
known as the “consumer”.
• Destination: Destination is the object used by the client to
specify the target that uses it to send the message to or to
receive the message from

1ST FLOOR HINDUSTAN BLDG, T.P STREET, OPP. TO AKBAR PEERBHOY COLLEGE, M.S ROAD ABOVE
JAVED HOTEL GRANT ROAD(E) MUMBAI-03 Mob. 7977-079-435
T.Y.I.T SEM-V ITCS CLASSES For BSc(I.T) & BSc(C.S) Enterprise Java

Working of Message-driven bean:

• In Message-driven beans (MDB), the client components don’t
locate Message-driven beans, and directly invoke methods.
Instead, the JMS clients send messages to message queues
managed by the JMS server (for example: an email inbox can
be a message queue) for which the javax.jms.MessageListener
interface is implemented.
• The message queue is monitored by a special kind of EJB(s) –
Message-driven Beans (MDBs) – that processes the incoming
messages and perform the services requested by the message.
• The MDBs are the end-point for JMS service request messages.
You assign a Message-driven Bean’s destination during
deployment by using Application Server resources.

Life cycle of Message-driven Bean:

• The EJB container usually creates a pool of Message-driven

Bean instances. For each instance, the EJB container
performs these tasks:
o If the Message-driven Bean uses dependency
injection, the Container injects these references
before instantiating the instance.
o The Container calls the method annotated
@PostConstruct, if any.
o Like a Stateless Session Bean, a Message-driven
Bean is never passivated. It has only two states:
 Not Exist
 Ready to receive message

1ST FLOOR HINDUSTAN BLDG, T.P STREET, OPP. TO AKBAR PEERBHOY COLLEGE, M.S ROAD ABOVE
JAVED HOTEL GRANT ROAD(E) MUMBAI-03 Mob. 7977-079-435
T.Y.I.T SEM-V ITCS CLASSES For BSc(I.T) & BSc(C.S) Enterprise Java

o At the end of the life cycle, the Container calls the

method annotated @PreDestroy, if any. The Bean
instance is then ready for garbage collection.
• To create a new instance of a Message-driven Bean, the
Container does the following: instantiates the Bean,
performs any required resource injection and calls the
@PostConstruct callback method, if it exists
• To remove an instance of a Message-driven Bean, the
Container calls the @PreDestroy callback method.
• On message arrival, the Container calls the “onMessage
method” of the Message-driven Bean to process the
message.
• The onMessage method normally casts the message to one
of the five JMS Message Types, and handles it in
accordance with the business logic of the Application.
• The onMessage method can call helper methods, or it can
invoke a Session Bean to process the information in the
message, or to store it in a database.
• A message can be delivered to a Message-driven Bean
within a transaction context, such that all operations within
the “onMessage method” are part of a single transaction. If
message processing is rolled back, the message will be
redelivered.

DECIDING ON REMOTE OR LOCAL ACCESS

When you design a Java EE application, one of the first

decisions you make is the type of client access allowed by the
enterprise beans: remote, local, or web service. Whether to allow
local or remote access depends on the following factors.
• Tight or loose coupling of related beans: Tightly coupled
beans depend on one another. For example, if a session bean
that processes sales orders calls a session bean that emails a
confirmation message to the customer, these beans are tightly
coupled. Tightly coupled beans are good candidates for local
access. Because they fit together as a logical unit, they typically
call each other often and would benefit from the increased
performance that is possible with local access.
• Type of client: If an enterprise bean is accessed by application
clients, it should allow remote access. In a production
environment, these clients almost always run on machines other

1ST FLOOR HINDUSTAN BLDG, T.P STREET, OPP. TO AKBAR PEERBHOY COLLEGE, M.S ROAD ABOVE
JAVED HOTEL GRANT ROAD(E) MUMBAI-03 Mob. 7977-079-435
T.Y.I.T SEM-V ITCS CLASSES For BSc(I.T) & BSc(C.S) Enterprise Java

than those on which the GlassFish Server is running. If an

enterprise bean’s clients are web components or other
enterprise beans, the type of access depends on how you want
to distribute your components.
• Component distribution: Java EE applications are scalable
because their server-side components can be distributed across
multiple machines. In a distributed application, for example, the
server that the web components run on may not be the one on
which the enterprise beans they access are deployed. In this
distributed scenario, the enterprise beans should allow remote
access.
• Performance: Owing to such factors as network latency,
remote calls may be slower than local calls. On the other hand,
if you distribute components among different servers, you may
improve the application’s overall performance. Both of these
statements are generalizations; performance can vary in
different operational environments.Nevertheless, you should
keep in mind how your application design might affect
performance.

Although it is uncommon, it is possible for an enterprise

bean to allow both remote and local access. If this is the case,
either the business interface of the bean must be explicitly
designated as a business interface by being decorated with the
@Remote or @Local annotations, or the bean class must explicitly
designate the business interfaces by using the @Remote and
@Local annotations. The same business interface cannot be both a
local and a remote business interface.

METHOD PARAMETERS AND ACCESS

The type of access affects the parameters of the bean

methods that are called by clients. The following sections apply not
only to method parameters but also to method return values.

Isolation
The parameters of remote calls are more isolated than those
of local calls. With remote calls, the client and the bean operate on
different copies of a parameter object. If the client changes the
value of the object, the value of the copy in the bean does not
change. This layer of isolation can help protect the bean if the client
accidentally modifies the data.

In a local call, both the client and the bean can modify the
same parameter object. In general, you should not rely on this side

1ST FLOOR HINDUSTAN BLDG, T.P STREET, OPP. TO AKBAR PEERBHOY COLLEGE, M.S ROAD ABOVE
JAVED HOTEL GRANT ROAD(E) MUMBAI-03 Mob. 7977-079-435
T.Y.I.T SEM-V ITCS CLASSES For BSc(I.T) & BSc(C.S) Enterprise Java

effect of local calls. Perhaps someday you will want to distribute

your components, replacing the local calls with remote ones.

As with remote clients, web service clients operate on

different copies of parameters than does the bean that implements
the web service.

Granularity of Accessed Data

Because remote calls are likely to be slower than local calls,
the parameters in remote methods should be relatively coarse-
grained. A coarse-grained object contains more data than a fine-
grained one, so fewer access calls are required. For the same
reason, the parameters of the methods called by web service
clients should also be coarse-grained.

Annotations Of EJB:

 Annotations were introduced in Java 5.0.

 Purpose of annotation is to attach additional information in the class or a meta-data of a
class within its source code.
 In EJB 3.0, annotations are used to describe configuration meta-data in ejb classes.

Name Description
Sr.
No
.

1 javax.ejb.Stateless Specifies that a given ejb class is a

stateless session bean.
Attributes
 name - Used to specify name of
the session bean.
 mappedName - Used to specify
the JNDI name of the session
bean.
 description - Used to provide
description of the session bean.

2 javax.ejb.Stateful Specifies that a given ejb class is a

stateful session bean.
Attributes
 name - Used to specify name of
the session bean.
 mappedName - Used to specify
the JNDI name of the session
bean.
 description - Used to provide
description of the session bean.

3 javax.ejb.MessageDrivenBean Specifies that a given ejb class is a

1ST FLOOR HINDUSTAN BLDG, T.P STREET, OPP. TO AKBAR PEERBHOY COLLEGE, M.S ROAD ABOVE
JAVED HOTEL GRANT ROAD(E) MUMBAI-03 Mob. 7977-079-435
T.Y.I.T SEM-V ITCS CLASSES For BSc(I.T) & BSc(C.S) Enterprise Java

message driven bean.

Attributes
 name - Used to specify name of
the message driven bean.
 messageListenerInterface -
Used to specify message listener
interface for the message driven
bean.
 activationConfig - Used to
specify the configuration details
of the message-driven bean in
operational environment of the
message driven bean.
 mappedName - Used to specify
the JNDI name of the session
bean.
 description - Used to provide
description of the session bean.

4 javax.ejb.EJB Used to specify or inject a dependency

as ejb instance into another ejb.
Attributes
 name - Used to specify name
which will be used to locate the
referenced bean in environment.
 beanInterface - Used to specify
the interface type of the
referenced bean.
 beanName - Used to provide
name of the referenced bean.
 mappedName - Used to specify
the JNDI name of the referenced
bean.
 description - Used to provide
description of the referenced
bean.

5 javax.ejb.Local Used to specify Local interface(s) of a

session bean. This local interface states
the business methods of the session bean
(which can be stateless or stateful).
This interface is used to expose the
business methods to local clients which
are running in same
deployment/application as EJB.
Attributes
 value - Used to specify the list of
local interfaces as an array of

1ST FLOOR HINDUSTAN BLDG, T.P STREET, OPP. TO AKBAR PEERBHOY COLLEGE, M.S ROAD ABOVE
JAVED HOTEL GRANT ROAD(E) MUMBAI-03 Mob. 7977-079-435
T.Y.I.T SEM-V ITCS CLASSES For BSc(I.T) & BSc(C.S) Enterprise Java

interfaces.

6 javax.ejb.Remote Used to specify Remote interface(s) of a

session bean. This remote interface
states the business methods of the
session bean (which can be stateless or
stateful).
This interface is used to expose the
business methods to remote clients
which are running in different
deployment/application as EJB.
Attributes
 value - Used to specify the list of
remote interfaces as an array of
interfaces.

7 javax.ejb.ActivationConfigPropert Used to specify properties required for a

y message driven bean. For example end
point, destination, message selector etc.
This annotation is passed as a parameter
to activationConfig attribute of
javax.ejb.MessageDrivenBean
annotation.
Attributes
 propertyName - name of the
property.
 propertyValue - value of the
property.

8 javax.ejb.PostActivate Used to specify callback method of ejb

lifecycle. This method will be called
when EJB container just
activated/reactivated the bean instance.
This interface is used to expose the
business methods to local clients which
are running in same
deployment/application as EJB.

Example: Develop “Converter” Stateless Session Bean. Write

Enterprise application for converting Japanese yen currency
to Eurodollars currency. converter consists of an enterprise
bean, which performs the calculations. Use following formula:
1 Euro = 115.3100 Yens. Develop a web client to test the
converter.
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-
8">
<title>JSP Page</title>
</head>

1ST FLOOR HINDUSTAN BLDG, T.P STREET, OPP. TO AKBAR PEERBHOY COLLEGE, M.S ROAD ABOVE
JAVED HOTEL GRANT ROAD(E) MUMBAI-03 Mob. 7977-079-435
T.Y.I.T SEM-V ITCS CLASSES For BSc(I.T) & BSc(C.S) Enterprise Java

<body>
<form method="get"
action="http://localhost:8080/StateLessEJB/ConverterServlet">
<b><h2>Converter Bean</h2></b>
<table border=2>
<tr>
<td>Enter Amount</td>
<td><input type="Text" name=txtnum></td>
</tr>
<tr>
<td><input type=Submit name=cmdsubmit></td>
<td><input type=Reset name=cmdreset></td>
</tr>
</table>
</form>
</body>
</html>

1ST FLOOR HINDUSTAN BLDG, T.P STREET, OPP. TO AKBAR PEERBHOY COLLEGE, M.S ROAD ABOVE
JAVED HOTEL GRANT ROAD(E) MUMBAI-03 Mob. 7977-079-435
T.Y.I.T SEM-V ITCS CLASSES For BSc(I.T) & BSc(C.S) Enterprise Java

ConverterBeanRemote.java
package server;

import java.math.BigDecimal;
import javax.ejb.Remote;

@Remote
public interface ConverterBeanRemote
{
public BigDecimal dollarToYen(BigDecimal dollars);
public BigDecimal yenToEuro(BigDecimal yen);
}

ConverterBean.java
package server;
import javax.ejb.Stateless;
import java.math.BigDecimal;
@Stateless
public class ConverterBean
{
private BigDecimal euroRate = new BigDecimal("0.0070");
private BigDecimal yenRate = new BigDecimal("112.58");
public BigDecimal dollarToYen(BigDecimal dollars)
{
BigDecimal result = dollars.multiply(yenRate);

return result.setScale(2, BigDecimal.ROUND_UP);

}
public BigDecimal yenToEuro(BigDecimal yen)
{
BigDecimal result = yen.multiply(euroRate);

return result.setScale(2, BigDecimal.ROUND_UP);

}
}

1ST FLOOR HINDUSTAN BLDG, T.P STREET, OPP. TO AKBAR PEERBHOY COLLEGE, M.S ROAD ABOVE
JAVED HOTEL GRANT ROAD(E) MUMBAI-03 Mob. 7977-079-435
T.Y.I.T SEM-V ITCS CLASSES For BSc(I.T) & BSc(C.S) Enterprise Java

ConverterServlet.java
package server;
import java.io.IOException;
import java.io.PrintWriter;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

@W ebServlet(name="ConverterServlet",
urlPatterns={"/ConverterServlet"})
public class ConverterServlet extends HttpServlet {

@EJB ConverterBeanRemote conv;

protected void processRequest(HttpServletRequest request,
HttpServletResponse response)
throws ServletException, IOException {
response.setContentType("text/html;charset=UTF-8");
PrintWriter out = response.getWriter();
try {
out.println("<html>");
out.println("<head>");
out.println("<title>Servlet ConverterServlet</title>");
out.println("</head>");
out.println("<body>");

String str=request.getParameter("txtnum");
int number=Integer.parseInt(str);
BigDecimal num=new BigDecimal(number);

out.println("<h2>Dollor to yen "

+ conv.dollarToYen(num) +"</h2>");
out.println("<h2>Yen to euro "
+ conv.yenToEuro(num) +"</h2>");
out.println("</body>");
out.println("</html>");
} finally {
out.close();
}

1ST FLOOR HINDUSTAN BLDG, T.P STREET, OPP. TO AKBAR PEERBHOY COLLEGE, M.S ROAD ABOVE
JAVED HOTEL GRANT ROAD(E) MUMBAI-03 Mob. 7977-079-435
T.Y.I.T SEM-V ITCS CLASSES For BSc(I.T) & BSc(C.S) Enterprise Java

Example: Develop a Stateful session bean to add items to

a
cart. Develop a web client to test the converter.

CartBeanRemote.java
package server;
import java.util.Collection;
import javax.ejb.Remote;

@Remote
public interface CartBeanRemote{
public void addItem(String item);
public void removeItem(String item);
public Collection getItems();
}

CartBean.java
package server;
import java.util.ArrayList;
import java.util.Collection;
import javax.annotation.PostConstruct;
import javax.ejb.Stateful;

@Stateful
public class CartBean implements CartBeanRemote
{
private ArrayList items;
@PostConstruct
public void initialize() {
items = new ArrayList();
}
@Override
public void addItem(String item) {
items.add(item);
}
@Override
public void removeItem(String item) {
items.remove(item);
}
@Override
public Collection getItems() {
return items;

1ST FLOOR HINDUSTAN BLDG, T.P STREET, OPP. TO AKBAR PEERBHOY COLLEGE, M.S ROAD ABOVE
JAVED HOTEL GRANT ROAD(E) MUMBAI-03 Mob. 7977-079-435
T.Y.I.T SEM-V ITCS CLASSES For BSc(I.T) & BSc(C.S) Enterprise Java

}
}
protected void processRequest(HttpServletRequest request,
HttpServletResponse response) throws ServletException,
IOException
{
response.setContentType("text/html;charset=UTF-8");
PrintWriter out = response.getWriter();
try
{
out.println("<html>");
out.println("<head>");
out.println("<title>Servlet CartServlet</title>");
out.println("</head>");
out.println("<body>");
final Context context= new InitialContext();
CartBeanRemote cart = (CartBeanRemote)context.lookup
("java:global/CartStatefulEJB/CartBean");
out.println("<br>Adding items to cart<br>");
cart.addItem("Pizza");
cart.addItem("Pasta");
cart.addItem("Noodles");
cart.addItem("Bread");
cart.addItem("Butter");
out.println("<br>Listing cart contents<br>");
Collection items = cart.getItems();
for (Iterator i = items.iterator(); i.hasNext();)
{
String item = (String) i.next();
out.println("<br>" + item);
}
}catch (Exception ex){
out.println("ERROR -->" + ex.getMessage());
}
out.println("</body>");
out.println("</html>");
out.close();

1ST FLOOR HINDUSTAN BLDG, T.P STREET, OPP. TO AKBAR PEERBHOY COLLEGE, M.S ROAD ABOVE
JAVED HOTEL GRANT ROAD(E) MUMBAI-03 Mob. 7977-079-435
T.Y.I.T SEM-V ITCS CLASSES For BSc(I.T) & BSc(C.S) Enterprise Java

SUMMARY

• A Session Bean represents a transient conversation with a

client.
• A Message-driven Bean combines features of a session bean
and a message listener, allowing a business component to
asynchronously receive messages.
• Based on the “span of conversation” between the Client and the
Bean, there are two types of Session Beans:
o Stateless Session Bean
o Stateful Session Bean
• In Message-driven beans (MDB) the JMS clients send
messages to message queues managed by the JMS server for
which the javax.jms.MessageListener interface is implemented.

UNIT END EXERCISE

1. Explain the Lifecycle of Stateless Session Bean.

2. List and explain Callback methods of Stateless Session
Bean.
3. Explain the Lifecycle of Stateful Session Bean.
4. List and explain Callback methods of Stateful Session Bean.
5. What factors are considered for Remote or Local access?
6. Explain the Lifecycle of Message Driven Bean.
7. What is MessageListener? Also explain onMessage().
8. What are the various ways of passing parameters in EJ

1ST FLOOR HINDUSTAN BLDG, T.P STREET, OPP. TO AKBAR PEERBHOY COLLEGE, M.S ROAD ABOVE
JAVED HOTEL GRANT ROAD(E) MUMBAI-03 Mob. 7977-079-435
T.Y.I.T SEM-V ITCS CLASSES For BSc(I.T) & BSc(C.S) Enterprise Java

1ST FLOOR HINDUSTAN BLDG, T.P STREET, OPP. TO AKBAR PEERBHOY COLLEGE, M.S ROAD ABOVE
JAVED HOTEL GRANT ROAD(E) MUMBAI-03 Mob. 7977-079-435