Cours EJB/J2EE 19/10/2004

Copyright Michel Buffa

Introduction aux Session Beans

Michel Buffa (buffa @unice.fr), UNSA 2002

Session Bean : rappel

n Un Session Bean représente

n une action, un verbe,
n une logique métier, un algorithme,
n Un encha înement de tâches…

n Exemples
n Saisie d'une commande,
n Compression vidéo,
n Gestion d'un caddy, d'un catalogue de produits,
n Transactions bancaires…

1
Cours EJB/J2EE 19/10/2004
Copyright Michel Buffa

Durée de vie d'un Session Bean

n Durée de vie = la session

n En gros, le temps qu'un client reste connecté sur le bean.
n Dans une logique e-commerce, le temps qu'un utilisateur est
connecté sur le site.

n Le container crée une instance lorsqu'un client se

connecte sur le Session Bean.
n Il peut le détruire lorsque le client se déconnecte.
n Les Session Beans ne résistent pas à des crashes du
serveur.
n Ce sont des objets en mémoire, non persistants.
n Le contraire des Entity Beans que nous verrons plus tard.

Types de Session Beans

n Chaque EJB a un moment donné entretient

une conversation avec un client.
n Conversation = suites d'appels de méthodes.

n Il existe deux types de Session Beans

1. Stateful Session Beans,
2. Stateless Session Beans .

n Chacun modélisant un type particulier de

conversation.

2
Cours EJB/J2EE 19/10/2004
Copyright Michel Buffa

Stateful Session Beans

n Certaines conversations se d éroulent sous

forment de requêtes succesives.
n Exemple : un client surfe sur un site de e-
commerce, sélectionne des produits, remplit son
caddy…

n D'une requête HTTP à l'autre, il faut un moyen

de conserver un état (le caddy par ex.)
n Autre exemple : une application bancaire. Le client
effectue plusieurs opérations. On en va pas à
chaque fois lui redemander son No de compte…

Stateful Session Beans

n En résumé, un Stateful Session Bean est utile pour

maintenir un état pendant la durée de vie du client
n au cours d'appels de méthodes successifs.
n Au cours de transactions successives.
n Si un appel de méthode change l'état du Bean, lors d'un autre
appel de méthode l'état sera disponible.

n Conséquence : une instance de Stateful Session Bean

par client.
n Avec certains containers, les Stateful Session Beans
peuvent être persistants (BAS/BES…) par sérialisation.

3
Cours EJB/J2EE 19/10/2004
Copyright Michel Buffa

Stateless Session Beans

n Certaines conversations peuvent se résumer à un

appel de méthode, sans besoin de conna ître l'état
courant du Bean
n Ex : simple traitement, simple calcul (validation de No de CB),
compression…
n Le client passe toutes les données nécessaires au traitement
lors de l'appel de méthode.

n Le container est responsable de la création et de la

destruction du Bean
n Il peut le détruire juste après un appel de méthode, ou le
garder en mémoire pendant un certain temps pour
réutilisation.

n Une instance de Stateless Session Bean n'est pas

propre à un client donné, elle peut être partagée entre
chaque appel de méthode.

Pooling de Stateless Session Beans

4
Cours EJB/J2EE 19/10/2004
Copyright Michel Buffa

Pooling des Stateful Session Beans

n Le pooling des instances de Stateful Session Beans

n'est pas aussi simple…
n Le client entretient une conversation avec le bean,
dont l'état doit être disponible lorsque ce même client
appelle une autre méthode.
n Problème si trop de clients utilisent ce type de Bean en
même temps.
n Ressources limitées (connexions, mémoire, sockets…)
n Mauvaise scalabilité du système,
n L'état peut occuper pas mal de mémoire…

n Problème similaire à la gestion des tâches dans un

OS…

Pooling des Stateful Session Beans

n Avec un OS : on utilise le concept de mémoire

virtuelle…
n Lorsqu'un processus ne fait plus rien (Idle), on
swappe son état mémoire sur disque dur,
libérant de la place.
n Lorsqu'on a de nouveau besoin de ce
processus, on fait l'inverse.
n Ceci arrive souvent lorsqu'on passe d'une
application à l'autre…

5
Cours EJB/J2EE 19/10/2004
Copyright Michel Buffa

Pooling des Stateful Session Beans

n Avec les Stateful Session Beans on fait pareil !

n Entre chaque appel de méthode, un client ne fait
rien (Idle),
n Un utilisateur d'un site de e-commerce lit les infos
sur la page www, réfléchit… de temps en temps il
clique sur un bouton…
n Pendant qu'il ne fait rien, l'état du bean est swappé
mais les ressources telles que les connexions BD,
sockets, la mémoire intrinsèque qu'il occupe,
peuvent être utilisées par un autre client.
n Etc…

Pooling des Stateful Session Beans

n Ceci a un coût : l'activation/passivation génère

des E/S
n Choix du bean à swapper par LRU le plus
souvent (Least Recent Used)
n Choix du bean à activer : lorsqu'on le demande
(just in time)

6
Cours EJB/J2EE 19/10/2004
Copyright Michel Buffa

En quoi consiste l'état d'un Bean Stateful?

n L'état conversationnel d'un bean suit les règles

de la sérialisation d'objets en java.
n En effet, la passivation (swap de la mémoire vers le
HD) et l'activation (l'inverse) sont réalisées par
sérialisation.

n Rappelez-vous que javax.ejb.EnterpriseBean

implémente java.io.Serializable
n Tous les attributs du Bean non transcients sont
donc concernés.

En quoi consiste l'état d'un Bean Stateful?

n Sont concernées également tous les attributs

issus du container
n Références vers EJBObject, EJBHome,
EJBContext, contextes JNDI…

7
Cours EJB/J2EE 19/10/2004
Copyright Michel Buffa

Passivation d'un Stateful Session Bean

Activation d'un Stateful Session Bean

8
Cours EJB/J2EE 19/10/2004
Copyright Michel Buffa

Activation/Passivation callbacks

n Lorsqu'un bean va être mis en passivation, le

container l'avertit en appelant sa méthode
ejbPassivate()
n Il peut libérer des ressources (connexions…)

n Idem lorsque le bean vient d'être activé, le

container appelle ejbActivate()

Count : l'interface distante

package examples ;
import javax.ejb.*;
import java.rmi.RemoteException;
/**
* These are CountBean ’s business logic methods.
*
* This interface is what clients operate on when they
* interact with EJB objects.The container vendor will
* implement this interface;the implemented object is
* the EJB object ,which delegates invocations to the
* actual bean.
*/
public interface Count extends EJBObject {
/**
* Increments the int stored as conversational state
*/
public int count()throws RemoteException;
}

9
Cours EJB/J2EE 19/10/2004
Copyright Michel Buffa

CountBean : la classe du bean

package examples ;
import javax.ejb.*;

/**
* Demonstration Stateful Session Bean.This Bean is initialized
* to some integer value,and has a business method which

* increments the value.

*
* This example shows the basics of how to write a stateful

* session bean,and how passivation/activation works.

*/
public class CountBean implements SessionBean {

// The current counter is our conversational state.

public int val;
//

//Business methods
//

CountBean : la classe du bean

/** Counts up */
public int count(){
System.out.println("count()");
return ++val;
}
//
// EJB-required methods
//
public void ejbCreate(int val)throws CreateException {
this.val =val;
System.out.println("ejbCreate()");
}
public void ejbRemove(){
System.out.println("ejbRemove()");
}
public void ejbActivate(){
System.out.println("ejbActivate()");
}
public void ejbPassivate(){
System.out.println("ejbPassivate()");
}
public void setSessionContext(SessionContext ctx){
}
}

10
Cours EJB/J2EE 19/10/2004
Copyright Michel Buffa

CountBean : la classe du bean

n Val est serializable, représente l'état du bean

n Le bean est stateful mais ce n'est précisé nulle
part dans le code.
n setSessionContext(SessionContext)
n Appelé par le container,
n L'objet SessionContext implémente
public interface javax.ejb.SessionContext extends javax.ejb.EJBContext {
public javax.ejb.EJBLocalObject getEJBLocalObject();
public javax.ejb.EJBObject getEJBObject();
}

n Ces deux méthodes permettent de récupérer une

référence sur l'EJBObject associé au Bean, remplace
le this pour les EJB !

CountHome : l'interface Home

package examples ;
import javax.ejb.*;
import java.rmi.RemoteException;
/**
* This is the home interface for CountBean. This interface
* is implemented by the EJB Server ’s glue-code tools - the
* implemented object is called the Home Object , and serves
* as a factory for EJB Objects.
*
* One create() method is in this Home Interface, which
* corresponds to the ejbCreate() method in the CountBean file.
*/
public interface CountHome extends EJBHome {
/*
* This method creates the EJB Object.
* @param val Value to initialize counter to
* @return The newly created EJB Object .
*/
Count create(int val) throws RemoteException , CreateException;
}

11
Cours EJB/J2EE 19/10/2004
Copyright Michel Buffa

ejb-jar.xml : descripteur de déploiement

<!DOCTYPE ejb-jar PUBLIC

"-//Sun Microsystems, Inc.//DTD Enterprise JavaBeans 2.0//EN"

"http://java.sun.com/dtd/ejb-jar_2_0.dtd">
<ejb-jar>
<enterprise-beans>

<session>
<ejb-name>Count</ejb-name>
<home>examples.CountHome</home>

<remote>examples.Count </remote>
<ejb-class >examples.CountBean</ejb-class >
<session-type>Stateful </session-type>

<transaction-type>Container</transaction -type>
</session>
</enterprise-beans>

</ejb-jar>

Descripteur de déploiement propriétaire

n Rien de spécial à signaler…

n Truc intéressant à faire : indiquer au container
que l'on ne désire pas plus de deux instances
de l'EJB dans le pool.
n Si on crée trois Beans, ça va obliger le container à
mettre en œuvre le pooling , à swapper l'état d'une
instance lors des requêtes…

12
Cours EJB/J2EE 19/10/2004
Copyright Michel Buffa

Client de l'EJB
package examples ;
import javax.ejb.*;
import javax.naming.*;
import java.util.Properties;
/** This class is a simple example of client code.
* We create 3 EJB Objects in this example, but we only allow
* the container to have 2 in memory. This illustrates how
* beans are passivated to storage. */
public class CountClient {
public static void main(String[] args) {
try {
/* Get System properties for JNDI initialization */
Properties props = System.getProperties();
/* Get a reference to the Home Object - the
* factory for EJB Objects */
Context ctx = new InitialContext(props);
CountHome home = (CountHome)
javax.rmi.PortableRemoteObject.narrow(
ctx.lookup ("CountHome"), CountHome.class );

Client de l'EJB

/* An array to hold 3 Count EJB Objects */

Count count[] = new Count[3];

int countVal = 0;
/* Create and count() on each member of array */
System.out.println("Instantiating beans . . . ");

for (int i=0; i < 3; i++) {

/* Create an EJB Object and initialize it
* to the current count value */

count[i] = home.create (countVal);

/* Add 1 and print */
countVal = count [i].count();

System.out.println(countVal);
/* Sleep for 1/2 second */
Thread.sleep(500);

} // try
...

13
Cours EJB/J2EE 19/10/2004
Copyright Michel Buffa

Client de l'EJB

/* Let’s call count() on each EJB Object to

* make sure the beans were passivated and
* activated properly. */
System.out.println("Calling count() on beans . . . ");
for (int i=0; i < 3; i++) {
/* Add 1 and print */
countVal = count[i].count();
System.out.println(countVal);
/* Sleep for 1/2 second */
Thread.sleep(500);
} // for
/* Done with EJB Objects, so remove them */
for (int i=0; i < 3; i++) {
count[i].remove();
}
} catch (Exception e) {
e.printStackTrace();
} // try
} // main
}

Exécution du client, déploiement du Bea,n

n Sortie client n Sortie

Instantiating beans . . . serveur
1 ejbCreate () ...
count() count()
2
ejbCreate () ejbPassivate()
3
count() ejbActivate ()
Calling count() on beans . . .
ejbCreate () count()
2
ejbPassivate() ejbPassivate()
3
count() ejbActivate ()
4
ejbPassivate() ejbRemove ()

ejbActivate () ejbActivate ()
count() ejbRemove ()

ejbPassivate() ejbRemove ()

ejbActivate ()
count()
ejbPassivate()
ejbActivate ()
count()

14
Cours EJB/J2EE 19/10/2004
Copyright Michel Buffa

Cycle de vie d'un Session Bean stateless

Cycle de vie d'un Session Bean stateful

15