Organizational Communications and Distributed Object Technologies - PowerPoint PPT Presentation

Loading...

PPT – Organizational Communications and Distributed Object Technologies PowerPoint presentation | free to download - id: 6fbc84-MmUyN



Loading


The Adobe Flash plugin is needed to view this content

Get the plugin now

View by Category
About This Presentation
Title:

Organizational Communications and Distributed Object Technologies

Description:

Organizational Communications and Distributed Object Technologies Lecture 14:Enterprise Java Beans – PowerPoint PPT presentation

Number of Views:40
Avg rating:3.0/5.0

less

Write a Comment
User Comments (0)
Transcript and Presenter's Notes

Title: 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.
About PowerShow.com