Ch4 ejb

Enterprise JavaBeans
Components

Objectives of This Chapter
• Introduce J2EE framework and EJB architecture
• Introduce the concepts of EJB component and its
run time environment
• Discuss the types of EJB components, connection,
and their deployments
• Introduce the new features of EJB 2.x( 3.x JPA)
• Distinguish between synchronous and
asynchronous method invocations
• Provides step by step tutorials on building,
deploying, and using EJB components

The EJB Architecture
• The EJB architecture is a component architecture
for development and deployment of component-
based distributed applications.
• An EJB component is a reusable, WORA (Write
Once Run Anywhere), portable, scalable, and
compiled software component
• The EJB architecture makes enterprise application
development much easier because there is no need
to care of system level services such as transaction
management, security management,
multithreading management and other common
management issues.

The EJB Architecture (cont.)
• The EJB architecture also supports WORA and
portable solution. An EJB component can be
developed once and then reused in many
applications and deployed on many different
platforms without recompilation or modification
of the source code of the EJB component.
• The EJB architecture also manages the EJB
component lifecycle from the creation to the
termination including activation and deactivation
of an EJB component.

• The EJB architecture provides web services and
compatibility with CORBA.
• An EJB component is a server side component
which provides services to remote or local clients
while a Java bean is a client side component
which is installed and run at the client side most of
time.

J2EE Server
Client
EJB Container Web Container
EJB EJB2 ServletJSP
DB

J2EE Server
• Java Naming and Directory Interface (JNDI) API
allows clients to lookup and locate the container
where EJB components are registered and hosted.
• J2EE supports authentication and authorization for
security purpose.
• J2EE supports HTTP service and EJB related
services, device access services, and
multithreading services.

EJB Container
• The EJB instances are running within the EJB
container. The container is a runtime environment
that controls an EJB component instance and
provides all necessary management services for its
whole lifetime.
• Transaction management: ensuring transaction
properties of multiple distributed transaction
executions.
• Persistence management: ensuring a persistent
state of an entity bean, which is backed up by
database.

EJB Container (cont.)
• Life cycle management: ensuring the EJB
component state transitions in its life cycle.
• The EJB container provides an interface for the
EJB component to the outside world. All access
requests to the EJB component and responses
from the EJB component must get through the
EJB container.
• The EJB container isolates EJB component from
direct access by its clients.

EJB Container (cont.)
• The container will intercept the invocation from
clients to ensure the persistence, properties of
transaction, security of client operations on EJB.
• The EJB container is in charge of generating an
EJB home object, which helps to locate, create,
and remove the EJB component object.

EJB Component
• An enterprise bean is a distributed component that
lives in an EJB container and is accessed by
remote clients over network via its remote
interface or is accessed by other enterprise beans
on the same server via its local interface.
• The EJB component is a remotely executable
component deployed on its server and it is self-
descriptive component specified by its
Deployment Descriptor (DD) in XML format.

The Component Model of EJB
• Each EJB component has a business logic
interface exposed by the component so that clients
can access the business logic operations via this
interface without knowing the detail
implementation behind the interface.
• We call such interface as a remote interface. An
instance of an EJB component is created and
managed via its home interface. Every enterprise
bean must have a home interface and a remote
interface.

The Component Model of EJB (cont.)
EJB Home
EJB Object
JNDI
EJB Context
New()
Register
EJB Container
Client
1.Look up(“myEJB”)
2,Create()
3. Invoke method
EJB
Class

• The EJB component model supports the following
enterprise bean types:
– Stateless session beans that implement various business
logics, such as language translation, logon process, tax
calculation, and currency conversion.
– Stateless session beans wrapped in a web service. Any
existing enterprise bean can be encapsulated in an
external web service by a WSDL document describing
the web service endpoint that the bean implements.
Such special beans for web services do not provide
interfaces that a regular EJB component provides.

– Stateful session beans play the same roles as stateless
session beans except they keep track of the states of the
conversation from clients to the EJB components. For
instance, a shopping cart bean can be a typical stateful
session bean.
– Message-driven beans, which were introduced lately,
represent a new EJB component type that work in an
asynchronous communication mode just like an event-
driven event delegation model in Java.

– Bean Managed Persistence (BMP) entity beans are
entity beans where their persistent storage management
are managed by themselves.
– Container Managed Persistence (CMP) entity beans are
entity beans where their persistent storage management
is specified by the deployment tool and managed by the
container. However, the CMP entity beans do not need
to handle any database SQL access. An entity bean is
backed up by a relational database.

Session Beans
• As its name implies, a session bean is an
interactive bean and its lifetime is during the
session with a specific client.
• A session bean corresponds to a particular client
on the server.
• It responses to the behavior of a client and
terminates when the client session is over.
• Session beans are often designed for business
logic and flow control in front of entity beans.
• There are two types of session beans: stateless
session beans and stateful session beans.

Session Beans (cont.)
//Converter.java specifies the remote interface for this
//converter session //bean component.
package converter;
import javax.ejb.EJBObject;
import java.rmi.RemoteException;
import java.math.*;
public interface Converter extends EJBObject {
public double cToF(double c) throws RemoteException;
public double fToC(double f) throws RemoteException;
}

// ConverterHome.java specifies the home interface for this
//EJB component.
package converter;
import java.io.Serializable;
import javax.ejb.CreateException;
import javax.ejb.EJBHome;
public interface ConverterHome extends EJBHome {
Converter create() throws RemoteException,
CreateException;
}

//The file ConverterBean.java specifies the EJB implementation class for
// above interfaces of this component.
package converter;
import javax.ejb.SessionBean;
import javax.ejb.SessionContext;
import java.math.*;
public class ConverterBean implements SessionBean {
public double cToF(double c) {
double temp=0; temp=c*9/5+32;
return temp;
}

public double fToC(double f) {
double temp=0; temp=(f-32)*5/9;
return temp;
}
public ConverterBean() {}
public void ejbCreate() {}
public void ejbRemove() {}
public void ejbActivate() {}
public void ejbPassivate() {}
public void setSessionContext(SessionContext sc) {}
} // ConverterBean

• A stateful session bean represents a specific client
and holds the data for this client during the
session.
• For example, a shopping cart session bean or a
student registration session bean is stateful
because the session must keep track of which
items or courses have been selected so far.

Entity Bean
• An entity bean represents some persistent data backed up
by a database. Students, teachers, and courses are
examples of entity beans.
• Each entity bean has an underlying table in the database
and each instance of the bean is stored in a row of the
table.
• An entity bean does not correspond to any specific client.
• It provides a shared access. It is supported by the EJB
transaction service via its container.
• It has a persistent state with a unique primary key
identifier which can be used by a client to locate a
particular entity bean.
• There are two types of entity beans: Bean Managed
Persistence (BMP) entity beans and Container Managed
Persistence (CMP) entity beans.

Entity Bean (cont.)
CREATE TABLE student
(id VARCHAR(3) CONSTRAINT pk_student PRIMARY KEY,
gpa Number(2,1)
);
//The following is the home interface for this student BMP
//entity bean.
import javax.ejb.*;
import java.util.*;
public interface StudentHome extends EJBHome {
public Student create(String id, double gpa)
throws RemoteException, CreateException;
public String findByPrimaryKey(String id)
throws FinderException, RemoteException;
}

Entity Bean (cont.)
//The following code is the remote interface for this
//student BMP entity bean.
import javax.ejb.EJBObject;
public interface Student extends EJBObject {
public double getGpa() throws RemoteException;
}

Entity Bean (cont.)
//The following is the BMP implementation entity bean where SQL
//statements are explicitly included.
import java.sql.*;
import javax.sql.*;
import java.util.*;
import javax.ejb.*;
import javax.naming.*;
public class StudentEJB implements EntityBean {
private String id;
private double gpa;
private EntityContext context;
private Connection con;
private String dbName = "java:comp/env/jdbc/StudentDB";
public double getGpa() {
return gpa;
}

Entity Bean (cont.)
//The following ejbXcallback methods executed by EJB container.
//When a new bean instance is created the method ejbCreate() is
// automatically called by the container to insert a row in a
//corresponding table in the database.
public String ejbCreate(String id, double gpa)
throws CreateException {
try {
insertRow(id, gpa);
} catch (Exception ex) {
throw new EJBException("ejbCreate: ");
}
this.id = id;
this.gpa = gpa;
return id;
}

Entity Bean (cont.)
public String ejbFindByPrimaryKey(String primaryKey)
throws FinderException {
boolean result;
try {
result = selectByPrimaryKey(primaryKey);
throw new EJBException("ejbFindByPrimaryKey: ");
}
if (result) {
return primaryKey;
}
else {
throw new ObjectNotFoundException
("Row for id " + primaryKey + " not found.");
}
}

Entity Bean (cont.)
public void ejbRemove() {
try {
deleteRow(id);
throw new EJBException("ejbRemove: ");
}
}
public void setEntityContext(EntityContext context) {
this.context = context;
try {
makeConnection();
throw new EJBException("Failed to connect to database.”);
}
}

Entity Bean (cont.)
public void ejbActivate() {
id = (String)context.getPrimaryKey();
}
public void ejbPassivate() {
id = null;
}
public void ejbLoad() {
try {
loadRow();
throw new EJBException("ejbLoad: ");
}
}

Entity Bean (cont.)
public void ejbStore() {
try {
storeRow();
throw new EJBException("ejbLoad: " );
}
}
public void ejbPostCreate(String id, double gpa) { }
void makeConnection() throws NamingException,
SQLException
{ InitialContext ic = new InitialContext();
DataSource ds = (DataSource) ic.lookup(dbName);
con = ds.getConnection();
}

Entity Bean (cont.)
//The following methods are callback methods to invoke SQL
//statements to access database
void insertRow (String id, double gpa) throws SQLException
{
String insertStatement = "insert into student values
(?,? )";
PreparedStatement prepStmt =
con.prepareStatement(insertStatement);
prepStmt.setString(1, id);
prepStmt.setDouble(2, gpa);
prepStmt.executeUpdate();
prepStmt.close();
}

Entity Bean (cont.)
void deleteRow(String id) throws SQLException {
String deleteStatement = "delete from student where id = ?
";
PreparedStatement prepStmt=con.prepareStatement(deleteStatement);
prepStmt.executeUpdate();
prepStmt.close();
}

Entity Bean (cont.)
boolean selectByPrimaryKey(String primaryKey) throws
SQLException
{
String selectStatement="select id "+"from student where
id = ? ";
con.prepareStatement(selectStatement);
prepStmt.setString(1, primaryKey);
ResultSet rs = prepStmt.executeQuery();
boolean result = rs.next();
prepStmt.close();
return result;
}

Entity Bean (cont.)
void loadRow() throws SQLException {
String selectStatement =
"select gpa " + "from student where id = ? ";
con.prepareStatement(selectStatement);
prepStmt.setString(1, this.id);
ResultSet rs = prepStmt.executeQuery();
if (rs.next()) {
this.gpa = rs.getDouble(2);
prepStmt.close();
}
else {
prepStmt.close();
throw new NoSuchEntityException(id + " not found.");
}
}

Entity Bean (cont.)
void storeRow() throws SQLException {
String updateStatement =
"update student set gpa = ? " + "where id = ?";
con.prepareStatement(updateStatement);
prepStmt.setDouble(1, gpa);
int rowCount = prepStmt.executeUpdate();
prepStmt.close();
if (rowCount == 0) {
throw new EJBException("Store id " + id + " failed.");
}
}
}

Message-Driven Beans (MDB)
• The MDB component is another type of Java
server component running on the EJB container.
• The MDB component works as a listener listening
to a queue supported by Java Message Server
(JMS).
• Once a client sends a message to the queue, the
MDB component will receive the message. It
works in an asynchronous communication mode.

Message-Driven Beans (MDB)
• The MDB technology is available in J2EE 1.4
(EJB2.X). The MDB technology can work in two
different ways: PTP (point to point) and
publisher/subscriber.
• PTP works in one-to-one mode and
publisher/subscriber works in a broadcasting (one
to many) mode.
• The MDB technology works in an asynchronous
fashion in that a notification can be received by a
MDB component and its reactions could be
immediate as long as MDB is active.

Message-Driven Beans (cont.)
• An MDB component works in the following way:
1. The container registers this MDB component with JMS.
2. The JMS registers all JMS destinations (Topic for
broadcasting or Queue for PTP) with Java Naming and
Directory Interface(JNDI).
3. The EJB container instantiates this MDB component.
4. The client looks up the destination with the MDB.
5. The client sends a message to the destination.
6. The EJB container selects the corresponding MDB to
consume the message.

Message-Driven Beans (cont.)
• MDB components work in a producer/consumer
asynchronous mode and the message type can be
text messages, object messages, stream messages,
or byte messages. Message are pushed and
processed in a MessageListener’s method called
onMessage().

The Connection Model of EJB
• There may be either synchronous or asynchronous
connections between two EJB components via
remote or local interfaces of the EJB components.

The Connection Model of EJB (cont.)
Home
Remote
Home
Remote or
Local
Home
Remote or
Local
DB DB
BMP CMP
Session Bean
JSP or Servlet
or Application
Client

Tight Coupling Synchronous Connections
• A synchronous invocation follows the request-
response interaction mode. A client invokes a
remote method in the interface of a target EJB
component object.
• The component interface hides all details of
implementations of business logic methods from
the clients.
• After the target EJB component object completes
its work it may respond the requests by returning
the result or it may request other services from
other components and wait for the result back and
may forward it to the client afterwards.

Tight Coupling Synchronous Connections (cont.)
• Synchronous interaction leads to a tight coupling
between EJB components.
• When a client component object initiates the
request the invocation thread is blocked from
further processing until it receives a reply from the
target EJB component.

Loosely Coupled Asynchronous Communication
• An asynchronous communication involves a
message-based communication between an EJB
component and its client.
• A client makes a request to an EJB component but
the client does not block itself. Instead it continues
its own process.
• There are two forms of asynchronous
communications: queue-based PTP and
publish/subscribe based message broadcasting.

Loosely Coupled Asynchronous Communication (cont.)
• The queue-based asynchronous communication
requires a message queue supported by JMS
which is between a client (message producer or
sender) and a message consumer or message
receiver.
• In publisher/subscriber mode the consumer
subscribes the topic into which the producer
pushes the message and more than one subscribers
(consumers) can receive the message from the
topic.
• In the asynchronous communication clients and
servers are loosely coupled which results in a
better throughout.

Association Relationships Between Entity Beans
package student;
import java.util.*;
import javax.ejb.EntityBean;
import javax.ejb.EntityContext;
import javax.naming.Context;
import javax.naming.InitialContext;
import util.Log;
public abstract class StudentBean implements EntityBean {
private EntityContext context;
//StudentID and StudentName are CMP fields
public abstract String getStudentID(); //primary key
public abstract void setStudentID(String id);
public abstract String getName();
public abstract void setName(String lastName);

Association Relationships Between Entity Beans (cont.)
//CMR(container-managed relationship) fields to course bean
public abstract Collection getCourses();
public abstract void setCourses (Collection course);
//StudentBean next defines its business logic such that getCourseList()
//returns all corresponding courses this student has taken and
//addCourse() will add a new course for this student.
public ArrayList getCourseList() {
ArrayList list = new ArrayList();
Iterator c = getCourses().iterator();
while (c.hasNext()) {
list.add(
(LocalCourse)c.next());
}
return list;
}
public void addCourse (LocalAddress course) {
getCourses().add(course);
}

//Student Local Home Interface
//Here's the LocalStudentHome home interface for the StudentBean:
import javax.ejb.EJBLocalHome;
import javax.ejb.FinderException;
public interface LocalStudentHome extends EJBLocalHome {
public LocalStudent create (String studentID, String Name)
throws CreateException;
public LocalStudent findByPrimaryKey (
String customerID)throws FinderException;
}

//The Student bean also defines a local interface. The bean's
//LocalStudent interface //extends the EJBLocalObject
//interface rather than the EJBObject interface.
import java.util.ArrayList;
import javax.ejb.EJBLocalObject;
public interface LocalStudent extends EJBLocalObject {
public String getStudentID();
public String getName();
public ArrayList getCourseList();
public void addCourse(LocalCourse course);
public void addCourse(String CourseKey);
}

Deployment Descriptor
1 * * *
Dept Student Course
DB DB DB

The Deployment Model of EJB
• An EJB component is packaged as a .jar file which
is assembled in turn with other web component
packages (.war) and J2EE application client
packages(.jar) in a J2EE application file(.ear).

The Deployment Model of EJB (cont.)
.jar( java archive) .war( web archive)
... ...
Client
Client DD
Java applet or
application
.jar (java archive)
EJB Component
EJB DD
EJB class
Remote Interface
Home Interface
Web component
DD XML
Servlet or
JSP or
HTML
J2EE application
J2EE application
DD XML
.ear (enterprise
archive)

• After creating the code for enterprise bean and its
client we need to compile them into class files.
• Next we need to pack EJB components, web
components, or client into Java archive files (.jar)
or web archive file (.war ) with their deployment
descriptor XML files and then assemble all of
these archive files into an enterprise archive file
(.ear) to be deployed on a server.

• A deployment descriptor (DD) is a deployment
definition file in XML format.
• It tells the types of the EJB, class names for
remote interfaces, home interfaces,
implementation beans, transaction management
specification, access control security, persistence
property of entity beans.
• DD is created automatically by deploytool after
the deployment wizard is completed.

The following is a partial content of a DD:
<?xml version=”1.0”>
<ejb-jar>
<enterprise-beans>
<entity>
<ejb-name>studentBean</ejb-name>
<home>studenthome</home>
<remote>student</remote>
<ejb-class>Student</ejb-class>
<persistence-type>Container</persistence-type>
<pri-key-class>Integer</pri-key-class>
…

<cmp-field><field-name>id</field-name></cmp-field>
…
<cmp-field><field-name>name</field-name></cmp-
field>
</enterprise-beans>
<assembly-descriptor>
<security-role>
…
</security-role>
…
</assebly-descriptor>
</ejb-jar>

Ch4 ejb

More Related Content

Similar to Ch4 ejb (20)

Recently uploaded (20)

Ch4 ejb