Organizational Communications and Distributed Object Technologies

Organizational Communications and
Distributed Object Technologies
Lecture 14:Enterprise Java

Beans
95-702 OCT
Master of Information
Some Useful Resources

Advanced Java 2 Platform How to
Program by Deitel, Deitel, & Santry
Thinking in Enterprise Java Bruce Eckel et. Al.
EJB 3.0 API Sun documentation
http://java.sun.com/products/ejb/docs.html
Java Enterprise In A Nutshell

Farley, Crawford & Flanagan
95-702 OCT
From The Java EE Tutorial

Session beans
Servlets
JSPs
Axis2
HTML
Entity beans
Message Driven
Beans
95-702 OCT
95-702 OCT
95-702 OCT
SOAP and Java EE
Slide from JAXM/JMS tutorial at Sun Microsystems

95-702 OCT
Slide from JAXM/JMS tutorial at Sun Microsystems

95-702 OCT
Benefits of Enterprise
Beans(1)
Simplify development of large,
distributed applications.
The developer can concentrate on
business problems.
The EJB container handles
transaction management, security,
and authorization.
Portable may be moved to other
Java EE containers.
95-702 OCT
Benefits of Enterprise
Beans(2)
Scalable the components may be
distributed across many machines.
Support for Location Transparency
the client need not be concerned with
the location of the bean.
Support for Transaction management ensures data integrity (over concurrent
access of shared resources).
Promotes thin clients and web services.
95-702 OCT
Main Concept: Interposition

EJB Container
Application
stub
skeleton
examine security credentials

start or join transaction
call any necessary persistence
functions
trigger various callbacks
call business logic
more work with transactions,
persistence and callbacks
send back result or an
exception
95-702 OCT
10
Enterprise Java Beans

Part of Java EE Enterprise Application Technologies
Currently at EJB3.0 (simplifies code with annotations)
Server-Side
EJB objects may offer a remote view (via
a remote procedure call protocol) a local view
(direct procedure call) or both
Managed
EJB container services are more involved than the
plain old JVM
Components
distributed in binary format and are
configurable
95-702 OCT
11
Server-Side Implications
In order to pull off the RPC trick we need:
A naming service
-- e.g. RMI clients make requests on the
rmiregistry
RPC proxies
-- communications code along with
the appropriate interface
95-702 OCT
12
Managed: EJB Container

Services
Object Persistence and
Synchronization
Declarative Security Control
Declarative Transaction Control
Concurrency Management
The programmer
Scalability Management
need not worry
about the details.

Think JVM on
steroids.
95-702 OCT
13
EJB Types
Entity Beans
Session Beans
Message-Driven Beans
95-702 OCT
14
EJB Types
Entity Beans
Session Beans
RMI-based server side components

Accessed using distributed object
Protocols (RMI IIOP)
Message-Driven Beans}
New since EJB 2.0

Asynchronous server side
component that responds to
JMS asynchronous messages
(Think provider like JAXM)
95-702 OCT
15
Entity Beans
Represent real world entities (customers,
orders, etc.)
Persistent Objects typically stored in a
relational database using CMP (Container
Managed Persistence) or BMP (Bean
Managed Persistence)
The client sees no difference between CMP
and BMP beans
CMP promotes component portability (more
reliant on the container to handle detail)
CMP uses its own Query Language EJB QL
CMP relies on an Abstract Schema in the
deployment descriptor
95-702 OCT
16
Session Beans
Are an extension of the client application

Manage processes or tasks
Are not persistent
Often employ several different kinds of entity beans
Implement business logic
Come in two types (which can be more easily
shared?)
Stateless session beans (no memory between calls)
purchase(severalIems,creditCardNo);
Stateful session beans (remember earlier calls)
addToCart(item);
purchase(creditCardNo);
95-702 OCT
17
Work in cooperation with Java Messaging System
(JMS).
JMS is an abstraction API on top of Message-Oriented
Middleware (MOM) like JDBC is an abstraction API
on top of SQL databases or like JAXR is an
abstraction API on registries or like JNDI is an
abstraction API on directories.
Each MOM vendor implements things differently.
MDBs allow the developer to program using the
publish-subscribe messaging model based on
asynchronous, distributed message queues.
The MOM vendor need only provide a service
provider for JMS (IBMs MQSeries or Progress
SonicMQ).
95-702 OCT
18
Are like session beans
Have no persistent state
Coordinate tasks involving other
session beans or entity beans
Listen for asynchronous messages
Unlike Session beans, provide no
remote interface describing the
methods that can be called
95-702 OCT
19
Are receivers of MOM messages
coming through the JMS API.
Usually take action when a
message is received.
Unlike session and entity beans,
Message-Driven Beans expose no
remote or local view. They are not
called directly by a client.
95-702 OCT
20
Implementing Entity and

Session Beans
Defining the component interfaces:
You may choose to define all or only some
of these depending on how you want your
bean used.
local interfaces do not require RMI
overhead.
Define a bean class.
For entity beans define a primary key.
95-702 OCT
21

Session Beans
Define the component interfaces
The remote interface specifies how the outside
world can access the beans business methods
The remote home interface specifies how the
outside world can access the beans life-cycle
methods (for creating, removing and finding)
The local interface specifies how the inside
world (same EJB container) can access the
beans business methods
The local home interface specifies how the
inside world can access the beans life-cycle
methods
95-702 OCT
22

Session Beans
Implement the bean
Fill in the code for the business and life-cycle
methods.
Its not normal to directly implement the
interfaces as we do in standard Java (though you
must provide many of the methods). The calls to
methods are not normal Java calls. They first go
through the container.
Session beans implement javax.ejb.SessionBean.
Entity beans implement javax.ejb.EntityBean.
Both beans extend javax.ejb.EnterpriseBean
95-702 OCT
23
For Entity Beans

Define a primary key class:
Required for entity beans.
Provides a pointer into the database.
Must implement Java.io.Serializable.
The EJB instance represents a particular row in
the corresponding database table.
The home interface for the entity EJB
represents the table as a whole (has finder
methods.)
95-702 OCT
24
Implementing a MessageDriven Bean

Has no local, local home, remote, or remote
home interfaces to define.
The container will call the onMessage()
method when an asynchronous message
arrives. (Like JAXM message provider.)
Extends the EnterpriseBean class and
implements the javax.ejb.MessageDrivenBean
and javax.jms.MessageListener interfaces
95-702 OCT
25
Implementing a MessageDriven Bean

Two basic messaging-system models
(1) point-to-point model allows messages to
be sent to a message queue to be read by
exactly one message consumer.
(2) publish/subscribe model allows
components to publish messages on a topic to
a server to be read by zero or more
subscribers. Subscribers register for a topic.
95-702 OCT
26
In Both Messaging Models

The messages hold:
-- a header containing the destination and the
sending time.
-- message properties to allow the receiver to
select which messages they would like to
receive. These may be set by the sender.
-- the message body itself.
95-702 OCT
27
Point-to-point on the
Client Side
import javax.jms.*;
QueueConnection qCon;
QueueSession qSes;
QueueSender qSen;
Through JNDI get access to a QueueSender.
Build messages and send them to the queue.
The queue is responsible for transporting the
message to another queue on the server.
95-702 OCT
28
Point-To-Point on the Server

Side
import javax.jms.*;
QueueConnection qCon;
QueueSession qSes;
QueueReceiver qRec;
Through JNDI get access to a QueueSender.
Build a MessageListener with an onMessage
method.
95-702 OCT
29
Entity Beans Revisited

Each entity bean has a unique identifier
called its primary key
The primary key can be used by the client
to locate the bean
Each bean represents a row in its table
Rows may have columns that reference
other entity beans (students take courses)
These relationships may be managed by
the bean or by the container (container
managed relationships)
95-702 OCT
30
Relationships
OrderEJB
1
CusomerEJB
Many
Many
LineItemEJB
ProductEJB
Many
A relationship field is like a foreign key in a database.

If a
b then a knows about or holds a pointer to b.
95-702 OCT
31
Entity Bean Life Cycle (From

Sun)
Client initiates
Container
initiates
Does not exist

setEntityContext
unsetEntityContext
Pool of available
instances
Client calls
ejbPassivate
ejbActivate
create and
container calls
-- Ready to have
ejbCreate
business methods called
and ejbPostCreate
-- Has an identity
Client calls
remove and
container calls
ejbRemove
95-702 OCT
32
A Typical Entity Bean

Needs:
A Home interface defining the create and
finder methods.
A Component interface defining the business
methods a client may call.
An implementation of the Component
interface.
Deployment descriptors.
95-702 OCT
33
A Home Interface
import javax.ejb.*;
// From Eckel
import java.util.Collection;
import java.rmi.RemoteException;
public interface MovieHome extends EJBHome {
public Movie create(Integer id, String title)
throws RemoteException, CreateException;
public Movie findByPrimaryKey(Integer id)
throws RemoteException, FinderException;
}
95-702 OCT
34
A Component Interface
import javax.ejb.*;
// From Eckel
/**
* A movie, with id and title.
*
* Note that there is no setId() method in the
* interface, to prevent clients from arbitrarily
* changing a movie's primary key.
*/
public interface Movie extends EJBObject {
public Integer getId() throws RemoteException;
public String getTitle() throws RemoteException;
public void setTitle(String title)
throws RemoteException;
}
95-702 OCT
35
The Container Implements

the component interface
(From Eckel)
95-702 OCT
36
import javax.ejb.CreateException;
import javax.ejb.EntityBean;
import javax.ejb.EntityContext;
// From Eckel
public abstract class MovieBean implements EntityBean {

// Container notifications methods
public Integer ejbCreate(Integer id, String title) throws CreateException {
if (id == null) throw new
CreateException("Primary key cannot be null");
if (id.intValue() == 0)
throw new CreateException("Primary key cannot be zero");
setId(id);
setTitle(title);
return null;
}
95-702 OCT
37
// From Eckel
public void ejbPostCreate(Integer id, String title) {}
public void ejbLoad() {}
public void ejbStore() {}
public void ejbRemove() {}
public void ejbActivate() {}
public void ejbPassivate() {}
public void setEntityContext(EntityContext ctx) {}
public void unsetEntityContext() {}
// Called by
// container
// Business methods provided by container

public abstract void setId(Integer id);
public abstract String getTitle();
public abstract void setTitle(String title);
public abstract Integer getId();
}
95-702 OCT
38
Deployment Descriptor
<ejb-jar>
// From Eckel
<enterprise-beans>
<entity>
<ejb-name>Movie</ejb-name>
<home>javatheater.ejb.MovieHome</home>
<remote>javatheater.ejb.Movie</remote>
<ejb-class>
javatheater.ejb.implementation.MovieBean
</ejb-class>
<persistence-type>Container</persistence-type>
<prim-key-class>java.lang.Integer</prim-key-class>
<reentrant>False</reentrant>
<cmp-version>2.x</cmp-version>
<abstract-schema-name>Movie</abstract-schema-name>
<cmp-field><field-name>id</field-name>-</cmp-field>
<cmp-field><field-name>title</field-name>-</cmp-field>
<primkey-field>id</primkey-field>
</entity>
</enterprise-beans>95-702 OCT
</ejb-jar> Master of Information
39
Client (From Eckel)

import javax.naming.*;
import javatheater.ejb.*;
public class MovieClient {
public static void main(String[] args) throws Exception {
javax.naming.Context initial =
new javax.naming.InitialContext();
Object objRef = initial.lookup("javatheater/Movie");
MovieHome movieHome =
(MovieHome) javax.rmi.PortableRemoteObject.narrow(
objRef,
MovieHome.class);
95-702 OCT
40
// Generate a primary key value

int pkValue =
(int) System.currentTimeMillis() % Integer.MAX_VALUE;
// Create a new Movie entity
Movie movie =
movieHome.create(
new Integer(pkValue), "A Bugs Life"
);
// As a test, locate the newly created entity
movie =
movieHome.findByPrimaryKey(new Integer(pkValue));
// Access the bean properties
System.out.println(movie.getId());
System.out.println(movie.getTitle());
// Remove the entity
movie.remove();
}
}
95-702 OCT
41
Session Beans Revisited

Represents a single client inside the J2EE
server.
Is not persistent.
May be stateful (holding the conversational
state of one client).
May be stateless (the container may assign
any bean to any client).
Is the only bean that may implement a web
service.
95-702 OCT
42
Life Cycle of Stateful Session

Bean
From Sun
Does not exist
Client calls remove, container calls ejbRemove
Client calls create.
Container calls
setSessionContext
Container calls ejbPassivate before
and then calls
passivating
ejbCreate
Ready for business
Passive
methods to be called
After activation the container calls
ejbActivate
95-702 OCT
43
Life Cycle of a Stateless

Session Bean (from Sun)
Does not exist
ejbRemove
setSessionContext
ejbCreate
Ready
95-702 OCT
44
A Typical Session Bean

Has
A Remote Interface defining the
business methods a client will call
A Home Interface for lifecycle
management
An enterprise bean class
95-702 OCT
45
Session Bean Remote

Interface(From Sun)
import javax.ejb.EJBObject;
import java.math.*;
public interface Converter extends EJBObject {
public BigDecimal dollarToYen(BigDecimal
dollars) throws RemoteException;
public BigDecimal yenToEuro(BigDecimal
yen)
}
95-702 OCT
46
The Home Interface

import
import
import
import
java.io.Serializable;
java.rmi.RemoteException;
javax.ejb.CreateException;
javax.ejb.EJBHome;
public interface ConverterHome extends

EJBHome
{
Converter create() throws
RemoteException, CreateException;
}
95-702 OCT
47
The Session Bean Class

import javax.ejb.SessionBean;
import javax.ejb.SessionContext;
import java.math.*;
public class ConverterBean implements SessionBean {
BigDecimal yenRate = new BigDecimal("121.6000");
BigDecimal euroRate = new BigDecimal("0.0077");
public BigDecimal dollarToYen(BigDecimal dollars) {
BigDecimal result = dollars.multiply(yenRate);
return
result.setScale(2,BigDecimal.ROUND_UP);
}
95-702 OCT
48
public BigDecimal yenToEuro(BigDecimal yen) {

BigDecimal result = yen.multiply(euroRate);
return result.setScale(2,BigDecimal.ROUND_UP);
}
public ConverterBean() {}
public void ejbCreate() {}
public void setSessionContext(SessionContext sc) {}
}
95-702 OCT
49
The Session Bean Client

import javax.naming.Context;
import javax.naming.InitialContext;
import javax.rmi.PortableRemoteObject;
import java.math.BigDecimal;
public class ConverterClient {
public static void main(String[] args) {
try {
Context initial = new InitialContext();
Object objref = initial.lookup
("java:comp/env/ejb/SimpleConverter");
ConverterHome home =
(ConverterHome)PortableRemoteObject.narrow(objref,
ConverterHome.class);
95-702 OCT
50
Converter currencyConverter = home.create();

BigDecimal param = new BigDecimal ("100.00");
BigDecimal amount =
currencyConverter.dollarToYen(param);
System.out.println(amount);
amount = currencyConverter.yenToEuro(param);
System.out.println(amount);
System.exit(0);
} catch (Exception ex) {
System.err.println("Caught an unexpected exception!");
ex.printStackTrace();
}
}
}
95-702 OCT
51
Message Driven Beans

Revisited
Handles asynchronous messages.
Normally acts as a JMS message listener.
The message may have originated from an
application client, another enterprise bean, a
web component or a non-Java application that
can generate messages.
Like a stateless session bean but with no
interfaces.
All operations within onMessage may be in a
transaction context.
95-702 OCT
52
From Sun
95-702 OCT
53
On The Client
// locate the connection factory and queue
connectionFactory =
(ConnectionFactory) jndiContext.lookup
("java:comp/env/jms/MyConnectionFactory");
destination =
(Queue)
jndiContext.lookup("java:comp/env/jms/QueueName");
95-702 OCT
54
// Next, the client creates the queue connection, session, and sender:
connection = connectionFactory.createConnection();
session = connection.createSession(false,
Session.AUTO_ACKNOWLEDGE);
messageProducer = session.createProducer(destination);
// Finally, the client sends several messages to the queue:
message = session.createTextMessage();
for (int i = 0; i < NUM_MSGS; i++) {
message.setText("This is message " + (i + 1));
System.out.println("Sending message: " +
message.getText());
messageProducer.send(message);
}
95-702 OCT
55
JMS Message Types(1)

The Message Body Contains:
TextMessage
A java.lang.String object (for example,
an XML document).
MapMessage
A set of name/value pairs, with names as
String objects and values as primitive types
in the Java programming language. The
entries can be accessed sequentially by enumerator
or randomly by name.
The order of the entries is undefined.
95-702 OCT
56
JMS Message Types(2)

BytesMessage
A stream of unin JMS Message Types(1) terpreted bytes.
This message type is
for literally encoding a body to match an existing message
format.
StreamMessage
A stream of primitive values in the Java programming
language, filled and read sequentially.
ObjectMessage A Serializable object in the Java
programming language.
95-702 OCT
57
Listening to the Queue

public void onMessage(Message inMessage) {
TextMessage msg = null;
try {
if (inMessage instanceof TextMessage) {
msg = (TextMessage) inMessage;
System.out.println("MESSAGE BEAN: Message received: "
+msg.getText());
} else {
System.out.println("Message of wrong type: " +
inMessage.getClass().getName());
}
} catch (JMSException e) {
e.printStackTrace();
mdc.setRollbackOnly();
} catch (Throwable te) {
te.printStackTrace();
}}
95-702 OCT
58
The Web Service as an

EJB
95-702 OCT
59
The Web Service as an

EJB
A Web service client can access Java EE
applications in two ways.
First, the client can access a Web service
created with JAX-RPC. Behind the
scenes, JAX-RPC uses a servlet to
implement the SOAP Web Service.
Second, a Web service client can access
a stateless session bean through the
service endpoint interface of the bean.
Other types of enterprise beans cannot
be accessed by Web service clients.
95-702 OCT
60
A Stateless Session Bean as

a Web Service
The client need not know that its
interacting with a Java EJB.
It calls the bean like it calls any
other web service.
Thus, .NET interoperates with Java
EE using XML on the wire.
95-702 OCT
61
The Web Service Endpoint

Interface
package helloservice;
import java.rmi.Remote;
The client cannot

see that its interacting
with an EJB
public interface HelloIF extends Remote {

public String sayHello(String name)
}
95-702 OCT
62
The Web Service Session

we added remote and home
BeanIfInterfaces
then this bean could
package helloservice;
import javax.ejb.SessionBean;
import javax.ejb.SessionContext;
also be called using in the traditional

manner with remote references.
No change to the bean would be
necessary.
public class HelloServiceBean implements SessionBean {

public String sayHello(String name) {
return "Hello " + name + "from HelloServiceEJB";
}
public HelloServiceBean() {}
WSDL can be generated and all
public void ejbCreate() {}
of the previous clients will work.
public void setSessionContext(SessionContext sc) {}
}
95-702 OCT
63

Organizational Communications and Distributed Object Technologies

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Organizational Communications and Distributed Object Technologies

Enviado por

Direitos autorais:

Formatos disponíveis

Organizational Communications and

Distributed Object Technologies

Lecture 14:Enterprise Java

Some Useful Resources

Java Enterprise In A Nutshell

From The Java EE Tutorial

From The Java EE Tutorial

From The Java EE Tutorial

SOAP and Java EE

Slide from JAXM/JMS tutorial at Sun Microsystems

Slide from JAXM/JMS tutorial at Sun Microsystems

Main Concept: Interposition

examine security credentials

Enterprise Java Beans

Managed: EJB Container

about the details.

RMI-based server side components

New since EJB 2.0

Are an extension of the client application

Implementing Entity and

Implementing Entity and

Implementing Entity and

For Entity Beans

Implementing a MessageDriven Bean

Implementing a MessageDriven Bean

In Both Messaging Models

Point-To-Point on the Server

Entity Beans Revisited

A relationship field is like a foreign key in a database.

Entity Bean Life Cycle (From

Does not exist

A Typical Entity Bean

The Container Implements

public abstract class MovieBean implements EntityBean {

// Business methods provided by container

Client (From Eckel)

// Generate a primary key value

Session Beans Revisited

Life Cycle of Stateful Session

Life Cycle of a Stateless

A Typical Session Bean

Session Bean Remote

The Home Interface

public interface ConverterHome extends

The Session Bean Class

public BigDecimal yenToEuro(BigDecimal yen) {

The Session Bean Client

Converter currencyConverter = home.create();

Message Driven Beans

JMS Message Types(1)

JMS Message Types(2)

Listening to the Queue

The Web Service as an

The Web Service as an

A Stateless Session Bean as

The Web Service Endpoint

The client cannot

public interface HelloIF extends Remote {

The Web Service Session

also be called using in the traditional

public class HelloServiceBean implements SessionBean {

Você também pode gostar