Organizational Communications and Distributed Object Technologies

1
Organizational Communications and Distributed
Object Technologies

• Lecture 14Enterprise Java Beans

2
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

3
From The Java EE Tutorial
Session beans Entity beans Message Driven Beans
Servlets JSPs Axis2 HTML
4
From The Java EE Tutorial
5
From The Java EE Tutorial
6
SOAP and Java EE
Slide from JAXM/JMS tutorial at Sun Microsystems
7
Slide from JAXM/JMS tutorial at Sun Microsystems
8
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.

9
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.

10
Main Concept Interposition
EJB Container
Application

• 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

skeleton
stub
11
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

12
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

13
Managed EJB Container Services

• Object Persistence and Synchronization
• Declarative Security Control
• Declarative Transaction Control
• Concurrency Management
• Scalability Management

The programmer need not worry about the
details. Think JVM on steroids.
14
EJB Types

• Entity Beans
• Session Beans
• Message-Driven Beans

15
EJB Types

• Entity Beans
• Session Beans
• Message-Driven Beans

RMI-based server side components Accessed using
distributed object Protocols (RMI IIOP)
New since EJB 2.0 Asynchronous server
side component that responds to JMS asynchronous
messages (Think provider like JAXM)
16
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

17
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)

18
Message-Driven Beans

• 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).

19
Message-Driven Beans

• 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

20
Message-Driven Beans

• 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.

21
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.

22
Implementing Entity and 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

23
Implementing Entity and 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

24
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.)

25
Implementing a Message-Driven 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

26
Implementing a Message-Driven 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.

27
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.

28
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.

29
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.

30
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)

31
Relationships

• OrderEJB
  CusomerEJB
• 1 Many
  1
• Many
• LineItemEJB
  ProductEJB

Many
1
A relationship field is like a foreign key in a
database. If a b then a knows about or
holds a pointer to b.
32
Entity Bean Life Cycle (From Sun)
Client initiates
Container initiates
Does not exist
setEntityContext
unsetEntityContext
Pool of available instances
Client calls remove and container calls ejbRemove
Client calls create and container calls
ejbCreate and ejbPostCreate
ejbPassivate
ejbActivate
-- Ready to have business methods called -- Has
an identity
33
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.

34
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

35
A Component Interface

• import javax.ejb. //
  From Eckel
• import java.rmi.RemoteException
•  
• /
•   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

36
The Container Implements the component interface
(From Eckel)
37
import javax.ejb.CreateException
// From Eckel import javax.ejb.EntityBean
import javax.ejb.EntityContext   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    
38
  public
void ejbPostCreate(Integer id, String title)
// Called by   public void ejbLoad()
//
container   public void ejbStore()   public
void ejbRemove()   public void ejbActivate()
  public void ejbPassivate()   public void
setEntityContext(EntityContext ctx)   public
void unsetEntityContext()     // 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()
// From Eckel
39
Deployment Descriptor
ltejb-jargt
// From Eckel  
ltenterprise-beansgt     ltentitygt      
ltejb-namegtMovielt/ejb-namegt      
lthomegtjavatheater.ejb.MovieHomelt/homegt      
ltremotegtjavatheater.ejb.Movielt/remotegt      
ltejb-classgt         javatheater.ejb.implementation
.MovieBean       lt/ejb-classgt      
ltpersistence-typegtContainerlt/persistence-typegt    
   ltprim-key-classgtjava.lang.Integerlt/prim-key-cla
ssgt       ltreentrantgtFalselt/reentrantgt      
ltcmp-versiongt2.xlt/cmp-versiongt      
ltabstract-schema-namegtMovielt/abstract-schema-namegt
      ltcmp-fieldgtltfield-namegtidlt/field-namegt-lt/cm
p-fieldgt       ltcmp-fieldgtltfield-namegttitlelt/field
-namegt-lt/cmp-fieldgt       ltprimkey-fieldgtidlt/primk
ey-fieldgt     lt/entitygt   lt/enterprise-beansgt lt/ej
b-jargt
40
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)      
41
// 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.findByPrimaryKe
y(new Integer(pkValue))       // Access the bean
properties     System.out.println(movie.getId())
    System.out.println(movie.getTitle())      
// Remove the entity     movie.remove()  
42
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.

43
Life Cycle of Stateful Session Bean
From Sun
Does not exist
Client calls remove, container calls ejbRemove
Client calls create. Container calls
setSessionContext and then calls ejbCreate
Container calls ejbPassivate before passivating
Passive
Ready for business methods to be called
After activation the container calls ejbActivate
44
Life Cycle of a Stateless Session Bean (from Sun)
Does not exist
ejbRemove
setSessionContext ejbCreate
Ready
45
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

46
Session Bean Remote Interface(From Sun)

• import javax.ejb.EJBObject
• import java.rmi.RemoteException
• import java.math.
• public interface Converter extends EJBObject
• public BigDecimal dollarToYen(BigDecimal
  
• dollars) throws
  RemoteException
• public BigDecimal yenToEuro(BigDecimal
• 
  yen)
• throws
  RemoteException

47
The Home Interface

• import java.io.Serializable
• import java.rmi.RemoteException
• import javax.ejb.CreateException
• import javax.ejb.EJBHome
• public interface ConverterHome extends
• 
  EJBHome
• Converter create() throws
• RemoteException, CreateException

48
The Session Bean Class

• import java.rmi.RemoteException
• 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,BigDeci
  mal.ROUND_UP)

49
public BigDecimal yenToEuro(BigDecimal yen)
BigDecimal result yen.multiply(euroRat
e) return result.setScale(2,BigDeci
mal.ROUND_UP) public ConverterBean() public
void ejbCreate() public void ejbRemove()
public void ejbActivate() public void
ejbPassivate() public void setSessionContext(Se
ssionContext sc)
50
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
• 
  ("javacomp/env/ejb/SimpleConverter")
• ConverterHome home
• (ConverterHome)PortableRemoteObjec
  t.narrow(objref,
• ConverterHome.class)

51
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()

52
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.

53
From Sun
54
On The Client

• // locate the connection factory and queue
• connectionFactory
• (ConnectionFactory) jndiContext.lookup
• ("javacomp/env/jms/MyConnectionFactory")
• destination
• (Queue) jndiContext.lookup("javacomp/env/jms/Queu
  eName")

55
// 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 lt NUM_MSGS i)
message.setText("This is message " (i 1))
System.out.println("Sending message
" message.getText())
messageProducer.send(message)
56
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.

57
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.

58
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("Mess
  age of wrong type "
• 
  inMessage.getClass().getName())
• catch (JMSException e)
• e.printStackTrace()
• mdc.setRollbackOnly()
• catch (Throwable te)
• te.printStackTrace()

59
The Web Service as an EJB
60
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.

61
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.

62
The Web Service Endpoint Interface
The client cannot see that its interacting with
an EJB

• package helloservice
• import java.rmi.RemoteException
• import java.rmi.Remote
• public interface HelloIF extends Remote
• public String sayHello(String name)
• throws RemoteException

63
The Web Service Session Bean
If we added remote and home Interfaces then this
bean could also be called using in the
traditional manner with remote references. No
change to the bean would be necessary.
package helloservice import java.rmi.RemoteExcept
ion import javax.ejb.SessionBean import
javax.ejb.SessionContext public class
HelloServiceBean implements SessionBean
public String sayHello(String name)
return "Hello " name "from HelloServiceEJB"
public HelloServiceBean() public
void ejbCreate() public void ejbRemove()
public void ejbActivate() public void
ejbPassivate() public void
setSessionContext(SessionContext sc)
WSDL can be generated and all of the previous
clients will work.