KWWSZZZDGHOHLPDJIUaGRQVH]FRXUV

Les Enterprise Java Beans

Didier DONSEZ
Université Joseph Fourier (Grenoble 1)
IMA – LSR/ADELE
'LGLHU'RQVH]#LPDJIU'LGLHU'RQVH]#LHHHRUJ
Plan

■ Rappels
• Programmation par Composant
• Architecture multi-tiers
■ Les EJB
■ Un exemple
Rappel
La programmation par composant

■ Limites de la programmation usuelle

« programming in the small »
• tout est la la charge du programmeur
• construction des différents modules
• définition des instances
• interconnexions des modules
• structure de l’application peu visible
• ensemble des fichiers de codes nécessaire
• évolution / modification difficile
• changement du mode de communication
• évolution, ajout, suppression de fonctionnalités
• modification du placement
• développement, génération des exécutables, déploiement
• pas ou peu d’outils pour les applications réparties
Rappel
La programmation par composant

■ Programmation constructive (ou par composition)

« programming in the large »
• Motivation : réutilisation de logiciel
• intégration de modules logiciels existants
• construction d'applications réparties par assemblage de
modules logiciels existants
• programmation à gros grain ("programming in the large")
• Approche : description de l'
architecture de l'
application à l'
aide d'
un
langage déclaratif
• modèle de construction des composants
FRPSRVDQWV interfaces, attributs, implémentation
• description des interactions entre composants (connecteurs)
• description de variables d'environnement
(placement, regroupement, sécurité, etc.)
Les composants...

■ Qu’est-ce que c’est ?

• 'pILQLWLRQXVXHOOH
• module logiciel autonome pouvant être installé sur différentes plates-formes
• qui exporte différents attributs, propriétés ou méthodes
• qui peut être configuré
• capable de s’auto-décrire
• ,QWpUrW être des briques de base configurables pour permettre la
construction d’une application par composition
■ Quelques composants célèbres (ou qui vont l’être)
• COM / DCOM, Java Beans,
Enterprise Java Beans, Composants CORBA
 Les modèles de composants :
caractérisation d’un composant

■ Comment coopère un composant 3URSULpWpV

• Ce que fournit le composant (entrées)
• composantes, interfaces, opérations, propriétés
FRQILJXUDEOHV
• Ce qu’utilise le composant (dépendances)
• composition et références aux autres composants V V
• modes de communication des connecteurs \ \
(synchrone, asynchrone, flots) Q Q

)RXUQLW

8WLOLVH
■ Propriétés configurables du composant F F
■ Contraintes techniques (QoS) D &RPSRVDQW D
V V
• middleware : placement, sécurité, transaction
\ \
• internes : cycle de vie, persistance
Q Q
• implantation : OS, bibliothèques, version F F

&RQWUDLQWHV
WHFKQLTXHV
Les modèles de composants :
conteneurs et structures d’accueil
■ Conteneur
• encapsulation d’un composant (et ses composantes)
• prise en charge (masque) les services systèmes
• nommage, sécurité, transaction, persistance ...
• prise en charge partielle des connecteurs
• invocations et événements
• techniquement par interposition (ou délégation)
■ Structures d’accueil
• espace d’exécution des conteneurs et des composants
• médiateur entre les conteneurs et les services systèmes
• des + comme le téléchargement de code (navigateur)
Les modèles de composants :
conteneurs et structures d’accueil

&RQQHFWHXU &RPSRVDQW
V\QFKURQH
8WLOLVH &RQWHQHXU
&OLHQW &RPSRVDQW
&RQQHFWHXU
DV\QFKURQH &RPSRVDQW

&RQWHQHXU &RQWHQHXU

6WUXFWXUHG¶DFFXHLO 6WUXFWXUHG¶DFFXHLO

0LGGOHZDUH 6HUYLFHV
Les modèles de composants :
de l’installation à l’introspection

■ Installer les composants

• technologie de packaging
• production des conteneurs
■ Créer les composants
• par des fabriques (maisons / « home »)
• configuration des valeurs initiales
■ Retrouver les composants
• services de désignation (Nommage ou Vendeur) ou maisons
■ Utiliser
• invocation synchrone et événements
■ Introspection
• découvrir leurs APIs (fonctionnelle)
• découvrir les connecteurs (structurelle)
Construction par assemblage de
composants

■ Construction par assemblage

plutôt que ingénierie de développement
• réduire les besoins en compétence technique
• focaliser l’expertise sur les problèmes du domaine
■ Langage de description d’Architecture
• capturer les composants
• fonctionnalités et besoins
• capturer les connecteurs
• composition et modes de communication
• impédance entre composants => adaptateurs
• C’est le point faible des solutions industrielles !
Rappel
/HV$UFKLWHFWXUHV0XOWLWLHUV
• Clients légers
• Browsers Web (HTTP/HTML)
• Applets (RMI)
• Contrôle ActiveX (DCOM)
• Clients CORBA (IIOP)
• Serveurs Applicatifs
• Présentation, Outils Métiers
• CGI, Servlet, …
• Source de Données
• Bases de Données Relationnelles ou Objets
• Intégrées (ERP), Legacy,
• Annuaires (LDAP),
• Flux (fournisseurs comme Reuter, Bloomberg) ...
Motivation pour
les Serveurs d ’Application
■ Objectifs
• Simplifier le développement d ’architectures multi-tiers
• présentation ÍÎ traitement (logique) ÍÎ données
■ Principe
• Le développer se concentre sur la logique de son application
• le reste est réalisé par la plate-forme d ’accueil
• Sessions, Transactions, Persistance, Securité, Nommage, Charge, ...

■ Programmation par composition de la logique application

• Solutions propriétaires
• Solution « ouverte » : DCOM, EJB, ...
• Indépendance Composants /¨Plateforme d ’accueil
Qu ’est que les EJB ?
(QWHUSULVH-DYD%HDQ

■ 1) Architecture permettant la création

d’applications réparties
■ 2) Composant exécuté sur un serveur et appelé
un client distant

■ Remarque
• rien à voir avec les JavaBean
• qui sont des composants côté client
Enterprise JavaBeans

■ Rendre une application

• IDFLOHjGpYHORSSHU, GpSOR\HU et DGPLQLVWUHU
• LQGpSHQGDPPHQWde la plate-forme permettant son exécution

• Un EB (EnterpriseBean) n’est pas spécifique de la plate-

forme dans laquelle il est utilisé
• Le déploiement d’un EB se fait sans recompilation ou
modification du code source
Enterprise Java Beans

■ EJB spécifications
GpILQLWLRQG¶XQHDUFKLWHFWXUHpour construire une application
en Java dont la partie serveur est construite à à l’ aide de
composants appelé Entreprise Beans (EB)
• Architecture = ensemble d’ interfaces
■ Caractéristiques principales des EB
• « écrit une fois, s’ exécute partout »
• composants « serveurs » spécialisés écrits en Java
• c.f. objets métiers de CORBA
■ EJB est la partie centrale de la plate-forme
Plate-forme Enterprise Java

&RPSRVDQWV -DYDEHDQV

50,-503,,23

&RPSRVDQWV (QWHUSULVH-DYD%HDQV

3ODWHIRUPH (-%
&RQWHQHXU6HUYHXU
-06 -1', 
-7$ -'%& 

3ODWHIRUPH 6HUYHXU8QL[17-90-'.

 Architecture de Serveur EBJ

&OLHQW +773 6HUYHXU 6HUYHXU(%-

+70/ :HE 50, 6*%'
64/
6HUYOHW 5HODWLRQQHO
;$
(%
&OLHQW&25%$ ,,23 &RQWDLQHU
(C++, Java, VB, ..)
(%
6*%'
&RQWDLQHU
&OLHQW-DYD 24/ 2EMHW
50,
Application,Applet -70 ;$

&OLHQW'&20 '&20
ActiveX
EJB
Caractéristiques principales

• L’ architecture EJB identifie les éléments suivants :

• composants logiciels ou EHDQV (EB),
• FRQWHQHXUV,
• VHUYHXUV,
• FOLHQWV.
Les conteneurs isolent les beans du client et d’ une
implémentation spécifique d’ un serveur
• Rappel : les beans sont dans la partie serveur
• Conteneurs et serveurs implémentent les mécanismes de
bas niveau utilisés par les applications
• transactions, persistance, gestion mémoire, sécurité, …
EJB
Modèle d’exécution
EJB
Caractéristiques principales
■ EJB s’intéresse aux activités liées au
GpYHORSSHPHQW, au GpSORLHPHQW et à
l’H[pFXWLRQ d’une application
■ EJB définit différents U{OHV associés aux
différentes parties intervenant dans la
production d’une application
■ EJB définit des FRQWUDWV associés à un EHDQ
• Ces contrats sont passés entre le FRQWHQHXU et les FOLHQWV qui
utilisent le bean.
=> ce sont des règles (obligations) qui doivent être respectées
par le fournisseur de l’ (% et de FRQWHQHXU
 EJB
Les différents rôles

)RXUQLVVHXU G¶(% Enterprise Bean (EB)

$VVHPEOHXUG¶DSSOLFDWLRQ Application 'pYHORSSHPHQW

GHO¶DSSOLFDWLRQ

/¶LQVWDOODWHXU 'pSORLHPHQW
HW H[pFXWLRQ

)RXUQLVVHXU GHFRQWHQHXU (-% Conteneur 'pYHORSSHPHQW

GXVHUYHXU
)RXUQLVVHXU GHVHUYHXU (-% Serveur (-%
Utilise
Produit
 EJB contrats

■ Fournir un modèle de développement uniforme

pour les applications qui utilisent les
composants EB
&RQWUDW Enterprise
&RQWUDWFRWpFOLHQW client
•
FOLHQW Bean
• fournir une vue uniforme du bean au client. En
&RQWUDW
particulier cette vue est indépendante de la plate-forme
de déploiement
• &RQWUDWFRWpFRQWHQHXU FRQWHQHXU
• permettre la portabilité des beans sur différents serveurs EBJ conteneur
EJB
• &RQWUDWFRWp“SDFNDJLQJ´HMEMDUHDU ILOH EJB serveur
• fournir un format de fichier standard pour “packager”
les beans. Ce format doit être supporter par tous les &RQWUDW
outils liés aux EJB SDUFNDJLQJ

)LFKLHUHMEMDUHDU
EJB
Le contrat coté client
■ Localiser le bean
• utilisation de JNDI
■ Utiliser le bean
• utilisation de l’ interface standard fournie par l’ EB provider
• +RPH Interface
méthodes liées à la gestion du bean : FUHDWH, UHPRYH, ILQGHU, ...)
• 5HPRWH Interface (méthodes de l’ application)
Le container implémente le mécanisme de
délégation permettant de “faire suivre” l’appel au
bean
• le client ne communique pas directement avec le bean mais avec le
container
EJB
Le contrat du “conteneur”

• L’ EJB conteneur permet

• gestion du cycle de vie, gestion de l’ état, sécurité, transaction
distribuée, concurrence, extensibilité
• ces services appellent des méthodes fournies par le bean (callback
methods)
• Les conteneurs gèrent 2 types de beans
• 6HVVLRQEHDQV
• (QWLW\ EHDQV
Session beans

• sont non persistant (short-lived)

• associé à XQVHXOFOLHQW
• XQIORWG¶H[pFXWLRQHVWFUppSRXU
• chaque appel de méthode
VWDWHOHVV sessions bean (sans état)
pas de donnée interne, inutile de le rendre passif, peut être partagé par
plusieurs clients
• plusieurs appels de méthodes en provenance du même client
VWDWHIXO sessions bean (avec état)
• détruits après un arrêt (ou une panne) du serveur EJB

• Remarque
• les stateful SB peuvent être inclus dans une transaction
Entity beans

■ Représentent les données d’une base de données

• en général, une ligne d ’ une table relationnelle (SGBD-R)
ou un objet persistant (SGBD-OO)
■ sont persistant (long-lived)
• la gestion de la persistance peut être faite par le bean (EHDQPDQDJHG
SHUVLVWHQFH) ou déléguée à son conteneur (FRQWDLQHUPDQDJHGSHUVLVWHQFH)
■ acceptent les accès multiples effectués par plusieurs
clients
• gestion de la concurrence
• différents niveaux d ’ isolation
■ peuvent participer à des transactions
■ survivent aux pannes d’un serveur EJB
• les pannes sont transparentes aux clients
Cycle de vie d’un bean

• Le conteneur gère le cycle de vie d’ un bean

• Il fournit
• administration du bean (‘Home implementation’ )
permet aux clients
de créer, détruire et rechercher un objet EJB
appelle les opérations correspondantes
fournies par le bean (callbacks)
• gestion de l’ état
Activation
» le bean est chargé en mémoire
Passivation (Désactivation )
» le conteneur peut sauvegarder l’ état du bean
Gestion des Ressources
« Pool » d ’instances
■ Le serveur EJB maintient un pool d ’instance de bean
Cycle de Vie d ’un Session Bean Stateless
(sans état)
Gestion des Ressources
Instance Swapping (i)
■ Les instances de stateless SB sont pris dans un pool à chaque appel
puis remis dans le pool après
Gestion des Ressources
Instance Swapping (ii)
Cycle de Vie d ’un Session Bean Stateful
(avec état)
Gestion des Ressources
Le mécanisme d ’Activation/Passivation

■ Rappel : le Stateful SB maintient un état conversationnel

■ Pour accepter un très grand d ’instances simultanément, le
serveur d ’EJB sauvegarde l ’état d ’instances non actives
(passivation) et restaure leur état lors qu ’un client appelle
une méthode sur l ’instance (activation)
■ méthodes « callback » appélées par le container
• ejbPassivate(), ejbActivate()
• implanté par sérialisation ou autre
vers un fichier de swap, une table de swap dans un SGBD, ...

• Remarque
• même principe que la mémoire virtuelle des SE
Gestion des Ressources
Le mécanisme d ’Activation/Passivation
Gestion des Ressources
Le mécanisme d ’Activation/Passivation
Cycle de Vie d ’un Entity Bean
Persistance (Entity Bean)

■ L ’Entity Bean correspond à une donnée

stockée dans une source de données
■ Il faut assurer la correspondance (mapping)
avec la source de données
• Base de Données Relationnelle
• correspondance (mapping) entre chaque champ d ’ une EB vers une colonne
d ’ une ligne d ’ une table, d ’ une vue, d ’ une requête multi-table
• indiquer la clé primaire (PK) qui identifie la ligne correspondante à un EB
• Base de Données Objet
• plus ou moins direct
• Base de Données Objet-Relationnelle
• Legacy
• Fichiers (IMS, CICS, Btrieve,…), ERP, Annuaire LDAP, …
• requiert des « wrappers » spécifiques
Persistance (Entity Bean)
Prise en charge de la persistance
■ Persistance gérée par le bean (bean-managed)
• le fournisseur de l’ Entity Bean écrit les opérations d’ accès aux données
permettant de gérer la persistance dans les callback appropriés (HME&UHDWH
HME6WRUHHME/RDGHME)LQG ...)
• en utilisation par exemple JDBC

■ Persistance gérée par le conteneur (container-managed)

• le fournisseur de l’ Entity Bean utilise les services du conteneur
(“container managed fields”)
• et précise le support utilisé pour la persistance
le code d’ accès à la base de donnée est délégué au conteneur

■ Dans les 2 cas

• le conteneur est responsable de la cohérence entre l’ état du bean et de
l’ état sauvegardé dans la base de données
Transaction
Gestion Declarative
■ Support de l’architecture XA (X/Open DTP)
• extensions standards à JDBC 2.0
• Java Transaction API (JTA)
■ Modèle de transaction plat
• pas de transactions imbriquées (nested)
■ Gestion “déclarative” des transactions
• l’ attribut transactionnel associé aux méthodes des Ebs est affecté
soit lors de la phase d’ implémentation du bean,
soit lors de son déploiement
• un bean peut aussi contrôler explicitement les transactions (JTA)
• un client peut aussi contrôler explicitement les transactions (JTA)

• concerne les Entity Beans et éventuellement les Stateful Session B.

 )URP*pUDUG9DQGRPH%XOO6RIW
Transaction
Attributs transactionnels
Beans Transac t ion Cl i e n t ’s T r a n s a c t i o n T r a n b
sac t ion assoc iat ed
At t ribut e e a n ’s m e t h o d

TX_NOT_SUPPORTED None None

T1 None

TX_NEVER None None

T1 Error

TX_REQUIRED None T2
T1 T1

TX_SUPPORTS None None

T1 T1

TX_REQUIRES_NEW None T2
T1 T2

TX_MANDATORY None Error

T1 T1

TX_BEAN_MANAGED None
T1
 [Monson, p231]
Transaction
Exemple
Interface [Link]

■ Interface optionnelle pour les Stateful Session Bean

■ Méthodes de callback
réagissant au comportement de la transaction
• afterBegin() juste après le [Link]()
• beforeCompletion() avant le commit()
• afterCompletion(boolean flag) après le commit() ou rollback()
■ Usage
• Rendre persistant l’ état d’ un SessionBean
• Fiabiliser l’ envoi de mail
• …
Gestion de la Concurrence

■ Accès de plusieurs clients à un Entity Bean

EJB Server
Client 1
EJB Object Instance Pool

instance bean
Client 2

■ Plusieurs problèmes
• Lecture Sale (Dirty Read)
• lecture des modifications d ’ une autre transaction qui avortera
• Lecture non répétable (Non repeatable read)
• la transaction lit successivement deux valeurs différentes d ’ une même donnée
• Lecture Fantôme (Phantom Read)
• une transaction ne lit pas des données insérées précédenment
Gestion de la Concurrence

■ La source de données « verrouille » la donnée

correspondant en fonction du type d ’accès
• Read Lock
• la valeur n ’ est pas changée par les autres transactions
• Write Lock
• la valeur n ’ est pas changée par d ’ autres transactions
• Exclusive Write Lock
• les autres transactions sont bloquées jusqu ’ au relachement
• Snapshot
• chaque transaction possède une valeur figée
■ Une transaction sera bloquée jusqu ’au relâchement du
verrou en fonction du niveau d ’isolation souhaité
Gestion de la Concurrence

■ Définition des niveaux d ’isolation de la transaction

• ISOLATION LEVEL (même définition que SQL et JDBC)
,VRODWLRQ/HYHO 6DOH 1RQ5pSpWDEOH )DQW{PHV
TRANSACTION_READ_UNCOMMITED RXL RXL RXL
TRANSACTION_READ_COMMITED QRQ RXL RXL
TRANSACTION_REPEATABLE_READ QRQ QRQ RXL
TRANSACTION_SERIALIZABLE QRQ QRQ QRQ
Répartition

B1 B2 B3
JTM
Serveur EJB Cas 1

B1 B2 B3
JTM
Serveur EJB 1 Serveur EJB 2 Serveur EJB 3 Cas 2

B1 B2 B3 JTM
Serveur EJB 1 Serveur EJB 2 Serveur EJB 3 Cas 3
B1 B2 B3
JTM JTM JTM
Serveur EJB 1 Serveur EJB 2 Serveur EJB 3 Cas 4
Sécurité

• La gestion de la sécurité est délégué au maximum au

conteneur
• objectif : simplifier la programmation du bean, améliorer la portabilité
• Le support de la sécurité est basé sur
• l’ API sécurité de Java (MDYD[VHFXULW\)
• les méthodes liées à la sécurité peuvent être implémenté par le
conteneur (MDYD[HME(-%&RQWH[W interface)
• utilisation d’ attributs de sécurité défini dans le descripteur du bean
utilisé lors de la phase de déploiement
UXQ$V0RGH&/,(17B,'(17,7<63(&,),('B,'(17,7<6<67(0B,'(17,7<
5XQ$V,GHQWLW\ : <identité> si 63(&,),('B,'(17,7<
 [Monson, p75]
Sécurité
Exemple
Principaux bénéfices

• Application complexe “facile” à écrire

• gestion des transaction de manière déclarative
• gestion de la persistance
• gestion intégré de la sécurité
• gestion de la répartition
• La plate-forme et le bus logiciel (middleware) sont
indépendants des applications
• Extensibilité du modèle
Processus de Développement, de
Déploiement et de Exécution
■ Développement d’un EB
• Ecrire la classe Primary Key (pour un “entity bean”)
• Ecrire la Home interface
• Ecrire la Remote interface
• Ecrire l’ implémentation du bean
• Compiler ces classes et interfaces
■ Déploiement du EB
• Construire le descripteur de déploiement (deploytool)
• Construire le fichier d’ archive .ear
• Vérifier le fichier d ’ archive
■ Exécution du EB
• Activer j2ee
• Exécuter le client
• qui peut être une servlet (éventuellement dans un .war déployé)
• ou une application Java
Exemple:
Beans Bancaires

■ Gestion de comptes bancaires

• Compte Bancaire (Composant persistant ➙ Entity Bean)
• Interface du Bean(vue par le client) ➙ [Link]
SXEOLFLQWHUIDFH$FFRXQWH[WHQGV (-%2EMHFW^
SXEOLFGRXEOHJHW%DODQFHWKURZV5HPRWH([FHSWLRQ
SXEOLFYRLGVHW%DODQFHGRXEOHGWKURZV5HPRWH([FHSWLRQ
SXEOLF6WULQJJHW&XVWRPHUWKURZV5HPRWH([FHSWLRQ
SXEOLFYRLGFUHGLWGRXEOHGWKURZV5HPRWH([FHSWLRQ
SXEOLFYRLGGHELWGRXEOHGWKURZV5HPRWH([FHSWLRQ `
• Transfert de Fond (Composant session ➙ Session Bean)
• Interface du Bean (vue par le client) ➙ [Link]
SXEOLFLQWHUIDFH7UDQVIHUH[WHQGV (-%2EMHFW^
SXEOLFGRXEOHWUDQVIHU)XQG$FFRXQW3.NVUF$FFRXQW3.NWUJ
GRXEOHGWKURZV5HPRWH([FHSWLRQ
SXEOLFGRXEOHWUDQVIHU)XQG$FFRXQWVUF$FFRXQWWUJ
GRXEOHGWKURZV5HPRWH([FHSWLRQ `
Architecture de l’application

RMI ext conteneur

EJB home stub EJB Home object

Client
distant (-%
&RPSWH
EJB object stub
RMI ext EJB Object %DQFDLUH

-'%&;$

-70
Oracle ou
Espace d’ adressage du client Espace d’ adressage du conteneur Instant DB

50,H[W H[WHQVLRQGH50,DILQ GHSURSDJHU OHFRQWH[WH GHODWUDQVDFWLRQFRPPH XQ

SDUDPqWUH VXSSOpPHQWDLUHRXXWLOLVDWLRQGH,,23
Exemple d ’Entity Bean
Account
• Spécification du bean
• entity bean “Account”
• gestion de la persistance gérée par le conteneur
• Le concepteur doit écrire le code suivant
• $FFRXQW+RPHMDYD
l’ interface de gestion du bean - Home interface
• $FFRXQWMDYD
l’ interface d’ accès à distance - Remote Interface
• $FFRXQW3.MDYD
La classe pour la gestion des clés d’ accès aux différents comptes - Primary Key
class (nécessaire uniquement pour les “entity beans”, encapsule le champ représentant la
clé primaire d’ un “entity bean” dans un objet)
• $FFRXQW%HDQMDYD
le code du bean
• le descripteur pour le déploiement
$FFRXQW3.MDYD
La clé primaire du compte
• représente la clé primaire
• n’ est pas toujours nécessaire
cas d’ une clé primaire non composée
• mais la classe doit implementer l’ interface Serializable
SDFNDJH%DQN
SXEOLFFODVV$FFRXQW3.LPSOHPHQWV MDYDLR6HULDOL]DEOH ^
SXEOLFLQWEUDQFKQR
SXEOLFLQWDFFQR

SXEOLF$FFRXQW3.LQWEUDQFKQRLQWDFFQR^
WKLVEUDQFKQR EUDQFKQRWKLVDFFQR DFFQR`
SXEOLF$FFRXQW3.^`
SXEOLF6WULQJWR6WULQJ^
UHWXUQ6WULQJYDOXH2IEUDQFKQR6WULQJYDOXH2IDFFQR`
`
$FFRXQWMDYD
l ’interface distance (remote)
• donne les prototypes des méthodes “ business”
• doit étendre l’ interface [Link]

SDFNDJH%DQN

SXEOLFLQWHUIDFH$FFRXQWH[WHQGV (-%2EMHFW ^
SXEOLFGRXEOHJHW%DODQFHWKURZV5HPRWH([FHSWLRQ
SXEOLFYRLGVHW%DODQFHGRXEOHG
WKURZV5HPRWH([FHSWLRQ$FFRXQW([FHSWLRQ 
SXEOLF6WULQJJHW&XVWRPHUWKURZV5HPRWH([FHSWLRQ
SXEOLFYRLGFUHGLWGRXEOHG
WKURZV5HPRWH([FHSWLRQ$FFRXQW([FHSWLRQ
SXEOLFYRLGGHELWGRXEOHG
WKURZV5HPRWH([FHSWLRQ$FFRXQW([FHSWLRQ
`
$FFRXQWMDYD
l ’interface distance (remote)
■ Remarques
• les méthodes setX et getX correspondent à un attribut X
• les paramêtres de méthode et les valeurs de retour doivent être de type
primitif, serialisable ou étendant/implémentant [Link]
• Exceptions
• les méthodes doivent comporter au minimum RemoteException
exception “ système” : SQL, Naming, ...
• des exceptions applicatives peuvent être ajoutés

SDFNDJH%DQN
SXEOLFFODVV$FFRXQW([FHSWLRQ H[WHQGVMDYDODQJ([FHSWLRQ^
SXEOLF$FFRXQW3.SN
SXEOLF$FFRXQW([FHSWLRQ^VXSHU`
SXEOLF$FFRXQW([FHSWLRQ$FFRXQW3. SN^VXSHUWKLVSN SN`
SXEOLF$FFRXQW([FHSWLRQPVJ^VXSHUPVJ``
 $FFRXQW+RPHMDYD
l ’interface maison (home)
• donne les prototypes des méthodes
de création/suppresion et de recherche
équivalent aux Factory de CORBA
• doit étendre l’ interface [Link]
SDFNDJH%DQN
SXEOLFLQWHUIDFH$FFRXQW+RPHH[WHQGV (-%+RPH ^
SXEOLF$FFRXQWFUHDWH LQWEUDQFKQRLQWDFFQR6WULQJFXVWRPHUGRXEOHEDODQFH
WKURZV5HPRWH([FHSWLRQ&UHDWH([FHSWLRQ
SXEOLF$FFRXQWILQG%\3ULPDU\.H\ $FFRXQW3.SN
WKURZV5HPRWH([FHSWLRQ)LQGHU([FHSWLRQ
SXEOLF(QXPHUDWLRQ ILQG/DUJH$FFRXQWV GRXEOHG
WKURZV5HPRWH([FHSWLRQ)LQGHU([FHSWLRQ
SXEOLF(QXPHUDWLRQ ILQG%\&XVWRPHU 6WULQJVWU
WKURZV5HPRWH([FHSWLRQ)LQGHU([FHSWLRQ
`
$FFRXQW+RPHMDYD
l ’interface maison (home)
■ Remarques sur les méthodes de création
• comporte [Link]
• [Link] est levée s’ il existe déjà une
donnée avec la clé primaire

• peut ne pas apparaître dans l’ interface Home

• signifie que les données ne peuvent être créée
que depuis la source de données (SGBD)
par exemple, ordre SQL INSERT
$FFRXQW+RPHMDYD
l ’interface maison (home)
■ Remarques sur méthode de recherche
• comporte [Link]

• la méthode de recherche sur clé findByPrimaryKey retourne

un Account
• [Link] est levée si aucun objet n’ est
trouvé

• les autres findByPrimaryKey retournent une Enumeration de

Account ou null si aucun objet n’ est trouvé
$FFRXQW%HDQMDYD
l ’implantation de l ’Entity Bean
• doit étendre l’ interface [Link]
■ donne l’implantation
• des méthodes de gestion du cycle de vie (“ callback” )
• ejbActivate() appelé lors de l’activation
• ejbPassivate() appelé lors de la passivation
• ejbLoad() appelé pour charger l’état de l’EB depuis la BD
• ejbStore() appelé pour décharger l’état de l’EB vers la BD
• ejbRemove() appelé quand le client appelle remove()
• setEntityContext() appelé par le container quand l’instance est crée
• unsetEntityContext() appelé par le container avant de supprimer l’instance
• des méthodes “ business” de l’ interface Account
• getbalance(), setbalance(), …, credit(), debit() appelées par le client
• des méthodes de creation de l’ interface AccountHome
• ejbCreate() ejbPostCreate()
• des méthodes de recherche de l’ interface AccountHome
• ejbFindByPrimaryKey() ejbFindLargeAccounts(), ejbFindByCustomer()
$FFRXQW%HDQMDYD
l ’implantation de l ’Entity Bean

■ Les attributs
SDFNDJH%DQN
SXEOLFFODVV$FFRXQW%HDQLPSOHPHQWV(QWLW\%HDQ ^

OHVDWWULEXWV

SULYDWHWUDQVLHQW (QWLW\&RQWH[WFW[
SXEOLFLQWEUDQFKQR 3.
SXEOLFLQWDFFQR 3.
SXEOLF6WULQJFXVWRPHU
SXEOLFGRXEOHEDODQFH


$FFRXQW%HDQMDYD
l ’implantation de l ’Entity Bean
■ Les méthodes de cycle de vie
• requises par l’ interface EntityBean
SXEOLFYRLG HME$FWLYDWH^`
SXEOLFYRLG HME'HVWUR\^`
SXEOLFYRLG HME3DVVLYDWH^`
SXEOLFYRLG HME/RDG^`
SXEOLFYRLG HME6WRUH^`
SXEOLFYRLG VHW(QWLW\&RQWH[W (QWLW\&RQWH[WFW[^WKLVFW[ FW[`
SXEOLFYRLG XQVHW(QWLW\&RQWH[W ^WKLVFW[ QXOO`

$FFRXQW%HDQMDYD
l ’implantation de l ’Entity Bean
■ Les méthodes “business”
• correspond à l’ interface distante
SXEOLFGRXEOHJHW%DODQFHWKURZV5HPRWH([FHSWLRQ ^UHWXUQEDODQFH`
SXEOLFYRLGVHW%DODQFHGRXEOHGWKURZV5HPRWH([FHSWLRQ$FFRXQW([FHSWLRQ^
LIGWKURZ QHZ$FFRXQW([FHSWLRQQHZ$FFRXQW3.WKLVEUDQFKQRWKLVDFFQR
EDODQFH G`
SXEOLF6WULQJ JHW&XVWRPHUWKURZV5HPRWH([FHSWLRQ ^UHWXUQFXVWRPHU`
SXEOLFYRLG FUHGLWGRXEOHGWKURZV5HPRWH([FHSWLRQ$FFRXQW([FHSWLRQ^
LIGWKURZ QHZ$FFRXQW([FHSWLRQQHZ$FFRXQW3.WKLVEUDQFKQRWKLVDFFQR
EDODQFH G`
SXEOLFYRLG GHELWGRXEOHGWKURZV5HPRWH([FHSWLRQ$FFRXQW([FHSWLRQ^
LIG EDODQFHG
WKURZ QHZ$FFRXQW([FHSWLRQQHZ$FFRXQW3.WKLVEUDQFKQRWKLVDFFQR
EDODQFH G`

$FFRXQW%HDQMDYD
l ’implantation de l ’Entity Bean
■ Les méthodes de création
SXEOLFYRLGHME&UHDWH LQWEUDQFKQRLQWDFFQR
6WULQJFXVWRPHUGRXEOHEDODQFHWKURZV
&UHDWH([FHSWLRQ ^
LIEDODQFHWKURZ QHZ&UHDWH([FHSWLRQ
WKLVEUDQFKQR EUDQFKQR WKLVDFFQR DFFQR
WKLVFXVWRPHU FXVWRPHU WKLVEDODQFH EDODQFH
`
SXEOLFYRLGHME3RVW&UHDWH LQWEUDQFKQRLQWDFFQR
6WULQJFXVWRPHUGRXEOHEDODQFH^`
`
■ Les méthodes de recherche
• sont générés au déploiement par le container
HME)LQG%\3ULPDU\.H\ HME)LQG/DUJH$FFRXQWV HME)LQG%\&XVWRPHU 
$FFRXQW%HDQMDYD
Remarque sur les méthodes de création

• pour chaque méthode create(X) de l’ interface distante

• il y a un couple ejbCreate(X) et ejbPostCreate(X)
• ejbPostCreate(X) effectue des compléments à la création
$FFRXQW%HDQMDYD
Remarque sur les méthodes de création
$FFRXQW%HDQMDYD
Remarque sur les méthodes de synchronisation ejbLoad() et
ejbStore()
■ Container-Managed Persistence
• en principe, ne font rien
• néanmoins, elles peuvent être complétées
pour formater des données commplexes, …
SXEOLFFODVV6WULQJV%HDQLPSOHPHQWV(QWLW\%HDQ ^
SULYDWHWUDQVLHQW(QWLW\&RQWH[WFW[
SULYDWHWUDQVLHQW9HFWRUPVJYHF
SXEOLF6WULQJPVJV3HUVLVWHQWILHOGGDQVXQHFRORQQH9$5&+$5
SXEOLFYRLGHME/RDG^
6WULQJ7RNHQL]HUVW QHZ6WULQJ7RNHQL]HUPVJVa
ZKLOHVWKDV0RUH7RNHQVPVJYHFDGG(OHPHQWVWQH[W7RNHQ
``
Descripteur de déploiement (addendum)

■ Si la persistance est gérée par le conteneur, le

Bean fournisseur/installateur doit spécifier, dans
l’environnement les propriétés du Bean
• le lien avec la base de données
[Link] jdbc_oracle1
[Link] Account
[Link] branchid
[Link] accountid
[Link] customer
[Link] balance
• la méthode de recherche du bean
[Link] where balance > ?
[Link] where customer like ?
$FFRXQW%HDQMDYD
Remarque sur la persistance gérée par le bean
(Bean-Managed Persistence)

• Les méthodes de création, de suppression, de synchronisation

et de recherche doivent être codé par le développeur
■ Exemple avec ejbCreate()
SXEOLFYRLGHME&UHDWH LQWEUDQFKQRLQWDFFQR6WULQJFXVWRPHUGRXEOH
EDODQFH
WKURZV&UHDWH([FHSWLRQ ^
LIEDODQFHWKURZ QHZ&UHDWH([FHSWLRQ
WKLVEUDQFKQR EUDQFKQR WKLVDFFQR DFFQR
WKLVFXVWRPHU FXVWRPHU WKLVEDODQFH EDODQFH
&RQQHFWLRQ FRQ QXOO3UHSDUHG6WDWHPHQWSV QXOO
WU\ ^FRQ JHW&RQQHFWLRQSV FRQSUHSDUH6WDWHPHQW
LQVHUWLQWR$FFRXQW EUDQFKLGDFFRXQWLGFXVWRPHUEDODQFHYDOXHV""""
SVVHW,QWEUDQFKQR SVVHW,QWDFFQR
SVVHW6WULQJFXVWRPHU SVVHW'RXEOHEDODQFH
LISVH[HFXWH8SGDWH ^
WKURZ QHZ&UHDWH([FHSWLRQ )DLOHG WRDGG$FFRXQW WRGDWDEDVH
`FDWFK64/([FHSWLRQVH^WKURZ QHZ&UHDWH([FHSWLRQ VHJHW0HVVDJH
`
$FFRXQW%HDQMDYD
Remarque sur la persistance gérée par le bean
(Bean-Managed Persistence)

■ Exemple avec ejbLoad()

SXEOLFYRLGHME/RDG WKURZV5HPRWH([FHSWLRQ^
$FFRXQW3.SN $FFRXQW3.FRQWH[WJHW3ULPDU\.H\
&RQQHFWLRQ FRQ QXOO3UHSDUHG6WDWHPHQWSV QXOO5HVXOW6HWUHVXOW QXOO
WU\ ^FRQ JHW&RQQHFWLRQSV FRQSUHSDUH6WDWHPHQW
VHOHFWFXVWRPHUEDODQFHIURP$FFRXQWZKHUHEUDQFKLG "DQG
DFFRXQWLG "
SVVHW,QWSNEUDQFKQRSVVHW,QWSNDFFQR
UHVXOW SVH[HFXWH4XHU\
LIUHVXOWQH[W^
EUDQFKQR SNEUDQFKQRDFFQR SNDFFQR
FXVWRPHU UHVXOWJHW6WULQJFXVWRPHU
EDODQFH UHVXOWJHW'RXEOHEDODQFH
`HOVH^WKURZ QHZ2EMHFW1RW)RXQG([FHSWLRQ&DQQRWILQG$FFRXQWSN`

Creation des instances
Home interface

Create(...)
newInstance()

Account Account
Client Home setEntityContext() Bean

ejbCreate(...)
Account Ref

Container
 Le client (Application Java)

LPSRUWEDQN 
SXEOLFFODVV&OLHQW&UHDWH^
SXEOLFVWDWLFYRLGPDLQ6WULQJ>@DUJY^
$FFRXQW+RPHDK$FFRXQWD
WU\^ UHFKHUFKHUO·LQWHUIDFH (-%KRPHLQWHUIDFH
,QLWLDO&RQWH[WFW[ QHZ,QLWLDO&RQWH[W
2EMHFWREMUHI FW[ORRNXS%DQN$FFRXQW
DK $FFRXQW+RPH3RUWDEOH5HPRWH2EMHFWQDUURZREMUHI$FFRXQW+RPHFODVV
`FDWFK1DPLQJ([FHSWLRQ^1DPLQJ([FHSWLRQSULQW6WDFN7UDFH`
FUpHUXQHLQVWDQFHG·HQWLWp
D DKFUHDWHDUJY>@DUJY>@DUJY>@
 LQYRTXHUXQHPpWKRGH ´EXVLQHVVµ
6\VWHPHUUSULQWOQDJHW&XVWRPHU
`
 Le client (Application Java) EJB1.1

LPSRUWEDQN 
SXEOLFFODVV&OLHQW&UHDWH^
SXEOLFVWDWLFYRLGPDLQ6WULQJ>@DUJY^
$FFRXQW+RPHDK$FFRXQWD
WU\^ UHFKHUFKHUO·LQWHUIDFH (-%KRPHLQWHUIDFH
,QLWLDO&RQWH[WFW[ QHZ,QLWLDO&RQWH[W
2EMHFWREMUHI FW[ORRNXSjava:comp/env/ejb/%DQN$FFRXQW
DK $FFRXQW+RPH3RUWDEOH5HPRWH2EMHFWQDUURZREMUHI$FFRXQW+RPHFODVV
`FDWFK1DPLQJ([FHSWLRQ^1DPLQJ([FHSWLRQSULQW6WDFN7UDFH`
FUpHUXQHLQVWDQFHG·HQWLWp
D DKFUHDWHDUJY>@DUJY>@DUJY>@
 LQYRTXHUXQHPpWKRGH ´EXVLQHVVµ
6\VWHPHUUSULQWOQDJHW&XVWRPHU
`
Méthodes de l’application
Remote interface

setBalance()
Begin

Account
Account
Client setBalance() Bean
EJB Object

commit
 Le client (Application Java)

LPSRUWEDQN 
SXEOLFFODVV&OLHQW6HW%DODQFH^
SXEOLFVWDWLFYRLGPDLQ6WULQJ>@DUJY^
$FFRXQW+RPHDK$FFRXQWD
WU\^ UHFKHUFKHUO·LQWHUIDFH (-%KRPHLQWHUIDFH
,QLWLDO&RQWH[WFW[ QHZ,QLWLDO&RQWH[W
2EMHFWREMUHI FW[ORRNXS%DQN$FFRXQW
DK $FFRXQW+RPH3RUWDEOH5HPRWH2EMHFWQDUURZREMUHI$FFRXQW+RPHFODVV
`FDWFK1DPLQJ([FHSWLRQ^1DPLQJ([FHSWLRQSULQW6WDFN7UDFH`
FUpHUXQHLQVWDQFHG·HQWLWp
WU\^
D DKILQG%\3ULPDU\.H\QHZ$FFRXQW3.DUJY>@DUJY>@
`FDWFK)LQGHU([FHSWLRQ^)LQGHU([FHSWLRQSULQW6WDFN7UDFH`
 LQYRTXHUXQHPpWKRGH´EXVLQHVVµ
DVHW%DODQFHDUJY>@
`
 Le client (Servlet 1/2)

LPSRUW
SXEOLFFODVV6HW%DODQFH6HUYOHWH[WHQGV+WWS6HUYOHW ^
$FFRXQW+RPH DK
SXEOLFYRLGLQLW6HUYOHW&RQILJFRQILJWKURZV6HUYOHW([FHSWLRQ^
WU\^
,QLWLDO&RQWH[WFW[ QHZ,QLWLDO&RQWH[W
2EMHFWREMUHI FW[ORRNXS%DQN$FFRXQW
DK $FFRXQW+RPH3RUWDEOH5HPRWH2EMHFWQDUURZREMUHI$FFRXQW+RPHFODVV
`FDWFK1DPLQJ([FHSWLRQ^1DPLQJ([FHSWLRQSULQW6WDFN7UDFH`
`

SXEOLFYRLG GHVWUR\^
6\VWHPRXWSULQWOQ'HVWUR\
`

 Le client (Servlet 2/2)

SXEOLFYRLGGR*HW +WWS6HUYOHW5HTXHVWUHTXHVW+WWS6HUYOHW5HVSRQVHUHVSRQVH
WKURZV6HUYOHW([FHSWLRQ,2([FHSWLRQ^
UHVSRQVHVHW&RQWHQW7\SHWH[WKWPO
3ULQW:ULWHU RXW UHVSRQVHJHW:ULWHU
RXWSULQWOQ+70/!+($'!7,7/(!6HW%DODQFH7,7/(!+($'!%2'<!
LQWDFFQR QHZ,QWHJHUUHTXHVWJHW3DUDPHWHU$&&12LQW9DOXH
LQWEUDQFKQR QHZ,QWHJHUUHTXHVWJHW3DUDPHWHU%5$1&+12LQW9DOXH
$FFRXQW3.SN QHZ $FFRXQW3.EUDQFKQRDFFQR
GRXEOHQHZEDODQFH QHZ'RXEOHUHTXHVWJHW3DUDPHWHU%$/$1&(GRXEOH9DOXH
WU\^
$FFRXQWD DKILQG%\3ULPDU\.H\SN DVHW%DODQFHQHZEDODQFH
RXWSULQWOQ+!1HZ%DODQFH+!
RXWSULQWOQ3!$FFRXQW SN 3!3!1HZ%DODQFHDJHW%DODQFH 3!
`FDWFK)LQGHU([FHSWLRQ^RXWSULQWOQ+!3UREOHP+!3!1R $FFRXQW SN 3!`
RXWSULQWOQ%2'<!+70/!RXWFORVH
``
Descripteur de déploiement

Home interface $FFRXQW+RPH

Remote interface $FFRXQW

Enterprise Bean $FFRXQW%HDQ

Account BeanHomeName ´%DQN$FFRXQWµ

Deployment
Descriptor
ControlDescriptors 7;B68332576

'DWD6RXUFHQDPH
Env. properties 

ContainerManagedFields EUDQFKQR DFFQR

FXVWRPHUEDODQFH
Gestion déclarative
des transactions
• Support du conteneur pour les transactions
• le conteneur utilise les attributs de transaction pour réaliser la politique
souhaitée
• Attributs des transactions

7;B127B6833257('
7;B1(9(5

7;B5(48,5('

7;B68332576

7;B5(48,5(6B1(:
7;B0$1'$725<

7;B%($1B0$1$*('
 Gestion des transactions

Le conteneur gère les

transaction à l’aide des preInvoke() {
classes d’interposition qui case TX_REQUIRES_NEW:
sont générées clientTransaction=[Link]();
automatiquement [Link]();
postInvoke(){
[Link] case TX_REQUIRES_NEW:
[Link]();
[Link](clientTransaction);

public void setBalance(double d){

[Link] [Link]();
[Link](d);
[Link]();
Exemple de Session Bean
Transfer
• Spécification du bean
• session bean “ Transfer”
• Le concepteur doit écrire le code suivant
• 7UDQVIHU+RPHMDYD
l’ interface de gestion du bean - Home interface
• 7UDQVIHUMDYD
l’ interface d’ accès à distance - Remote Interface
• 7UDQVIHU%HDQMDYD
le code du bean
• le descripteur pour le déploiement
• pas de TransferPK !!
7UDQVIHUMDYD
l ’interface distance (remote)
• donne les prototypes des méthodes “ business”
• doit étendre l’ interface [Link]

SDFNDJH%DQN

SXEOLFLQWHUIDFH7UDQVIHUH[WHQGV (-%2EMHFW ^
SXEOLFYRLGIXQG7UDQVIHU$FFRXQW3. VUF$FFRXQW3. WUJGRXEOHDPRXQW
WKURZV5HPRWH([FHSWLRQ$FFRXQW([FHSWLRQ
`
 7UDQVIHU+RPHMDYD
l ’interface maison (home)
• donne les prototypes des méthodes
de création
• doit étendre l’ interface [Link]

SDFNDJH%DQN
SXEOLFLQWHUIDFH7UDQIHU+RPHH[WHQGV (-%+RPH ^
SXEOLF7UDQIHUFUHDWH WKURZV5HPRWH([FHSWLRQ&UHDWH([FHSWLRQ
`
7UDQVIHU%HDQMDYD
l ’implantation du Session Bean
• doit étendre l’ interface [Link]
■ donne l’implantation
• des méthodes de gestion du cycle de vie (“ callback” )
• ejbActivate() appelé lors de l’activation
• ejbPassivate() appelé lors de la passivation
• ejbLoad() {} inutilisé mais présent
• ejbStore() {} inutilisé mais présent
• ejbRemove() appelé quand le client appelle remove()
• setEntityContext() appelé par le container quand l’instance est crée
• unsetEntityContext() appelé par le container avant de supprimer l’instance
• des méthodes “ business” de l’ interface Account
• fundTransfer() appelée par le client
• des méthodes de creation de l’ interface AccountHome
• ejbCreate() ejbPostCreate()
7UDQVIHU%HDQMDYD
l ’implantation du Session Bean
SDFNDJH%DQN
SXEOLFFODVV7UDQVIHU%HDQLPSOHPHQWV6HVVLRQ%HDQ ^
SULYDWHWUDQVLHQW (QWLW\&RQWH[WFW[
SULYDWH$FFRXQW+RPHDK

SXEOLFYRLGIXQG7UDQVIHU$FFRXQW3.VUF$FFRXQW3.WUJGRXEOHDPRXQW
WKURZV 5HPRWH([FHSWLRQ$FFRXQW([FHSWLRQ ^
WU\^$FFRXQWDVUF DKILQG%\3ULPDU\.H\VUF
`FDWFK)LQGHU([FHSWLRQH^WKURZ QHZ$FFRXQW([FHSWLRQVUF`
WU\ ^$FFRXQWDWUJ DKILQG%\3ULPDU\.H\WUJ
`FDWFK)LQGHU([FHSWLRQ H^WKURZ QHZ$FFRXQW([FHSWLRQWUJ`
DVUFGHELWDPRXQW
DWUJFUHGLWDPRXQW
`

7UDQVIHU%HDQMDYD
l ’implantation du Session Bean

PpWKRGHVUHTXLVHVSDUO·LQWHUIDFH6HVVLRQ%HDQ
SXEOLFYRLG HME$FWLYDWH^`
SXEOLFYRLG HME'HVWUR\^`
SXEOLFYRLG HME3DVVLYDWH^`
SXEOLFYRLG HME/RDG^`
SXEOLFYRLG HME6WRUH^`
SXEOLFYRLG VHW(QWLW\&RQWH[W (QWLW\&RQWH[WFW[^WKLVFW[ FW[`
SXEOLFYRLG XQVHW(QWLW\&RQWH[W ^WKLVFW[ QXOO`

7UDQVIHU%HDQMDYD
l ’implantation du Session Bean
SXEOLFYRLGHME&UHDWH WKURZV&UHDWH([FHSWLRQ ^
WU\^
,QLWLDO&RQWH[WFW[ QHZ,QLWLDO&RQWH[W
2EMHFWREMUHI FW[ORRNXS7UDQVIHU
WKLVDK $FFRXQW+RPH3RUWDEOH5HPRWH2EMHFWQDUURZ
REMUHI7UDQVIHU+RPHFODVV
`FDWFK1DPLQJ([FHSWLRQ^WKURZ QHZ&UHDWH([FHSWLRQ`
`

SXEOLFYRLGHME3RVW&UHDWH 
^`
`
Gestion de la sécurité
Stratégies de Conception

■ Amélioration des performances avec un session bean

• Entity-Bean : grain fin / Session Bean : gros grain
• réduction du trafic réseau et de la latence
Limites : La réentrance

■ La réentrance

• Exemple
SXEOLFFODVV$B%HDQLPSOHPHQWV(QWLW\%HDQ ^$HVWO ·LQWHUIDFHGLVWDQWH
SULYDWHWUDQVLHQW (QWLW\&RQWH[WFW[
SXEOLFYRLGPHWKRGB^
%E «UpFXSqUHXQHUpIpUHQFHGLVWDQWH
$P\VHOI $FW[JHW(-%2EMHFW
EPHWKRGBP\VHOI``
SXEOLFFODVV%B%HDQLPSOHPHQWV(QWLW\%HDQ ^%HVWO ·LQWHUIDFHGLVWDQWH
SULYDWHWUDQVLHQW (QWLW\&RQWH[WFW[
SXEOLFYRLGPHWKRGB$D^DPHWKRGB ORRSEDFN  ``
Limites : La réentrance

• interdit pour les session bean

• autorisé mais déconseillé pour les entity bean
■ Problème
• pas de différence
entre multithreading multiclient et réentrance
Relations entre composants CORBA 3.0
et les EJB
■ Un EJB peut être placé dans un conteneur de composants
CORBA
■ Un composant CORBA écrit en Java et utilisant seulement
les APIs EJB peut être mis dans un conteneur EJB
■ Correspondance entre les APIs EJB et les APIs CORBA
Components
EJB vs MTS

■ Voir Gopalan
• [Link]
Outils de Développement

■ Bases de Données
■ Moniteurs Transactionnels
■ Serveurs Applicatifs
■ Outils de programmation
Outils de Développement

■ WebLogic ■ Forte
■ IBM ■ Progress
■ Oracle ■ Novell
■ GemStone ■ Novera
■ BEA ■ Borland
■ Borland ■ Informix
■ Netscape ■ IONA
■ Lotus ■ Allaire
■ SilverStream ■ EJBHome, JOnAS, ...
J2EE
Java 2 Enterprise Edition
• Spécifie la plateforme complet Java pour des applications
multi-tiers (vs J2SE,J2ME)
■ Architecture
Applet Container Web Container EJB Container

Applet Servlet
EJB
JSP
J2SE
JMS, JNDI, JTA, JMS, JNDI, JTA,
Application Client JDBC, RMI(IIOP) JDBC, RMI(IIOP)
Container Java Mail, JAF Java Mail, JAF
Application
client J2SE J2SE

JMS, JNDI,
RMI(IIOP), JDBC

J2SE Database
J2EE
Java 2 Enterprise Edition
■ Deux types de composants J2EE
• Web Component (fichier JAR .war)
• Servlet, JSP, HTML (formulaire associé à une servlet)
• EB Component (fichier JAR .ear)
• Entity Bean, Session Bean
■ Plateforme de référence
• SUN j2sdkee
Java ONE (Open Net Environment)

■ Annoncé le 5/2/2001
■ Ajout des « standards » Web Services dans J2EE
• SOAP, WSDL, UDDI, ebXML, …
■ Nouvelles API
• Context API
Interface vers les données contextuelles d’ un service Web
• JAX/RPC (Java API for XML based RPC)
Interface aux protocoles de transport de message XML de type RPC (SOAP, W3C
XP, … )
• JAXB (Java API for XML Data Binding)
Correspondance automatique entre des objets Java et des données XML
• JAXM (Java API for XML Messaging)
Interface aux protocoles de transport de messages XML : SOAP, ebXML Message
Service, …
• JAXP (Java API for XML Processing)
Gestion des arborescence DOM
• JAXR (Java API for XML Registries)
Interface aux annuaires ebXML Registry/Repository et UDDI Business Registry
Les spécifications EJB

■ EJB 1.0
■ EJB 1.1
• JDBC 2.0, Descripteurs XML
• contexte standard JNDI
■ EJB 2.0
• Connector
• Message Driven Bean (JMS), ...
■ La suite
• Héritage ?
• Réentrance ?
• Modèles de transaction avancées ?
EJB 2.0 What’ new

■ Abstract Persistente State

■ What is persistent state ?
■ Notion of « dependent classes »
■ Can be pluggable
■ Relationship
• EJB1.1 coded by the developper
• in 2.0 ??

■ New methods : Select

• can b
• ejBSelect<type>
• ejbSelect<type>inEntity
■ New ejbHome methods
Persistence

■ Abstract Persistente State

■ What is persistent state ?
■ Notion of « dependent classes »
■ Can be pluggable
■ Relationship
• EJB1.1 coded by the developper
• in 2.0 ??

■ New methods : Select

• can b
• ejBSelect<type>
• ejbSelect<type>inEntity
■ New ejbHome methods
EJB QL (Query Language)

■ SQL like
• used to specified finder and select
■ Form of Query
• [Select_clause] From_clause [Where_Clause]
• Navigation
■ Query
• static in DD
• has parameters that corresponds to finder/select methods
parameters
• can use finder methods of other entity beans
EJB QL (Query Language)
Example
■ No SELECT and navigation
)5202UGHU%HDQ RO,1ROLQH,WHPV
:+(5(OSURGXFWSURGXFWBW\SH "
■ SELECT and @@ operator
6(/(&7##R
)5202UGHU%HDQ R2UGHU%HDQ R
:+(5(RTXDQWLW\ !RTXDQWLW\ $1'
RFXVWRPHUODVWQDPH ¶6PLWK·$1'
RFXVWRPHUILUVWQDPH ¶-RKQ·
■ SELECT and @@ operator
6(/(&7O !SURGXFW )5202UGHU%HDQ $6RO,1ROLQH,WHPV
6(/(&7OSURGXFW )5202UGHU%HDQ $6RO,1ROLQH,WHPV ,OOHJDO
JMS Integration

• publisher
• bean can send message
• subscriber - Message Driven Bean
• new EJB bean type
• similar to Stateless Session Bean
• transaction attribute of onMessage()
Only : NotSupported, Required
» The use of the other transaction attributes is not meanigful for
message-driven beans because there can be no pre-existing
transaction context (RequiresNew, Supports) and no client to
handle exceptions (Mandatory, Never).
• Transaction
• Receive/Send Messages can be in a transaction scope
MessageDrivenBean

■ Subscriber of an JMS Queue or Topic

■ package [Link];
import [Link];
import [Link];

public interface MessageDrivenBean extends MessageListener{

public void onMessage(Message message);
public void ejbCreate();
public void ejbRemove();
public void setMessageDrivenContext(MessageDrivenContext mdc);
}
MessageDrivenBean
Exemple
SXEOLFFODVV0DUNHWLQJ%HDQLPSOHPHQWVMDYD[HME0HVVDJH'ULYHQ%HDQ ^

SXEOLFYRLGRQ0HVVDJH0HVVDJHPHVVDJH^

2EMHFW0HVVDJHRUGHU0HVVDJH 2EMHFW0HVVDJHRUGHU0HVVDJH

2UGHU'HWDLORUGHU'HWDLO 2UGHU'HWDLORUGHU0HVVDJHJHW2EMHFW

,QWHJHUFXVWRPHU,' RUGHU'HWDLOJHW&XVWRPHU,'

,QLWLDO&RQWH[WMQGL(QF QHZ,QLWLDO&RQWH[W
&DWDORJ+RPHFDWDORJ+RPH 
&DWDORJ+RPHMQGL(QFORRNXSMDYDFRPSHQYHMEFDWDORJ

,WHUDWRUSURGXFW,'V RUGHU'HWDLOJHW3URGXFWV,'V
ZKLOHSURGXFW,'VKDV1H[W^
,QWHJHUSURGXFW,' ,QWHJHUSURGXFW,'VQH[W
&DWDORJFDW &DWDORJ+RPHILQG%\3URGXFW,'SURGXFW,'
FDWDGG&XVWRPHU7R0DLOLQJ/LVWFXVWRPHU,'
`
`
`
Timer Service

■ Business Work-Flows or Process-Flows

• rely on timed notifications.
■ EJB Timer service
• Notify beans (except SF SB) but must implement
[Link]
• Schedule
• at a specific time (« at 10:30 AM on May 23 »),
• after a duration of time (« in 30 days »)
• or at timed intervals (« every 12 hours »).
• Call the ejbTimeout method of the bean's implementation
class defined by the [Link] interface
■ 4 interfaces in the [Link]
• TimedObject, Timer, TimerHandle, TimerService
EMB (Enterprise Media Beans) -65

■ Motivations
• Intégration des données multimedia (orienté Streaming) dans
les applications J2EE (EJB-JSP/JSF/Servlet)
■ 2 types de composants EMB
 Architecture d’applications
utilisant des EMB
+70/60,/
:HE6HUYHU (-%6HUYHU
+773
web cam site

blah blah
blah blah
blah blah
blah blah
blah blah

5'%06(53
6HUYOHW
6HUYOHW
03(*« (QWHUSULVH -'%&
)LOWHU
)LOWHU (QWHUSULVH
50,66/ %HDQV 'DWD6RXUFH
JMF 5763 -63-6)
-63-6) %HDQV -&$
RealOne ,,2366/
WMP, …

[+70/60,/ (QWHUSULVH
(QWHUSULVH
+773 6WUHDPLQJ 0HGLD%HDQV
0HGLD%HDQV
6HUYHU
03(*« 6WUHDP
5HSRVLWRU\ 0HGLD
0HGLD
5763 0HWDGDWD 3OXJLQ
J2ME 3OXJLQ
Mobile Media 5HSRVLWRU\
API (JSR135)
Composants EMB

■ Media Foundation Beans

• 7UDQVLHQWORFDOLPPXWDEOH
• Services
• Extraction des metadatas (durée d’ une chanson, … )
• Conversion de formats, ajout d’ information (watermark, … )
• Analyse des capacités du terminal (CC/PP)
• Architectures à plugin
• Media Format Plug, Media Converter
■ Media Entity Beans
• Représente des objets multimédia
• 3HUVLVWHQW (Primary Key) et PRGLILDEOHHWREVHUYDEOH
• Les objets multimédia peuvent être liés les uns aux autres
• Inclusion, prédecesseur/sucesseur, content/representant (thumbnail), …
• Intégration VHDPOHVV dans une application J2EE
• Les streams sont opaques et stockés sur des sources externes
• BLOB, UDT, url [Link] url rtsp:// …
Exemple d’application
utilisant des EB et des EMB
■ Emmy Award
EMB - Media Foundation Beans
EMB - Media Entity Beans
Components and interactions
Interoperablity

• Distribution
• Transaction (optional)
• TX propagation rely on OTS TX propagation
• Naming
• CoCosNaming
• Client
• Security
• CORBA IIOP CSIv2lebvel 1
• SSL, TSL
Transaction

• Message Driven bean issues

• not propogation via JMS
• bean can only NOT_SUPPORTED or REQUIRED
• onMessage()
• Local Optimisation
• on commit ?
Connection Factory
Future

• Deferred features
• Pluggable Persistence Manager
• Support for method interceptor
• Support for Component based inheritance
• Read-Only Beans with CMP (optimisation
• Aggregate operations for EJB QL finder method
• Related
• Java Connector Specification
API
• Question about JOS (
Web Services

■ * Support for the use of Message-Driven Beans with JAXM

messaging.
• Enterprise JavaBeans 2.0 introduced the message-driven bean as a new component
• type in the EJB architecture. Use of message-driven beans in EJB 2.0, however, is
• limited to the Java Message Service API. With the growing need for Enterprise
• JavaBeans to support use with web services, it becomes important to extend the
use
• of message-driven beans to support JAXM (the Java APIs for XML Messaging) in
• addition to JMS. This will support the asynchronous delivery of XML business
• documents by means of the message-driven bean type.
■ * Support for Web Services Usages
• Enterprise JavaBeans 2.1 will include support for the necessary elements to
enable
• enterprise beans usage with web services. This will include, among other items,
• expanding the environment support and deployment descriptor infrastructure for
• enterprise beans that use JAX-RPC and JAXM to access service endpoints or to
• implement web service endpoints.
■ [Link]
Pont avec DCOM et CORBA

■ Pont avec DCOM

• COM Client invoque EJB Server
• EJB Client invoque COM Server
• Spécification SUN J2EE CAS

■ Pont avec CORBA

• © (QWHUSULVH-DYD%HDQV70 &RPSRQHQWVDQG &25%$
&OLHQWV ª[Link]
iiop/[Link]
XDocLet

■ Motivation
• Inclure les informations de déploiement dans les
commentaires des sources du bean
• Pour en générer les fichiers de déploiement
■ Outillage
• Basé sur les DocLet (JavaDoc)
• Tache ANT
<taskdef
name="ejbdoclet"
classname="[Link]"
/>
Exemple XDocLet
/**
* @[Link]
* name="CustomerBean"
* type="CMP"
* view-type="both"
* primkey-field="id"
* @[Link]
* remote-class="[Link]"
* local-class="[Link]"
* @[Link]
* remote-class="[Link]"
* local-class="[Link]"
* @ejb:pk
* class="[Link]"
* @ejb:finder
* signature= "[Link] findAllCustomers()"
* query ="SELECT OBJECT(c) FROM CustomerBean AS c"
* @ejb:transaction
type="Required"
*/
public abstract class CustomerBean implements EntityBean { …
}
Bibliographie

■ Homepage EJB et J2EE

• [Link]
• [Link]
■ Pour pratiquer
• L’ implantation de référence J2EE
• [Link]
• Le Tutorial de Sun
• [Link]
• JOnAS un “ J2EE” Open-Source (made in France)
• [Link]
• OpenEJB un autre “ J2EE” Open-Source (made in France)
• [Link]
• Tutorial de Gopalan
• [Link]
• Le Training de jGuru
• [Link]
Performances et Benchmarks
■ ECPerf Version 1.0 (Draft 02/2001)
• Pas de charge de travail induite par l’ interface utilisateur (génération des pages de
présentation HTML)
• Ni aux performances des serveurs bases de données (Entrée-Sorties disque, Contrôle de
concurrence, gestion des buffers, … )
• S’ interesse à la capacité du container d’ EJB de gérer l’ usage de de la mémoire, le cache , les
pools de connexions aux SGBDs, l’ activation et la passivation des Beans, …
■ Modèle d’applications
• bases de données et les charges de travail de 4 domaines d’ activité d’ une entreprise:
Fabrication (Manufacturing), Fournisseur (Supplier), Clientèle (Customer), et Société
(Corporate).
■ Mesures
• BBops/min (Benchmark Business Operations Per Minute)
• qui est la somme des transactions de prises de commande du domaine Clientèle et des ordres de
fabrication du domaine Fabrication par minute.
• $/Bbops
• la mesure économique qui est le ratio performance sur prix du matériel, du logiciel et d’ une année de
maintenance.
■ [Link] [Link]
Bibliographie
Livres
■ Ed Roman, Scatt Ambler, Tyler Jewell, Mastering Entreprise Javabeans, End
edition, 2002, Ed Wiley, ISBN 0-471-41711-4
• Très complet
• Existe en version électronique téléchargeable
■ Richard Monson-Haefel, “ Enterprise JavaBeans ”, 1st Edition June 1999
(est.), ISBN 1-56592-605-6, Ed O'
Reilly
• seconde édition, Mars ??? 2000, ISBN ????
• Livre consacré aux EJB(spec 1.1). l ’ exemple développé dans le livre est de la Réservation de
Croisières
• Andrew Patzer , "Programmation Java côté serveur : Servlets, JSP et EJB", Ed
Eyrolles-Wrox, 2000, ISBN 1-861002-77-7 (sources des exemples sur
[Link])
• chapitres 23
• [Link]
• [Link]
Bibliographie
Livres
■ Robert Orfali, Dan Harkey, “ Client/Server Programming with Java and Corba ”,
2ème édition, 1998, Ed Wiley, ISBN 0-471-24578-X.
• Livre plutôt orienté CORBA, le chapitre 34 est consacré aux EJB et l ’ exemple développé dans le
livre(Réservation de Hôtel/Sejour) est transposé aux EJB
■ Andreas Vogel, Madhav Rangarao, “ Programming Enterprise Javabeans, JTS
and OTS : Building Distributed Transactions With Java and C++ ”, 1999, Ed
John Wiley & Sons; ISBN 0-471-31972-4
• Livre plutôt orienté OTS/JTS, le dernier chapitre est consacré au EJB et l ’ exemple développé dans
le livre(Réservation de Billet d ’ Avion) pour OTS est transposé aux EJB.
Sources du Cours

■ Ce cours a été construit à partir des présentations

et des livres de :
• Michel Riveill
• Philippe Merle
• Gérard Vandome
• Tom Valesky
• Richard Monson-Haefel
• Monica Pawlan
• Gopalan Suresh Raj
• Marek Prochazka (University of Charles, Pragues)
Limites

■ Limited set of Component Mode

• Entity, session, message-driven

■ Change usage of service

• Eg how to add TX attributes
■ Single level component

■ EJB app is a set of isolated beans

• No implicit access restriction
■ EjB do not supported shared instances
• Only a bean’ s home can be shared
■ Proposal EOA

■ POA for EJB

• Intercepts methods invocations