des enterprise beans - Département Informatique
des enterprise beans - Département Informatique
des enterprise beans - Département Informatique
You also want an ePaper? Increase the reach of your titles
YUMPU automatically turns print PDFs into web optimized ePapers that Google loves.
Guide du développeur<br />
Enterprise JavaBeans<br />
VERSION 5<br />
Borland ®<br />
JBuilder
Consultez le fichier DEPLOY.TXT situé dans le répertoire redist de JBuilder pour avoir la liste complète <strong>des</strong> fichiers<br />
que vous pouvez distribuer en accord avec votre contrat de licence JBuilder.<br />
Les applications mentionnées dans ce manuel sont brevetées par Borland Software Corporation ou en attente de<br />
brevet. Ce document ne donne aucun droit sur ces brevets.<br />
COPYRIGHT © 1997, 2001 Borland Software Corporation. Tous droits réservés. Tous les produits Borland sont <strong>des</strong><br />
marques commerciales ou <strong>des</strong> marques déposées de Borland Software Corporation aux Etats-Unis et dans les<br />
autres pays. Les autres noms de produits sont <strong>des</strong> marques commerciales ou <strong>des</strong> marques déposées de leurs<br />
fabricants respectifs.<br />
Pour connaître les conditions et limites <strong>des</strong> fournisseurs tiers, lisez les Remarques version sur votre CD JBuilder.<br />
JBE0050WW21002entjb 2E1R0401<br />
0102030405-9 8 7 6 54321<br />
Table <strong>des</strong> matières<br />
Chapitre 1<br />
Introduction<br />
au développement <strong>des</strong> EJB 1-1<br />
Pourquoi avons-nous besoin<br />
<strong>des</strong> Enterprise JavaBeans . . . . . . . . . . . 1-2<br />
Rôles dans le développement<br />
d’une application EJB . . . . . . . . . . . . . . 1-3<br />
Rôles application . . . . . . . . . . . . . . . . 1-3<br />
Rôles infrastructure . . . . . . . . . . . . . . 1-3<br />
Rôles déploiement et opérations . . . . . . . 1-4<br />
Architecture EJB . . . . . . . . . . . . . . . . . . 1-5<br />
Le serveur EJB . . . . . . . . . . . . . . . . . 1-5<br />
Le conteneur EJB . . . . . . . . . . . . . . . . 1-6<br />
Comment fonctionne un <strong>enterprise</strong> bean . 1-6<br />
Types d’<strong>enterprise</strong> <strong>beans</strong> . . . . . . . . . . . . . 1-7<br />
Beans session . . . . . . . . . . . . . . . . . . 1-7<br />
Beans entité . . . . . . . . . . . . . . . . . . . 1-7<br />
Développement <strong>des</strong> <strong>enterprise</strong> <strong>beans</strong> . . . . . . 1-8<br />
Comment contacter le support développeur<br />
de Borland . . . . . . . . . . . . . . . . . . . . 1-9<br />
Ressources en ligne. . . . . . . . . . . . . . . 1-9<br />
World Wide Web . . . . . . . . . . . . . . 1-9<br />
Groupes de discussion Borland . . . . . .1-10<br />
Groupes de discussion Usenet . . . . . .1-10<br />
Rapports de bogues. . . . . . . . . . . . .1-10<br />
Conventions de la documentation . . . . . . . . 1-11<br />
Chapitre 2<br />
Configuration du serveur<br />
d’applications cible 2-1<br />
Ajout <strong>des</strong> fichiers du serveur d’applications<br />
à votre projet . . . . . . . . . . . . . . . . . . . 2-2<br />
Rendre ORB accessible à JBuilder . . . . . . . . 2-3<br />
Sélection d’un serveur d’applications . . . . . . 2-4<br />
Chapitre 3<br />
Création <strong>des</strong> <strong>enterprise</strong> <strong>beans</strong><br />
avec JBuilder 3-1<br />
Création d’un groupe EJB. . . . . . . . . . . . . 3-2<br />
Création d’un groupe EJB vide . . . . . . . . 3-2<br />
Création d’un groupe EJB<br />
à partir d’<strong>enterprise</strong> <strong>beans</strong> existant . . . . . 3-3<br />
Création d’un <strong>enterprise</strong> bean . . . . . . . . . . 3-4<br />
Création d’un bean session . . . . . . . . . . 3-6<br />
Création d’un bean entité . . . . . . . . . . . 3-7<br />
Ajout de la logique métier à votre bean. . . . 3-9<br />
Exposition <strong>des</strong> métho<strong>des</strong> métier<br />
via l’interface distante. . . . . . . . . . . . 3-11<br />
Génération de la classe du bean à partir<br />
d’une interface distante. . . . . . . . . . . . . 3-12<br />
Création <strong>des</strong> interfaces locale et distante<br />
d’un bean existant. . . . . . . . . . . . . . . . 3-15<br />
Compilation du bean . . . . . . . . . . . . . . . 3-17<br />
Modification <strong>des</strong> <strong>des</strong>cripteurs de déploiement 3-20<br />
Chapitre 4<br />
Création <strong>des</strong> <strong>beans</strong> entité<br />
à partir d’une table existante<br />
dans une base de données 4-1<br />
Création <strong>des</strong> <strong>beans</strong> entité<br />
avec le Modeleur Bean entité EJB . . . . . . . . 4-1<br />
Chapitre 5<br />
Test d’un <strong>enterprise</strong> bean 5-1<br />
Création d’un client de test . . . . . . . . . . . . 5-1<br />
Utilisation de l’application client de test . . . . . 5-3<br />
Test de votre <strong>enterprise</strong> bean . . . . . . . . . . . 5-5<br />
Chapitre 6<br />
Déploiement <strong>des</strong> <strong>enterprise</strong> <strong>beans</strong> 6-1<br />
Création d’un fichier <strong>des</strong>cripteur<br />
de déploiement . . . . . . . . . . . . . . . . . . 6-2<br />
Le rôle du <strong>des</strong>cripteur de déploiement . . . . . . 6-2<br />
Les types d’informations<br />
du <strong>des</strong>cripteur de déploiement . . . . . . . 6-3<br />
Informations structurelles. . . . . . . . . . 6-4<br />
Informations sur l’assemblage<br />
de l’application . . . . . . . . . . . . . . . 6-4<br />
Sécurité . . . . . . . . . . . . . . . . . . . . 6-5<br />
Rôles de sécurité . . . . . . . . . . . . . . . 6-5<br />
Permissions de métho<strong>des</strong> . . . . . . . . . . 6-5<br />
Liaison aux références<br />
<strong>des</strong> rôles de sécurité . . . . . . . . . . . . 6-5<br />
Déploiement sur un serveur d’applications . . . 6-6<br />
Déploiement d’un<br />
ou de plusieurs fichiers JAR . . . . . . . . . 6-6<br />
Déploiement sur les serveurs WebLogic<br />
ou WebSphere . . . . . . . . . . . . . . . . . 6-9<br />
Définition <strong>des</strong> options de déploiement<br />
avec la boîte de dialogue Propriétés . . . . 6-10<br />
i
Déploiement dynamique<br />
sur un serveur d’applications . . . . . . . . 6-11<br />
Chapitre 7<br />
Utilisation de l’éditeur<br />
de <strong>des</strong>cripteur de déploiement 7-1<br />
Affichage de l’éditeur de <strong>des</strong>cripteur<br />
de déploiement . . . . . . . . . . . . . . . . . . 7-2<br />
Visualisation du <strong>des</strong>cripteur de déploiement<br />
d’un <strong>enterprise</strong> bean . . . . . . . . . . . . . . . 7-2<br />
Ajout <strong>des</strong> informations<br />
d’un nouvel <strong>enterprise</strong> bean . . . . . . . . . . 7-4<br />
Modification <strong>des</strong> informations<br />
concernant le bean . . . . . . . . . . . . . . . . 7-5<br />
Informations sur les <strong>enterprise</strong> <strong>beans</strong> . . . . . . 7-5<br />
Panneau Main . . . . . . . . . . . . . . . . . 7-5<br />
Panneau Environment . . . . . . . . . . . . . 7-7<br />
Panneau EJB references . . . . . . . . . . . . 7-8<br />
Panneau Security role references . . . . . . . 7-9<br />
Panneau Resource references . . . . . . . . .7-10<br />
Panneau Persistence . . . . . . . . . . . . . .7-12<br />
Panneau Finders . . . . . . . . . . . . . . . .7-14<br />
Panneau Properties. . . . . . . . . . . . . . .7-15<br />
Transactions conteneur . . . . . . . . . . . . . .7-20<br />
Ajout d’une transaction gérée<br />
par le conteneur. . . . . . . . . . . . . . . .7-20<br />
Travail sur les sources de données . . . . . . . .7-21<br />
Définition <strong>des</strong> niveaux d’isolation . . . . . .7-23<br />
Définition <strong>des</strong> propriétés<br />
<strong>des</strong> sources de données . . . . . . . . . . .7-23<br />
Ajout <strong>des</strong> rôles de sécurité<br />
et <strong>des</strong> métho<strong>des</strong> autorisées . . . . . . . . . . .7-25<br />
Création d’un rôle de sécurité. . . . . . . . .7-25<br />
Assignation <strong>des</strong> métho<strong>des</strong> autorisées . . . .7-26<br />
Visualisation et modification <strong>des</strong> propriétés<br />
WebLogic et WebSphere . . . . . . . . . . . . .7-27<br />
Vérification <strong>des</strong> informations du <strong>des</strong>cripteur. .7-28<br />
Chapitre 8<br />
Utilisation de DataExpress<br />
pour les composants EJB 8-1<br />
Les composants DataExpress EJB . . . . . . . . 8-2<br />
Composants pour le serveur . . . . . . . . . 8-2<br />
Composants pour le client. . . . . . . . . . . 8-2<br />
Création <strong>des</strong> <strong>beans</strong> entité . . . . . . . . . . . . . 8-2<br />
Création du bean session côté serveur. . . . . . 8-3<br />
Ajout <strong>des</strong> composants fournisseur<br />
et résolveur au bean session. . . . . . . . . 8-3<br />
Ecriture de la méthode setSessionContext() . 8-4<br />
Ajout d’une référence EJB<br />
au <strong>des</strong>cripteur de déploiement . . . . . . 8-5<br />
Ajout <strong>des</strong> métho<strong>des</strong> de fourniture<br />
et de résolution . . . . . . . . . . . . . . . . 8-5<br />
Appel de la méthode find . . . . . . . . . . . 8-6<br />
Construction du côté client . . . . . . . . . . . . 8-7<br />
Gestion <strong>des</strong> relations . . . . . . . . . . . . . . . . 8-9<br />
Projet exemple. . . . . . . . . . . . . . . . . . . . 8-9<br />
Chapitre 9<br />
Développement <strong>des</strong> <strong>beans</strong> session 9-1<br />
Types de <strong>beans</strong> session . . . . . . . . . . . . . . . 9-1<br />
Beans session stateful . . . . . . . . . . . . . . 9-1<br />
Beans session stateless . . . . . . . . . . . . . 9-2<br />
Ecriture de la classe du bean session . . . . . . . 9-2<br />
Implémentation de l’interface SessionBean. . 9-2<br />
Ecriture <strong>des</strong> métho<strong>des</strong> métier . . . . . . . . . 9-3<br />
Ajout d’une ou de plusieurs métho<strong>des</strong><br />
ejbCreate() . . . . . . . . . . . . . . . . . . . 9-3<br />
Comment JBuilder peut vous aider<br />
à créer un bean session . . . . . . . . . . . . 9-4<br />
La vie d’un bean session . . . . . . . . . . . . . . 9-5<br />
Beans stateless . . . . . . . . . . . . . . . . . . 9-5<br />
Beans stateful . . . . . . . . . . . . . . . . . . 9-6<br />
Etat prêt pour la méthode et état prêt<br />
pour la transaction . . . . . . . . . . . . . 9-7<br />
Un bean session pour faire vos courses. . . . . . 9-9<br />
Fichiers de l’exemple du chariot virtuel . . 9-10<br />
Le bean session Cart . . . . . . . . . . . . . 9-10<br />
Ajout <strong>des</strong> métho<strong>des</strong> nécessaires . . . . . 9-11<br />
Ajout <strong>des</strong> métho<strong>des</strong> métier . . . . . . . . 9-13<br />
Classe Item . . . . . . . . . . . . . . . . . . . 9-15<br />
Exceptions . . . . . . . . . . . . . . . . . . . 9-15<br />
Interfaces exigées . . . . . . . . . . . . . . . 9-16<br />
L’interface locale . . . . . . . . . . . . . . 9-16<br />
L’interface distante. . . . . . . . . . . . . 9-17<br />
Le <strong>des</strong>cripteur de déploiement de Cart . 9-18<br />
Chapitre 10<br />
Développement <strong>des</strong> <strong>beans</strong> entité 10-1<br />
Persistance et <strong>beans</strong> entité . . . . . . . . . . . . 10-1<br />
Persistance gérée par le bean. . . . . . . . . 10-2<br />
Persistance gérée par le conteneur. . . . . . 10-2<br />
Clés primaires <strong>des</strong> <strong>beans</strong> entité . . . . . . . . . 10-3<br />
Ecriture de la classe du bean entité . . . . . . . 10-3<br />
Implémentation de l’interface EntityBean . 10-4<br />
Déclaration et implémentation<br />
<strong>des</strong> métho<strong>des</strong> <strong>des</strong> <strong>beans</strong> entité . . . . . . . 10-5<br />
ii
Création <strong>des</strong> métho<strong>des</strong> Create. . . . . . .10-5<br />
Création <strong>des</strong> métho<strong>des</strong> Find. . . . . . . .10-7<br />
Ecriture <strong>des</strong> métho<strong>des</strong> métier . . . . . . .10-8<br />
Utilisation <strong>des</strong> experts de JBuilder<br />
pour créer un bean entité . . . . . . . . . .10-8<br />
La vie d’un bean entité . . . . . . . . . . . . . .10-8<br />
L’état de non existence . . . . . . . . . . . . .10-9<br />
L’état en pool . . . . . . . . . . . . . . . . . .10-9<br />
L’état prêt . . . . . . . . . . . . . . . . . . . 10-10<br />
Retour à l’état en pool . . . . . . . . . . . . 10-10<br />
Exemple du bean entité bank . . . . . . . . . . 10-11<br />
L’interface locale d’un bean entité . . . . . 10-11<br />
L’interface distante d’un bean entité . . . . 10-12<br />
Un bean entité dont la persistance<br />
est gérée par le conteneur . . . . . . . . . 10-12<br />
Un bean entité dont la persistance<br />
est gérée par le bean . . . . . . . . . . . . 10-14<br />
La classe clé primaire . . . . . . . . . . . . 10-19<br />
Le <strong>des</strong>cripteur de déploiement . . . . . . . 10-19<br />
Descripteur de déploiement<br />
d’un bean entité dont la persistance<br />
est auto-gérée . . . . . . . . . . . . . . 10-21<br />
Descripteur de déploiement<br />
d’un bean entité dont la persistance<br />
est gérée par le conteneur . . . . . . . 10-22<br />
Chapitre 11<br />
Création <strong>des</strong> interfaces<br />
locales et distantes 11-1<br />
Création de l’interface locale . . . . . . . . . . . 11-1<br />
La classe de base EJBHome . . . . . . . . . . 11-2<br />
Création d’une interface locale<br />
pour un bean session . . . . . . . . . . . . . 11-2<br />
Métho<strong>des</strong> create() <strong>des</strong> <strong>beans</strong> session . . . 11-3<br />
Création d’une interface locale<br />
pour un bean entité. . . . . . . . . . . . . . 11-4<br />
Métho<strong>des</strong> create() <strong>des</strong> <strong>beans</strong> entité . . . . 11-4<br />
Métho<strong>des</strong> find <strong>des</strong> <strong>beans</strong> entité . . . . . . 11-5<br />
Création de l’interface distante . . . . . . . . . . 11-6<br />
L’interface EJBObject . . . . . . . . . . . . . . 11-7<br />
Chapitre 12<br />
Développement <strong>des</strong> clients<br />
<strong>des</strong> <strong>enterprise</strong> <strong>beans</strong> 12-1<br />
Localisation de l’interface locale . . . . . . . . 12-2<br />
Obtenir l’interface distante. . . . . . . . . . . . 12-2<br />
Beans session. . . . . . . . . . . . . . . . . . 12-2<br />
Beans entité . . . . . . . . . . . . . . . . . . 12-3<br />
Les métho<strong>des</strong> find et la classe<br />
de la clé primaire . . . . . . . . . . . . . 12-4<br />
Métho<strong>des</strong> create et remove . . . . . . . . 12-4<br />
Appel <strong>des</strong> métho<strong>des</strong> . . . . . . . . . . . . . . . 12-5<br />
Suppression <strong>des</strong> instances de <strong>beans</strong> . . . . . . 12-6<br />
Référencement d’un bean avec son handle. . . 12-6<br />
Gestion <strong>des</strong> transactions . . . . . . . . . . . . . 12-7<br />
Découvrir les informations sur le bean . . . . . 12-8<br />
Création d’un client avec JBuilder . . . . . . . 12-9<br />
Chapitre 13<br />
Gestion <strong>des</strong> transactions 13-1<br />
Caractéristiques <strong>des</strong> transactions . . . . . . . . 13-1<br />
Support <strong>des</strong> transactions dans le conteneur . . 13-2<br />
Enterprise <strong>beans</strong> et transactions. . . . . . . . . 13-3<br />
Comparaison entre<br />
les transactions gérées par le bean<br />
et celles gérées par le conteneur . . . . . . 13-3<br />
Attributs <strong>des</strong> transactions . . . . . . . . . . 13-4<br />
Transactions locales et globales . . . . . . . 13-5<br />
Utilisation de l’API de transaction . . . . . . . 13-6<br />
Gestion <strong>des</strong> exceptions dans les transactions . 13-8<br />
Exceptions au niveau du système . . . . . . 13-8<br />
Exceptions au niveau de l’application . . . 13-8<br />
Gestion <strong>des</strong> exceptions au niveau<br />
de l’application . . . . . . . . . . . . . . . 13-9<br />
Annulation de la transaction . . . . . . . 13-9<br />
Options pour continuer une transaction 13-10<br />
Index I-1<br />
iii
Chapitre<br />
1<br />
Chapitre1Introduction<br />
au développement <strong>des</strong> EJB<br />
“Enterprise JavaBeans (EJB) specification” (http://java.sun.com/<br />
products/ejb/docs.html) définit de manière formelle un modèle de<br />
composant Java côté serveur et une interface de programmation pour les<br />
serveurs d’applications. Les développeurs construisent <strong>des</strong> composants,<br />
appelés <strong>enterprise</strong> <strong>beans</strong>, pour contenir la logique métier de l’entreprise.<br />
Les <strong>enterprise</strong> <strong>beans</strong> s’exécutent sur un serveur EJB qui fournit aux <strong>beans</strong><br />
<strong>des</strong> services comme la gestion <strong>des</strong> transactions et la sécurité. Les<br />
développeurs n’ont pas à se préoccuper de la programmation de ces<br />
services de bas niveau et complexes ; ils peuvent se concentrer sur<br />
l’encapsulation <strong>des</strong> règles métier de leur organisation à l’intérieur <strong>des</strong><br />
<strong>beans</strong>, tout en sachant que les services sont accessibles aux <strong>beans</strong> lorsque<br />
c’est nécessaire.<br />
Outre son rôle d’ultime arbitre pour le cadre de travail EJB, la spécification<br />
Enterprise JavaBeans sert essentiellement aux fournisseurs, comme<br />
Borland, qui construisent les serveurs EJB et les conteneurs dans lesquels<br />
s’exécutent les <strong>beans</strong>. Ce manuel aidera le développeur JBuilder à savoir<br />
ce qu’il veut savoir sur le développement <strong>des</strong> <strong>enterprise</strong> <strong>beans</strong> et sur la<br />
création <strong>des</strong> applications qui les utilisent.<br />
Si vous êtes déjà familier du développement <strong>des</strong> EJB et souhaitez<br />
apprendre à créer <strong>des</strong> <strong>enterprise</strong> <strong>beans</strong> avec JBuilder, commencez par le<br />
Chapitre 3, “Création <strong>des</strong> <strong>enterprise</strong> <strong>beans</strong> avec JBuilder”.<br />
Introduction au dé veloppement <strong>des</strong> EJB 1-1
Pourquoi avons-nous besoin <strong>des</strong> Enterprise JavaBeans <br />
Pourquoi avons-nous besoin <strong>des</strong> Enterprise JavaBeans <br />
Le modèle client-serveur de développement <strong>des</strong> applications a eu une<br />
popularité considérable. L’application client réside sur une machine locale<br />
et accède aux données d’un ensemble de données tel qu’un système de<br />
gestion de bases de données relationnelles (SGBR). Ce modèle fonctionne<br />
bien tant que le système n’a qu’un petit nombre d’utilisateurs. Lorsque de<br />
plus en plus d’utilisateurs veulent accéder aux données, ces applications<br />
n’évoluent pas suffisamment bien pour suivre la demande. Comme la<br />
logique se trouve sur le client, il doit être installé sur chaque machine. La<br />
gestion devient donc de plus en plus difficile.<br />
Petit à petit, est apparue la nécessité de diviser les applications en un<br />
nombre de niveaux supérieur aux deux niveaux du modèle client-serveur.<br />
Dans une application multiniveau, seule l’interface utilisateur réside sur la<br />
machine locale alors que la logique de l’application s’exécute dans un<br />
niveau intermédiaire sur un serveur. Le niveau final est toujours constitué<br />
par les données stockées. Lorsqu’il convient de mettre à jour la logique<br />
d’une application, les modifications sont apportées au logiciel du niveau<br />
intermédiaire sur le serveur, ce qui simplifie considérablement la gestion<br />
<strong>des</strong> mises à jour.<br />
Pourtant, la création d’applications distribuées fiables, sécurisées et faciles<br />
à gérer est notoirement difficile. Par exemple, la gestion <strong>des</strong> transactions<br />
dans un système distribué est une lourde tâche. Heureusement,<br />
l’utilisation de composants respectant la spécification EJB pour construire<br />
<strong>des</strong> systèmes distribués permet de :<br />
• Diviser le développement d’un système distribué en plusieurs tâches<br />
spécifiques assignées à <strong>des</strong> spécialistes.<br />
Par exemple, si l’application est un système comptable, le développeur<br />
d’<strong>enterprise</strong> <strong>beans</strong> doit connaître la comptabilité. L’administrateur<br />
système doit savoir comment surveiller une application déployée en<br />
cours d’exécution. Chaque spécialiste assume un rôle particulier.<br />
• Rendre les services du serveur et du conteneur EJB accessibles à<br />
l’<strong>enterprise</strong> bean et aux développeurs d’applications.<br />
Le fournisseur de serveur EJB et le fournisseur de conteneur EJB (c’est<br />
souvent le même) prennent en charge beaucoup <strong>des</strong> tâches les plus<br />
difficiles, si bien que le développeur n’a pas à le faire. Par exemple, le<br />
conteneur dans lequel un <strong>enterprise</strong> bean s’exécute peut fournir au<br />
bean les services de transaction et de sécurité automatiquement.<br />
• Rendre portables les <strong>enterprise</strong> <strong>beans</strong>.<br />
Le bean une fois écrit peut être déployé sur n’importe quel serveur EJB<br />
qui respecte le standard Enterprise JavaBeans. Cependant, chaque bean<br />
est à même d’inclure <strong>des</strong> éléments spécifiques au fournisseur.<br />
1-2 Guide du dé veloppeur Enterprise JavaBeans
R ô les dans le dé veloppement d’ une application EJB<br />
Rôles dans le développement d’une application EJB<br />
Le travail de développement d’une application distribuée EJB se divise en<br />
six parties ou rôles distincts. Chaque rôle est pris en charge par un<br />
spécialiste du domaine. Le travail ainsi divisé, la création et la gestion<br />
d’un système distribué deviennent beaucoup plus faciles.<br />
Rôles application<br />
Ceux qui assurent les rôles concernant les applications écrivent le code <strong>des</strong><br />
<strong>enterprise</strong> <strong>beans</strong> et <strong>des</strong> applications qui les utilisent. Ce deux domaines<br />
exigent une compréhension du métier lui-même mais à <strong>des</strong> niveaux<br />
différents. Voici les deux rôles application :<br />
• Fournisseur de <strong>beans</strong><br />
Les fournisseurs de <strong>beans</strong> (également appelés développeurs de <strong>beans</strong>)<br />
créent les <strong>enterprise</strong> <strong>beans</strong> et écrivent la logique <strong>des</strong> métho<strong>des</strong> métier<br />
qu’ils intègrent. Ils définissent également les interfaces distante et<br />
locale <strong>des</strong> <strong>beans</strong> et ils créent les <strong>des</strong>cripteurs de déploiement <strong>des</strong> <strong>beans</strong>.<br />
Les fournisseurs de <strong>beans</strong> n’ont pas obligatoirement besoin de savoir<br />
comment leurs <strong>beans</strong> seront assemblés et déployés.<br />
• Assembleur d’applications<br />
Les assembleurs d’applications écrivent les applications qui utilisent les<br />
<strong>enterprise</strong> <strong>beans</strong>. Ces applications comprennent habituellement<br />
d’autres composants, comme les clients GUI, les applets, les JSP<br />
(JavaServer Pages) et les servlets. Ces composants sont assemblés en<br />
une application distribuée. Les assembleurs ajoutent <strong>des</strong> instructions<br />
d’assemblage aux <strong>des</strong>cripteurs de déploiement <strong>des</strong> <strong>beans</strong>. Bien que les<br />
assembleurs d’applications aient besoin de connaître les métho<strong>des</strong><br />
contenues dans les <strong>enterprise</strong> <strong>beans</strong> pour les appeler, ils n’ont pas<br />
besoin de savoir comment elles sont implémentées.<br />
Les utilisateurs de JBuilder concernés par Enterprise JavaBeans sont<br />
généralement <strong>des</strong> fournisseurs de <strong>beans</strong> et <strong>des</strong> assembleurs<br />
d’applications. Ce manuel leur est donc dédié. JBuilder possède <strong>des</strong><br />
experts, <strong>des</strong> concepteurs et d’autres outils qui simplifient le<br />
développement <strong>des</strong> <strong>enterprise</strong> <strong>beans</strong> et <strong>des</strong> applications qui les utilisent.<br />
Rôles infrastructure<br />
Sans le support d’une infrastructure, les <strong>enterprise</strong> <strong>beans</strong> et les<br />
applications qui les utilisent ne peuvent pas s’exécuter. Bien que les deux<br />
rôles concernant l’infrastructure soient distincts, ils sont presque toujours<br />
assurés par le même fournisseur. Ils apportent aux <strong>enterprise</strong> <strong>beans</strong> les<br />
Introduction au dé veloppement <strong>des</strong> EJB 1-3
R ô les dans le dé veloppement d’ une application EJB<br />
services du niveau système ainsi que l’environnement dans lequel ils<br />
s’exécutent. Voici les deux rôles infrastructure :<br />
• Fournisseur de serveurs EJB<br />
Les fournisseurs de serveurs EJB sont <strong>des</strong> spécialistes de la gestion<br />
distribuée <strong>des</strong> transactions, <strong>des</strong> objets distribués et d’autres services de<br />
bas niveau. Ils fournissent le cadre de travail applicatif dans lequel<br />
s’exécutent les conteneurs EJB. Au minimum, les fournisseurs de<br />
serveurs EJB doivent fournir aux <strong>beans</strong> un service d’annuaire et un<br />
service de transaction.<br />
• Fournisseur de conteneurs EJB<br />
Les fournisseurs de conteneurs EJB fournissent les outils nécessaires au<br />
déploiement <strong>des</strong> <strong>enterprise</strong> <strong>beans</strong> et le support <strong>des</strong> <strong>beans</strong> à l’exécution.<br />
Un conteneur procure <strong>des</strong> services de gestion à un ou à plusieurs <strong>beans</strong>.<br />
Il communique avec le serveur EJB afin d’accéder aux services dont le<br />
bean a besoin.<br />
Dans la majorité <strong>des</strong> cas, le fournisseur de serveurs EJB et le fournisseur<br />
de conteneurs EJB sont confondus. Borland AppServer fournit à la fois le<br />
serveur et le conteneur.<br />
Rôles déploiement et opérations<br />
Les dernières étapes du développement d’une application distribuée EJB<br />
sont le déploiement de l’application et la surveillance, pendant qu’elle<br />
s’exécute, de l’informatique de l’entreprise et de l’infrastructure de son<br />
réseau. Voici les rôles déploiement et opérations :<br />
• Déployeur<br />
Les déployeurs connaissent l’environnement opératoire <strong>des</strong><br />
applications distribuées. Ils adaptent l’application EJB à<br />
l’environnement opératoire cible en modifiant les propriétés <strong>des</strong><br />
<strong>enterprise</strong> <strong>beans</strong> au moyen <strong>des</strong> outils fournis par le fournisseur de<br />
conteneurs. Par exemple, les déployeurs déterminent les politiques de<br />
transaction et de sécurité en définissant les propriétés correspondantes<br />
dans le <strong>des</strong>cripteur de déploiement. Ils intègrent d’autre part,<br />
l’application aux logiciels de gestion existant dans l’entreprise.<br />
• Administrateur système<br />
L’application une fois déployée, l’administrateur système la surveille<br />
pendant son exécution et prend les décisions appropriées si elle se<br />
comporte anormalement. Les administrateurs système sont chargés de<br />
configurer et d’administrer l’informatique et l’infrastructure réseau de<br />
l’entreprise, ce qui comprend le serveur EJB et le conteneur EJB.<br />
1-4 Guide du dé veloppeur Enterprise JavaBeans
Architecture EJB<br />
Architecture EJB<br />
Les applications distribuées multiniveaux sont souvent composées d’un<br />
client s’exécutant sur une machine locale, d’un niveau intermédiaire<br />
s’exécutant sur un serveur qui contient la logique métier et d’un niveau<br />
final constitué d’un système d’information d’entreprise (SIE). Un SIE peut<br />
être un système de bases de données relationnelles, un système ERP, une<br />
application standard, ou tout ensemble contenant les données qu’il faut<br />
accéder. Cette figure montre un système distribué EJB typique comportant<br />
trois niveaux : le client; le serveur, le conteneur et les <strong>beans</strong> déployés sur<br />
eux; ainsi que le système d’information de l’entreprise.<br />
Figure 1.1<br />
Diagramme de l’architecture EJB<br />
Notre sujet étant le développement <strong>des</strong> <strong>enterprise</strong> <strong>beans</strong>, nous nous<br />
concentrerons sur le niveau intermédiaire.<br />
Le serveur EJB<br />
Le serveur EJB fournit aux <strong>enterprise</strong> <strong>beans</strong> <strong>des</strong> services système et gère<br />
les conteneurs dans lesquels s’exécutent les <strong>beans</strong>. Il doit offrir un service<br />
d’annuaire accessible via JNDI et un service de transaction. Très souvent,<br />
le serveur EJB fait bénéficier de fonctions supplémentaires qui le<br />
Introduction au dé veloppement <strong>des</strong> EJB 1-5
Architecture EJB<br />
distinguent de ses concurrents. Borland AppServer est un exemple de<br />
serveur EJB.<br />
Le conteneur EJB<br />
Un conteneur est un système d’exécution pour un ou plusieurs <strong>enterprise</strong><br />
<strong>beans</strong>. Il fournit la communication entre les <strong>beans</strong> et le serveur EJB. Il<br />
fournit la gestion <strong>des</strong> transactions, de la sécurité et de la distribution sur le<br />
réseau. Un conteneur est à la fois du code et un outil qui génère le code<br />
spécifique à chaque <strong>enterprise</strong> bean. Un conteneur fournit également les<br />
outils du déploiement de l’<strong>enterprise</strong> bean ; c’est aussi un moyen pour le<br />
conteneur de surveiller et de gérer l’application.<br />
Le serveur EJB et le conteneur EJB fournissent ensemble l’environnement<br />
où le bean s’exécute. Le conteneur fournit <strong>des</strong> services de gestion à un ou à<br />
plusieurs <strong>beans</strong>. Le serveur fournit les services au bean, mais le conteneur<br />
agit pour le compte <strong>des</strong> <strong>beans</strong> pour obtenir ces services.<br />
Bien qu’il s’agisse d’une partie vitale de l’architecture Enterprise<br />
JavaBeans, les développeurs d’<strong>enterprise</strong> bean et les assembleurs<br />
d’applications n’ont pas à se préoccuper du conteneur. C’est un acteur “en<br />
coulisse” <strong>des</strong> systèmes distribués EJB. Nous n’en dirons donc pas plus sur<br />
les conteneurs et leur fonctionnement. Pour avoir <strong>des</strong> informations,<br />
reportez-vous à la “Enterprise JavaBeans 1.1 Specification” elle-même<br />
(http://java.sun.com/products/ejb/docs.html). Pour <strong>des</strong> informations<br />
spécifiques au conteneur EJB de Borland, voyez le Enterprise JavaBeans<br />
Programmer’s Guide de Borland AppServer.<br />
Comment fonctionne un <strong>enterprise</strong> bean <br />
Le développeur de <strong>beans</strong> doit créer les interfaces et les classes suivantes :<br />
• L’interface locale du bean<br />
L’interface locale définit les métho<strong>des</strong> utilisées par le client pour créer,<br />
localiser et détruire les instances d’un <strong>enterprise</strong> bean.<br />
• L’interface distante du bean<br />
L’interface distante définit les métho<strong>des</strong> métier implémentées dans le<br />
bean. Un client accède à ces métho<strong>des</strong> via l’interface distante.<br />
• La classe de l’<strong>enterprise</strong> bean<br />
La classe de l’<strong>enterprise</strong> bean implémente la logique métier pour le<br />
bean. Le client accède à ces métho<strong>des</strong> via l’interface distante du bean.<br />
Le bean une fois déployé dans le conteneur EJB, le client appelle la<br />
méthode create() définie dans l’interface locale pour instancier le bean.<br />
L’interface locale n’est pas implémentée dans le bean lui-même, mais par<br />
1-6 Guide du dé veloppeur Enterprise JavaBeans
Types d’<strong>enterprise</strong> <strong>beans</strong><br />
Types d’ <strong>enterprise</strong> <strong>beans</strong><br />
le conteneur. D’autres métho<strong>des</strong>, déclarées dans l’interface locale,<br />
permettent au client de localiser une instance d’un bean et de supprimer<br />
l’instance d’un bean lorsqu’elle n’est plus nécessaire.<br />
Lorsque l’<strong>enterprise</strong> bean est instancié, le client peut appeler les métho<strong>des</strong><br />
métier qu’il contient. Toutefois, le client n’appelle jamais de méthode<br />
directement dans l’instance du bean. Les métho<strong>des</strong> accessibles au client<br />
sont définies dans l’interface distante du bean, et celle-ci est implémentée<br />
par le conteneur. Lorsque le client appelle une méthode, le conteneur<br />
reçoit la demande et la délègue à l’instance du bean.<br />
Un <strong>enterprise</strong> bean peut être un bean session ou un bean entité.<br />
Beans session<br />
Un <strong>enterprise</strong> bean session s’exécute au bénéfice d’un client unique. D’une<br />
certaine façon, le bean session représente le client pour le serveur EJB.<br />
Les <strong>beans</strong> session peuvent maintenir l’état du client, ce qui signifie qu’ils<br />
peuvent conserver <strong>des</strong> informations pour le client. L’exemple classique où<br />
un bean session peut être utilisé est celui du chariot que “remplit” un<br />
acheteur dans un magasin en ligne du web. Au fur et à mesure que<br />
l’acheteur sélectionne un élément à mettre dans son chariot, le bean<br />
session conserve la liste <strong>des</strong> éléments sélectionnés.<br />
Les <strong>beans</strong> session peuvent avoir une courte durée de vie. Généralement, le<br />
bean est supprimé par le client lorsque celui-ci termine la session.<br />
Les <strong>beans</strong> session peuvent être stateful ou stateless. Les <strong>beans</strong> Stateless ne<br />
maintiennent pas d’état pour un client particulier. Puisqu’ils ne<br />
maintiennent pas d’état conversationnel, les <strong>beans</strong> stateless peuvent être<br />
utilisés pour supporter plusieurs clients.<br />
Beans entité<br />
Un bean entité fournit un objet vue <strong>des</strong> données d’une base.<br />
Habituellement, le bean représente une ligne dans un ensemble de tables<br />
d’une base de données relationnelles. Un bean entité sert généralement<br />
plusieurs clients.<br />
Au contraire <strong>des</strong> <strong>beans</strong> session, les <strong>beans</strong> entité sont supposés avoir une<br />
longue durée de vie. Ils maintiennent un état persistant, vivant aussi<br />
longtemps que les données restent dans la base, et non aussi (peu)<br />
longtemps qu’un client particulier a besoin d’eux.<br />
Introduction au dé veloppement <strong>des</strong> EJB 1-7
D é veloppement <strong>des</strong> <strong>enterprise</strong> <strong>beans</strong><br />
Le conteneur peut gérer la persistance du bean, ou le bean peut la gérer<br />
lui-même. Si la persistance est gérée par le bean, le développeur du bean<br />
doit écrire le code incluant les appels à la base de données.<br />
Développement <strong>des</strong> <strong>enterprise</strong> <strong>beans</strong><br />
Les chapitres suivants expliquent comment utiliser les experts, les<br />
concepteurs et les outils de JBuilder qui faciliteront et accéléreront la<br />
création de vos <strong>enterprise</strong> <strong>beans</strong>. Il part de l’hypothèse que vous savez ce<br />
que sont les Enterprise JavaBeans, comment ils fonctionnent et quelles<br />
sont leurs exigences.<br />
Si votre connaissance d’EJB est insuffisante ou si vous voulez avoir plus<br />
d’informations sur le développement EJB avant de commencer à utiliser<br />
les experts et les outils EJB de JBuilder, lisez le Chapitre 9,<br />
“Développement <strong>des</strong> <strong>beans</strong> session” et les chapitres qui suivent avant de<br />
continuer.<br />
Le développement <strong>des</strong> Enterprise JavaBeans avec JBuilder se divise en<br />
plusieurs étapes :<br />
1 Configuration du serveur d’applications cible (voir Chapitre 2)<br />
2 Création d’un groupe EJB (voir page 3-2)<br />
3 Création d’un <strong>enterprise</strong> bean et de ses interfaces locale et distante (voir<br />
page 3-4)<br />
4 Compilation du bean (voir page 3-17)<br />
5 Modification du <strong>des</strong>cripteur de déploiement (voir page 3-20)<br />
6 Création d’une application client de test (voir page 5-1)<br />
7 Test de votre <strong>enterprise</strong> bean (voir page 5-5)<br />
8 Déploiement sur un serveur d’applications (voir page 6-6)<br />
Vous pouvez aussi utiliser JBuilder pour créer <strong>des</strong> <strong>enterprise</strong> <strong>beans</strong> de<br />
type entité, basés sur les tables de n’importe quelle base de données<br />
accessible via JDBC. Voir “Création <strong>des</strong> <strong>beans</strong> entité avec le Modeleur<br />
Bean entité EJB”, page 4-1.<br />
Si vous préférez créer d’abord l’interface distante d’un <strong>enterprise</strong> bean,<br />
vous pouvez ensuite utiliser le Créateur de bean EJB pour créer le<br />
squelette de la classe et l’interface locale en fonction de cette interface<br />
distante. Pour plus d’informations, voir “Génération de la classe du bean à<br />
partir d’une interface distante”, page 3-12.<br />
1-8 Guide du dé veloppeur Enterprise JavaBeans
Comment contacter le support dé veloppeur de Borland<br />
Comment contacter le support développeur de Borland<br />
Borland offre aux développeurs diverses options de support. Elles<br />
comprennent <strong>des</strong> services gratuits sur Internet, où vous pouvez consulter<br />
notre importante base d’informations et entrer en contact avec d’autres<br />
utilisateurs de produits Borland. En outre, vous pouvez choisir parmi<br />
plusieurs catégories de support, allant de l’installation <strong>des</strong> produits<br />
Borland au support tarifé de niveau consultant, en passant par une<br />
assistance complète.<br />
Pour obtenir <strong>des</strong> informations sur les services Borland de support aux<br />
développeurs, veuillez consulter notre site Web, à l’adresse<br />
http://www.borland.fr/Support/.<br />
Quand vous contacterez le support, préparez <strong>des</strong> informations complètes<br />
sur votre environnement, la version du produit que vous utilisez et une<br />
<strong>des</strong>cription détaillée du problème.<br />
Pour avoir de l’aide sur les outils tiers, ou leur documentation, contactez<br />
votre fournisseur.<br />
Ressources en ligne<br />
Vous pouvez obtenir <strong>des</strong> informations depuis les sources ci-après:<br />
World Wide Web<br />
FTP<br />
Listserv<br />
http://www.borland.fr/<br />
ftp.borland.com<br />
Documents techniques accessibles par anonymous<br />
ftp.<br />
Pour vous abonner aux bulletins électroniques, utilisez<br />
le formulaire en ligne :<br />
http://www.borland.com/contact/listserv.html<br />
ou, pour l’international,<br />
http://www.borland.com/contact/intlist.html<br />
World Wide Web<br />
Consultez régulièrement www.borland.fr/jbuilder. L’équipe produit de<br />
JBuilder y place notes techniques, analyses <strong>des</strong> produits concurrents,<br />
réponses aux questions fréquemment posées, exemples d’applications,<br />
mises à jour du logiciel et informations sur les produits existants ou<br />
nouveaux.<br />
Vous pouvez vous connecter en particulier aux URL suivantes :<br />
• http://www.borland.fr/Produits/jbuilder/ (mises à jour du logiciel et<br />
autres fichiers)<br />
Introduction au dé veloppement <strong>des</strong> EJB 1-9
Comment contacter le support dé veloppeur de Borland<br />
• http://community.borland.com/ (contient notre magazine<br />
d’informations web pour les développeurs)<br />
Groupes de discussion Borland<br />
Vous pouvez vous inscrire à JBuilder et participer à de nombreux groupes<br />
de discussion dédiés à JBuilder.<br />
Vous trouverez <strong>des</strong> groupes de discussion, animés par les utilisateurs,<br />
pour JBuilder et d’autres produits Borland, à l’adresse<br />
http://www.borland.fr/Newsgroups/<br />
Remarque<br />
Groupes de discussion Usenet<br />
Les groupes Usenet suivants sont dédiées à Java et concernent la<br />
programmation :<br />
• news:comp.lang.java.advocacy<br />
• news:comp.lang.java.announce<br />
• news:comp.lang.java.<strong>beans</strong><br />
• news:comp.lang.java.databases<br />
• news:comp.lang.java.gui<br />
• news:comp.lang.java.help<br />
• news:comp.lang.java.machine<br />
• news:comp.lang.java.programmer<br />
• news:comp.lang.java.security<br />
• news:comp.lang.java.softwaretools<br />
Ces groupes de discussion sont maintenus par les utilisateurs et ne sont<br />
pas <strong>des</strong> sites Borland officiels.<br />
Rapports de bogues<br />
Si vous pensez avoir trouvé un bogue dans le logiciel, merci de le signaler<br />
dans la page du support développeur de JBuilder, à l’adresse<br />
http://www.borland.fr/Support/jbuilder/. Sur ce site, vous pouvez<br />
également demander une fonctionnalité ou consulter la liste <strong>des</strong> bogues<br />
déjà signalés.<br />
Quand vous signalez un bogue, indiquez toutes les étapes nécessaires à la<br />
reproduction de ce bogue, ainsi que tout paramètre spécial de votre<br />
environnement et les autres programmes utilisés avec JBuilder. Précisez<br />
bien le comportement attendu et ce qui s’est réellement passé.<br />
Si vous avez <strong>des</strong> commentaires (compliments, suggestions ou questions)<br />
concernant la documentation de JBuilder, vous pouvez envoyer un e-mail<br />
à jpgpubs@borland.com. Uniquement pour la documentation. Les<br />
questions de support doivent être adressées au support développeur.<br />
JBuilder est fait par <strong>des</strong> développeurs pour <strong>des</strong> développeurs. Nous<br />
apprécions vraiment vos remarques, car elles nous aident à améliorer<br />
notre produit.<br />
1-10 Guide du dé veloppeur Enterprise JavaBeans
Conventions de la documentation<br />
Conventions de la documentation<br />
La documentation Borland sur JBuilder utilise les polices et les symboles<br />
décrits dans le tableau ci-<strong>des</strong>sous pour signaler du texte particulier.<br />
Tableau 1.1 Polices et symboles<br />
Police<br />
Police à<br />
espacement fixe<br />
Gras<br />
Italiques<br />
Signification<br />
La police à espacement fixe représente :<br />
• du texte tel qu’il apparaît à l’écran<br />
• du texte que vous devez taper, comme “Entrez Hello World<br />
dans le champ Titre de l’expert Application.”<br />
• <strong>des</strong> noms de fichiers<br />
• <strong>des</strong> noms de chemins<br />
• <strong>des</strong> noms de répertoires ou de dossiers<br />
• <strong>des</strong> comman<strong>des</strong>, comme SET PATH, CLASSPATH<br />
• du code Java<br />
• <strong>des</strong> types de données Java, comme boolean, int et long.<br />
• <strong>des</strong> identificateurs Java, comme <strong>des</strong> noms de variables,<br />
classes, interfaces, composants, propriétés, métho<strong>des</strong> et<br />
événements<br />
• <strong>des</strong> noms de paquets<br />
• <strong>des</strong> noms d’argument<br />
• <strong>des</strong> noms de champs<br />
• <strong>des</strong> mots clés Java, comme void et static<br />
Le gras est utilisé pour désigner les outils java, bmj (Borland<br />
Make for Java), bcj (Borland Compiler for Java) et les options du<br />
compilateur. Par exemple : javac, bmj, -classpath.<br />
L’italique est utilisé pour les termes nouveaux, les titres <strong>des</strong><br />
manuels et, parfois, pour la mise en valeur.<br />
Touches<br />
Cette police indique une touche de votre clavier. Par exemple,<br />
“Appuyez sur Echap pour quitter un menu.”<br />
[ ] Les crochets droits dans le texte ou dans la syntaxe entourent les<br />
éléments facultatifs. Ne tapez pas ces crochets.<br />
< > Les crochets angulaires dans le texte ou dans la syntaxe<br />
indiquent une chaîne variable ; entrez la chaîne appropriée à<br />
votre code. Ne tapez pas ces crochets. Les crochets angulaires<br />
sont également utilisés pour les balises HTML.<br />
... Dans les exemples de code, les points de suspension indiquent<br />
du code manquant. Sur un bouton, les points de suspension<br />
indiquent que ce bouton ouvre un dialogue de sélection.<br />
Introduction au dé veloppement <strong>des</strong> EJB 1-11
Conventions de la documentation<br />
JBuilder est disponible sur plusieurs plates-formes. Reportez-vous au<br />
tableau ci-<strong>des</strong>sous pour une <strong>des</strong>cription <strong>des</strong> conventions et répertoires<br />
associés aux diverses plates-formes dans la documentation.<br />
Tableau 1.2 Conventions et répertoires associés aux plates-formes<br />
Elément<br />
Chemins<br />
Répertoire de base<br />
Répertoire<br />
.jbuilder5<br />
Répertoire jbproject<br />
Captures d’écran<br />
Signification<br />
Les chemins d’accès mentionnés dans la documentation sont<br />
indiqués par une barre oblique (/).<br />
Pour la plate-forme Windows, utilisez une barre oblique<br />
inverse (\).<br />
L’emplacement du répertoire de base dépend de la<br />
plate-forme.<br />
• Pour UNIX et Linux, le répertoire de base peut varier. Par<br />
exemple, ce peut être /user/[nomutilisateur] ou /home/<br />
[nomutilisateur]<br />
• Pour Windows 95/98, le répertoire de base est C:\Windows<br />
• Pour Windows NT, le répertoire de base est C:\Winnt\<br />
Profiles\[nomutilisateur]<br />
• Pour Windows 2000, le répertoire de base est C:\Documents<br />
and Settings\[nomutilisateur]<br />
Le répertoire .jbuilder5, où sont stockés les paramètres de<br />
fonctionnement de JBuilder, est placé dans le répertoire de<br />
base.<br />
Le répertoire jbproject, qui contient les fichiers projet, classe<br />
et source, est placé dans le répertoire de base. JBuilder<br />
enregistre les fichiers dans ce chemin par défaut.<br />
Les captures d’écran reflètent l’apparence Metal de JBuilder<br />
sur diverses plates-formes.<br />
1-12 Guide du dé veloppeur Enterprise JavaBeans
Chapitre<br />
2<br />
Chapitre2Configuration du serveur<br />
d’applications cible<br />
Remarque<br />
Remarque<br />
Avant de commencer à créer <strong>des</strong> Enterprise JavaBeans, vous devez<br />
configurer le serveur d’applications sur lequel vous allez les déployer.<br />
Dans tous les cas, Borland AppServer (BAS) ou Inprise Application<br />
Server 4.1 (IAS) doit avoir été installé sur votre ordinateur.<br />
Pour configurer JBuilder afin qu’il cible un ou plusieurs serveurs<br />
d’applications,<br />
1 Choisissez Outils|Configuration Entreprise.<br />
2 Sélectionnez la page Serveur d’applications.<br />
Vous pouvez accomplir l’étape suivante quel que soit le serveur<br />
d’applications pour lequel vous développez vos <strong>enterprise</strong> <strong>beans</strong>. Si<br />
vous ne l’accomplissez pas, les experts EJB sera estompés dans la<br />
galerie d’objets.<br />
3 Sélectionnez la page BAS 4.5 ou la page IAS 4.1 et spécifiez le répertoire<br />
où est installé Borland AppServer 4.5 ou Inprise Application Server 4.1.<br />
Pour BAS 4.5, c’est habituellement /Borland/AppServer. Définir une <strong>des</strong><br />
Configuration du serveur d’ applications cible 2-1
Ajout <strong>des</strong> fichiers du serveur d’ applications à votre projet<br />
pages <strong>des</strong> serveurs d’applications Borland vous empêche de définir<br />
l’autre.<br />
4 Si vous voulez cibler le serveur WebLogic ou WebSphere, sélectionnez<br />
la page WebLogic ou WebSphere pour la version souhaitée et spécifiez<br />
le répertoire où est installé le serveur d’applications WebLogic ou<br />
WebSphere. Pour WebSphere, vous devez également spécifier où est<br />
installé le JDK IBM livré avec WebSphere. Pour WebLogic 6.0, le<br />
répertoire local de BEA est exigé.<br />
5 Si vous voulez utiliser le serveur d’applications que vous être en train<br />
de définir comme cible du projet en cours, cochez la case Appliquer les<br />
paramètres pour le serveur d’application modifié au projet en cours.<br />
6 Choisissez OK.<br />
Lorsque vous fermez la boîte de dialogue, une bibliothèque BAS 4.5 est<br />
automatiquement créée et elle contient tous les fichiers BAS qui vous<br />
seront nécessaires pour le développement EJB. (Si votre cible est Inprise<br />
Application Server, le nom de la bibliothèque sera IAS 4.1.)<br />
Vous devez fermer puis redémarrer JBuilder pour activer les experts EJB.<br />
Si vous voulez rendre VisiBroker ORB accessible à JBuilder, vous pouvez<br />
attendre de terminer cette étape avant d’interrompre et de redémarrer<br />
JBuilder.<br />
Ajout <strong>des</strong> fichiers du serveur d’applications à votre projet<br />
Vous devez ajouter à votre projet une bibliothèque contenant les fichiers<br />
de votre serveur d’applications. Au début de chaque nouveau projet, vous<br />
devez accomplir cette étape. Si vous avez coché la case Appliquer les<br />
2-2 Guide du dé veloppeur Enterprise JavaBeans
Rendre ORB accessible à JBuilder<br />
paramètres pour le serveur d’application modifié au projet en cours dans<br />
la boîte de dialogue Configuration Entreprise, vous pouvez, pour cette<br />
fois, sauter cette étape car JBuilder a déjà ajouté la bibliothèque appropriée<br />
au projet en cours. Mais, au prochain démarrage d’un nouveau projet,<br />
vous devrez respecter les étapes suivantes pour ajouter une bibliothèque<br />
au projet en cours :<br />
1 Choisissez Projet|Propriétés du projet et assurez-vous que l’onglet<br />
Chemins est sélectionné.<br />
2 Cliquez sur l’onglet Bibliothèques nécessaires.<br />
3 Cliquez sur le bouton Ajouter pour afficher la boîte de dialogue<br />
Sélection de bibliothèques. Les bibliothèques disponibles dépendent<br />
<strong>des</strong> serveurs d’applications installés et configurés avec Outils|<br />
Configuration Entreprise.<br />
4 Sélectionnez la bibliothèque appropriée. Par exemple, si vous ciblez<br />
Borland AppServer, sélectionnez la bibliothèque BAS 4.5 et cliquez<br />
deux fois sur OK pour fermer les boîtes de dialogue.<br />
Rendre ORB accessible à JBuilder<br />
Lorsque vous utilisez Outils|Configuration Entreprise pour définir<br />
Borland AppServer ou Inprise Application Server, vos paramètres<br />
CORBA sont automatiquement configurés en même temps. Vous pouvez<br />
voir les paramètres en cours sur la page CORBA de la boîte de dialogue<br />
Configuration Entreprise. Vous pouvez souhaiter utiliser cette page pour<br />
définir le port SmartAgent de VisiBroker par un numéro unique. De<br />
même, pour ajouter au menu Outils une commande démarrant le<br />
SmartAgent, cochez l’option Ajouter un nouvel élément Smart Agent<br />
VisiBroker au menu Outils.<br />
Configuration du serveur d’ applications cible 2-3
S é lection d’ un serveur d’ applications<br />
Il reste encore une étape à accomplir : démarrer le SmartAgent VisiBroker.<br />
Cela gère les problèmes d’amorçage initial comme la façon dont le client<br />
localise le service d’annuaire, ou autre.<br />
Pour démarrer le Smart Agent, choisissez Outils|Smart Agent VisiBroker.<br />
Sélection d’un serveur d’applications<br />
JBuilder peut cibler un <strong>des</strong> multiples serveurs d’applications. Après avoir<br />
sélectionné le serveur d’applications cible, terminez la configuration de<br />
JBuilder en modifiant les propriétés de votre projet :<br />
1 Choisissez Projet|Propriétés du projet.<br />
2 Cliquez sur l’onglet Serveurs.<br />
3 Cliquez sur le bouton à points de suspension pour afficher la boîte de<br />
dialogue Sélection du serveur d’applications. Les serveurs<br />
d’applications disponibles dans la boîte de dialogue dépendent <strong>des</strong><br />
serveurs d’applications supportés par JBuilder, du fait qu’ils aient été<br />
ajoutés en utilisant l’API OpenTools de JBuilder ou le bouton Ajouter<br />
de cette boîte de dialogue.<br />
4 Sélectionnez le serveur d’applications sur lequel s’exécuteront les <strong>beans</strong><br />
que vous construisez. Borland AppServer 4.5 est le serveur par défaut.<br />
L’option EJB 1.1 est générique. Sélectionnez-la si le serveur<br />
d’applications que vous utilisez n’est actuellement pas pris en charge<br />
par JBuilder. Vous pouvez modifier le <strong>des</strong>cripteur de déploiement<br />
résultant à l’aide <strong>des</strong> outils fournis avec ce serveur d’applications, pour<br />
définir les paramètres exactement comme vous le souhaitez. Vous<br />
pouvez également choisir cette option si vous ne ciblez aucun serveur<br />
d’applications particulier.<br />
5 Choisissez OK pour fermer la boîte de dialogue.<br />
2-4 Guide du dé veloppeur Enterprise JavaBeans
Chapitre<br />
3<br />
Chapitre3Création <strong>des</strong><br />
<strong>enterprise</strong> <strong>beans</strong><br />
avec JBuilder<br />
Chaque <strong>enterprise</strong> bean que vous créez doit appartenir à un groupe EJB<br />
de JBuilder. Un groupe EJB est un groupement logique d’un ou de<br />
plusieurs <strong>beans</strong> qui seront déployés dans un même fichier JAR. Il contient<br />
les informations utilisées pour produire le ou les <strong>des</strong>cripteurs de<br />
déploiement pour ce fichier JAR. Vous pouvez modifier le contenu d’un<br />
groupe EJB avec l’éditeur de <strong>des</strong>cripteur de déploiement.<br />
Lorsque vous disposez d’un groupe EJB et que vous l’avez modifié pour<br />
votre liaison avec l’éditeur de <strong>des</strong>cripteur de déploiement, vous pouvez<br />
Construire ou Reconstruire le groupe EJB pour produire le JAR. JBuilder<br />
utilise le <strong>des</strong>cripteur de déploiement pour vous aider à identifier les<br />
fichiers classe à empaqueter.<br />
Selon l’extension de son nom de fichier, un groupe EJB peut appartenir à<br />
l’un ou à l’autre <strong>des</strong> deux types suivants :<br />
.ejbgrp<br />
.ejbgrpx<br />
Un fichier binaire.<br />
Un fichier XML. L’information est la même que dans un<br />
fichier .ejbgrp mais, comme c’est un fichier texte, il est plus<br />
facile de travailler avec lorsque vous utilisez un système de<br />
contrôle de version.<br />
Vous pouvez avoir plusieurs groupes EJB dans un projet. Tous les<br />
groupes EJB d’un même projet utilisent le même chemin de classes du<br />
projet et le même JDK, ils sont aussi configurés pour le même serveur<br />
d’applications cible.<br />
Si ce n’est déjà fait, suivez les instructions décrites au Chapitre 2,<br />
“Configuration du serveur d’applications cible”. Vous devez suivre les<br />
Cré ation <strong>des</strong> <strong>enterprise</strong> <strong>beans</strong> avec JBuilder 3-1
Cré ation d’ un groupe EJB<br />
Création d’un groupe EJB<br />
étapes permettant d’ajouter la bibliothèque contenant les fichiers de votre<br />
serveur d’applications à chaque projet EJB que vous entreprenez.<br />
Il y a deux façons de créer un groupe EJB :<br />
• Utiliser l’expert Groupe EJB vide pour créer un groupe EJB vide lorsque<br />
vous n’avez pas encore créé vos <strong>enterprise</strong> <strong>beans</strong>.<br />
• Utiliser l’expert Groupe EJB depuis <strong>des</strong>cripteurs pour créer un EJB à<br />
partir <strong>des</strong> <strong>des</strong>cripteurs de déploiement <strong>des</strong> <strong>enterprise</strong> <strong>beans</strong> dont vous<br />
disposez.<br />
Si vous n’avez pas ouvert de projet avant de lancer l’expert de groupe EJB,<br />
JBuilder affiche d’abord l’expert projet. L’expert EJB apparaît après la<br />
création d’un nouveau projet.<br />
Création d’un groupe EJB vide<br />
Remarque<br />
Si vous n’avez pas encore créé vos <strong>enterprise</strong> <strong>beans</strong>, commencez par créer<br />
un groupe EJB vide. Pour créer un groupe EJB vide,<br />
1 Choisissez Fichier|Nouveau et cliquez sur l’onglet Entreprise.<br />
Si les experts EJB de la page Entreprise sont estompés, vous n’avez pas<br />
encore configuré votre serveur d’applications. Pour plus<br />
d’informations sur la façon de le faire, voir Chapitre 2, “Configuration<br />
du serveur d’applications cible”.<br />
2 Double-cliquez sur l’icône de l’expert Groupe EJB vide pour faire<br />
apparaître l’expert :<br />
3-2 Guide du dé veloppeur Enterprise JavaBeans
3 Spécifiez le nom du groupe EJB.<br />
Cré ation d’ un groupe EJB<br />
4 Spécifiez le type du nouveau groupe.<br />
Les choix sont ejbgrp, qui stocke en interne les <strong>des</strong>cripteurs de<br />
déploiement au format .zip et était utilisé avant JBuilder 5, et ejbgrpx,<br />
qui stocke les <strong>des</strong>cripteurs de déploiement au format XML. Le format<br />
XML permet aux utilisateurs de fusionner les modifications s’ils les<br />
vérifient à l’aide d’un système de contrôle <strong>des</strong> sources. Nous<br />
recommandons ejbgrpx sauf si vous partagez le fichier avec une<br />
version antérieure de JBuilder.<br />
5 Spécifiez le nom du fichier JAR où vous mettrez votre ou vos <strong>enterprise</strong><br />
<strong>beans</strong>.<br />
JBuilder propose une valeur par défaut correspondant au nom de votre<br />
groupe EJB. Vous pouvez accepter ce nom ou en saisir un autre.<br />
JBuilder propose également un chemin d’accès basé sur le chemin de<br />
votre projet. Vous pouvez modifier ou accepter le chemin par défaut.<br />
6 Cliquez sur OK pour créer le groupe EJB.<br />
Création d’un groupe EJB à partir d’<strong>enterprise</strong> <strong>beans</strong><br />
existant<br />
Si vous disposez déjà d’<strong>enterprise</strong> <strong>beans</strong> BAS, ajoutez-les au groupe EJB<br />
en suivant les étapes ci-<strong>des</strong>sous :<br />
1 Choisissez Fichier|Nouveau et cliquez sur l’onglet Entreprise.<br />
2 Double-cliquez sur l’icône de l’expert Groupe EJB depuis <strong>des</strong>cripteurs<br />
pour faire apparaître l’expert.<br />
3 Spécifiez le nom de votre nouveau groupe EJB.<br />
Cré ation <strong>des</strong> <strong>enterprise</strong> <strong>beans</strong> avec JBuilder 3-3
Cré ation d’ un <strong>enterprise</strong> bean<br />
4 Spécifiez le type du nouveau groupe.<br />
Les choix sont ejbgrp, qui stocke en interne les <strong>des</strong>cripteurs de<br />
déploiement au format .zip et était utilisé avant JBuilder 5, et ejbgrpx,<br />
qui stocke les <strong>des</strong>cripteurs de déploiement au format XML. Le format<br />
XML permet aux utilisateurs de fusionner les modifications s’ils les<br />
vérifient à l’aide d’un système de contrôle <strong>des</strong> sources. Nous<br />
recommandons ejbgrpx sauf si vous partagez le fichier avec une<br />
version antérieure de JBuilder.<br />
5 Spécifiez le nom et le chemin du fichier JAR où sera votre <strong>enterprise</strong><br />
bean.<br />
JBuilder propose une valeur par défaut correspondant au nom de votre<br />
groupe EJB. Vous pouvez accepter ce nom ou en saisir un autre.<br />
6 Cliquez sur Suivant et spécifiez le répertoire contenant le ou les<br />
<strong>des</strong>cripteurs de déploiement que vous voulez ajouter au groupe.<br />
L’expert vous montre alors les <strong>des</strong>cripteurs de déploiement présents<br />
dans le répertoire spécifié dans le champ Descripteurs utilisables<br />
trouvés.<br />
Création d’un <strong>enterprise</strong> bean<br />
7 Cliquez sur Terminer pour créer le groupe EJB contenant les<br />
<strong>des</strong>cripteurs de déploiement <strong>des</strong> <strong>beans</strong> existants.<br />
La galerie d’objets de JBuilder contient deux experts permettant de créer<br />
<strong>des</strong> <strong>enterprise</strong> <strong>beans</strong> : l’expert Enterprise JavaBean et le Modeleur Bean<br />
entité EJB. Le menu Experts en contient un autre : l’expert Créateur de<br />
bean EJB. Cette section explique comment créer un <strong>enterprise</strong> bean avec<br />
l’expert Enterprise JavaBean.<br />
3-4 Guide du dé veloppeur Enterprise JavaBeans
Cré ation d’ un <strong>enterprise</strong> bean<br />
L’expert Enterprise JavaBean et l’expert Modeleur Bean entité EJB utilisent<br />
un modèle dans lequel la classe et les interfaces locale et distante de votre<br />
<strong>enterprise</strong> bean sont créées en même temps. Si vous préférez commencer<br />
le développement de votre <strong>enterprise</strong> bean en créant en premier votre<br />
interface distante, voyez “Génération de la classe du bean à partir d’une<br />
interface distante”, page 3-12, pour savoir comment utiliser l’expert<br />
Créateur de bean EJB afin de générer la classe de votre bean à partir de<br />
l’interface distante que vous avez créée.<br />
Pour commencer à créer un <strong>enterprise</strong> bean avec l’expert Enterprise<br />
JavaBean,<br />
1 Choisissez Fichier|Nouveau et cliquez sur l’onglet Entreprise.<br />
2 Double-cliquez sur l’icône de l’expert Enterprise JavaBean.<br />
L’expert apparaît.<br />
3 Dans la liste déroulante, sélectionnez le groupe EJB auquel vous voulez<br />
faire appartenir votre <strong>enterprise</strong> bean. Cliquez sur Suivant pour passer<br />
à l’étape 2 de l’expert.<br />
Si vous n’avez pas défini de groupe EJB avant de lancer l’expert<br />
Enterprise JavaBeans ou si vous voulez en créer un nouveau, cliquez<br />
sur le bouton Nouveau pour lancer l’expert Groupe EJB vide. Vous<br />
devez avoir défini au moins un groupe EJB dans votre projet avant de<br />
pouvoir créer un <strong>enterprise</strong> bean. Lorsque le groupe EJB a été créé avec<br />
Cré ation <strong>des</strong> <strong>enterprise</strong> <strong>beans</strong> avec JBuilder 3-5
Cré ation d’ un <strong>enterprise</strong> bean<br />
l’expert Groupe EJB vide, sélectionnez le nouveau groupe et choisissez<br />
Suivant pour reprendre les étapes de l’expert Enterprise JavaBean.<br />
4 Spécifiez le nom de classe de votre bean, la paquet qui le contiendra et<br />
sa classe de base.<br />
Ensuite, vous devez décider si vous créez un bean session ou un bean<br />
entité.<br />
Création d’un bean session<br />
Si vous créez un bean session,<br />
1 Cliquez sur Bean session stateless ou sur Bean session stateful.<br />
Pour plus d’ informations sur les types de <strong>beans</strong> session, voir “Types de<br />
<strong>beans</strong> session”, page 9-1.<br />
2 Si vous sélectionnez un Bean session stateful, vous pouvez aussi choisir<br />
d’implémenter l’interface SessionSynchronization en cochant la case<br />
Synchronisation de session.<br />
Pour plus d’informations sur l’interface SessionSynchronization, voir<br />
“L’interface SessionSynchronization”, page 9-8.<br />
3-6 Guide du dé veloppeur Enterprise JavaBeans
3 Cliquez sur Suivant pour aller à l’étape 3.<br />
Cré ation d’ un <strong>enterprise</strong> bean<br />
4 Spécifiez <strong>des</strong> noms pour les Classe de l’interface locale, Classe de<br />
l’interface distante et Nom du bean local ; JBuilder propose <strong>des</strong> noms<br />
par défaut en se servant du nom de classe de votre bean.<br />
5 Cliquez sur Terminer.<br />
Création d’un bean entité<br />
Si vous créez un bean entité,<br />
1 Choisissez entre les options Bean entité à persistance gérée par Bean et<br />
Bean entité EJB 1.1 à persistance gérée par conteneur. (Si WebSphere 3.5<br />
est votre serveur d’applications cible, la seconde option est Bean entité<br />
EJB 1.0 à persistance gérée par conteneur.)<br />
Pour plus d’informations sur la persistance gérée par le bean ou par le<br />
conteneur, voir “Persistance et <strong>beans</strong> entité”, page 10-1.<br />
2 Spécifiez une Classe clé primaire.<br />
Cré ation <strong>des</strong> <strong>enterprise</strong> <strong>beans</strong> avec JBuilder 3-7
Cré ation d’ un <strong>enterprise</strong> bean<br />
3 Cliquez sur Suivant pour aller à l’étape 3.<br />
4 Spécifiez <strong>des</strong> noms pour les Classe de l’interface locale, Classe de<br />
l’interface distante et Nom du bean local ; JBuilder propose <strong>des</strong> noms<br />
par défaut en se servant du nom de classe de votre bean.<br />
5 Cliquez sur Terminer.<br />
Lorsque vous avez cliqué sur le bouton Terminer, JBuilder crée la classe<br />
du bean et ses interfaces locale et distante. Vous les verrez apparaître dans<br />
le volet projet. Examinez le code source de la classe du bean et vous verrez<br />
que la classe implémente l’interface SessionBean s’il s’agit d’un bean<br />
session et qu’elle implémente l’interface EntityBean s’il s’agit d’un bean<br />
entité. JBuilder a ajouté <strong>des</strong> métho<strong>des</strong> dont le corps vide : ce sont les<br />
métho<strong>des</strong> que tous les <strong>enterprise</strong> <strong>beans</strong> doivent implémenter. Vous<br />
pouvez ajouter au corps de ces métho<strong>des</strong> le code qui fournit la logique<br />
nécessaire à votre bean lorsque qu’elles sont appelées.<br />
L’interface locale étend l’interface EJBHome et contient la méthode create()<br />
qui crée le bean. L’interface distante étend l’interface EJBObject mais elle<br />
est vide car vous n’avez déclaré aucune méthode de logique métier pour<br />
votre bean.<br />
Bien que vous puissiez commencer votre bean entité en utilisant l’expert<br />
Enterprise JavaBeans, le meilleur moyen de créer <strong>des</strong> <strong>beans</strong> entité est<br />
d’utiliser le Modeleur Bean entité EJB. Les <strong>beans</strong> entité que vous créez<br />
avec l’expert Enterprise JavaBean ne supporteront pas la vérification de<br />
l’éditeur de <strong>des</strong>cripteur de déploiement si vous ne complétez pas le bean<br />
plus avant.<br />
3-8 Guide du dé veloppeur Enterprise JavaBeans
Ajout de la logique métier à votre bean<br />
Cré ation d’ un <strong>enterprise</strong> bean<br />
Dans le code source de la classe de votre bean, définissez et écrivez les<br />
métho<strong>des</strong> qui implémentent la logique nécessaire à votre <strong>enterprise</strong> bean.<br />
Si vous devez lui ajouter <strong>des</strong> propriétés, vous pouvez soit les ajouter<br />
directement dans le code source, soit utiliser la page Propriétés du<br />
concepteur de bean.<br />
Pour utiliser le concepteur de bean afin de mettre en œuvre les propriétés,<br />
1 Double-cliquez sur la classe du bean dans le volet projet.<br />
2 Cliquez sur l’onglet Bean pour afficher le concepteur de bean.<br />
3 Cliquez sur l’onglet Propriétés pour afficher la page Propriétés.<br />
Cré ation <strong>des</strong> <strong>enterprise</strong> <strong>beans</strong> avec JBuilder 3-9
Cré ation d’ un <strong>enterprise</strong> bean<br />
Pour ajouter une nouvelle propriété,<br />
1 Cliquez sur le bouton Ajouter une propriété pour afficher la boîte de<br />
dialogue Nouvelle propriété.<br />
2 Spécifiez le Nom de propriété et le Type.<br />
3 Spécifiez vos métho<strong>des</strong> d’accès en définissant les options Getter et<br />
Setter.<br />
Si vous voulez que votre propriété possède une méthode getter, vous<br />
devez choisir si elle doit apparaître dans la classe et/ou dans l’interface<br />
distante du bean. Si vous voulez que votre propriété possède une<br />
méthode setter, vous devez choisir si elle doit apparaître dans la classe<br />
et/ou dans l’interface distante du bean.<br />
4 Choisissez Appliquer pour ajouter immédiatement la nouvelle<br />
propriété au code source de votre bean. Les métho<strong>des</strong> d’accès que vous<br />
spécifiez sont ajoutées à la classe et/ou à l’interface distante du bean,<br />
selon les options choisies.<br />
5 Vous pouvez continuer d’ajouter de nouvelles propriétés dans la boîte<br />
de dialogue. Cliquez sur OK une fois terminé.<br />
Si vous utilisez l’expert Enterprise JavaBean pour initialiser un bean entité<br />
dont la persistance est gérée par le conteneur, vous ajouterez <strong>des</strong><br />
propriétés à votre bean. N’oubliez pas qu’une <strong>des</strong> propriétés doit être la<br />
clé primaire et que vous devez spécifier le ou les champs qui la constituent<br />
dans le panneau Persistence de l’éditeur de <strong>des</strong>cripteur de déploiement. Si<br />
vous ne le faites pas, l’éditeur de <strong>des</strong>cripteur de déploiement ne pourra<br />
pas vérifier la validité du <strong>des</strong>cripteur de déploiement.<br />
Vous pouvez aussi utiliser le page Propriétés pour modifier une propriété.<br />
Par exemple, si vous ne spécifiez pas de setter pour une propriété lorsque<br />
vous la déclarez et si vous décidez ensuite que votre bean en a besoin,<br />
vous n’avez qu’à cocher la case Setter de cette propriété dans la page<br />
Propriétés : JBuilder ajoutera la méthode setter à votre code source. Ou<br />
encore, vous pouvez supprimer une méthode getter ou setter en<br />
supprimant la coche de la case correspondante.<br />
3-10 Guide du dé veloppeur Enterprise JavaBeans
Cré ation d’ un <strong>enterprise</strong> bean<br />
Pour enlever une propriété à un bean en utilisant le page Propriétés,<br />
1 Sélectionnez la propriété listée dans la table <strong>des</strong> propriétés.<br />
2 Cliquez sur le bouton Remove.<br />
JBuilder vous demande si vous voulez supprimer la propriété et le code<br />
qui lui est associé.<br />
3 Choisissez Oui.<br />
Vous pouvez aussi utiliser la page Propriétés pour modifier le nom de la<br />
propriété et son type. Le concepteur de bean est un outil bidirectionnel, les<br />
modifications effectuées dans la page Propriétés se retrouvent dans le<br />
code et les modifications apportées au code se retrouvent dans la page<br />
Propriétés.<br />
Exposition <strong>des</strong> métho<strong>des</strong> métier via l’interface distante<br />
Une fois les métho<strong>des</strong> de logique métier déclarées dans le code source de<br />
votre bean, vous devez spécifier quelles sont celles que vous voulez<br />
ajouter à l’interface distante. Le client ne peut appeler que les métho<strong>des</strong><br />
exposées via l’interface distante du bean.<br />
Pour ajouter <strong>des</strong> métho<strong>des</strong> à l’interface distante,<br />
1 Double-cliquez sur l’<strong>enterprise</strong> bean dans le volet projet.<br />
2 Cliquez sur l’onglet Bean pour afficher le concepteur de bean.<br />
3 Cliquez sur l’onglet Métho<strong>des</strong>.<br />
4 Dans la boîte Métho<strong>des</strong>, cochez les cases situées à côté <strong>des</strong> métho<strong>des</strong><br />
que vous voulez exposer dans l’interface distante.<br />
Cré ation <strong>des</strong> <strong>enterprise</strong> <strong>beans</strong> avec JBuilder 3-11
G é n é ration de la classe du bean à partir d’ une interface distante<br />
Au fur et à mesure que vous cochez <strong>des</strong> métho<strong>des</strong> dans la boîte Métho<strong>des</strong>,<br />
elles sont ajoutées à l’interface distante.<br />
Pour supprimer une méthode de l’interface distante, supprimez la coche<br />
de la case de la méthode dans la boîte Métho<strong>des</strong>.<br />
Pour modifier une <strong>des</strong> métho<strong>des</strong>, cliquez <strong>des</strong>sus avec le bouton droit pour<br />
afficher le menu contextuel et choisissez Modifier la sélection. Le fichier<br />
s’ouvre dans l’éditeur de code, votre curseur est positionné sur la<br />
méthode, et vous pouvez la modifier immédiatement.<br />
Le menu contextuel offre d’autres comman<strong>des</strong> intéressantes. Vous pouvez<br />
choisir Retirer ce qui est sélectionné pour supprimer une méthode de la<br />
classe du bean. Choisir Tout cocher coche toutes les métho<strong>des</strong> et les ajoute<br />
toutes à l’interface distante ; choisir Tout décocher supprime la sélection<br />
de toutes les métho<strong>des</strong> de sorte qu’aucune méthode n’est ajoutée à<br />
l’interface distante.<br />
Vous pouvez utiliser la page Métho<strong>des</strong> pour vérifier que les métho<strong>des</strong><br />
déclarées dans la classe de votre bean ont la même signature que dans<br />
l’interface locale et l’interface distante. Par exemple, imaginons que vous<br />
avez ajouté un paramètre à la méthode ejbCreate() dans la classe de votre<br />
bean, mais négligé de le faire pour la méthode create() de l’interface<br />
locale. La boîte Métho<strong>des</strong> affichera la méthode ejbCreate() et la méthode<br />
create() en caractères de couleur rouge. Si vous cliquez sur une méthode<br />
affichée en rouge, une boîte Description du problème apparaîtra et décrira<br />
la nature du problème. Vous pourrez alors ajouter le paramètre à la<br />
méthode create() pour unifier les signatures <strong>des</strong> métho<strong>des</strong> et régler le<br />
problème. Ou, si vous supprimez <strong>des</strong> métho<strong>des</strong> dans la classe de votre<br />
bean mais oubliez de le faire dans l’interface distante, la boîte Métho<strong>des</strong><br />
affichera ces métho<strong>des</strong> en rouge pour vous rappeler de les supprimer<br />
aussi dans l’interface distante.<br />
Génération de la classe du bean à partir d’une interface distante<br />
Certains développeurs préfèrent commencer le développement d’un<br />
<strong>enterprise</strong> bean en concevant l’interface distante. Si cette approche vous<br />
convient, vous pouvez utiliser le Créateur de bean EJB pour générer le<br />
squelette de la classe du bean à partir de votre interface distante existante.<br />
Pour générer la classe du bean à partir d’une interface distante,<br />
1 Affichez l’interface distante dans l’éditeur.<br />
3-12 Guide du dé veloppeur Enterprise JavaBeans
G é n é ration de la classe du bean à partir d’ une interface distante<br />
2 Choisissez Experts|EJB|Créateur de bean EJB pour afficher l’expert<br />
Créateur de bean EJB.<br />
3 Sélectionnez le groupe EJB auquel appartient le bean et cliquez sur<br />
Suivant.<br />
4 Sélectionnez le type d’EJB que vous voulez générer et cliquez sur<br />
Suivant.<br />
Cré ation <strong>des</strong> <strong>enterprise</strong> <strong>beans</strong> avec JBuilder 3-13
G é n é ration de la classe du bean à partir d’ une interface distante<br />
Si vous avez sélectionné une <strong>des</strong> options <strong>des</strong> <strong>beans</strong> session, cette page<br />
apparaît:<br />
• Spécifiez les Options de bean EJB : Classe Bean, Nom de bean,<br />
interface locale et Nom JNDI.<br />
Si vous avez sélectionné une <strong>des</strong> options <strong>des</strong> <strong>beans</strong> entité CMP, cet<br />
écran apparaît:<br />
• Spécifiez les Options de bean EJB : Classe Bean, Nom de bean,<br />
interface locale et Nom JNDI, Classe clé primaire, et les champs que<br />
voulez rendre persistants.<br />
5 Choisissez Terminer.<br />
Le Créateur de bean EJB crée le squelette de la classe du bean spécifié<br />
en incluant les métho<strong>des</strong> trouvées dans l’interface distante. Dans la<br />
3-14 Guide du dé veloppeur Enterprise JavaBeans
Cré ation <strong>des</strong> interfaces locale et distante d’ un bean existant<br />
classe générée, ces métho<strong>des</strong> contiennent un commentaire vous<br />
rappelant de compléter leurs implémentations. Vous devez ajouter<br />
votre propre code aux métho<strong>des</strong> pour les implémenter à votre<br />
convenance.<br />
Le Créateur de Bean EJB crée aussi une interface locale s’il en existe pas.<br />
S’il existe déjà une interface locale, le Créateur de Bean EJB vous<br />
demande si vous voulez remplacer l’interface locale et agit en fonction<br />
de la réponse.<br />
Création <strong>des</strong> interfaces locale et distante d’un bean existant<br />
Si vous avez déjà la classe d’un bean, mais pas les interfaces locale et<br />
distante requises, vous pouvez utiliser l’expert Créateur d’interface EJB<br />
pour les générer. Vous pouvez aussi utiliser l’expert si vous avez fait <strong>des</strong><br />
modifications significatives dans le code source de votre bean et si vous<br />
voulez que ces modifications se retrouvent dans les interfaces. En utilisant<br />
le Créateur d’interface EJB, vous régénérez de nouvelles interfaces basées<br />
sur le nouveau code source de la classe du bean.<br />
Pour utiliser l’expert Créateur d’interface EJB,<br />
1 Ouvrez le code source de la classe de votre bean dans l’éditeur de code.<br />
2 Choisissez Experts|EJB|Créateur d’interface EJB.<br />
3 Sélectionnez le groupe EJB auquel appartient le bean et cliquez sur<br />
Suivant.<br />
Cré ation <strong>des</strong> <strong>enterprise</strong> <strong>beans</strong> avec JBuilder 3-15
Cré ation <strong>des</strong> interfaces locale et distante d’ un bean existant<br />
Cette page apparaît pour un bean session :<br />
Cette page apparaît pour un bean entité :<br />
4 Acceptez les noms par défaut ou entrez-en d’autres.<br />
5 Si l’<strong>enterprise</strong> bean est un bean session, sélectionnez l’option Stateless<br />
ou l’option Stateful. Si l’<strong>enterprise</strong> bean est un bean entité, sélectionnez<br />
l’option Persistance gérée par bean ou l’option Persistance gérée par<br />
conteneur.<br />
3-16 Guide du dé veloppeur Enterprise JavaBeans
Compilation du bean<br />
6 Cliquez sur Suivant pour passer à l’étape 3, qui affiche les métho<strong>des</strong> du<br />
bean :<br />
Compilation du bean<br />
7 Laissez sélectionnées les métho<strong>des</strong> que vous voulez exposer dans<br />
l’interface distante et supprimez la coche de celles que vous ne voulez<br />
pas faire apparaître dans cette interface.<br />
8 Choisissez Terminer.<br />
Lorsque vous avez écrit et enregistré votre <strong>enterprise</strong> bean, ses interfaces<br />
et toutes les classes de support éventuelles, vous êtes presque prêt à<br />
compiler. Auparavant et uniquement si votre cible est Borland AppServer<br />
ou Inprise Application Server 4.1 et si vous voulez tester votre bean en<br />
local, générez et ajoutez les stubs client à votre chemin d’accès aux classes.<br />
Pour cela, modifiez les propriétés de construction de votre interface locale<br />
et compilez.<br />
Pour modifier les propriétés de construction d’un groupe EJB afin de<br />
générer et d’ajouter les stubs client à votre chemin d’accès aux classes<br />
pour chacun <strong>des</strong> <strong>beans</strong> du groupe (cette étape est facultative),<br />
1 Cliquez avec le bouton droit sur le groupe EJB dans le volet projet et<br />
choisissez Propriétés.<br />
2 Sélectionnez l’onglet Construction.<br />
Cré ation <strong>des</strong> <strong>enterprise</strong> <strong>beans</strong> avec JBuilder 3-17
Compilation du bean<br />
3 Sélectionnez l’onglet EJB.<br />
4 Modifiez les propriétés de construction à votre convenance.<br />
Vous pouvez changer le nom du fichier JAR de <strong>des</strong>tination et<br />
l’emplacement où il est généré.<br />
Si, pour modifier les <strong>des</strong>cripteurs de déploiement, vous voulez utiliser<br />
un autre outil que l’éditeur de <strong>des</strong>cripteur de déploiement de JBuilder,<br />
modifiez les <strong>des</strong>cripteurs de déploiement avec l’outil de votre choix.<br />
Vous pouvez également insérer <strong>des</strong> <strong>des</strong>cripteurs de déploiement dans<br />
un groupe EJB et copier <strong>des</strong> <strong>des</strong>cripteurs de déploiement n’importe où<br />
ailleurs. Vous pouvez aussi supprimer un <strong>des</strong>cripteur de déploiement.<br />
Si vous voulez que soient ajoutés au fichier JAR <strong>des</strong> fichiers<br />
supplémentaires, cliquez sur le bouton Ajouter et spécifiez<br />
l’emplacement de ces fichiers. Cela vous sera utile si, par exemple, vous<br />
avez ajouté une nouvelle classe à votre projet et si vous voulez qu’elle<br />
fasse partie du fichier JAR. Ou, si vous avez <strong>des</strong> <strong>des</strong>cripteurs de<br />
déploiement que vous avez modifiés hors de JBuilder, vous pouvez les<br />
ajouter ici en ne sélectionnant pas Inclure les <strong>des</strong>cripteurs de<br />
déploiement dans le fichier JAR <strong>des</strong>tination. Les <strong>des</strong>cripteurs de<br />
déploiement montrés dans la liste Descripteurs de déploiement dans le<br />
groupe ne seront pas ajoutés au fichier JAR, mais ceux spécifiées dans<br />
la liste Fichiers supplémentaires pour le répertoire META-INF dans<br />
JAR le seront.<br />
Si vous ciblez plusieurs serveurs d’applications différents, vous pouvez<br />
utiliser l’option Retirer les fichiers stubs lors <strong>des</strong> modifications du<br />
3-18 Guide du dé veloppeur Enterprise JavaBeans
Compilation du bean<br />
serveur d’applications pour supprimer les stubs client utilisés par<br />
l’ancien serveur d’applications lorsque vous en choisissez un nouveau.<br />
L’option Toujours créer un JAR lors de la construction du projet est<br />
activée par défaut. En ne sélectionnant pas cette option, vous pouvez<br />
différer la construction du fichier JAR jusqu’à ce que vous soyez prêt à<br />
commencer les tests.<br />
5 Cliquez sur l’onglet du serveur d’applications que vous ciblez. Par<br />
exemple, cette image illustre la sélection de l’onglet BAS 4.5 :<br />
6 Sélectionnez les options de construction que vous souhaitez. Si vous<br />
avez besoin d’informations sur les options disponibles, cliquez sur le<br />
bouton Aide.<br />
Vous pouvez également modifier les propriétés de construction de chaque<br />
bean plutôt que de l’ensemble du groupe EJB :<br />
1 Cliquez avec le bouton droit sur l’interface locale du bean et choisissez<br />
Propriétés.<br />
2 Cliquez sur l’onglet Construction.<br />
3 Cliquez sur l’onglet VisiBroker.<br />
4 Cochez la case Créer IIOP et sélectionnez toute autre option Java2IIOP<br />
nécessaire.<br />
5 Cliquez sur OK.<br />
Pour compiler toutes les classes du projet, cliquez avec le bouton droit sur<br />
le fichier projet (.jpx) et choisissez Construire, ou choisissez<br />
directement Projet|Construire le projet.<br />
Cré ation <strong>des</strong> <strong>enterprise</strong> <strong>beans</strong> avec JBuilder 3-19
Modification <strong>des</strong> <strong>des</strong>cripteurs de dé ploiement<br />
Au cours du processus de compilation, JBuilder peut détecter l’existence<br />
d’un problème dans un <strong>des</strong>cripteur de déploiement qui le rend invalide.<br />
Si cela se produit, vous verrez apparaître dans le volet message un<br />
message vous demandant de vérifier le bean dans l’éditeur de <strong>des</strong>cripteur<br />
de déploiement. Pour plus d’informations sur la vérification d’un<br />
<strong>des</strong>cripteur de déploiement, voir “Vérification <strong>des</strong> informations du<br />
<strong>des</strong>cripteur”, page 7-28.<br />
Remarque <strong>des</strong>tinée aux utilisateurs de WebLogic. Si votre cible est le<br />
serveur WebLogic, vous provoquerez une erreur pendant le processus de<br />
construction si le répertoire temporaire ou le chemin d’accès aux classes<br />
porte un nom contenant <strong>des</strong> espaces, comme dans C:/Documents and<br />
Settings/jbprojects.<br />
Si vous avez choisi de générer les stubs client, plusieurs fichiers s’affichent<br />
désormais sous le nœud de l’interface locale dans le volet projet lorsque<br />
vous cliquez sur son icône pour le développer. Ces fichiers générés sont les<br />
stubs client et les classes Helper nécessaires au fonctionnement <strong>des</strong> EJB.<br />
Modification <strong>des</strong> <strong>des</strong>cripteurs de déploiement<br />
Chaque <strong>enterprise</strong> bean conforme aux spécifications EJB 1.1 requiert une<br />
entrée <strong>des</strong>cripteur de déploiement au format XML. Comme vous avez<br />
utilisé les experts de JBuilder pour créer un ou plusieurs <strong>enterprise</strong> <strong>beans</strong>,<br />
vous avez également créé un ou plusieurs <strong>des</strong>cripteurs de déploiement.<br />
Lorsque vous compilez votre projet, JBuilder crée un fichier JAR, en<br />
fonction du nom configuré, et l’affiche en tant que nœud sous le groupe<br />
dans le volet projet.<br />
Vous pouvez également créer le fichier JAR sans compiler tout le projet.<br />
Cliquez avec le bouton droit sur le nœud du groupe EJB dans le volet<br />
projet et sélectionnez Construire pour compiler le nœud du groupe EJB. Si<br />
vous voulez modifier les propriétés de construction avant d’exécuter la<br />
commande Construire, sélectionnez Propriétés dans le même menu et<br />
faites toutes les modifications souhaitées dans la boîte de dialogue<br />
Construction. Choisissez ensuite Construire pour générer le fichier JAR.<br />
Le fichier JAR contient tous les <strong>des</strong>cripteurs de déploiement. Chaque<br />
<strong>des</strong>cripteur de déploiement est un fichier XML, sauf pour WebSphere qui<br />
utilise un fichier .ser pour chacun <strong>des</strong> <strong>beans</strong>. Chaque fichier JAR peut<br />
contenir un ou plusieurs <strong>des</strong>cripteurs de déploiement.<br />
JBuilder ciblera un <strong>des</strong> multiples serveurs d’applications. Le serveur<br />
d’applications ciblé détermine le nombre de <strong>des</strong>cripteurs de déploiement<br />
présents dans le fichier JAR généré. Chaque fichier JAR aura un<br />
ejb-jar.xml (sauf ceux ciblant WebSphere 3.5) décrivant les attributs de<br />
déploiement <strong>des</strong> <strong>beans</strong> du groupe communs à tous les serveurs<br />
d’applications. ejb-jar.xml est le <strong>des</strong>cripteur de déploiement conforme à<br />
EJB 1.1. Si vous avez sélectionné EJB 1.1 comme serveur d’applications<br />
3-20 Guide du dé veloppeur Enterprise JavaBeans
Modification <strong>des</strong> <strong>des</strong>cripteurs de dé ploiement<br />
cible, ce sera le seul <strong>des</strong>cripteur de déploiement que le fichier JAR<br />
contiendra.<br />
Toutes les informations spécifiques au fournisseur sont stockées dans le<br />
fichier ejb-inprise.xml, même lorsque le fournisseur n’est pas Borland.<br />
Lorsque vous compilez, les fichiers XML spécifiques au fournisseur sont<br />
générés à partir de cette information. Ils sont également générés lorsque<br />
vous cliquez sur l’onglet Source de l’éditeur de <strong>des</strong>cripteur de<br />
déploiement.<br />
Si votre cible est Borland AppServer, il n’y aura qu’un fichier XML<br />
spécifique du serveur d’applications supplémentaire, ejb-inprise.xml. Si<br />
votre cible est WebLogic Server, le fichier JAR généré inclut un fichier<br />
weblogic-ejb-jar.xml et un fichier XML supplémentaire pour chaque bean<br />
entité dont la persistance est gérée par le conteneur. Si votre cible est<br />
WebSphere, le fichier JAR généré contiendra un fichier .ser pour chacun<br />
<strong>des</strong> <strong>beans</strong>.<br />
L’éditeur de <strong>des</strong>cripteur de déploiement de JBuilder permet de modifier<br />
les <strong>des</strong>cripteurs de déploiement existants.<br />
Pour afficher l’éditeur de <strong>des</strong>cripteur de déploiement, double-cliquez sur<br />
le groupe EJB dans le volet projet. L’éditeur de <strong>des</strong>cripteur de<br />
déploiement apparaît. Remarquez l’arborescence du groupe EJB qui<br />
apparaît dans le volet structure.<br />
Pour voir les informations concernant un <strong>enterprise</strong> bean dans l’éditeur de<br />
<strong>des</strong>cripteur de déploiement, cliquez sur le bean dans le volet structure.<br />
Ou, si vous sélectionnez le nœud Descripteur de déploiement EJB dans le<br />
volet structure, vous pouvez cliquer sur l’onglet Contents pour afficher le<br />
Cré ation <strong>des</strong> <strong>enterprise</strong> <strong>beans</strong> avec JBuilder 3-21
Modification <strong>des</strong> <strong>des</strong>cripteurs de dé ploiement<br />
contenu du groupe EJB et double-cliquer ensuite sur l’icône du bean que<br />
vous voulez voir. Lorsqu’un bean est sélectionné dans l’éditeur, plusieurs<br />
onglets apparaissent dans l’éditeur de <strong>des</strong>cripteur de déploiement.<br />
Utilisez ces onglets pour aller dans les panneaux où vous pouvez modifier<br />
les informations de déploiement.<br />
Notez que l’onglet Propriétés EJB n’apparaît pas si le serveur<br />
d’applications cible est Borland AppServer ou Inprise Application Server.<br />
La page Propriétés EJB vous permet de modifier les valeurs s’appliquant<br />
aux serveurs d’applications WebLogic ou WebSphere.<br />
Pour <strong>des</strong> informations détaillées sur l’utilisation de l’éditeur de<br />
<strong>des</strong>cripteur de déploiement, voir Chapitre 7, “Utilisation de l’éditeur<br />
de <strong>des</strong>cripteur de déploiement”.<br />
Après avoir modifié le <strong>des</strong>cripteur, vous pouvez vérifier le fichier pour<br />
vous assurer que les informations du <strong>des</strong>cripteur sont exactes, que les<br />
fichiers classe <strong>des</strong> <strong>beans</strong> sont présents, etc.<br />
Pour vérifier les informations du <strong>des</strong>cripteur, cliquez sur le bouton<br />
Vérifier dans la barre d’outils de l’éditeur de <strong>des</strong>cripteur de déploiement.<br />
La vérification effectue ce qui suit :<br />
• S’assure que le <strong>des</strong>cripteur respecte la spécification EJB 1.1.<br />
• S’assure que les classes référencées par les <strong>des</strong>cripteurs de déploiement<br />
respectent la spécification EJB 1.1.<br />
Si la vérification échoue, un ou plusieurs messages apparaissent dans un<br />
panneau d’historique décrivant les échecs.<br />
3-22 Guide du dé veloppeur Enterprise JavaBeans
Chapitre<br />
4<br />
<strong>beans</strong> entité<br />
à partir d’une table existante<br />
dans une base de données<br />
Chapitre4Création <strong>des</strong><br />
Souvent les données que vous souhaitez modeler dans un bean entité<br />
existent déjà dans une base de données. Vous pouvez utiliser le Modeleur<br />
Bean entité de JBuilder pour créer de tels <strong>beans</strong> entité.<br />
Création <strong>des</strong> <strong>beans</strong> entité avec le Modeleur Bean entité EJB<br />
L’expert Modeleur Bean entité EJB crée <strong>des</strong> <strong>beans</strong> entité en fonction de<br />
tables existant dans toute base de données accessible via JDBC. Vous<br />
pouvez utiliser cet expert pour créer plusieurs <strong>beans</strong> entité en même<br />
temps et spécifier n’importe quelle relation entre ces <strong>beans</strong>.<br />
Lorsque vous avez utilisé le Modeleur Bean entité EJB pour générer le<br />
code fournissant les <strong>beans</strong> entité, leurs clés primaires, leurs interfaces<br />
locale et distante et les entrées appropriées dans le <strong>des</strong>cripteur de<br />
déploiement, vous pouvez ensuite modifier les résultats avec les autres<br />
outils de JBuilder, comme le concepteur de bean, l’éditeur de <strong>des</strong>cripteur<br />
de déploiement ou l’éditeur de code.<br />
Pour afficher le modeleur de bean entité EJB, choisissez Fichier|Nouveau,<br />
cliquez sur l’onglet Entreprise et choisissez Modeleur Bean entité EJB. Si<br />
vous avez défini au moins un groupe EJB dans votre projet, le Modeleur<br />
Bean entité EJB apparaît.<br />
Cré ation <strong>des</strong> <strong>beans</strong> entité à partir d’ une table existante dans une base de donné es 4-1
Cré ation <strong>des</strong> <strong>beans</strong> entité avec le Modeleur Bean entité EJB<br />
Tous les <strong>enterprise</strong> <strong>beans</strong> développés avec JBuilder doivent appartenir à<br />
un groupe EJB. Si vous n’avez pas au moins un groupe EJB dans votre<br />
projet, cliquez sur le bouton Nouveau pour lancer l’expert Groupe EJB<br />
vide. Lorsque vous avez créé un groupe EJB avec l’expert Groupe EJB<br />
vide, le Modeleur Bean entité EJB apparaît.<br />
Pour créer un ou plusieurs <strong>beans</strong> à partir de tables de base de données<br />
existantes, suivez ces étapes :<br />
1 Sélectionnez un groupe EJB pour y placer votre bean et choisissez<br />
Suivant pour aller à l’étape 2.<br />
Le groupe EJB sélectionné sert à déterminer où seront écrites les<br />
informations de déploiement.<br />
4-2 Guide du dé veloppeur Enterprise JavaBeans
Cré ation <strong>des</strong> <strong>beans</strong> entité avec le Modeleur Bean entité EJB<br />
2 Spécifiez une source de données JDBC.<br />
Entrez les informations nécessaires à la connexion à la source de<br />
données JDBC.<br />
Pour utiliser une connexion existante, cliquez sur le bouton Choisir une<br />
connexion existante et sélectionnez une connexion. Les autres<br />
informations de cette page sont ensuite entrées automatiquement à<br />
l’exception du mot de passe, que vous devez saisir vous-même si la<br />
connexion en utilise un.<br />
S’il n’y a pas de connexion existante ou si vous voulez en créer une,<br />
sélectionnez un pilote dans la liste déroulante Pilote et spécifiez une<br />
URL.<br />
Spécifiez le Nom d’utilisateur pour la source de données et le Mot de<br />
passe, si nécessaire. Sélectionnez toutes les propriétés avancées dont<br />
vous avez besoin. Enfin, spécifiez un nom JNDI pour la source de<br />
données.<br />
3 Spécifiez les options Types de schémas et table souhaitées.<br />
Si vous cochez l’option Tous les schémas, le Modeleur Bean entité EJB<br />
chargera tous les schémas aux quels l’utilisateur a le droit de se<br />
connecter. Si vous conservez non cochée l’option Tous les schémas, il<br />
chargera les seuls schémas qui portent le nom de l’utilisateur, ce qui<br />
devrait réduire le temps nécessaire à l’établissement de la connexion et<br />
au chargement <strong>des</strong> données.<br />
Cochez l’option Vues si vous voulez que <strong>des</strong> vues soient chargées dans<br />
le Modeleur Bean entité EJB. Si vous ne voulez pas charger de vue,<br />
conservez l’option Vues non cochée.<br />
Cré ation <strong>des</strong> <strong>beans</strong> entité à partir d’ une table existante dans une base de donné es 4-3
Cré ation <strong>des</strong> <strong>beans</strong> entité avec le Modeleur Bean entité EJB<br />
Le Modeleur Bean entité EJB essaie de se connecter à la source de<br />
données spécifiée. La page suivante apparaît uniquement si la<br />
connexion réussit.<br />
4 Sélectionnez les tables que vous voulez associer aux <strong>beans</strong> entité.<br />
Pour chaque table sélectionnée, un bean entité sera créé. Dans la liste<br />
Disponibles, sélectionnez les tables voulues et faites-les passer dans la<br />
liste Sélectionnées à l’aide <strong>des</strong> boutons > et >>. Lorsque vous avez<br />
sélectionné toutes vos tables, choisissez Suivant.<br />
4-4 Guide du dé veloppeur Enterprise JavaBeans
Cré ation <strong>des</strong> <strong>beans</strong> entité avec le Modeleur Bean entité EJB<br />
5 Sélectionnez les colonnes de chaque table que vous voulez associer aux<br />
champs <strong>des</strong> <strong>beans</strong> entité et spécifiez toutes les relations que vous<br />
voulez établir entre les tables.<br />
Dans la section Tables et liaisons, vous verrez toutes les tables<br />
sélectionnées à l’étape précédente. Sélectionnez tour à tour chaque table<br />
en cliquant <strong>des</strong>sus et utilisez ensuite la section Colonnes de la table<br />
sélectionnée pour placer chaque colonne de la table dans la liste<br />
Disponibles ou dans la liste Sélectionnées. Par défaut, toutes les<br />
colonnes de toutes les tables sont sélectionnées.<br />
Vous pouvez établir <strong>des</strong> relations entre les tables en faisant glisser le<br />
pointeur de la souris d’une table à l’autre dans la section Tables et<br />
liaisons, à gauche. Vous pouvez également utiliser le bouton Ajouter un<br />
lien. Lorsque vous avez choisi une de ces deux métho<strong>des</strong>, une boîte de<br />
dialogue apparaît et vous propose une relation établie entre les deux<br />
tables, en fonction de leurs clés étrangères et primaires, de leurs index<br />
uniques, <strong>des</strong> noms et <strong>des</strong> types de leurs champs. Vous pouvez accepter<br />
cette relation ou la modifier pour en créer une autre. Pour supprimer<br />
un lien entre <strong>des</strong> tables, choisissez Retirer le lien.<br />
Voici un exemple de trois tables liées entre elles :<br />
Cré ation <strong>des</strong> <strong>beans</strong> entité à partir d’ une table existante dans une base de donné es 4-5
Cré ation <strong>des</strong> <strong>beans</strong> entité avec le Modeleur Bean entité EJB<br />
Lorsque vous avez sélectionné dans chaque table toutes les colonnes<br />
que vous voulez associer aux champs <strong>des</strong> <strong>beans</strong> entité que vous êtes en<br />
train de créer, choisissez Suivant.<br />
6 Spécifiez les noms et les types de données <strong>des</strong> champs <strong>des</strong> <strong>beans</strong> entité<br />
à faire correspondre aux colonnes <strong>des</strong> tables.<br />
Cliquez sur l’onglet approprié pour sélectionner la table par laquelle<br />
vous voulez commencer le processus. Pour chaque colonne de cette<br />
table, un Nom de champ et un Type de champ vous sont proposés.<br />
Vous pouvez accepter ces propositions ou modifier les noms et types<br />
suggérés pour qu’ils soient comme vous le voulez.<br />
Pour modifier le type de données de plusieurs champs en même temps,<br />
sélectionnez les champs souhaités et choisissez Mettre à jour le type de<br />
champ. Une boîte de dialogue apparaît dans laquelle vous pouvez<br />
taper le nouveau type de champ. Lorsque vous choisissez appliquer ou<br />
OK, le type de chaque champ sélectionné est modifié.<br />
Si la table a déjà une clé primaire, le champ ou l’ensemble de champs<br />
correspondant est sélectionné lorsque la page Affectation <strong>des</strong> colonnes<br />
apparaît la première fois. S’il n’y a pas de clé primaire, vous devez<br />
sélectionner un ou plusieurs champs pour en créer une en cochant la<br />
case de ces champs dans la colonne Clé primaire. Lorsque vous avez<br />
4-6 Guide du dé veloppeur Enterprise JavaBeans
Cré ation <strong>des</strong> <strong>beans</strong> entité avec le Modeleur Bean entité EJB<br />
fini d’associer les colonnes sélectionnées aux noms et types de champs<br />
de votre bean entité pour chaque table, choisissez Suivant.<br />
7 Spécifiez le paquet, les classes et interfaces, le nom JNDI pour chaque<br />
bean que vous créez.<br />
Pour chaque table, JBuilder suggère le nom du bean entité, le nom<br />
utilisé par JNDI, le nom <strong>des</strong> interfaces locale et distante, le nom de la<br />
classe du bean, et le type de la classe clé primaire. Vous pouvez<br />
spécifier un paquet différent pour chacun d’entre eux ; par défaut, le<br />
paquet du projet est utilisé. Vous pouvez accepter ces valeurs telles<br />
quelles ou les modifier à votre convenance. Lorsque vous avez fini de<br />
spécifier les informations pour toutes les tables, choisissez Suivant.<br />
8 Choisissez si la persistance <strong>des</strong> <strong>beans</strong> entité sera gérée par le conteneur<br />
ou par le bean.<br />
Cré ation <strong>des</strong> <strong>beans</strong> entité à partir d’ une table existante dans une base de donné es 4-7
Cré ation <strong>des</strong> <strong>beans</strong> entité avec le Modeleur Bean entité EJB<br />
Si vous voulez que le code généré utilise le style EJB 2.0, sélectionnez<br />
l’option Style de code EJB 2.0. Pour plus d’informations sur ces options,<br />
choisissez le bouton Aide dans le Modeleur Bean entité EJB.<br />
Par défaut, la classe de base de votre bean est java.lang.Object. Si vous<br />
voulez utiliser une autre classe comme base de vos <strong>beans</strong> entité, utilisez<br />
le champ Classe de base pour le bean entité pour spécifier cette autre<br />
classe.<br />
Si vous voulez que vos <strong>beans</strong> entité soient capables de renvoyer toutes<br />
les lignes d’un ensemble de données, cochez l’option Générer la<br />
méthode findAll() <strong>des</strong> interfaces locales. Le Modeleur Bean entité EJB<br />
place une méthode findAll() dans l’interface locale de vos <strong>beans</strong>. Vous<br />
pouvez aussi choisir que les commentaires d’en-tête apparaissent dans<br />
les fichiers résultant.<br />
Les options disponibles sur cet écran dépendent de votre serveur<br />
d’applications cible. Par exemple, il n’apparaît pas d’option de gestion<br />
de la persistance par le conteneur lorsque WebSphere 3.5 est la cible car<br />
WebSphere 3.5 ne prend pas en charge la gestion de la persistance par<br />
le conteneur.<br />
Si votre serveur d’applications cible est WebLogic Server et si vous<br />
créez un bean entité dont la persistance est gérée par le conteneur, cette<br />
page inclut un champ Nom de pool où vous devez entrer le nom du<br />
pool de vos <strong>beans</strong> CMP WebLogic :<br />
9 Choisissez Terminer.<br />
Pour chaque table, JBuilder crée un bean entité et toutes les interfaces <strong>des</strong><br />
classes de support. Vous pouvez maintenant ajouter aux <strong>beans</strong> la logique<br />
métier que vous voulez, définir les métho<strong>des</strong> que le client pourra appeler<br />
dans l’interface distante, compiler les <strong>beans</strong> et modifier les <strong>des</strong>cripteurs de<br />
déploiement <strong>des</strong> <strong>beans</strong>.<br />
4-8 Guide du dé veloppeur Enterprise JavaBeans
Chapitre<br />
5<br />
Chapitre5Test d’un<br />
<strong>enterprise</strong> bean<br />
Création d’un client de test<br />
Lorsque vous avez créé un <strong>enterprise</strong> bean, JBuilder peut vous aider à<br />
créer une application client qui teste son fonctionnement.<br />
Pour créer une application client de test,<br />
1 Ouvrez le projet contenant le groupe EJB de votre <strong>enterprise</strong> bean.<br />
2 Choisissez Fichier|Nouveau, cliquez sur l’onglet Entreprise et<br />
double-cliquez sur Client test EJB.<br />
Test d’ un <strong>enterprise</strong> bean 5-1
Cré ation d’ un client de test<br />
3 Sélectionnez le bean pour lequel vous voulez créer un client en utilisant<br />
une <strong>des</strong> options de sélection et en spécifiant le bean :<br />
• Sélectionnez A partir du projet si votre bean appartient au projet en<br />
cours et spécifiez le bean concerné en le sélectionnant dans la liste<br />
déroulante.<br />
• Sélectionnez A partir du JAR ou du répertoire si votre bean n’est pas<br />
dans le projet en cours, mais ailleurs dans un fichier JAR ou un<br />
répertoire. Utilisez le bouton ... pour naviguer jusqu’à<br />
l’emplacement du fichier JAR et sélectionnez-le, puis utilisez la liste<br />
déroulante pour sélectionner le bean souhaité.<br />
4 Sélectionnez le nom du paquet dans la liste <strong>des</strong> paquets. Le paquet<br />
courant est la valeur par défaut.<br />
5 Entrez un nom pour la classe client de test ou acceptez le nom par<br />
défaut.<br />
6 Sélectionnez les options souhaitées :<br />
• Créer une méthode pour tester les appels d’interface distante avec<br />
les arguments par défaut<br />
Ajoute une méthode testRemoteCallsWithDefaultArguments() qui teste<br />
les appels d’interface distante avec les arguments par défaut. Par<br />
exemple, l’argument par défaut d’une String est “”, l’argument par<br />
défaut d’un int est 0, etc.<br />
• Générer les messages historiques<br />
Ajoute le code qui affiche les messages vous informant de l’état du<br />
bean lorsque le client s’exécute. Par exemple, un message est affiché<br />
lorsque l’initialisation du bean démarre et un autre lorsqu’elle se<br />
termine. Cette option génère également les enveloppes pour toutes<br />
les métho<strong>des</strong> déclarées dans les interfaces locale et distante et les<br />
fonctions d’initialisation. Enfin, les messages signalent le temps<br />
nécessaire à l’accomplissement de chaque appel de méthode.<br />
• Générer la fonction principale<br />
Ajoute au client une fonction main.<br />
• Générer les commentaires d’en-tête<br />
Ajoute au client <strong>des</strong> commentaires d’en-tête JavaDoc que vous<br />
pouvez remplir d’informations sur le titre, l’auteur, etc.<br />
7 Choisissez OK.<br />
L’expert Client Test EJB génère un client de test créant une référence à<br />
l’<strong>enterprise</strong> bean.<br />
Si l’option Générer les messages historiques est sélectionnée, pour chaque<br />
méthode déclarée dans l’interface distante du bean, l’expert déclare et<br />
5-2 Guide du dé veloppeur Enterprise JavaBeans
Utilisation de l’ application client de test<br />
implémente une méthode qui appelle la méthode distante. Chacune de ces<br />
métho<strong>des</strong> signale le succès de l’invocation de la méthode distante et le<br />
temps nécessaire à son exécution.<br />
Il y a plusieurs façons d’utiliser l’application client de test générée. Si vous<br />
avez ajouté une fonction main() à l’application client de test, vous pouvez<br />
écrire le code qui invoque les appels aux métho<strong>des</strong> de l’<strong>enterprise</strong> bean<br />
dans la fonction main(). Pour cela, appelez d’abord une méthode create ou<br />
find et, si une référence distante est renvoyée, utilisez cette référence pour<br />
appeler les métho<strong>des</strong> métier du bean. Ou, car l’expert a déclaré un objet<br />
client dans la fonction main(), vous pouvez utiliser cet objet client pour<br />
simplement appeler les métho<strong>des</strong> déclarées dans l’application client de<br />
test qui appellent les métho<strong>des</strong> distantes du bean.<br />
Si vous avez sélectionné l’option Créer une méthode pour tester les appels<br />
d’interface distante avec les arguments par défaut, votre classe client<br />
contient désormais une méthode testRemoteCallsWithDefaultArguments(). Si<br />
vous avez sélectionné l’option historique, cette méthode appelle les<br />
enveloppes <strong>des</strong> métho<strong>des</strong> distantes qui ont été générées à partir de cette<br />
option. Pour tester chaque méthode distante, vous pouvez ensuite appeler<br />
simplement testRemoteCallsWithDefaultArguments() après avoir créé une<br />
référence à l’interface distante soit dans la méthode create() de la classe<br />
du client, soit dans une de ses métho<strong>des</strong> findByXXX().<br />
Si vous n’avez pas sélectionné l’option historique, la méthode<br />
testRemoteCallsWithDeafultArguments() nécessite la transmission d’une<br />
interface distante en tant que paramètre. Vous devez créer une référence à<br />
l’interface distante soit dans la méthode create() de la référence à<br />
l’interface locale ou dans une de ses métho<strong>des</strong> findByXXX(). Ajoutez ensuite<br />
le code à la classe client pour appeler la méthode<br />
testRemoteCallsWithDefaultArguments(), en lui passant la référence à<br />
l’interface distante comme argument.<br />
Si vous préférez écrire la logique appelant chacune <strong>des</strong> métho<strong>des</strong> métier à<br />
partir d’une autre classe, vous pouvez choisir de créer et d’utiliser une<br />
instance de l’application client de test. Voir “Utilisation de l’application<br />
client de test”, page 5-3.<br />
Compilez votre application client de test.<br />
Utilisation de l’application client de test<br />
Vous pouvez ajouter rapidement la déclaration d’une classe client de test<br />
à n’importe quelle classe.<br />
1 Affichez dans l’éditeur la classe dans laquelle vous voulez insérer la<br />
déclaration.<br />
Test d’ un <strong>enterprise</strong> bean 5-3
Utilisation de l’ application client de test<br />
2 Choisissez Experts|EJB|Utiliser client Test EJB.<br />
3 Si le client de test existe déjà, cochez l’option La classe client test EJB<br />
existe déjà.<br />
Si cette option n’est pas cochée, lorsque vous cliquez sur Suivant,<br />
l’expert Client Test EJB démarre. Lorsque vous êtes prêt, l’expert<br />
Utilisation d’un client Test EJB reprend son déroulement.<br />
4 Cliquez sur Suivant pour aller à l’étape 2.<br />
5 Pour le champ Classe, naviguez jusqu’à la classe client de test que vous<br />
voulez utiliser.<br />
6 Dans le champ Champ, spécifiez un nom pour la variable qui<br />
contiendra l’instance de la classe client de test, ou acceptez la valeur par<br />
défaut proposée par l’expert.<br />
7 Choisissez Terminer.<br />
5-4 Guide du dé veloppeur Enterprise JavaBeans
Test de votre <strong>enterprise</strong> bean<br />
Test de votre <strong>enterprise</strong> bean<br />
L’expert ajoute à la classe une déclaration de l’application client de test<br />
spécifiée, par exemple :<br />
EmployeeTestClient1 employeeTestClient1 = new EmployeeTestClient1();<br />
Vous voilà prêt à appeler les métho<strong>des</strong> déclarées dans l’application client<br />
de test.<br />
Lorsque vous avez créé l’application client de test, vous êtes prêt à<br />
démarrer le conteneur et à exécuter l’application client. Créez deux<br />
configurations d’exécution : Serveur et Client.<br />
Pour créer une configuration Serveur,<br />
1 Choisissez Exécuter|Configurations.<br />
Test d’ un <strong>enterprise</strong> bean 5-5
Test de votre <strong>enterprise</strong> bean<br />
2 Cliquez sur le bouton Nouveau, puis sur l’onglet EJB.<br />
3 Entrez Serveur dans le champ Nom de configuration.<br />
4 Remplissez les Paramètres du Serveur d’applications et le Nom<br />
d’instance du Serveur d’applications nécessaires pour exécuter le<br />
serveur. Si vous avez sélectionné un serveur d’applications cible,<br />
comme décrit dans “Sélection d’un serveur d’applications”, page 2-4,<br />
<strong>des</strong> valeurs par défaut remplissent déjà Paramètres du Serveur<br />
d’applications et Nom d’instance du Serveur d’applications. Si vous<br />
n’avez pas sélectionné de serveur d’applications cible, le serveur<br />
d’applications sélectionné par défaut sera BAS 4.5.<br />
5 Sélectionnez dans la liste <strong>des</strong> JAR EJB le fichier JAR contenant les <strong>beans</strong><br />
que vous voulez tester. S’il n’en existe qu’un, il est déjà sélectionné. Les<br />
fichiers JAR de cette liste ont été extraits <strong>des</strong> groupes EJB du projet.<br />
La liste <strong>des</strong> JAR EJB est désactivée pour WebSphere 3.5 car ce serveur<br />
d’applications ne prend pas en charge le déploiement sur un serveur en<br />
train de s’exécuter.<br />
Pour WebLogic Server 6.0, le ou les fichiers JAR sont copiés dans le<br />
répertoire \config\\applications.<br />
6 Cliquez sur OK.<br />
Pour créer une configuration Client,<br />
1 Choisissez Exécuter|Configurations.<br />
2 Cliquez sur le bouton Nouveau, puis sur l’onglet Application.<br />
5-6 Guide du dé veloppeur Enterprise JavaBeans
3 Entrez Client dans le champ Nom de configuration.<br />
Test de votre <strong>enterprise</strong> bean<br />
4 Cliquez sur le bouton ... situé à côté du champ Classe principale et<br />
naviguez jusqu’à l’application client de test que vous avez créée, ou<br />
jusqu’à l’application contenant la fonction main() appelant les métho<strong>des</strong><br />
du client de test.<br />
5 Cliquez deux fois sur OK.<br />
Vous voilà prêt à démarrer le conteneur. Sélectionnez la configuration<br />
d’exécution Serveur dans la liste déroulante du bouton Exécuter de la<br />
barre d’outils de JBuilder :<br />
Le conteneur démarre. Soyez patient car le processus de démarrage est<br />
relativement long. Vous pouvez suivre sa progression dans la fenêtre<br />
message. Toute erreur qui se produit apparaît également ici.<br />
Sélectionnez ensuite la configuration d’exécution Client pour exécuter<br />
votre application client. Les messages apparaissant dans le volet <strong>des</strong><br />
messages signalent le succès ou l’échec de l’exécution de l’application<br />
client.<br />
Une autre façon de tester votre bean consiste simplement à cliquer avec le<br />
bouton droit sur son groupe EJB dans le volet projet et à choisir Exécuter.<br />
Vous pouvez déboguer avec JBuilder vos <strong>enterprise</strong> <strong>beans</strong> ou le client<br />
exactement comme vous le feriez pour tout autre code Java. Pour plus<br />
d’informations sur le débogage, voir “Débogage <strong>des</strong> programmes Java”<br />
dans Construction d’applications avec JBuilder.<br />
Test d’ un <strong>enterprise</strong> bean 5-7
5-8 Guide du dé veloppeur Enterprise JavaBeans
Chapitre<br />
6<br />
Chapitre6Déploiement<br />
<strong>des</strong> <strong>enterprise</strong> <strong>beans</strong><br />
Le déploiement d’un <strong>enterprise</strong> bean sur un serveur d’applications se<br />
compose généralement <strong>des</strong> étapes suivantes :<br />
1 Création d’un fichier <strong>des</strong>cripteur de déploiement basé sur XML et<br />
conforme à la spécification EJB 1.1 de Sun. (WebSphere 3.5 fait<br />
exception. Il est conforme aux spécifications EJB 1.0 et il ne prend pas<br />
en charge les <strong>des</strong>cripteurs de déploiement basés sur XML.)<br />
Quand vous utilisez les experts EJB de JBuilder pour créer vos <strong>beans</strong>,<br />
les <strong>des</strong>cripteurs de déploiement sont créés pour vous en même temps.<br />
2 Modification <strong>des</strong> <strong>des</strong>cripteurs de déploiement, si nécessaire.<br />
Vous pouvez modifier les <strong>des</strong>cripteurs de déploiement créés par<br />
JBuilder en utilisant l’éditeur de <strong>des</strong>cripteur de déploiement de<br />
JBuilder.<br />
3 Création d’un fichier JAR EJB contenant le <strong>des</strong>cripteur de déploiement<br />
et toutes les classes requises pour que l’EJB fonctionne (classe bean,<br />
interface distante, interface locale, stubs et squelettes, classe clé<br />
primaire si l’EJB est un bean entité et toute autre classe associée).<br />
Quand vous compilez votre groupe EJB en utilisant l’environnement de<br />
développement de JBuilder, le fichier JAR correspondant est créé pour<br />
vous.<br />
4 Déploiement de votre EJB dans un conteneur EJB.<br />
JBuilder offre un expert Déploiement EJB qui simplifie le processus de<br />
déploiement <strong>des</strong> <strong>enterprise</strong> <strong>beans</strong> de Borland. Si votre serveur<br />
d’applications cible est WebLogic ou WebSphere, choisir Outils|<br />
Déploiement EJB affiche une boîte de dialogue de paramètres de<br />
D é ploiement <strong>des</strong> <strong>enterprise</strong> <strong>beans</strong> 6-1
Cré ation d’ un fichier <strong>des</strong>cripteur de dé ploiement<br />
déploiement spécifiques à votre serveur. Lorsque vous avez rempli les<br />
paramètres pour répondre à vos besoins et choisi OK pour fermer la<br />
boîte de dialogue, l’EJB est déployé comme vous l’avez spécifié.<br />
Création d’un fichier <strong>des</strong>cripteur de déploiement<br />
Au fur et à mesure que vous créez vos <strong>enterprise</strong> <strong>beans</strong> en utilisant les<br />
outils EJB de JBuilder, ce dernier crée en même temps les <strong>des</strong>cripteurs de<br />
déploiement. Vous pouvez ensuite utiliser l’éditeur de <strong>des</strong>cripteur de<br />
déploiement pour ajouter <strong>des</strong> informations supplémentaires et modifier<br />
les attributs <strong>des</strong> <strong>des</strong>cripteurs de déploiement.<br />
Chaque <strong>des</strong>cripteur de déploiement conforme à la spécification EJB 1.1<br />
(cela exclut ceux qui sont utilisés par WebSphere 3.5) :<br />
• Doit être basé sur XML et conforme aux règles XML.<br />
• Doit respecter la norme DTD de la spécification EJB 1.1.<br />
• Se conformer aux règles sémantiques spécifiées dans la DTD.<br />
• Se référer à la DTD à l’aide de l’instruction suivante :<br />
<br />
Quand vous utilisez les outils EJB de JBuilder pour créer et modifier vos<br />
<strong>des</strong>cripteurs de déploiement, vous n’avez pas à vous préoccuper<br />
d’apprendre XML ou de vous conformer aux règles sémantiques<br />
spécifiées dans la DTD de Sun. L’éditeur de <strong>des</strong>cripteur de déploiement<br />
impose ces règles aux données que vous entrez et modifiez. Au fur et à<br />
mesure que vous remplissez les informations dans l’éditeur de<br />
<strong>des</strong>cripteur de déploiement, il vous permet de savoir quelles données sont<br />
requises. Les outils de JBuilder configurent automatiquement les<br />
extensions spécifiques à Borland dans un fichier ejb-inprise.xml. Pour plus<br />
d’informations sur l’éditeur de <strong>des</strong>cripteur de déploiement, voir<br />
Chapitre 7, “Utilisation de l’éditeur de <strong>des</strong>cripteur de déploiement”.<br />
Le rôle du <strong>des</strong>cripteur de déploiement<br />
Le rôle du <strong>des</strong>cripteur de déploiement est de fournir <strong>des</strong> informations sur<br />
chaque EJB à rassembler et à déployer dans un fichier JAR particulier. Il<br />
est <strong>des</strong>tiné à être utilisé par l’utilisateur du fichier JAR de l’EJB. C’est à<br />
vous, développeur du bean, de créer le <strong>des</strong>cripteur de déploiement. Vous<br />
pouvez aussi modifier le <strong>des</strong>cripteur de déploiement une fois que<br />
l’<strong>enterprise</strong> bean a été déployé.<br />
Les informations contenues dans le <strong>des</strong>cripteur de déploiement sont<br />
utilisées pour définir les attributs <strong>des</strong> <strong>enterprise</strong> <strong>beans</strong>. Ces attributs<br />
6-2 Guide du dé veloppeur Enterprise JavaBeans
Le rô le du <strong>des</strong>cripteur de dé ploiement<br />
déterminent comment va fonctionner l’<strong>enterprise</strong> bean dans un<br />
environnement particulier. Par exemple, quand vous définissez les<br />
attributs transactionnels d’un bean, ils déterminent le comportement du<br />
bean lorsqu’il est impliqué dans une transaction. Le <strong>des</strong>cripteur de<br />
déploiement mémorise les informations suivantes :<br />
• Des informations sur les types, qui définissent les types, ou noms, <strong>des</strong><br />
classes <strong>des</strong> interfaces locales et distantes et de la classe du bean.<br />
• Des noms JNDI, qui définissent le nom sous lequel l’interface locale de<br />
l’<strong>enterprise</strong> bean sera enregistrée.<br />
• Des champs pour permettre la persistance gérée par le conteneur.<br />
• Des règles transactionnelles qui gouvernent le comportement<br />
transactionnel d’un bean.<br />
• Des attributs de sécurité qui gouvernent l’accès à un <strong>enterprise</strong> bean.<br />
• Des informations spécifiques à Borland, comme les informations sur les<br />
sources de données utilisées pour les connexions aux bases de données.<br />
Les types d’informations du <strong>des</strong>cripteur de déploiement<br />
Les informations contenues dans le <strong>des</strong>cripteur de déploiement peuvent<br />
être divisées en deux types de base :<br />
• Des informations structurelles sur les <strong>enterprise</strong> <strong>beans</strong>.<br />
Les informations structurelles décrivent la structure d’un <strong>enterprise</strong><br />
bean et déclarent les dépendances externes de l’<strong>enterprise</strong> bean. Ces<br />
informations sont obligatoires. Les informations structurelles ne<br />
doivent généralement pas être modifiées car cela risque de détruire la<br />
fonctionnalité du bean.<br />
• Des informations sur l’assemblage de l’application.<br />
Les informations sur l’assemblage de l’application décrivent comment<br />
le ou les <strong>enterprise</strong> <strong>beans</strong> inclus dans le fichier ejb-jar.xml sont<br />
composés dans l’unité de déploiement d’une application plus grande.<br />
Cette information est facultative. Les informations au niveau de<br />
l’assemblage peuvent être modifiées sans risque de détruire la<br />
fonctionnalité du bean, bien que cela puisse altérer le comportement de<br />
l’application assemblée.<br />
D é ploiement <strong>des</strong> <strong>enterprise</strong> <strong>beans</strong> 6-3
Le rô le du <strong>des</strong>cripteur de dé ploiement<br />
Informations structurelles<br />
Le développeur du bean doit fournir les informations structurelles<br />
suivantes pour chaque bean du jar EJB :<br />
Tous les <strong>enterprise</strong> <strong>beans</strong><br />
• Nom de l’<strong>enterprise</strong> bean, mnémonique utilisé pour faire référence au<br />
bean dans le <strong>des</strong>cripteur de déploiement.<br />
• Classe de l’<strong>enterprise</strong> bean<br />
• Interface locale de l’<strong>enterprise</strong> bean<br />
• Interface distante de l’<strong>enterprise</strong> bean<br />
• Type de l’<strong>enterprise</strong> bean, bean session ou bean entité<br />
• Entrées d’environnement, si le bean a <strong>des</strong> paramètres de configuration<br />
• Références à la factory <strong>des</strong> ressources<br />
• Références aux EJB, si un <strong>enterprise</strong> bean fait référence à d’autres<br />
<strong>enterprise</strong> <strong>beans</strong><br />
• Références aux rôles de sécurité, si un <strong>enterprise</strong> bean a besoin<br />
d’accéder à <strong>des</strong> rôles spécifiques<br />
Beans session<br />
• Type de gestion de l’état du bean session, stateful ou stateless<br />
• Type de transaction du bean session pour les <strong>beans</strong> stateful ayant <strong>des</strong><br />
callbacks de synchronisation<br />
Beans entité<br />
• Type de gestion de la persistance du bean entité<br />
• Classe de la clé primaire du bean entité<br />
• Champs gérés par le conteneur pour les <strong>beans</strong> gérés par le conteneur<br />
Informations sur l’assemblage de l’application<br />
Vous pouvez spécifier n’importe lesquelles <strong>des</strong> informations suivantes sur<br />
l’assemblage de l’application. Pendant l’assemblage de l’application, ces<br />
informations sont facultatives. Ces mêmes informations ne sont pas<br />
facultatives pour le rôle du déployeur.<br />
• Liaison <strong>des</strong> références aux <strong>enterprise</strong> <strong>beans</strong><br />
• Rôles de sécurité<br />
• Permissions de métho<strong>des</strong><br />
• Liaison aux références <strong>des</strong> rôles de sécurité<br />
• Attributs <strong>des</strong> transactions<br />
6-4 Guide du dé veloppeur Enterprise JavaBeans
Le rô le du <strong>des</strong>cripteur de dé ploiement<br />
Durant le processus d’assemblage ou de déploiement d’une application,<br />
vous pouvez modifier les informations structurelles suivantes :<br />
• Les valeurs <strong>des</strong> entrées d’environnement. L’assembleur de l’application<br />
peut changer <strong>des</strong> propriétés existantes et/ou définir <strong>des</strong> propriétés<br />
environnementales.<br />
• Champs de <strong>des</strong>cription. L’assembleur de l’application peut changer <strong>des</strong><br />
<strong>des</strong>criptions existantes ou en définir de nouvelles.<br />
Vous ne devez modifier aucun autre type d’informations structurelles.<br />
Cependant, vous pouvez modifier n’importe quelles informations sur<br />
l’assemblage de l’application au moment du déploiement.<br />
Sécurité<br />
L’assembleur de l’application spécifie généralement les informations<br />
suivantes dans le <strong>des</strong>cripteur de déploiement :<br />
• Rôles de sécurité<br />
• Permissions de métho<strong>des</strong><br />
• Liens entre les références aux rôles de sécurité et les rôles de sécurité<br />
Rôles de sécurité<br />
En utilisant les éléments de rôles de sécurité dans le <strong>des</strong>cripteur de<br />
déploiement, le développeur peut définir un ou plusieurs rôles de<br />
sécurité. Ils définissent les rôles de sécurité requis pour les clients <strong>des</strong><br />
<strong>enterprise</strong> <strong>beans</strong>.<br />
Permissions de métho<strong>des</strong><br />
En utilisant les éléments de permissions de métho<strong>des</strong> dans le <strong>des</strong>cripteur<br />
de déploiement, le développeur peut définir une ou plusieurs permissions<br />
de métho<strong>des</strong>. Les permissions de métho<strong>des</strong> sont <strong>des</strong> relations à deux entre<br />
les rôles de sécurité et les métho<strong>des</strong> <strong>des</strong> interfaces locale et distante de<br />
l’<strong>enterprise</strong> bean.<br />
Liaison aux références <strong>des</strong> rôles de sécurité<br />
Si <strong>des</strong> rôles de sécurité ont été définis, le développeur doit les lier aux<br />
références aux rôles de sécurité en utilisant l’élément rôle-lien dans le<br />
<strong>des</strong>cripteur de déploiement.<br />
Si votre serveur d’applications cible est Borland AppServer, vous aurez un<br />
<strong>des</strong>cripteur de déploiement supplémentaire pour votre <strong>enterprise</strong> bean,<br />
ejb-inprise.xml. Pour connaître les informations spécifiques à Borland sur<br />
les <strong>des</strong>cripteurs de déploiement, voir le chapitre “Déploiement <strong>des</strong><br />
Enterprise JavaBeans” dans le Enterprise JavaBeans Programmer’s Guide de<br />
Borland AppServer.<br />
D é ploiement <strong>des</strong> <strong>enterprise</strong> <strong>beans</strong> 6-5
D é ploiement sur un serveur d’ applications<br />
Déploiement sur un serveur d’applications<br />
Lorsque votre bean fonctionne à votre convenance et si vous avez choisi<br />
Borland AppServer comme serveur d’applications pour le projet en cours,<br />
vous pouvez déployer votre bean sur Borland AppServer en utilisant<br />
l’expert Déploiement EJB de JBuilder. Si votre serveur d’applications cible<br />
est WebLogic Server ou WebSphere Application Server, choisir Outils|<br />
Déploiement EJB affiche une boîte de dialogue sur les paramètres<br />
permettant le déploiement sur ces serveurs.<br />
Les étapes décrites ci-<strong>des</strong>sous supposent que vous déployez pour le<br />
conteneur Borland. Démarrez le serveur d’applications et utilisez l’expert<br />
Déploiement EJB.<br />
Déploiement d’un ou de plusieurs fichiers JAR<br />
Pour déployer un ou plusieurs fichiers JAR sur Borland Application<br />
Server,<br />
1 Choisissez Outils|Déploiement EJB pour afficher l’expert Déploiement<br />
EJB.<br />
Les fichiers JAR du projet en cours apparaissent.<br />
2 Spécifiez le ou les fichiers JAR contenant les <strong>beans</strong> que vous voulez<br />
déployer.<br />
Si vous voulez déployer <strong>des</strong> fichiers JAR supplémentaires, cliquez sur<br />
le bouton Add et spécifiez les fichiers JAR que vous voulez ajouter.<br />
Pour retirer un fichier JAR de la liste, sélectionnez-le et cliquez sur<br />
Remove. Au cours de cette étape, vous avez également accès à l’outil<br />
d’archive de BAS 4.5 et à l’éditeur de <strong>des</strong>cripteur de déploiement.<br />
6-6 Guide du dé veloppeur Enterprise JavaBeans
3 Cliquez sur Next pour aller à l’étape suivante.<br />
D é ploiement sur un serveur d’ applications<br />
4 Spécifiez le chemin <strong>des</strong> classes <strong>des</strong> bibliothèques dont dépendent vos<br />
<strong>enterprise</strong> <strong>beans</strong>, les options de génération <strong>des</strong> stubs et les options de<br />
vérification. Cliquez sur Next.<br />
L’expert analyse le ou les fichiers JAR et rend compte du résultat.<br />
D é ploiement <strong>des</strong> <strong>enterprise</strong> <strong>beans</strong> 6-7
D é ploiement sur un serveur d’ applications<br />
5 Cliquez sur Next s’il n’y a pas d’erreur signalée ; sinon, corrigez-les et<br />
recommencez.<br />
6 Utilisez cette page pour sélectionner le conteneur dans lequel vous<br />
voulez déployer votre EJB.<br />
Dans cet exemple, l’utilisateur a cliqué sur le bouton Add EJB<br />
Container pour sélectionner un conteneur :<br />
6-8 Guide du dé veloppeur Enterprise JavaBeans
D é ploiement sur un serveur d’ applications<br />
Cliquez sur Next lorsque vous avez spécifié un conteneur.<br />
L’expert tente de déployer l’EJB et rend compte du résultat.<br />
7 Cliquez sur Finish pour fermer l’expert.<br />
Déploiement sur les serveurs WebLogic ou WebSphere<br />
Les développeurs pour WebLogic et WebSphere peuvent aussi déployer<br />
leurs EJB avec la commande Outils|Déploiement EJB. Si WebLogic ou<br />
WebSphere est le serveur d’applications sélectionné pour le projet en<br />
cours, cette commande affiche une boîte de dialogue de paramètres de<br />
déploiement spécifiques à ce serveur. Par exemple, voici la boîte de<br />
dialogue de paramètres de déploiement pour WebSphere :<br />
Remplissez les champs dont vous avez besoin et choisissez OK. Pour plus<br />
d’informations, cliquez sur le bouton Help dans la boîte de dialogue <strong>des</strong><br />
paramètres de déploiement.<br />
D é ploiement <strong>des</strong> <strong>enterprise</strong> <strong>beans</strong> 6-9
D é ploiement sur un serveur d’ applications<br />
Définition <strong>des</strong> options de déploiement avec la boîte de<br />
dialogue Propriétés<br />
Bien que vous puissiez utiliser Outils|Déploiement EJB pour définir les<br />
options de déploiement sur le serveur d’applications en cours pour le<br />
projet, vous pouvez aussi utiliser la boîte de dialogue Propriétés. Ces<br />
propriétés sont enregistrées pour le nœud particulier pour lequel elles ont<br />
été définies.<br />
Pour définir les options de déploiement en utilisant la boîte de dialogue<br />
Propriétés,<br />
1 Cliquez avec le bouton droit sur le nœud du groupe EJB, ou sur un JAR<br />
enfant de ce nœud, pour afficher le menu contextuel.<br />
2 Choisissez Propriétés pour afficher la boîte de dialogue Propriétés. Si<br />
vous avez cliqué avec le bouton droit sur le nœud du groupe EJB, vous<br />
devez alors cliquer sur l’onglet Déploiement de la boîte de dialogue<br />
Propriétés et ensuite sur la page spécifique à votre serveur<br />
d’applications (par exemple, BAS 4.5).<br />
3 Définissez vos options. Pour BAS 4.5, vous ne définirez que les<br />
paramètres de la VM. Pour IAS 4.1, vous pouvez définir un nom d’hôte<br />
et <strong>des</strong> paramètres VM. Les utilisateurs de WebLogic peuvent définir un<br />
nom d’unité, <strong>des</strong> options de déploiement, un mot de passe et les<br />
paramètres de la VM. Les utilisateurs de WebSphere peuvent définir le<br />
nom du nœud primaire, le nom du serveur d’applications, le nom du<br />
conteneur, les paramètres VM et une option pour générer XML. Si<br />
plusieurs nœuds sont sélectionnés, chacun ayant <strong>des</strong> options de<br />
déploiement différentes, les valeurs par défaut sont utilisées.<br />
4 Si votre serveur d’applications cible est WebSphere et si vous voulez<br />
qu’un fichier XML soit généré comme entrée de l’utilitaire XMLConfig<br />
WebSphere, cochez la case Générer XML. Si cette option n’est pas<br />
cochée, le fichier ne sera pas créé. Si vous apportez vos propres<br />
modifications au fichier XML généré (nommé<br />
deploy_.xml et apparaissant sous le nœud projet),<br />
désélectionnez cette option pour être certain de ne pas perdre vos<br />
modifications.<br />
6-10 Guide du dé veloppeur Enterprise JavaBeans
D é ploiement sur un serveur d’ applications<br />
Déploiement dynamique sur un serveur d’applications<br />
Pendant le cycle du développement, il vous sera probablement nécessaire<br />
de déployer, redéployer et dé-déployer rapidement vos <strong>enterprise</strong> <strong>beans</strong><br />
sur un conteneur déjà en train de s’exécuter. Dans le volet projet, cliquez<br />
avec le bouton droit sur le nœud du groupe EJB, ou sur un de ses nœuds<br />
enfant, pour voir la liste <strong>des</strong> options de déploiement :<br />
• Déployer – Déploie un JAR sur le conteneur en train de s’exécuter sur le<br />
serveur d’applications du projet.<br />
• Redéployer – Redéploie un JAR sur le conteneur en train de s’exécuter.<br />
• Annuler le déploiement – Annule le déploiement d’un JAR déjà<br />
déployé sur le conteneur en train de s’exécuter.<br />
• Lister les déploiements – Liste tous les JAR déployés sur le conteneur<br />
en train de s’exécuter.<br />
• Arrêter le conteneur – Arrête le conteneur. Cette option n’apparaît que<br />
pour WebSphere. Lorsqu’un EJB déployé change, le conteneur doit être<br />
arrêté puis redémarré pour que les modifications soient enregistrées.<br />
• Démarrer le conteneur – Démarre le conteneur. Cette option n’apparaît<br />
que pour WebSphere.<br />
D é ploiement <strong>des</strong> <strong>enterprise</strong> <strong>beans</strong> 6-11
6-12 Guide du dé veloppeur Enterprise JavaBeans
Chapitre<br />
7<br />
Chapitre7Utilisation de l’éditeur<br />
de <strong>des</strong>cripteur de déploiement<br />
JBuilder comprend un éditeur de <strong>des</strong>cripteur de déploiement vous<br />
permettant de modifier les informations de déploiement Borland (comme<br />
les politiques de transactions ou les éléments de sécurité) dans un fichier<br />
<strong>des</strong>cripteur de déploiement d’un EJB. Vous pouvez également modifier la<br />
façon d’assurer la persistance d’un <strong>enterprise</strong> bean.<br />
L’éditeur de <strong>des</strong>cripteur de déploiement de JBuilder permet de modifier<br />
les <strong>des</strong>cripteurs de déploiement Borland existants. Pour plus<br />
d’informations sur les <strong>des</strong>cripteurs de déploiement, voir Chapitre 6,<br />
“Déploiement <strong>des</strong> <strong>enterprise</strong> <strong>beans</strong>”.<br />
Vous pouvez aussi voir et modifier certaines <strong>des</strong> propriétés spécifiques<br />
aux serveurs WebLogic et WebSphere. Pour plus d’informations, voir<br />
“Visualisation et modification <strong>des</strong> propriétés WebLogic et WebSphere”,<br />
page 7-27.<br />
Utilisation de l’éditeur de <strong>des</strong>cripteur de dé ploiement 7-1
Affichage de l’éditeur de <strong>des</strong>cripteur de dé ploiement<br />
Affichage de l’éditeur de <strong>des</strong>cripteur de déploiement<br />
Pour afficher l’éditeur de <strong>des</strong>cripteur de déploiement, double-cliquez sur<br />
le groupe EJB dans le volet projet. L’éditeur de <strong>des</strong>cripteur de<br />
déploiement apparaît.<br />
Remarquez l’arborescence du groupe EJB qui apparaît dans le volet<br />
structure.<br />
Visualisation du <strong>des</strong>cripteur de déploiement d’un <strong>enterprise</strong> bean<br />
Pour voir les informations concernant un <strong>enterprise</strong> bean dans l’éditeur de<br />
<strong>des</strong>cripteur de déploiement, cliquez sur le bean dans le volet structure. Ou<br />
cliquez sur l’onglet Contents pour afficher le contenu du groupe EJB, et<br />
double-cliquez ensuite sur l’icône du bean que vous voulez voir. Si vous<br />
7-2 Guide du dé veloppeur Enterprise JavaBeans
Visualisation du <strong>des</strong>cripteur de dé ploiement d’ un <strong>enterprise</strong> bean<br />
faites cela, plusieurs onglets supplémentaires apparaissent dans l’éditeur<br />
de <strong>des</strong>cripteur de déploiement :<br />
Vous pouvez cliquer sur ces onglets en bas de l’éditeur de <strong>des</strong>cripteur de<br />
déploiement pour voir les autres pages. Utilisez l’éditeur pour apporter<br />
toutes les modifications souhaitées aux informations de déploiement du<br />
bean.<br />
Vous pouvez voir <strong>des</strong> informations supplémentaires sur un <strong>des</strong>cripteur<br />
de déploiement en utilisant le volet structure :<br />
Développez le nœud de l’<strong>enterprise</strong> bean concerné dans le volet structure.<br />
Vous verrez certains <strong>des</strong> nœuds supplémentaires suivants (ou tous) :<br />
Home Interface, Remote Interface, Method Permissions et Container<br />
Transactions. Sélectionner un de ces nœuds affiche <strong>des</strong> informations<br />
supplémentaires sur le bean. Par exemple, sélectionner Home Interface<br />
affiche dans le volet contenu les icônes et les noms <strong>des</strong> métho<strong>des</strong> de<br />
l’interface locale, sélectionner Remote Interface affiche les icônes et les<br />
noms <strong>des</strong> métho<strong>des</strong> de l’interface distante. Vous pouvez aussi utiliser les<br />
nœuds Security Roles et Data Sources du volet structure pour afficher <strong>des</strong><br />
informations sur les rôles de sécurité et les sources de données, et pour les<br />
modifier.<br />
Utilisation de l’éditeur de <strong>des</strong>cripteur de dé ploiement 7-3
Ajout <strong>des</strong> informations d’ un nouvel <strong>enterprise</strong> bean<br />
Pour voir le code source de chaque <strong>des</strong>cripteur, cliquez sur l’onglet Source<br />
DD EJB. Pour chaque <strong>des</strong>cripteur de déploiement du groupe EJB, un<br />
onglet apparaît portant le même nom que le fichier. Sélectionnez l’onglet<br />
du fichier que vous voulez voir. Pendant que vous visualisez le code<br />
source d’un <strong>des</strong>cripteur de déploiement, vous pouvez cliquer sur les<br />
éléments du volet structure pour placer une barre de surbrillance sur<br />
l’élément correspondant dans le code source. Vous pouvez modifier le<br />
code source directement.<br />
Ajout <strong>des</strong> informations d’un nouvel <strong>enterprise</strong> bean<br />
Pour ajouter un <strong>enterprise</strong> bean au <strong>des</strong>cripteur de déploiement en<br />
utilisant l’éditeur de <strong>des</strong>cripteur de déploiement,<br />
1 Sélectionnez le nœud EJB Deployment Descriptor dans le volet<br />
structure.<br />
2 Sélectionnez le type de bean que vous voulez ajouter.<br />
• Pour ajouter un bean session, cliquez sur l’icône dans la barre<br />
d’outils de l’éditeur de <strong>des</strong>cripteur de déploiement.<br />
• Pour ajouter un bean entité, cliquez sur l’icône dans la barre<br />
d’outils de l’éditeur de <strong>des</strong>cripteur de déploiement.<br />
Une boîte de dialogue apparaît.<br />
3 Dans la boîte de dialogue, entrez le nom de l’<strong>enterprise</strong> bean à ajouter<br />
et choisissez OK.<br />
Le nouveau bean apparaît dans le volet structure.<br />
7-4 Guide du dé veloppeur Enterprise JavaBeans
Modification <strong>des</strong> informations concernant le bean<br />
4 Sélectionnez le bean dans le volet structure.<br />
Une série de panneaux apparaissent dans le volet contenu pour<br />
l’<strong>enterprise</strong> bean sélectionné. Utilisez les onglets du bas pour afficher le<br />
panneau voulu et saisir les informations sur le nouveau bean.<br />
Modification <strong>des</strong> informations concernant le bean<br />
Pour modifier les informations d’un bean, sélectionnez celui-ci dans le<br />
volet structure. Une série de panneaux apparaissent dans le volet contenu<br />
pour l’<strong>enterprise</strong> bean sélectionné. Utilisez les onglets du bas pour afficher<br />
le panneau voulu et modifier les informations existant sur le bean.<br />
Si vous êtes un habitué d’XML et du code source <strong>des</strong> <strong>des</strong>cripteurs de<br />
déploiement, vous pouvez sélectionner l’onglet Source DD EJB et effectuer<br />
vos modifications directement dans le code source.<br />
Informations sur les <strong>enterprise</strong> <strong>beans</strong><br />
Cette section décrit le type d’information que vous pouvez créer et stocker<br />
pour les <strong>enterprise</strong> <strong>beans</strong> dans un <strong>des</strong>cripteur de déploiement.<br />
Panneau Main<br />
Utilisez le panneau Main pour entrer ou modifier les informations<br />
générales sur l’<strong>enterprise</strong> bean.<br />
Voici le panneau Main pour un bean session :<br />
Utilisation de l’éditeur de <strong>des</strong>cripteur de dé ploiement 7-5
Informations sur les <strong>enterprise</strong> <strong>beans</strong><br />
Voici le panneau Main pour un bean entité :<br />
Le panneau Main comprend les informations suivantes :<br />
• Description : Un résumé <strong>des</strong> objectifs et <strong>des</strong> fonctions du bean. Cette<br />
information est facultative.<br />
• Bean Name : Un nom logique assigné à l’<strong>enterprise</strong> bean par le<br />
fournisseur du bean. Chaque <strong>enterprise</strong> bean possède un nom logique.<br />
Il n’y a pas de relation structurelle entre le nom logique du bean et le<br />
nom JNDI qui lui est assigné. Le déployeur du bean peut changer le<br />
nom logique du bean.<br />
• Home Interface : Le nom complet de l’interface locale de l’<strong>enterprise</strong><br />
bean. Cette information est obligatoire.<br />
• Remote Interface : Le nom complet de l’interface distante de<br />
l’<strong>enterprise</strong> bean. Cette information est obligatoire.<br />
• Bean Class : Le nom complet de la classe Java qui implémente les<br />
métho<strong>des</strong> métier du bean. Cette information est obligatoire.<br />
• JNDI Name : Le nom JNDI de l’interface locale de l’<strong>enterprise</strong> bean.<br />
• Small icon : Le nom du fichier de l’icône 16 x 16 pixels utilisée pour<br />
représenter le bean.<br />
• Large icon : Le nom du fichier de l’icône 32 x 32 pixels utilisée pour<br />
représenter le bean.<br />
Pour les <strong>beans</strong> session, le panneau Main inclut en outre ce qui suit :<br />
• Session Type : Spécifie si l’<strong>enterprise</strong> bean est Stateless ou Stateful.<br />
7-6 Guide du dé veloppeur Enterprise JavaBeans
Informations sur les <strong>enterprise</strong> <strong>beans</strong><br />
• Transaction Type : Spécifie si les mo<strong>des</strong> transactionnels sont définis<br />
par le bean ou par le conteneur.<br />
Pour les <strong>beans</strong> entité, le panneau Main inclut en outre ce qui suit :<br />
• Primary Key Class : Le nom complet de la classe de la clé primaire du<br />
bean entité. La classe de la clé primaire est obligatoire.<br />
• Reentrant : Indique si le bean est réentrant. Borland vous recommande<br />
d’éviter de rendre un bean réentrant.<br />
Panneau Environment<br />
Le panneau Environment est une liste <strong>des</strong> entrées d’environnement de<br />
l’<strong>enterprise</strong> bean. Les entrées d’environnement vous permettent de<br />
personnaliser la logique métier du bean lorsque le bean est assemblé ou<br />
déployé. L’environnement vous permet de personnaliser le bean sans<br />
accéder au code source du bean, ni le modifier.<br />
Chaque <strong>enterprise</strong> bean définit son propre jeu d’entrées d’environnement.<br />
Toutes les instances d’un <strong>enterprise</strong> bean partagent les mêmes entrées<br />
d’environnement. Les instances d’un <strong>enterprise</strong> bean ne peuvent pas<br />
modifier l’environnement du bean à l’exécution.<br />
Pour ajouter une entrée d’environnement,<br />
1 Cliquez sur Add pour créer une nouvelle entrée.<br />
Une nouvelle ligne vierge apparaît.<br />
Utilisation de l’éditeur de <strong>des</strong>cripteur de dé ploiement 7-7
Informations sur les <strong>enterprise</strong> <strong>beans</strong><br />
2 Entrez une propriété dans la colonne Property et sa valeur dans la<br />
colonne Value.<br />
3 Choisissez le type de la propriété dans le menu Type.<br />
4 Ajoutez autant d’entrées que souhaité.<br />
Pour supprimer une ligne,<br />
1 Sélectionnez la ligne.<br />
2 Cliquez sur le bouton Remove.<br />
Pensez à ce qui suit lorsque vous travaillez sur les entrées<br />
d’environnement :<br />
• Le fournisseur du bean doit déclarer toutes les entrées<br />
d’environnement accédées dans le code de l’<strong>enterprise</strong> bean.<br />
• Si le fournisseur du bean a attribué une valeur à une entrée<br />
d’environnement, cette valeur peut être modifiée ensuite lors de<br />
l’assemblage ou du déploiement.<br />
• L’assembleur peut modifier les valeurs <strong>des</strong> entrées d’environnement<br />
définies par le fournisseur du bean.<br />
• Le déployeur doit s’assurer que les valeurs de toutes les entrées<br />
d’environnement sont pertinentes.<br />
Panneau EJB references<br />
Le panneau EJB References est une liste de toutes les références aux<br />
interfaces locales <strong>des</strong> autres <strong>enterprise</strong> <strong>beans</strong> que l’<strong>enterprise</strong> bean<br />
requiert.<br />
7-8 Guide du dé veloppeur Enterprise JavaBeans
Informations sur les <strong>enterprise</strong> <strong>beans</strong><br />
Chaque référence EJB décrit ce que l’<strong>enterprise</strong> bean référençant requiert<br />
comme interfaces pour le bean référencé. Vous pouvez définir <strong>des</strong><br />
références entre <strong>des</strong> <strong>beans</strong> appartenant au même fichier JAR ou à partir<br />
d’un <strong>enterprise</strong> bean externe (se trouvant hors du fichier JAR), par<br />
exemple d’un bean session vers un bean entité. Chaque référence contient<br />
les champs suivants :<br />
• Description : Une brève <strong>des</strong>cription du bean référencé. Cette<br />
information est facultative.<br />
• Name : Le nom du bean référencé.<br />
• IsLink : Lorsque l’option IsLink est cochée, la référence porte sur un<br />
bean du fichier JAR, la valeur JNDI Name n’est donc pas appropriée. Si<br />
IsLink n’est pas cochée, le nom JNDI est utilisé pour trouver le bean.<br />
Lorsque vous cochez cette option, vous sélectionnez ensuite dans la<br />
liste déroulante Link le bean référencé.<br />
• Link : Lie la référence EJB à l’<strong>enterprise</strong> bean cible. La valeur Link est le<br />
nom du bean cible. Cette information est facultative.<br />
• Type : Le type attendu pour le bean référencé.<br />
• Home : Le type Java attendu pour l’interface locale du bean référencé.<br />
• Remote : Le type Java attendu pour l’interface distante du bean<br />
référencé.<br />
• JNDI Name : Le nom JNDI du bean référencé.<br />
Voici <strong>des</strong> points importants à considérer pour ce qui concerne les<br />
références EJB :<br />
• L’<strong>enterprise</strong> bean cible doit avoir un type compatible avec la référence<br />
EJB déclarée.<br />
• Toutes les références EJB déclarées doivent être liées aux interfaces<br />
locales <strong>des</strong> <strong>enterprise</strong> <strong>beans</strong> existant dans l’environnement<br />
d’exploitation.<br />
• Si une valeur Link est spécifiée, la référence à l’<strong>enterprise</strong> bean doit être<br />
liée à l’interface locale de l’<strong>enterprise</strong> bean cible.<br />
Panneau Security role references<br />
Le panneau Security role references est une liste de toutes les références<br />
de l’<strong>enterprise</strong> bean aux rôles de sécurité. Le panneau lie les références<br />
aux rôles de sécurité utilisées par le développeur du bean à <strong>des</strong> rôles de<br />
Utilisation de l’éditeur de <strong>des</strong>cripteur de dé ploiement 7-9
Informations sur les <strong>enterprise</strong> <strong>beans</strong><br />
sécurité spécifiques définis par l’assembleur de l’application ou par le<br />
déployeur.<br />
Avant que vous ajoutiez une référence à un rôle de sécurité, un ou<br />
plusieurs rôles de sécurité doivent avoir été définis ; sinon, le bouton Add<br />
n’est pas accessible dans le panneau. Pour plus d’informations sur la<br />
création et l’assignation <strong>des</strong> rôles de sécurité pour le déploiement d’une<br />
application, voir “Ajout <strong>des</strong> rôles de sécurité et <strong>des</strong> métho<strong>des</strong> autorisées”,<br />
page 7-25.<br />
Pour ajouter un rôle, cliquez sur le bouton Add et remplissez les trois<br />
champs suivants :<br />
• Description : C’est un champ facultatif décrivant le rôle de sécurité.<br />
• Role : C’est le nom du rôle de sécurité spécifié par le développeur du<br />
bean.<br />
• Link : C’est le nom du rôle de sécurité utilisé lorsque l’application est<br />
déployée. Habituellement, ce rôle est défini par l’assembleur de<br />
l’application ou par le déployeur pour que celle-ci fonctionne dans un<br />
environnement d’exploitation particulier.<br />
Panneau Resource references<br />
Le panneau Resource references est une liste de toutes les références aux<br />
factories de ressources <strong>des</strong> <strong>enterprise</strong> <strong>beans</strong>. Il permet à l’assembleur de<br />
l’application et/ou au déployeur du bean de localiser toutes les références<br />
7-10 Guide du dé veloppeur Enterprise JavaBeans
Informations sur les <strong>enterprise</strong> <strong>beans</strong><br />
utilisées par l’<strong>enterprise</strong> bean. Chaque bean entité dont la persistance est<br />
gérée par le conteneur doit faire référence à une ressource.<br />
Pour ajouter une référence à une ressource, cliquez sur le bouton Add et<br />
remplissez les champs suivants :<br />
• Description : Une <strong>des</strong>cription de la référence ressource. Cette<br />
information est facultative.<br />
• Name : Le nom de l’entrée d’environnement utilisé dans le code de<br />
l’<strong>enterprise</strong> bean.<br />
• Type : Le type Java de la factory de la ressource attendu par le code de<br />
l’<strong>enterprise</strong> bean. (C’est le type Java de la factory de la ressource, et non<br />
celui de la ressource.)<br />
• Authentification : Une authentification Application indique que<br />
l’<strong>enterprise</strong> bean effectue par programme la connexion à la ressource.<br />
Une authentification Container indique que le conteneur se connecte à<br />
la ressource en fonction <strong>des</strong> informations de mappage fournies par le<br />
déployeur.<br />
• JNDI Name : Un nom JNDI pour la référence ressource.<br />
• CMP (container-managed persistence) : Si vous faites gérer la<br />
persistance du bean par le conteneur, vous devez avoir une (et une<br />
seule) référence ressource dont le champ CMP est coché.<br />
Utilisation de l’éditeur de <strong>des</strong>cripteur de dé ploiement 7-11
Informations sur les <strong>enterprise</strong> <strong>beans</strong><br />
Panneau Persistence<br />
Le panneau Persistence apparaît uniquement pour les <strong>beans</strong> entité. Il<br />
indique comment est gérée la persistance de l’<strong>enterprise</strong> bean. Les<br />
informations affichées dans ce panneau varient selon que la persistance<br />
est gérée par le bean ou par le conteneur.<br />
Le panneau Persistence comprend les champs suivants :<br />
• Persistence Type : Indique si la persistance est gérée par le bean<br />
lui-même ou par le conteneur.<br />
• Primary Key Class : Le nom complet de la classe de la clé primaire du<br />
bean entité. Cette information est obligatoire.<br />
• Bouton Get Meta Data : Cliquer sur ce bouton lit les métadonnées pour<br />
la table et remplit la liste déroulante associée à chacune <strong>des</strong> cellules<br />
Column Name(s). Chaque élément de la liste déroulante est un couple<br />
nom de colonne/type de colonne. Faire une sélection dans la liste<br />
déroulante remplit à la fois la cellule du nom de colonne et la cellule du<br />
type de colonne. La liste déroulante ne contient que les noms de<br />
colonne ayant déjà été utilisés dans le panneau.<br />
Pour les <strong>beans</strong> dont la persistance est gérée par le conteneur, les<br />
informations supplémentaires suivantes sont incluses pour vous<br />
permettre d’établir la correspondance entre les champs du bean et les<br />
colonnes d’une table de base de données :<br />
• Table(s) : Le nom de la ou <strong>des</strong> tables de la base référencées par le bean.<br />
7-12 Guide du dé veloppeur Enterprise JavaBeans
Informations sur les <strong>enterprise</strong> <strong>beans</strong><br />
• CMP : Une marque de sélection indique que le champ est géré par le<br />
conteneur.<br />
• isPK : Une marque de sélection indique que le champ est la clé<br />
primaire.<br />
• Field Type : Le type de données du champ.<br />
• Field Name : Le nom du champ. La colonne Field Name présente la<br />
liste de tous les champs du bean entité.<br />
• Column Name : Vous pouvez faire correspondre <strong>des</strong> champs<br />
composés du bean (par exemple, adresse.rue) aux colonnes de la table<br />
de la base de données. Vous pouvez mapper soit le champ racine (par<br />
exemple, adresse), soit les sous-champs (par exemple, adresse.rue),<br />
mais pas les deux.<br />
• Column Type : Le type de données du champ.<br />
• EJB Reference : Si le type de champ est une classe EJB, un menu<br />
apparaît et présente la liste <strong>des</strong> références EJB à sélectionner. Ces<br />
références sont définies dans le panneau EJB references.<br />
Pour définir un bean entité dont la persistance est gérée par le conteneur,<br />
sélectionnez Container comme Persistence Type. Si vous avez utilisé le<br />
Modeleur Bean entité EJB pour générer le bean, Container est déjà<br />
sélectionné. Le panneau affiche le nom de la classe clé primaire qui n’est<br />
pas modifiable. Dans le champ CMP Description, vous pouvez entrer du<br />
texte décrivant le bean.<br />
Pour chaque champ de votre bean entité dont la persistance sera gérée par<br />
le conteneur, le champ CMP est coché. Pour chaque champ, entrez le nom<br />
de la colonne à laquelle il correspond. Si vous avez utilisé le Modeleur<br />
Bean entité EJB, JBuilder a établi ces correspondances à votre place.<br />
Modifiez Column Name et Column Type si vous le voulez. Vous pouvez<br />
entrer dans le champ Description un texte décrivant chaque champ, mais<br />
cela n’est pas obligatoire.<br />
L’éditeur de <strong>des</strong>cripteur de déploiement utilise JDBC pour obtenir les<br />
métadonnées <strong>des</strong> tables existantes. Vous pouvez lier facilement les <strong>beans</strong><br />
entité existants aux tables existantes. Par exemple, vous pourriez avoir<br />
acquis un <strong>enterprise</strong> bean tiers et souhaiter l’utiliser avec une table de<br />
votre base de données. Pour remplir les champs Column Name et Column<br />
Type, cliquez sur le bouton Get Meta Data, les métadonnées seront<br />
trouvées et affichées.<br />
Utilisation de l’éditeur de <strong>des</strong>cripteur de dé ploiement 7-13
Informations sur les <strong>enterprise</strong> <strong>beans</strong><br />
Panneau Finders<br />
Le panneau Finders spécifie les clauses “where” utilisées pour un bean<br />
géré par le conteneur afin d’exécuter les métho<strong>des</strong> find (de recherche)<br />
définies par ce bean.<br />
Vous trouverez les informations suivantes dans le panneau Finders :<br />
• Method : Le nom de la méthode find et la liste de tous ses paramètres.<br />
• Where Clause : Spécifie la clause SQL “where” utilisée par le conteneur<br />
pour extraire les enregistrement de la base de données. Notez que les<br />
instructions SQL ne peuvent pas toutes être converties dans la logique<br />
de requête WebLogic.<br />
• Load State : Lorsqu’il est sélectionné, cet attribut permet au conteneur<br />
de pré-charger tous les champs gérés par le conteneur chaque fois<br />
qu’une opération de recherche est effectuée.<br />
Pour spécifier une méthode find,<br />
1 Cliquez sur le bouton Add.<br />
Une boîte de dialogue Finder apparaît.<br />
2 Sélectionnez la signature pour la méthode find souhaitée dans la liste<br />
déroulante.<br />
3 Modifiez éventuellement les noms <strong>des</strong> arguments et spécifiez la clause<br />
Where de l’opération de recherche.<br />
7-14 Guide du dé veloppeur Enterprise JavaBeans
Informations sur les <strong>enterprise</strong> <strong>beans</strong><br />
Voici un exemple :<br />
Panneau Properties<br />
Le panneau Properties contient <strong>des</strong> informations qui varient en fonction<br />
du contexte. Lorsque vous sélectionnez un <strong>enterprise</strong> bean dans le volet<br />
structure, le panneau Properties suivant apparaît:<br />
Pour ajouter une propriété à l’<strong>enterprise</strong> bean sélectionné dans le volet<br />
structure,<br />
1 Cliquez sur le bouton Add pour ajouter une ligne au panneau.<br />
2 Dans la liste déroulante Name, sélectionnez la propriété à ajouter.<br />
Utilisation de l’éditeur de <strong>des</strong>cripteur de dé ploiement 7-15
Informations sur les <strong>enterprise</strong> <strong>beans</strong><br />
3 Spécifiez une valeur dans le champ Value.<br />
Vous spécifierez certaines valeurs en les sélectionnant dans une liste<br />
déroulante, d’autres en saisissant la valeur appropriée, chaîne ou entier<br />
par exemple ; les valeurs booléennes seront représentées par une case à<br />
cocher — cocher la case indique que la valeur est true. Voici la liste <strong>des</strong><br />
valeurs possibles et leur <strong>des</strong>cription :<br />
ejb.cmp.primaryKeyGenerator<br />
Spécifie une classe, écrite par l’utilisateur, qui implémente l’interface<br />
com.inprise.ejb.cmp.PrimaryKeyGenerator et génère les clés primaires.<br />
Pour plus d’informations sur la génération <strong>des</strong> clés primaires, voir<br />
l’exemple /Borland/AppServer/examples/ejb/pkgen.<br />
ejb.cmp.getPrimaryKeyBeforeInsertSql<br />
Spécifie le SQL exécuté par le moteur CMP pour générer une clé<br />
primaire lorsqu’a lieu le prochain INSERT. Le moteur CMP met à jour<br />
le bean entité avec la valeur de la clé primaire. Cette propriété est<br />
habituellement utilisée en conjonction avec les séquences Oracle. Pour<br />
plus d’informations sur la génération <strong>des</strong> clés primaires, voir l’exemple<br />
/Borland/AppServer/examples/ejb/pkgen.<br />
ejb.cmp.getPrimaryKeyAfterInsertSql<br />
Spécifie le SQL exécuté par le moteur CMP pour générer une clé<br />
primaire après le prochain INSERT. Le moteur CMP met à jour le bean<br />
entité avec la valeur de la clé primaire. Lorsque vous spécifiez cette<br />
propriété, vous devez également spécifier la propriété<br />
ejb.cmp.ignoreColumnsOnInsert. Pour plus d’informations sur la<br />
génération <strong>des</strong> clés primaires, voir l’exemple /Borland/AppServer/<br />
examples/ejb/pkgen.<br />
ejb.cmp.ignoreColumnsOnInsert<br />
Spécifie le nom de la colonne que le CMP ne doit pas définir au cours<br />
de l’INSERT. Cette propriété est utilisée en conjonction avec la<br />
propriété ejb.cmp.getPrimaryKeyAfterInsertSql. Pour plus d’informations<br />
sur la génération <strong>des</strong> clés primaires, voir l’exemple /Borland/AppServer/<br />
examples/ejb/pkgen.<br />
ejb.cmp.checkExistenceBeforeCreate<br />
Supprime la vérification d’existence qui a lieu avant la création d’un<br />
nouveau bean entité. La spécification EJB 1.1 exige que le conteneur<br />
vérifie d’abord l’existence d’un bean entité (c’est-à-dire, vérifie<br />
l’existence d’une ligne de la table) et déclenche une<br />
javax.ejb.DuplicateKeyException si une telle entité est trouvée. Pour<br />
améliorer les performances, vous pouvez souhaiter éliminer cet accès<br />
7-16 Guide du dé veloppeur Enterprise JavaBeans
Informations sur les <strong>enterprise</strong> <strong>beans</strong><br />
supplémentaire à la base de données et compter sur la base de données<br />
pour empêcher l’insertion <strong>des</strong> valeurs dupliquées.<br />
ejb.cmp.jdbcAccesserFactory<br />
Spécifie une factory pour une instance implémentée par l’utilisateur de<br />
l’interface com.inprise.ejb.cmp.JdbcAccessor. Cette interface vous donne<br />
la moyen d’écrire du code spécifique pour lire une valeur dans un<br />
java.sqlResultSet ou pour écrire une valeur dans un<br />
java.sql.PreparedStatement. La valeur par défaut est none.<br />
ejb.cmp.manager<br />
Spécifie le nom de la classe implémentant l’interface<br />
com.inprise.ejb.cmp.Manager. Une instance de cette classe est utilisée<br />
pour assurer la persistance gérée par le conteneur (CMP).<br />
ejb.maxBeansInPool<br />
Spécifie le nombre maximal de <strong>beans</strong> présents dans le pool <strong>des</strong> <strong>beans</strong><br />
prêts. Si le pool <strong>des</strong> <strong>beans</strong> prêts dépasse cette limite, <strong>des</strong> entités seront<br />
supprimées du conteneur par l’appel de unsetEntityContext(). La valeur<br />
par défaut est 1000.<br />
ejb.maxBeansInCache<br />
Spécifie le nombre maximal de <strong>beans</strong> présents dans le cache Option A<br />
(voir ci-<strong>des</strong>sous ejb.transactionCommitMode). Si le cache dépasse cette<br />
limite, <strong>des</strong> entités seront déplacées dans le pool <strong>des</strong> <strong>beans</strong> prêts par<br />
l’appel de ejbPassivate(). La valeur par défaut est 1000.<br />
ejb.transactionCommitMode<br />
Indique la disposition d’un bean entité par rapport à une transaction.<br />
Les valeurs sont :<br />
• A ou Exclusif — Cette entité a un accès exclusif à une table<br />
particulière de la base de données. Ainsi, l’état du bean à la fin de la<br />
dernière transaction validée est supposé être l’état du bean au début<br />
de la prochaine transaction. Les <strong>beans</strong> sont mis en cache entre les<br />
transactions.<br />
• B ou Partagé — Cette entité partage l’accès à une table particulière<br />
de la base de données. Mais, pour <strong>des</strong> questions de performances, un<br />
bean particulier reste associé à une clé primaire particulière entre les<br />
transactions afin d’éviter les appels externes à ejbActivate() et à<br />
ejbPassivate() entre les transactions. Le bean reste dans le pool actif.<br />
Il s’agit du mode de fonctionnement par défaut.<br />
• C ou Aucun — Cette entité partage l’accès à une table particulière de<br />
la base de données. Un bean particulier ne reste pas associé à une clé<br />
primaire particulière entre les transactions, mais retourne au pool<br />
Utilisation de l’éditeur de <strong>des</strong>cripteur de dé ploiement 7-17
Informations sur les <strong>enterprise</strong> <strong>beans</strong><br />
<strong>des</strong> <strong>beans</strong> prêts après chaque transaction. Ce n’est généralement pas<br />
utile.<br />
ejb.cmp.optimisticConcurrencyBehavior<br />
Vous pouvez spécifier l’une <strong>des</strong> options suivantes :<br />
• UpdateAllFields<br />
• UpdateModifiedFields<br />
• VerifyModifiedFields<br />
• VerifyAllFields<br />
• UpdateAllFields — Effectue la mise à jour de tous les champs, qu’ils<br />
aient été modifiés ou non. Soit un bean CMP (persistance gérée par le<br />
conteneur) comportant trois champs : “key”, “value1” et “value2”<br />
stockés dans une table appelée “MyTable”, la mise à jour ci-<strong>des</strong>sous<br />
sera effectuée à la fin de chaque transaction que le bean ait été<br />
modifié ou pas :<br />
UPDATE MyTable SET (value1 = , value2 = )<br />
WHERE key = <br />
• UpdateModifiedFields — Il s’agit du mode de fonctionnement par<br />
défaut. Effectue uniquement la mise à jour <strong>des</strong> champs qui ont été<br />
modifiés, ou empêche la mise à jour si le bean n’a pas été modifié.<br />
Avec le bean précédent, si seule “value1” a été modifiée, la mise à<br />
jour suivante est effectuée:<br />
UPDATE MyTable SET (value1 = )<br />
WHERE key = <br />
Cela peut entraîner une amélioration significative <strong>des</strong> performances<br />
pour les raisons suivantes :<br />
1 Très souvent, l’accès aux données s’effectue en lecture seulement.<br />
Dans ces cas-là, il est souhaitable de ne pas envoyer de mise à jour<br />
à la base de données. Borland a constaté une grande amélioration<br />
<strong>des</strong> performances à la suite de cette seule optimisation.<br />
2 De nombreuses bases de données écrivent <strong>des</strong> historiques en<br />
fonction du type <strong>des</strong> colonnes modifiées. Par exemple, SQL Server<br />
consignera la mise à jour si un champ TEXT ou IMAGE est mis à<br />
jour, que la valeur de la colonne ait réellement changé ou non.<br />
Notez que, souvent, la base de données ne sait (ou ne peut) pas<br />
distinguer la mise à jour d’une colonne par la valeur qu’elle<br />
contenait déjà (ce qui se produit avec “UpdateAllFields”) d’une<br />
véritable modification de la valeur de la colonne. Supprimer la<br />
mise à jour lorsque la valeur n’est pas vraiment modifiée, peut<br />
avoir un impact considérable sur les performances si vous utilisez<br />
un SGBD de ce type.<br />
3 Il y a moins de trafic vers la base de données sur le réseau et<br />
moins de travail pour le pilote JDBC. Les difficultés liées au<br />
7-18 Guide du dé veloppeur Enterprise JavaBeans
Informations sur les <strong>enterprise</strong> <strong>beans</strong><br />
réseau ne sont généralement pas significatives mais celles<br />
concernant le pilote JDBC le sont. Nos mesures de performance<br />
indiquent que 70 % du temps CPU est dévolu au pilote JDBC dans<br />
les applications EJB à grande échelle. Souvent, cela provient du<br />
fait que de nombreux pilotes JDBC du commerce ne sont pas<br />
suffisamment bien réglés vis à vis <strong>des</strong> performances. Et même<br />
pour les pilotes bien réglés, moins ils ont de travail, mieux c’est.<br />
• VerifyModifiedFields — Dans ce mode, le moteur CMP effectue une<br />
mise à jour adaptée en vérifiant que les champs qu’il met à jour sont<br />
cohérents par rapport aux valeurs qu’ils contenaient au préalable.<br />
Ainsi, dans l’exemple précédent où seule “value1” a été modifiée, la<br />
mise à jour suivante est effectuée:<br />
UPDATE MyTable SET (value1 = )<br />
WHERE key = AND value1 = <br />
• VerifyAllFields — Ce mode est semblable à VerifyModifiedFields,<br />
mais tous les champs sont vérifiés. La mise à jour serait donc :<br />
UPDATE MyTable SET (value1 = )<br />
WHERE key = AND value1 = AND value2 = <br />
Ces deux vérifications peuvent être utilisées pour répliquer le niveau<br />
d’isolation SERIALIZABLE dans le conteneur. Souvent vos<br />
applications exigeront l’isolation SERIALIZABLE. Mais, demander à la<br />
base de données d’implémenter cela pour vous risque de coûter trop<br />
cher en performance. Nos tests montrent qu’utiliser SERIALIZABLE<br />
avec Oracle, plutôt qu’un niveau d’isolation moins restrictif, peut<br />
ralentir une application de plus de 50 %. La raison principale de ce<br />
ralentissement est qu’Oracle assure un accès concurrentiel de type<br />
optimiste utilisant un modèle de verrouillage de niveau ligne. Avec les<br />
deux définitions précédentes, vous demandez pratiquement au moteur<br />
CMP d’implémenter un accès concurrentiel optimiste utilisant un<br />
verrouillage de niveau champ. Et, comme dans tout système de<br />
concurrence, l’accès simultané est d’autant meilleur que la granularité<br />
du verrouillage est plus fine.<br />
ejb.findByPrimaryKeyBehavior<br />
Indique le comportement souhaité pour la méthode<br />
findByPrimaryKey(). Les valeurs sont :<br />
• Verify — Le comportement standard pour findByPrimaryKey() est de<br />
vérifier que la clé primaire spécifiée existe dans la base de données.<br />
• Load — Ce comportement provoque la chargement de l’état du bean<br />
dans le conteneur lorsque findByPrimaryKey() est invoquée, si l’appel<br />
de la méthode find s’exécute au sein d’une transaction active. On<br />
part de l’hypothèse que les objets seront généralement trouvés, et il<br />
est optimal de charger l’état d’un objet au moment où on le trouve. Il<br />
s’agit du mode de fonctionnement par défaut.<br />
Utilisation de l’éditeur de <strong>des</strong>cripteur de dé ploiement 7-19
Transactions conteneur<br />
• None — Ce comportement indique que findByPrimaryKey() doit être<br />
sans effet. Cela entraîne que la vérification du bean sera différée<br />
jusqu’à ce que l’objet soit réellement utilisé. Comme un objet peut<br />
toujours être supprimé entre l’appel de la méthode find et son<br />
utilisation réelle, dans la majorité <strong>des</strong> programmes, cette<br />
optimisation ne changera rien à la logique client.<br />
Transactions conteneur<br />
Pour plus d’informations sur le panneau Properties dans d’autres<br />
contextes, voir “Définition <strong>des</strong> propriétés <strong>des</strong> sources de données”,<br />
page 7-23, et “Assignation <strong>des</strong> métho<strong>des</strong> autorisées”, page 7-26.<br />
Le mode transactionnel <strong>des</strong> <strong>enterprise</strong> <strong>beans</strong> dont les transactions sont<br />
gérées par le conteneur doit être défini par le conteneur. L’éditeur de<br />
<strong>des</strong>cripteur de déploiement vous permet de définir les mo<strong>des</strong><br />
transactionnels gérés par le conteneur et de les associer aux métho<strong>des</strong> <strong>des</strong><br />
interfaces locale et distante de l’<strong>enterprise</strong> bean.<br />
Ajout d’une transaction gérée par le conteneur<br />
Pour ajouter une transaction conteneur,<br />
1 Double-cliquez sur l’<strong>enterprise</strong> bean dans le volet structure pour<br />
développer son arborescence.<br />
2 Cliquez sur Container Transactions dans le volet structure.<br />
7-20 Guide du dé veloppeur Enterprise JavaBeans
Travail sur les sources de donné es<br />
3 Cliquez sur le bouton Add pour ajouter une ligne à la grille.<br />
4 Dans cette ligne, choisissez l’interface qui expose la méthode :<br />
sélectionnez Home ou Remote, ou sélectionnez * pour inclure les deux<br />
interfaces.<br />
5 Dans la liste déroulante Methods, sélectionnez une méthode, ou<br />
sélectionnez * pour inclure toutes les métho<strong>des</strong> possibles pour la<br />
transaction.<br />
6 Dans la liste déroulante Transaction Attribute, sélectionnez l’attribut<br />
souhaité pour la transaction.<br />
Pour une <strong>des</strong>cription <strong>des</strong> attributs <strong>des</strong> transactions, voir “Attributs <strong>des</strong><br />
transactions”, page 13-4.<br />
7 Entrez une <strong>des</strong>cription de la transaction dans le champ Description.<br />
Cette information est facultative.<br />
Travail sur les sources de données<br />
Pour voir les informations sur une source de données dans votre<br />
<strong>des</strong>cripteur de déploiement, développez le nœud Data Sources dans le<br />
volet structure et sélectionnez une <strong>des</strong> sources de données. L’éditeur de<br />
<strong>des</strong>cripteur de déploiement affiche le panneau Data Source. Vous pouvez<br />
utiliser ce panneau pour modifier les informations de la source de<br />
données sélectionnée. Seuls les <strong>beans</strong> entité ont une source de données.<br />
Utilisation de l’éditeur de <strong>des</strong>cripteur de dé ploiement 7-21
Travail sur les sources de donné es<br />
L’éditeur de <strong>des</strong>cripteur de déploiement vous permet de spécifier une<br />
nouvelle source de données pour les <strong>beans</strong> entité et de définir le niveau<br />
d’isolation <strong>des</strong> transactions.<br />
Pour ajouter une nouvelle source de données au <strong>des</strong>cripteur de<br />
déploiement,<br />
1 Cliquez sur l’icône dans la barre d’outils de l’éditeur de<br />
<strong>des</strong>cripteur de déploiement.<br />
Une boîte de dialogue New DataSource apparaît.<br />
2 Entrez le nom de la nouvelle source de données et choisissez OK.<br />
La nouvelle source de données est ajoutée à l’arborescence du volet<br />
structure.<br />
3 Sélectionnez la source de données dans l’arborescence.<br />
4 Entrez les informations pour la nouvelle source de données.<br />
La source de données est définie par un nom, un emplacement URL et,<br />
si nécessaire, un nom d’utilisateur et un mot de passe permettant d’y<br />
accéder. Le panneau inclut également le nom de classe du pilote JDBC<br />
et les propriétés JDBC.<br />
5 Lorsque vous avez spécifié la connexion à la source de données, vous<br />
pouvez cliquer sur le bouton Test Connection.<br />
L’éditeur de <strong>des</strong>cripteur de déploiement essaie d’établir la connexion à<br />
la source de données spécifiée. Les résultats sont reportés dans<br />
l’historique <strong>des</strong> messages.<br />
7-22 Guide du dé veloppeur Enterprise JavaBeans
Définition <strong>des</strong> niveaux d’isolation<br />
Travail sur les sources de donné es<br />
Le niveau d’isolation limite la façon dont <strong>des</strong> transactions multiples et<br />
entrelacées interfèrent les unes sur les autres dans une base de données<br />
multi-utilisateur. Voici les violations possibles :<br />
• Lecture brouillée: La transaction t1 modifie une ligne, la transaction t2<br />
lit ensuite cette ligne. Puis, t1 effectue une annulation (rollback). t2 a<br />
donc vu une ligne qui n’a jamais vraiment existé.<br />
• Lecture ne pouvant pas être répétée: La transaction t1 extrait une<br />
ligne. Ensuite, la transaction t2 met à jour cette ligne et t1 extrait à<br />
nouveau la même ligne. La transaction t1 a donc extrait la même ligne<br />
deux fois et a vu deux valeurs différentes.<br />
• Ligne fantôme : La transaction t1 lit un ensemble de lignes satisfaisant<br />
certaines conditions de recherche. Ensuite, la transaction t2 insère une<br />
ou plusieurs lignes satisfaisant les mêmes conditions de recherche. Si la<br />
transaction t1 répète la lecture, elle verra <strong>des</strong> lignes qui n’existaient pas<br />
au préalable. Ces lignes sont appelées lignes fantômes.<br />
Pour définir ou modifier le niveau d’isolation <strong>des</strong> transactions pour une<br />
source de données, choisissez un niveau d’isolation dans la liste<br />
déroulante Isolation Level :<br />
Attribut Syntaxe Description<br />
Uncommitted TRANSACTION_READ_UNCOMMITTED Autorise l’ensemble<br />
<strong>des</strong> trois violations<br />
Committed TRANSACTION_READ_COMMITTED Autorise les lectures<br />
ne pouvant pas être<br />
répétées et les lignes<br />
fantômes, n’autorise<br />
pas les lectures<br />
brouillées.<br />
Repeatable TRANSACTION_REPEATABLE_READ Autorise les lignes<br />
fantômes, mais pas<br />
les deux autres<br />
violations.<br />
Serializable TRANSACTION_SERIALIZABLE N’autorise aucune<br />
<strong>des</strong> trois violations.<br />
Définition <strong>des</strong> propriétés <strong>des</strong> sources de données<br />
Lorsqu’une source de données est sélectionnée dans l’éditeur de<br />
<strong>des</strong>cripteur de déploiement, un onglet Properties apparaît en même temps<br />
que l’onglet Data Source. Le panneau Properties vous permet de définir<br />
<strong>des</strong> propriétés affectant le moteur Borland de persistance gérée par le<br />
conteneur (CMP).<br />
Utilisation de l’éditeur de <strong>des</strong>cripteur de dé ploiement 7-23
Travail sur les sources de donné es<br />
Pour modifier les propriétés d’une source de données,<br />
1 Sélectionnez la source de données dans le volet structure.<br />
2 Cliquez sur l’onglet Propriétés.<br />
3 Dans le panneau Properties, sélectionnez la propriété à définir dans la<br />
liste déroulante Name.<br />
La valeur Type est remplie automatiquement en fonction de votre<br />
sélection dans la liste Name.<br />
4 Sélectionnez la valeur de la propriété dans la colonne Value.<br />
5 Ajoutez <strong>des</strong> propriétés en cliquant sur le bouton Add pour ajouter une<br />
nouvelle ligne, puis en sélectionnant les entrées Name et Value de la<br />
nouvelle propriété.<br />
Voici les propriétés possibles :<br />
Propriété<br />
uniqueSequence<br />
batchUpdates<br />
Description<br />
Détermine si le moteur CMP doit déclarer une séquence<br />
unique pour les colonnes clé primaire. Habituellement,<br />
cela s’effectue en déclarant les colonnes appropriées<br />
comme clés primaires (voir primaryKeyDeclaration).<br />
Indique si le moteur CMP doit traiter par lot les mises à<br />
jour dans la base de données. Cela peut générer un gain<br />
significatif de performance lors de transactions mettant à<br />
jour un grand nombre d’entités, et doit être utilisé si le<br />
pilote le supporte. Malheureusement, la majorité d’entre<br />
eux ne supportent pas encore ces mises à jour par lot. La<br />
valeur par défaut est false.<br />
7-24 Guide du dé veloppeur Enterprise JavaBeans
Ajout <strong>des</strong> rô les de sé curité et <strong>des</strong> mé tho<strong>des</strong> autorisé es<br />
Propriété<br />
reuseStatements<br />
notNullDeclaration<br />
dialect<br />
primaryKeyDeclaration<br />
Description<br />
Détermine si le moteur CMP doit réutiliser <strong>des</strong><br />
instructions préparées, de transaction en transaction. La<br />
réutilisation d’instructions préparées a un effet positif sur<br />
les performances, elles doivent être utilisées sauf si les<br />
présentations du pilote JDBC sont réutilisées. La valeur<br />
par défaut est true.<br />
Détermine si les champs Java qui ne peuvent être nuls<br />
(comme int ou float) doivent être mappés sur <strong>des</strong><br />
colonnes non nulles. La valeur par défaut est true.<br />
Détermine le type de la source de données, par exemple<br />
un JDataStore, Oracle, Informix ou une autre source de<br />
données. Sélectionnez un dialecte dans la liste déroulante<br />
de la colonne Value. Si vous ne définissez pas ce champ, le<br />
moteur CMP crée <strong>des</strong> tables uniquement pour JDataStore.<br />
La valeur par défaut est none.<br />
Détermine si le moteur CMP déclare les colonnes clé<br />
primaire de la table comme clés primaires. Certaines bases<br />
de données ne supportent pas les déclarations de clés<br />
primaires. La valeur par défaut est true.<br />
Ajout <strong>des</strong> rôles de sécurité et <strong>des</strong> métho<strong>des</strong> autorisées<br />
L’éditeur de <strong>des</strong>cripteur de déploiement vous permet de créer ou de<br />
modifier les rôles de sécurité dans le <strong>des</strong>cripteur de déploiement. Après<br />
avoir créé <strong>des</strong> rôles de sécurité, vous pouvez leur associer <strong>des</strong> métho<strong>des</strong><br />
<strong>des</strong> interfaces locale et distante de l’<strong>enterprise</strong> bean, définissant ainsi la<br />
vue sécurité de l’application.<br />
Cette section décrit l’utilisation de l’éditeur de <strong>des</strong>cripteur de déploiement<br />
pour créer les rôles de sécurité et leur assigner les métho<strong>des</strong> de<br />
l’<strong>enterprise</strong> bean. La section “Panneau Security role references”, page 7-9<br />
décrit l’utilisation du panneau Roles pour assigner à ces rôles <strong>des</strong> groupes<br />
d’utilisateurs et/ou <strong>des</strong> comptes utilisateur.<br />
La définition <strong>des</strong> rôles de sécurité dans le <strong>des</strong>cripteur de déploiement est<br />
facultative.<br />
Création d’un rôle de sécurité<br />
Pour créer un rôle de sécurité dans le <strong>des</strong>cripteur de déploiement,<br />
1 Cliquez sur l’icône dans la barre d’outils de l’éditeur de<br />
<strong>des</strong>cripteur de déploiement.<br />
2 Dans la boîte de dialogue qui apparaît, entrez le nom du nouveau rôle<br />
de sécurité et choisissez OK.<br />
Utilisation de l’éditeur de <strong>des</strong>cripteur de dé ploiement 7-25
Ajout <strong>des</strong> rô les de sé curité et <strong>des</strong> mé tho<strong>des</strong> autorisé es<br />
Le nouveau rôle apparaît sous le nœud Security Roles dans le volet<br />
structure. Si vous ne le voyez pas, vérifiez que vous avez bien développé<br />
le nœud Security Roles. Un panneau Properties dédié au rôle apparaît<br />
également :<br />
Vous pouvez entrer la <strong>des</strong>cription du nouveau rôle dans le panneau<br />
Properties. Cette information est facultative.<br />
Assignation <strong>des</strong> métho<strong>des</strong> autorisées<br />
Lorsque vous avez défini un rôle de sécurité, vous pouvez spécifier les<br />
métho<strong>des</strong> <strong>des</strong> interfaces locale et distante d’un <strong>enterprise</strong> bean que le rôle<br />
de sécurité est autorisé à appeler.<br />
Vous n’êtes pas obligé d’associer un rôle de sécurité aux métho<strong>des</strong> d’une<br />
interface locale ou distante d’un <strong>enterprise</strong> bean. En ce cas, aucun <strong>des</strong><br />
rôles de sécurité définis dans le <strong>des</strong>cripteur de déploiement ne sera<br />
autorisé à appeler ces métho<strong>des</strong>.<br />
Pour autoriser <strong>des</strong> métho<strong>des</strong>,<br />
1 Développez le nœud du bean dans le volet structure pour faire<br />
apparaître son sous-nœud Method Permissions.<br />
7-26 Guide du dé veloppeur Enterprise JavaBeans
Visualisation et modification <strong>des</strong> proprié t é s WebLogic et WebSphere<br />
2 Sélectionnez le nœud Method Permission pour afficher un panneau<br />
Properties.<br />
Chaque rôle de sécurité défini apparaît comme titre de colonne.<br />
3 Cliquez sur le bouton Add pour ajouter une ligne au panneau.<br />
4 Dans la nouvelle ligne, choisissez Home, Remote ou * (pour indiquer<br />
les deux) dans la liste déroulante du champ Interface.<br />
5 Dans la liste déroulante Method, sélectionnez la méthode que vous<br />
autorisez à appeler, ou sélectionnez * pour autoriser l’appel de toutes<br />
les métho<strong>des</strong>.<br />
6 Cochez la case de chaque rôle de sécurité que vous voulez autoriser à<br />
appeler les métho<strong>des</strong> spécifiées.<br />
7 Enfin, décrivez l’autorisation définie par cette ligne dans le champ<br />
Description, si vous le souhaitez.<br />
Visualisation et modification <strong>des</strong> propriétés WebLogic et<br />
WebSphere<br />
Vous pouvez utiliser l’éditeur de <strong>des</strong>cripteur de déploiement pour<br />
visualiser et modifier certains éléments spécifiques au fournisseur et<br />
uniques à WebLogic et WebSphere. Si votre serveur d’applications cible<br />
est le serveur WebLogic ou le serveur WebSphere, l’éditeur de <strong>des</strong>cripteur<br />
de déploiement affiche un onglet EJB Properties en bas du volet contenu.<br />
Utilisation de l’éditeur de <strong>des</strong>cripteur de dé ploiement 7-27
V é rification <strong>des</strong> informations du <strong>des</strong>cripteur<br />
Pour voir les propriétés spécifiques à WebLogic ou WebSphere,<br />
1 Double-cliquez sur le nœud du groupe EJB dans le volet projet.<br />
2 Cliquez dans le volet structure sur l’<strong>enterprise</strong> bean avec lequel vous<br />
travaillez.<br />
3 Cliquez sur l’onglet EJB Properties.<br />
Le panneau EJB Properties affiche un tableau <strong>des</strong> propriétés spécifiques<br />
au serveur WebLogic ou au serveur WebSphere. Par exemple, voici le<br />
panneau EJB Properties qui apparaît lorsque WebLogic Server 6.0 est le<br />
serveur d’applications sélectionné :<br />
Vous pouvez utiliser ce tableau pour voir les valeurs <strong>des</strong> propriétés ou les<br />
modifier. Utilisez la colonne de droite pour saisir les valeurs <strong>des</strong><br />
propriétés que vous voulez modifier. Les valeurs <strong>des</strong> propriétés sont<br />
stockées dans les <strong>des</strong>cripteurs de déploiement spécifiques au serveur<br />
d’applications.<br />
Vérification <strong>des</strong> informations du <strong>des</strong>cripteur<br />
Après avoir modifié le fichier <strong>des</strong>cripteur, vous pouvez vérifier que les<br />
informations du <strong>des</strong>cripteur sont au format correct, que les fichiers classe<br />
<strong>des</strong> <strong>beans</strong> nécessaires sont présents, etc.<br />
Pour vérifier les informations, cliquez sur l’icône de vérification ( )<br />
dans la barre d’outils de l’éditeur de <strong>des</strong>cripteur de déploiement. Avant<br />
de choisir l’icône de vérification, vous pouvez définir les options de<br />
vérification en cliquant sur l’icône .<br />
7-28 Guide du dé veloppeur Enterprise JavaBeans
V é rification <strong>des</strong> informations du <strong>des</strong>cripteur<br />
La vérification effectue ce qui suit :<br />
• S’assure que le <strong>des</strong>cripteur respecte la spécification EJB 1.1.<br />
• S’assure que les classes référencées par les <strong>des</strong>cripteurs de déploiement<br />
respectent la spécification EJB 1.1.<br />
Set Class Path est utilisé pour la réflexion du code binaire, non pour celle<br />
du code source. Pour activer la réflexion du code binaire, ajoutez cette<br />
instruction à la section Preferences du fichier Borland/AppServer/console/<br />
plugins/iaspt.ini :<br />
UseSourceReflection=false<br />
Pour définir le chemin d’accès aux classes, cliquez sur l’icône et<br />
utilisez la boîte de dialogue qui apparaît pour indiquer le nouveau<br />
chemin.<br />
Utilisation de l’éditeur de <strong>des</strong>cripteur de dé ploiement 7-29
7-30 Guide du dé veloppeur Enterprise JavaBeans
Chapitre<br />
8<br />
Chapitre8Utilisation de DataExpress<br />
pour les composants EJB<br />
JBuilder propose plusieurs composants permettant de récupérer les<br />
données <strong>des</strong> <strong>beans</strong> entité dans <strong>des</strong> ensembles de données DataExpress<br />
(fourniture) ou d’enregistrer les données <strong>des</strong> ensembles de données<br />
DataExpress dans les <strong>beans</strong> entité (résolution). Ces composants<br />
DataExpress pour EJB facilitent l’implémentation du modèle de<br />
conception où le bean session enveloppe le bean entité. En utilisant ce<br />
modèle de conception, les clients n’ont pas directement accès aux <strong>beans</strong><br />
entité mais les accèdent en utilisant <strong>des</strong> <strong>beans</strong> session. Les <strong>beans</strong> session,<br />
qui sont co-localisés avec les <strong>beans</strong> entité, rassemblent tous les appels aux<br />
<strong>beans</strong> entité dans une même transaction et renvoient ensuite toutes les<br />
données en même temps. Les ensembles de données sont le moyen de<br />
transport <strong>des</strong> données entre le bean session et le client, et vice-versa.<br />
Comme les données sont expédiées sur la ligne une seule fois pour fournir<br />
les données au client, et une seule fois encore pour résoudre les<br />
modifications dans les <strong>beans</strong> entité sur le serveur, les performances<br />
s’améliorent.<br />
Ces composants rendent également plus faciles la construction <strong>des</strong><br />
applications client utilisant <strong>des</strong> composants visuels orientés DataExpress<br />
comme dbSwing ou InternetBeans Express. Pour une <strong>des</strong>cription<br />
complète de DataExpress, voir “Les applications de bases de données de<br />
JBuilder” dans le Guide du développeur d’applications bases de données.<br />
Ce chapitre explique comment utiliser ces composants pour transférer <strong>des</strong><br />
données depuis les <strong>beans</strong> entité déployés sur un serveur vers votre<br />
application client et vice-versa. Le code utilisé dans le chapitre provient<br />
du projet exemple /JBuilder5/samples/Ejb/ejbdx.jpx. L’exemple accède à<br />
<strong>des</strong> données stockées dans le DataStore Employee. L’exemple crée un bean<br />
entité pour contenir les données Employee. Il crée aussi un bean session<br />
Utilisation de DataExpress pour les composants EJB 8-1
Les composants DataExpress EJB<br />
Personnel qui lit les données de Employee et les envoie ensuite au client. Le<br />
client renvoie les données au bean Personnel, qui résout les données dans<br />
les instances du bean entité Employee.<br />
Les composants DataExpress EJB<br />
Création <strong>des</strong> <strong>beans</strong> entité<br />
Quatre <strong>des</strong> composants DataExpress EJB appartiennent à la page EJB de la<br />
palette de composants. Vous pouvez travailler avec ces composants dans<br />
le concepteur d’interface utilisateur, en définissant <strong>des</strong> propriétés et <strong>des</strong><br />
événements à l’aide de l’inspecteur. Il existe d’autres classes que votre<br />
code peut appeler mais que vous ne pouvez pas mettre en œuvre de<br />
manière visuelle. Pour plus d’informations sur les classes, voir la<br />
Référence API.<br />
Composants pour le serveur<br />
Les deux composants de la page EJB de la palette de composants utilisés<br />
par le bean session déployé sur le serveur sont EntityBeanProvider et<br />
EntityBeanResolver. EntityBeanProvider fournit <strong>des</strong> données depuis les <strong>beans</strong><br />
session déployés sur le serveur et EntityBeanResolver résout les données<br />
dans ces <strong>beans</strong> entité. Vous ajoutez ces composants au bean session que<br />
vous créez pour rendre le bean session capable de fournir les données <strong>des</strong><br />
<strong>beans</strong> entité et de les résoudre.<br />
Composants pour le client<br />
Deux <strong>des</strong> composants de la page EJB sont utilisés côté client :<br />
EjbClientDataSet et SessionBeanConnection. EjbClientDataSet fournit les<br />
données depuis le bean session et résout les modifications dans le bean<br />
session référencé dans SessionBeanConnection. Un SessionBeanConnection<br />
contient la référence à un bean session sur le serveur et les noms <strong>des</strong><br />
métho<strong>des</strong> servant à fournir les ensembles de données à partir de ce bean<br />
session et à résoudre les ensembles de données dans ce bean session.<br />
Commencez par utiliser le Modeleur Bean entité EJB pour créer les <strong>beans</strong><br />
entité qui accèdent aux données qui vous intéressent. Le projet exemple<br />
crée les <strong>beans</strong> entité Employee et Department mais ce chapitre ne s’occupe que<br />
de Employee.<br />
8-2 Guide du dé veloppeur Enterprise JavaBeans
Création du bean session côté serveur<br />
Cré ation du bean session cô t é serveur<br />
Créez le bean session qui résidera sur le serveur. Envisagez l’utilisation de<br />
l’expert Enterprise JavaBean pour créer un bean session stateless. Dans la<br />
prochaine section, vous ajouterez les classes EntityBeanProvider et<br />
EntityBeanResolver à ce bean. Comme ces classes ne sont pas sérialisables, il<br />
est plus facile de les placer dans un bean session stateless qui, pour<br />
Borland Application Server, n’est jamais désactivé. Si votre application<br />
exige un bean session stateful, il faut soit que le bean session stateful fasse<br />
référence au bean session stateless, soit que vous ré-instanciez<br />
EntityBeanProvider et EntityBeanResolver lorsque le bean session stateful est<br />
activé.<br />
Voici à quoi ressemble une classe bean résultante, nommée PersonnelBean :<br />
public class PersonnelBean implements SessionBean {<br />
private SessionContext sessionContext;<br />
public void ejbCreate() {<br />
}<br />
public void ejbRemove() throws RemoteException {<br />
}<br />
public void ejbActivate() throws RemoteException {<br />
}<br />
public void ejbPassivate() throws RemoteException {<br />
}<br />
public void setSessionContext(SessionContext sessionContext) throws<br />
RemoteException {<br />
this.sessionContext = sessionContext;<br />
}<br />
}<br />
Cliquez sur l’onglet Conception pour afficher le concepteur d’interface<br />
utilisateur.<br />
Ajout <strong>des</strong> composants fournisseur et résolveur au bean<br />
session<br />
Depuis la page EJB de la palette de composants, ajoutez un<br />
EntityBeanProvider et un EntityBeanResolver au bean session. Vous devez<br />
aussi ajouter un composant ensemble de données pour contenir les<br />
données récoltées dans les <strong>beans</strong> entité avant qu’elles ne soient envoyées<br />
au client, ainsi que les données renvoyées par le client. Depuis la page<br />
DataExpress de la palette de composants, ajoutez un composant<br />
TableDataSet et donnez à ce TableDataSet un nom plus évocateur.<br />
Voici à quoi doit ressembler la partie supérieure de PersonnelBean ; le<br />
TableDataSet a été renommé en employeeDataSet :<br />
public class PersonnelBean implements SessionBean {<br />
private SessionContext sessionContext;<br />
Utilisation de DataExpress pour les composants EJB 8-3
Cré ation du bean session cô t é serveur<br />
EntityBeanProvider entityBeanProvider = new EntityBeanProvider();<br />
EntityBeanResolver entityBeanResolver = new EntityBeanResolver();<br />
TableDataSet employeeDataSet = new TableDataSet();<br />
...<br />
En utilisant l’inspecteur, définissez les propriétés provider et resolver du<br />
TableDataSet par les composants EntityBeanProvider et EntityBeanResolver<br />
nouvellement ajoutés. Le résultat est l’ajout de deux nouvelles métho<strong>des</strong><br />
dans la méthode jbInit() :<br />
employeeDataSet.setProvider(entityBeanProvider);<br />
employeeDataSet.setResolver(entityBeanResolver);<br />
En revanche, le projet exemple contient ces métho<strong>des</strong> dans la méthode<br />
setSessionContext(). Vous pouvez vous-même ajouter les appels de ces<br />
métho<strong>des</strong> à setSessionContext() si vous préférer imiter exactement le projet<br />
exemple. Les deux approches conviennent parfaitement.<br />
Ajoutez aux membres de cette classe une référence à l’interface locale du<br />
bean entité contenant les données que vous voulez accéder. Pour cet<br />
exemple, la référence est faite à l’interface locale du bean entité Employee,<br />
comme montré ici en gras.<br />
public class PersonnelBean implements SessionBean {<br />
private SessionContext sessionContext;<br />
EntityBeanProvider entityBeanProvider = new EntityBeanProvider();<br />
EntityBeanResolver entityBeanResolver = new EntityBeanResolver();<br />
TableDataSet employeeDataSet = new TableDataSet();<br />
EmployeeHome employeeHome;<br />
...<br />
Ecriture de la méthode setSessionContext()<br />
Dans la méthode sessionContext() du bean session, ajoutez un bloc try.<br />
Modifiez la méthode pour qu’elle ressemble à ceci :<br />
public void setSessionContext(SessionContext sessionContext)<br />
throws RemoteException {<br />
this.sessionContext = sessionContext;<br />
try {<br />
Context context = new InitialContext();<br />
Object object = context.lookup("java:comp/env/ejb/Employee");<br />
employeeHome = (EmployeeHome) PortableRemoteObject.narrow(object,<br />
EmployeeHome.class);<br />
entityBeanProvider.setEjbHome(employeeHome);<br />
entityBeanResolver.setEjbHome(employeeHome);<br />
}<br />
catch (Exception ex) {<br />
throw new EJBException(ex);<br />
}<br />
}<br />
8-4 Guide du dé veloppeur Enterprise JavaBeans
Cré ation du bean session cô t é serveur<br />
Notez que setSessionContext() définit la valeur <strong>des</strong> propriétés ejbHome <strong>des</strong><br />
composants EntityBeanProvider et EntityBeanResolver par le nom de<br />
l’interface locale du bean entité Employee.<br />
Ajout d’une référence EJB au <strong>des</strong>cripteur de déploiement<br />
Vous devez ajouter une référence EJB à Personnel dans le <strong>des</strong>cripteur de<br />
déploiement pour que la recherche fonctionne. Vous pouvez utiliser<br />
l’éditeur de <strong>des</strong>cripteur de déploiement :<br />
1 Dans le volet projet, double-cliquez sur le nœud de groupe EJB. Pour le<br />
projet exemple, il s’agit de personnel.ejbgrpx.<br />
L’éditeur de <strong>des</strong>cripteur de déploiement apparaît.<br />
2 Cliquez sur le bean Personnel dans le volet structure.<br />
3 Cliquez sur l’onglet EJB References dans l’éditeur de <strong>des</strong>cripteur de<br />
déploiement.<br />
4 Cliquez sur le bouton Add pour ajouter une référence au bean entité<br />
contenant les données qui vous intéressent.<br />
5 Entrez un nom de référence. Dans le projet exemple, le nom est ejb/<br />
Employee.<br />
6 Cochez la case IsLink.<br />
7 Spécifiez le bean entité dans la liste déroulante Link.<br />
Le reste <strong>des</strong> données doit être rempli automatiquement.<br />
Ajout <strong>des</strong> métho<strong>des</strong> de fourniture et de résolution<br />
Vous devez ajouter deux métho<strong>des</strong> au bean session, un fournisseur et un<br />
résolveur. Les noms de ces métho<strong>des</strong> utilisent la valeur que vous avez<br />
spécifiée comme valeur de la propriété methodName pour le composant<br />
EjbClientDataSet. Ainsi, le fournisseur de PersonnelBean devient<br />
provideEmployee() et le résolveur resolveEmployee().<br />
Le fournisseur doit appeler la méthode d’une classe EntityBeanConnection<br />
qui fournit les données d’un bean entité à un ensemble de données<br />
pouvant être envoyé sur la ligne. Voici à quoi doit ressembler la méthode<br />
provideEmployee() générée :<br />
public DataSetData [] provideEmployee(RowData [] parameterArray,<br />
RowData [] masterArray) {<br />
return EntityBeanConnection.provideDataSets(new StorageDataSet []<br />
{employeeDataSet}, parameterArray, masterArray);<br />
}<br />
Utilisation de DataExpress pour les composants EJB 8-5
Cré ation du bean session cô t é serveur<br />
Le résolveur doit appeler la méthode d’une classe EntityBeanConnection qui<br />
résout toutes les mises à jour dans les <strong>beans</strong> entité. Voici comment<br />
resolveEmployee() doit se présenter :<br />
public DataSetData [] resolveEmployee(DataSetData[] dataSetDataArray) {<br />
return EntityBeanConnection.saveChanges(dataSetDataArray,<br />
new DataSet [] {employeeDataSet});<br />
}<br />
Ajoutez ensuite ces métho<strong>des</strong> à l’interface distante. Le moyen le plus<br />
simple est d’utiliser Beans express. Le fichier source du bean étant ouvert<br />
dans l’éditeur, cliquez sur l’onglet Bean, cliquez sur l’onglet Métho<strong>des</strong> et<br />
cochez les cases situées à côté <strong>des</strong> métho<strong>des</strong> que vous venez d’ajouter.<br />
Vous pouvez maintenant tester l’interface distante de votre bean session<br />
afin de vérifier que les deux métho<strong>des</strong> sont désormais définies :<br />
public interface Personnel extends EJBObject {<br />
public com.borland.dx.dataset.DataSetData[]<br />
providePersonnel(com.borland.dx.ejb.RowData[] parameterArray,<br />
com.borland.dx.ejb.RowData[] masterArray) throws RemoteException;<br />
public com.borland.dx.dataset.DataSetData[]<br />
resolvePersonnel(com.borland.dx.dataset.DataSetData[] dataSetDataArray)<br />
throws RemoteException;<br />
}<br />
Appel de la méthode find<br />
Vous devez indiquer au EntityBeanProvider les <strong>beans</strong> entité à fournir. Pour<br />
ce faire, ajoutez un événement au EntityBeanProvider :<br />
1 Alors que vous êtes dans le concepteur d’interface utilisateur,<br />
sélectionnez le EntityBeanProvider dans le volet structure.<br />
2 Cliquez sur l’onglet Evénements de l’inspecteur, puis double-cliquez<br />
dans la colonne vierge associé à l’événement findEntityBeans. Un nouvel<br />
événement est ajouté.<br />
Voici le code résultant pour cet événement, tel qu’il apparaît dans le<br />
projet ejbdx.jpx :<br />
entityBeanProvider1.addEntityBeanFindListener(new<br />
com.borland.dx.ejb.EntityBeanFindListener() {<br />
public void findEntityBeans(EntityBeanFindEvent e) {<br />
entityBeanProvider1_findEntityBeans(e);<br />
}<br />
});<br />
...<br />
void entityBeanProvider_findEntityBeans(EntityBeanFindEvent e) {<br />
}<br />
8-6 Guide du dé veloppeur Enterprise JavaBeans
Construction du côté client<br />
Construction du cô t é client<br />
3 Ajoutez au nouveau gestionnaire d’événement une méthode find pour<br />
renvoyer les <strong>beans</strong> entité souhaités. Le code ajouté apparaît ici en gras :<br />
void entityBeanProvider_findEntityBeans(EntityBeanFindEvent e) {<br />
try {<br />
e.setEntityBeanCollection(employeeHome.findAll());<br />
}<br />
catch (Exception ex) {<br />
throw new EJBException(ex);<br />
}<br />
}<br />
Dans cet exemple, le gestionniare d’événement appelle une méthode<br />
findAll() pour renvoyer tous les <strong>beans</strong> entité. Vous pouvez appeler<br />
n’importe quelle méthode find. Vous pourriez utiliser la propriété<br />
parameterRow du EntityBeanProvider pour déterminer de manière<br />
dynamique quelle méthode find appeler et/ou quels paramètres lui<br />
transmettre.<br />
Pour la résolution, le EntityBeanResolver peut déterminer par défaut<br />
comment appliquer les mises à jour et les suppressions. Mais il ne peut<br />
pas déterminer automatiquement comment créer de nouveaux <strong>beans</strong><br />
entité car il n’a aucun moyen de savoir quelle méthode create() appeler et<br />
quels paramètres lui transmettre. Aussi, lorsque vous voulez ajouter une<br />
ligne à la source de données, vous devez ajouter vous-même l’événement<br />
create et fournir la logique nécessaire. Vous pouvez utiliser l’inspecteur<br />
pour ajouter le code squelette de l’événement create à votre bean session.<br />
Vous trouverez un exemple d’événement create dans le projet exemple<br />
ejbdx.jpx. Vous pouvez aussi utiliser les autres événements disponibles<br />
dans EntityBeanResolver pour surcharger le comportement par défaut, si<br />
vous le voulez.<br />
Déployez les <strong>beans</strong> session et entité sur le serveur d’applications. Pour<br />
plus d’informations sur le déploiement <strong>des</strong> <strong>beans</strong>, voir “Déploiement sur<br />
un serveur d’applications”, page 6-6.<br />
Maintenant que vous avez créé les <strong>beans</strong> entité et le bean session qui les<br />
accède et que vous les avez déployés sur votre serveur d’applications<br />
cible, vous êtes prêt à construire le client.<br />
Suivez ces étapes :<br />
1 Créez un module de données. Choisissez Fichier|Nouveau|Module de<br />
données.<br />
2 Dans la palette, sélectionnez le composant EjbClientDataSet et ajoutez-le<br />
au module de données.<br />
Utilisation de DataExpress pour les composants EJB 8-7
Construction du cô t é client<br />
3 Dans la palette, sélectionnez le composant SessionConnectionBean et<br />
ajoutez-le au module de données.<br />
4 Dans l’inspecteur, définissez la propriété sessionBeanConnection du<br />
EjbClientDataSet par le nom du SessionBeanConnection.<br />
5 Dans l’inspecteur, spécifiez un nom pour la propriété methodName pour le<br />
composant EjbClientDataSet.<br />
La propriété methodName détermine comment sont nommées les<br />
métho<strong>des</strong> qui fournissent et résolvent les données. Par exemple, si vous<br />
spécifiez la valeur Employee pour methodName, les métho<strong>des</strong> qui<br />
fournissent et résolvent les données du bean session deviendront<br />
provideEmployee() et resolveEmployee(). Plus tard, vous devrez ajouter ces<br />
métho<strong>des</strong> au bean session que vous créez.<br />
6 Dans l’inspecteur ou directement dans le code source, définissez la<br />
propriété jndiName du composant SessionBeanConnection. Ou bien, vous<br />
pouvez spécifier le nom de l’interface distante du bean session que<br />
vous allez créer comme valeur de la propriété sessionBeanRemote.<br />
Vous pouvez aussi utiliser l’inspecteur pour ajouter un événement<br />
creating à votre SessionBeanConnection. Le code que vous ajoutez au<br />
gestionnaire de l’événement peut contrôler la création du bean session<br />
après la recherche JNDI. Habituellement, vous devez ajouter un<br />
événement creating si vous voulez invoquer une méthode create() sur<br />
l’interface locale qui requiert <strong>des</strong> paramètres.<br />
Voici le code source résultant, tel qui se trouve dans le projet exemple /<br />
JBuilder5/samples/Ejb/ejbdx.jpx.<br />
import com.borland.dx.dataset.*;<br />
import com.borland.dx.ejb.*;<br />
public class PersonnelDataModule implements DataModule {<br />
private static PersonnelDataModule myDM;<br />
SessionBeanConnection sessionBeanConnection = new SessionBeanConnection();<br />
EjbClientDataSet personnelDataSet = new EjbClientDataSet();<br />
public PersonnelDataModule() {<br />
try {<br />
jbInit();<br />
}<br />
catch(Exception e) {<br />
e.printStackTrace();<br />
}<br />
}<br />
private void jbInit() throws Exception {<br />
try {<br />
sessionBeanConnection.setJndiName("Personnel");<br />
sessionBeanConnection.addCreateSessionBeanListener(new<br />
com.borland.dx.ejb.CreateSessionBeanListener() {<br />
public void creating(CreateSessionBeanEvent e) {<br />
sessionBeanConnection_creating(e);<br />
8-8 Guide du dé veloppeur Enterprise JavaBeans
Gestion <strong>des</strong> relations<br />
}<br />
});<br />
personnelDataSet.setSessionBeanConnection(sessionBeanConnection);<br />
personnelDataSet.setMethodName("Personnel");<br />
}<br />
catch (Exception ex) {<br />
}<br />
}<br />
public static PersonnelDataModule getDataModule() {<br />
if (myDM == null) {<br />
myDM = new PersonnelDataModule();<br />
}<br />
return myDM;<br />
}<br />
public com.borland.dx.ejb.SessionBeanConnection getSessionBeanConnection() {<br />
return sessionBeanConnection;<br />
}<br />
public com.borland.dx.ejb.EjbClientDataSet getPersonnelDataSet() {<br />
return personnelDataSet;<br />
}<br />
}<br />
}<br />
Gestion <strong>des</strong> relations<br />
Projet exemple<br />
void sessionBeanConnection_creating(CreateSessionBeanEvent e) {<br />
Le EntityBeanProvider facilite automatiquement les relations. Par exemple,<br />
si vous avez un bean entité Employee possédant une méthode getDept() qui<br />
renvoie un Dept, où Dept est un bean entité distant, un DataSet est créé<br />
possédant tous les champs du bean entité Employee plus tous les champs du<br />
bean entité Dept (y compris les colonnes cachées contenant les clés<br />
primaires de chacun <strong>des</strong> <strong>beans</strong> entité). Sauf Dept.ejbPrimaryKey, les champs<br />
de Dept sont en lecture seule.<br />
Pour résoudre les modifications dans le cas d’une relation un-à-un, vous<br />
devez ajouter un auditeur d’événement au EntityBeanProvider car il ne lui<br />
est pas possible de déterminer de manière dynamique l’interface locale du<br />
bean entité concerné. Le projet exemple ejbdx.jpx ne gère pas de relation.<br />
Jusqu’à présent, nous avons vu comment transférer efficacement <strong>des</strong><br />
données, dans un sens et dans l’autre, entre le client et le serveur. Le projet<br />
exemple /JBuilder5/samples/Ejb/ejbdx.jpx montre comment mettre en<br />
œuvre les techniques décrites avec un client Java utilisant <strong>des</strong> contrôles<br />
Utilisation de DataExpress pour les composants EJB 8-9
Projet exemple<br />
dbSwing et avec un client Web utilisant la technologie JSP combinée à<br />
InternetBeansExpress. Vous serez alors en mesure de travailler avec de<br />
véritables données. Consultez la page Ejb.html du projet pour les<br />
instructions complètes permettant d’exécuter le projet exemple.<br />
8-10 Guide du dé veloppeur Enterprise JavaBeans
Chapitre<br />
9<br />
Chapitre9Développement<br />
<strong>des</strong> <strong>beans</strong> session<br />
Types de <strong>beans</strong> session<br />
Les outils EJB de JBuilder peuvent grandement simplifier la création <strong>des</strong><br />
<strong>enterprise</strong> <strong>beans</strong> et de leurs interfaces de support. Toutefois, vous devez<br />
savoir ce qu’exigent ces classes et ces interfaces, afin de pouvoir modifier<br />
les fichiers produits par JBuilder et comprendre le travail que celui-ci fait<br />
pour vous. Les chapitres suivants vous y aideront.<br />
Un bean session existe habituellement pour la durée de vie d’une session<br />
client unique. Les métho<strong>des</strong> d’un bean session accomplissent un ensemble<br />
de tâches ou de processus pour le compte du client qui utilise le bean. Les<br />
<strong>beans</strong> session sont persistants uniquement pour la durée de la connexion<br />
avec le client. D’une certaine façon, le bean session représente le client<br />
pour le serveur EJB. Il fournit généralement un service au client. A moins<br />
de travailler avec <strong>des</strong> données persistantes existant dans un ensemble de<br />
données, vous utiliserez habituellement <strong>des</strong> <strong>beans</strong> session.<br />
Voici les deux types de <strong>beans</strong> session : ceux qui peuvent maintenir <strong>des</strong><br />
informations d’état entre les appels <strong>des</strong> métho<strong>des</strong>, appelés <strong>beans</strong> stateful,<br />
et ceux qui ne le peuvent pas, appelés <strong>beans</strong> stateless.<br />
Beans session stateful<br />
Les <strong>beans</strong> session stateful sont <strong>des</strong> objets utilisés par un seul client et ils<br />
maintiennent un état pour le compte de ce client. Par exemple, supposons<br />
un bean session représentant un chariot de supermarché. Au fur et à<br />
D é veloppement <strong>des</strong> <strong>beans</strong> session 9-1
Ecriture de la classe du bean session<br />
mesure que l’acheteur d’un magasin en ligne sélectionne ses achats,<br />
ceux-ci sont ajoutés à son chariot par le stockage <strong>des</strong> éléments sélectionnés<br />
dans une liste à l’intérieur de l’objet bean session représentant le chariot.<br />
Lorsque l’acheteur a fini ses achats, la liste est utilisée pour calculer le<br />
montant total.<br />
Beans session stateless<br />
Les <strong>beans</strong> session stateless ne maintiennent d’état pour aucun client<br />
spécifique. De ce fait, ils peuvent être utilisés par de nombreux clients. Par<br />
exemple, imaginons un bean session de tri contenant une méthode<br />
sortList(). Le client invoque sortList() en lui passant une liste d’éléments<br />
non triée. sortList() passe en retour au client la liste triée.<br />
Ecriture de la classe du bean session<br />
Pour créer la classe d’un bean session,<br />
• Créez une classe qui implémente l’interface javax.ejb.SessionBean.<br />
• Implémentez une ou plusieurs métho<strong>des</strong> ejbCreate(). Si vous créez un<br />
bean session stateless, la classe implémente une seule méthode sans<br />
paramètre, ejbCreate(). Si vous avez déjà créé l’interface locale du bean,<br />
le bean doit avoir une méthode ejbCreate(), avec la même signature,<br />
pour chaque méthode create() de l’interface locale.<br />
• Définissez et implémentez les métho<strong>des</strong> métier que votre bean doit<br />
avoir. Si vous avez déjà créé l’interface distante du bean, les métho<strong>des</strong><br />
doivent être définies exactement comme elles le sont dans l’interface<br />
distante.<br />
L’expert Enterprise JavaBean de JBuilder peut commencer ces tâches à<br />
votre place, y compris la création <strong>des</strong> interfaces locale et distante. Il crée<br />
une classe étendant l’interface SessionBean et écrit les implémentations<br />
vi<strong>des</strong> <strong>des</strong> métho<strong>des</strong> SessionBean. Vous remplissez ces implémentations si<br />
votre bean en a besoin. La section suivante explique quelles sont ces<br />
métho<strong>des</strong> et comment elles sont utilisées.<br />
Implémentation de l’interface SessionBean<br />
L’interface SessionBean définit les métho<strong>des</strong> que tous les <strong>beans</strong> session<br />
doivent implémenter. Elle étend l’interface EnterpriseBean.<br />
package javax.ejb;<br />
public interface SessionBean extends EnterpriseBean {<br />
void setSessionContext(SessionContext sessionContext)<br />
throws EJBException, RemoteException;<br />
void ejbRemove() throws EJBException, RemoteException;<br />
9-2 Guide du dé veloppeur Enterprise JavaBeans
}<br />
Ecriture de la classe du bean session<br />
void ejbActivate() throws EJBException, RemoteException;<br />
void ejbPassivate() throws EJBException, RemoteException;<br />
Les métho<strong>des</strong> de l’interface SessionBean sont intimement associées au cycle<br />
de vie d’un bean session. Ce tableau explique leur fonction :<br />
Méthode<br />
setSessionContext()<br />
ejbRemove()<br />
ejbActivate()<br />
ejbPassivate()<br />
Description<br />
Définit le contexte d’une session. Le conteneur du bean<br />
appelle cette méthode pour associer l’instance d’un bean<br />
session à son contexte. L’interface contexte de session fournit<br />
les métho<strong>des</strong> d’accès aux propriétés d’exécution du contexte<br />
dans lequel la session s’exécute. Habituellement, un bean<br />
session retient son contexte dans un champ de données.<br />
Signale à un objet session qu’il va être supprimé. Le<br />
conteneur appelle cette méthode chaque fois qu’il supprime<br />
un bean session stateful à la suite de l’appel par le client d’un<br />
méthode remove() de l’interface locale ou distante.<br />
Signale à un objet session stateful qu’il a été activé.<br />
Signale à un objet session stateful qu’il va être désactivé par<br />
le conteneur.<br />
Les métho<strong>des</strong> ejbActivate() et ejbPassivate() permettent à un bean session<br />
stateful de gérer <strong>des</strong> ressources. Pour plus d’informations, voir “Beans<br />
stateful”, page 9-6.<br />
Ecriture <strong>des</strong> métho<strong>des</strong> métier<br />
Dans la classe de votre <strong>enterprise</strong> bean, écrivez les implémentations<br />
complètes <strong>des</strong> métho<strong>des</strong> métier dont a besoin votre bean en utilisant<br />
l’éditeur de code de JBuilder. Pour rendre ces métho<strong>des</strong> accessibles à un<br />
client, vous devez les déclarer dans l’interface distante du bean,<br />
exactement comme elles sont déclarées dans la classe du bean. Le<br />
concepteur de bean de JBuilder peut effectuer cette tâche à votre place.<br />
Voir “Exposition <strong>des</strong> métho<strong>des</strong> métier via l’interface distante”, page 3-11.<br />
Ajout d’une ou de plusieurs métho<strong>des</strong> ejbCreate()<br />
Si vous utilisez l’expert Enterprise JavaBean pour commencer à créer votre<br />
<strong>enterprise</strong> bean, vous verrez que l’expert ajoute à la classe du bean une<br />
méthode ejbCreate() qui ne prend pas de paramètre. Vous pouvez ajouter<br />
<strong>des</strong> métho<strong>des</strong> ejbCreate() supplémentaires qui incluent <strong>des</strong> paramètres.<br />
Alors que les <strong>beans</strong> session stateless ne nécessitent jamais plus d’une<br />
méthode ejbCreate() sans paramètre car ils ne conservent pas d’état, les<br />
<strong>beans</strong> session stateful exigent souvent une ou plusieurs métho<strong>des</strong><br />
ejbCreate() avec paramètres.<br />
D é veloppement <strong>des</strong> <strong>beans</strong> session 9-3
Ecriture de la classe du bean session<br />
Lorsque vous ajoutez <strong>des</strong> métho<strong>des</strong> ejbCreate() avec paramètres,<br />
respectez les règles suivantes :<br />
• Chaque ejbCreate() doit être déclarée publique.<br />
• Chacune doit renvoyer void.<br />
• Les paramètres d’une méthode ejbCreate() doivent être en même<br />
nombre et avoir le même type que ceux de la méthode create()<br />
correspondante dans l’interface distante du bean. Pour les <strong>beans</strong><br />
session stateless, il ne peut y avoir qu’une méthode ejbCreate() sans<br />
paramètre.<br />
Voici la signature de toutes les métho<strong>des</strong> ejbCreate() d’un bean session :<br />
public void ejbCreate( ) {<br />
// implémentation<br />
}<br />
La méthode ejbCreate() n’a pas besoin de déclencher une exception, bien<br />
qu’elle puisse déclencher <strong>des</strong> exceptions spécifiques à l’application et<br />
d’autres exceptions comme javax.ejb.CreateException. L’expert Enterprise<br />
JavaBean génère une méthode ejbCreate() déclenchant<br />
javax.ejb.CreateException.<br />
Comment JBuilder peut vous aider à créer un bean session<br />
A l’aide de l’expert Enterprise JavaBean de JBuilder, vous pouvez<br />
commencer à créer un bean session en sélectionnant, sur la seconde page,<br />
l’option Bean session stateless ou Bean session stateful :<br />
Non seulement l’expert Enterprise JavaBean crée la classe de votre<br />
<strong>enterprise</strong> bean, mais il crée en même temps les interfaces locale et<br />
distante du bean. De cette façon, vous êtes sûr que la méthode create() de<br />
9-4 Guide du dé veloppeur Enterprise JavaBeans
La vie d’un bean session<br />
La vie d’ un bean session<br />
l’interface locale renvoie l’interface distante tandis que la méthode<br />
ejbCreate() renvoie toujours void.<br />
Après avoir écrit les métho<strong>des</strong> métier dans la classe de votre bean, vous<br />
pouvez utiliser le concepteur de bean pour spécifier celles que vous<br />
voulez définir dans l’interface distante du bean. Une application client<br />
accède uniquement aux métho<strong>des</strong> définies dans l’interface distante.<br />
Lorsque vous avez spécifié les métho<strong>des</strong> qu’un client pourra appeler, le<br />
concepteur de bean définit ces métho<strong>des</strong> dans l’interface distante à votre<br />
place.<br />
Si vous avez déjà la classe complète d’un <strong>enterprise</strong> bean, mais pas les<br />
interfaces locale et distante requises, vous pouvez les faire créer par<br />
l’expert Interfaces EJB de JBuilder. Les signatures <strong>des</strong> métho<strong>des</strong> dans les<br />
interfaces locale et distante seront conformes aux spécifications EJB 1.1<br />
sans que vous ayez à vous en occuper.<br />
Pour plus d’informations sur l’utilisation <strong>des</strong> outils EJB de JBuilder pour<br />
créer <strong>des</strong> <strong>beans</strong> session, voir Chapitre 3, “Création <strong>des</strong> <strong>enterprise</strong> <strong>beans</strong><br />
avec JBuilder”.<br />
Les bean session stateful et stateless ont <strong>des</strong> cycles de vie différents. Il<br />
serait bon que vous sachiez ce qui se passe dans la vie de chacun.<br />
Beans stateless<br />
La vie d’un bean session stateless commence lorsque le client appelle la<br />
méthode create() de l’interface locale du bean session. Le conteneur crée<br />
une nouvelle instance du bean session et renvoie au client la référence vers<br />
un objet.<br />
Lors du processus de création, le conteneur invoque la méthode<br />
setSessionContext() de l’interface SessionBean et appelle la méthode<br />
D é veloppement <strong>des</strong> <strong>beans</strong> session 9-5
La vie d’ un bean session<br />
ejbCreate() de l’implémentation du bean session. Le nouvel objet bean<br />
rejoint le pool <strong>des</strong> objets bean stateless prêts à être utilisés par les clients.<br />
Comme les objets bean session stateless ne maintiennent pas d’état<br />
spécifique au client, le conteneur peut assigner n’importe quel objet bean<br />
pour traiter l’appel de la méthode à venir. Lorsque le conteneur supprime<br />
un objet du pool <strong>des</strong> objets bean session, il appelle la ejbRemove() de l’objet<br />
bean.<br />
Notez que l’appel de la méthode create() ou de la méthode remove() <strong>des</strong><br />
interfaces locale/distante n’ajoute pas ou ne supprime pas d’objet bean<br />
session stateless dans le pool <strong>des</strong> <strong>beans</strong> session stateless. Le conteneur<br />
contrôle le cycle de vie <strong>des</strong> <strong>beans</strong> stateless.<br />
Beans stateful<br />
La vie d’un bean session stateful commence lorsque le client appelle la<br />
méthode create() de l’interface locale du bean session. Le conteneur crée<br />
une nouvelle instance du bean session, l’initialise et renvoie au client la<br />
référence vers un objet.<br />
Lors du processus de création, le conteneur invoque la méthode<br />
setSessionContext() de l’interface SessionBean et appelle la méthode<br />
ejbCreate() de l’implémentation du bean session. En tant que fournisseur<br />
du bean, vous pouvez utiliser ces métho<strong>des</strong> pour initialiser le bean<br />
session.<br />
L’état du bean session est désormais prêt pour la méthode, c’est-à-dire<br />
qu’il peut effectuer <strong>des</strong> opérations non transactionnelles ou être inclus<br />
dans une transaction pour <strong>des</strong> opérations transactionnelles. Le bean reste<br />
dans cet état jusqu’à ce qu’un <strong>des</strong> trois faits suivants se produise :<br />
• Le bean entre dans une transaction.<br />
• Le bean est supprimé.<br />
• Le bean est désactivé.<br />
Lorsqu’un client appelle la méthode remove() de l’interface locale ou<br />
distante, le conteneur invoque la méthode ejbRemove() correspondante sur<br />
l’objet bean session. En tant que fournisseur du bean, vous placerez dans<br />
cette méthode le code de nettoyage spécifique à l’application. Après<br />
l’exécution de ejbRemove(), l’objet bean n’est plus utilisable. Si le client<br />
9-6 Guide du dé veloppeur Enterprise JavaBeans
La vie d’ un bean session<br />
tente d’appeler une méthode de l’objet bean, le conteneur déclenche<br />
java.rmi.NoSuchObjectException.<br />
Le conteneur peut désactiver l’instance du bean session. Cela se produit<br />
habituellement pour <strong>des</strong> raisons de gestion <strong>des</strong> ressources, par exemple<br />
lorsqu’un objet session est provisoirement inactif ou si le conteneur<br />
demande plus de mémoire. Le conteneur désactive le bean en appelant la<br />
méthode ejbPassivate() du bean. Lorsque l’instance d’un bean est<br />
désactivée, ce que nous appellerons la désactivation, le conteneur stocke<br />
sur disque les informations de références et l’état de l’objet session, et<br />
libère la mémoire allouée au bean. Vous pouvez ajouter du code à<br />
ejbPassivate() si vous voulez accomplir certaines tâches juste avant que la<br />
désactivation se produise.<br />
Le conteneur active à nouveau l’objet bean en appelant la méthode<br />
ejbActivate(). Cela se produit lorsque le client appelle une méthode sur le<br />
bean session qui est désactivé. Pendant l’activation, le conteneur recrée<br />
l’objet session en mémoire et restaure son état. Si vous voulez que quelque<br />
chose se produise immédiatement après que le bean soit à nouveau actif,<br />
ajoutez votre code à la méthode ejbActivate().<br />
Etat prêt pour la méthode et état prêt pour la transaction<br />
Lorsqu’un client appelle une méthode sur un objet bean session dans un<br />
contexte transactionnel, le conteneur démarre une nouvelle transaction ou<br />
inclut l’objet bean dans une transaction existante. Le bean passe de l’état<br />
prêt pour la méthode à l’état prêt pour la transaction. Il existe dans le cycle<br />
de vie d’une transaction <strong>des</strong> points, appelés points de synchronisation de<br />
la transaction, où un objet bean session peut être averti <strong>des</strong> événements<br />
transactionnels à venir, et cet objet peut accomplir auparavant une action<br />
si nécessaire.<br />
D é veloppement <strong>des</strong> <strong>beans</strong> session 9-7
La vie d’ un bean session<br />
L’interface SessionSynchronization<br />
Un bean session peut implémenter l’interface SessionSynchronization s’il<br />
veut être averti de l’état de toute transaction dans lequel il est impliqué.<br />
Seuls les <strong>beans</strong> session stateful utilisant <strong>des</strong> transactions gérées par le<br />
conteneur peuvent implémenter SessionSynchronization ; son utilisation est<br />
facultative. Les métho<strong>des</strong> de SessionSynchronization sont <strong>des</strong> callbacks<br />
effectués dans le bean par le conteneur, et elles marquent <strong>des</strong> points dans<br />
le cours de la transaction. Voici l’interface SessionSynchronization :<br />
public interface javax.ejb.SessionSynchronization<br />
{<br />
public abstract void afterBegin() throws RemoteException;<br />
public abstract void beforeCompletion() throws RemoteException;<br />
public abstract void afterCompletion(boolean completionStatus) throws<br />
RemoteException;<br />
}<br />
L’expert Enterprise JavaBean peut ajouter ces métho<strong>des</strong> à la classe de<br />
votre bean. Dans l’expert, cochez la case Synchronisation de session :<br />
l’expert déclarera les trois métho<strong>des</strong> dans la classe de votre bean, en<br />
laissant vide le corps de ces métho<strong>des</strong> :<br />
9-8 Guide du dé veloppeur Enterprise JavaBeans
Un bean session pour faire vos courses<br />
Le tableau suivant décrit chacune de ces métho<strong>des</strong> :<br />
Méthode<br />
afterBegin()<br />
beforeCompletion()<br />
afterCompletion()<br />
Description<br />
Signale à l’instance du bean qu’elle va être utilisée dans<br />
une transaction. Tout code écrit dans afterBegin()<br />
s’exécute dans la portée de la transaction.<br />
Signale à l’instance du bean que la transaction va être<br />
validée. Si le bean a <strong>des</strong> valeurs en cache, utilisez<br />
beforeCompletion() pour les écrire dans la base de<br />
données. Si nécessaire, un bean session peut utiliser la<br />
méthode beforeCompletion() pour forcer la transaction à<br />
effectuer un rollback en appelant la méthode<br />
setRollbackOnly() de l’interface SessionContext.<br />
Signale à l’instance du bean que la transaction est finie. Si<br />
la transaction a été validée (commit), le paramètre<br />
completionStatus est défini par true. Si la transaction a été<br />
annulée (rollback), ce paramètre est défini par false.<br />
Voici comment sont utilisées les métho<strong>des</strong> SessionSynchronization : Le<br />
client appelle une méthode métier transactionnelle définie dans l’interface<br />
distante, ce qui place l’objet bean dans l’état prêt pour la transaction. Le<br />
conteneur appelle la méthode afterBegin() dans l’objet bean. Plus tard, si<br />
la transaction est validée (commit), le conteneur appelle la méthode<br />
beforeCompletion() puis, si la validation réussit, la méthode<br />
afterCompletion(true). Si la transaction a été annulée (rollback) ou si sa<br />
validation a échoué, le conteneur appelle afterCompletion(false). L’objet<br />
bean session est désormais à nouveau dans l’état prêt pour la méthode.<br />
Pour plus d’informations sur l’utilisation <strong>des</strong> <strong>beans</strong> session dans les<br />
transactions, voir Chapitre 13, “Gestion <strong>des</strong> transactions”.<br />
Un bean session pour faire vos courses<br />
Cette exemple démontre l’utilisation d’un <strong>enterprise</strong> bean de type session<br />
et stateful, Cart, qui se transforme en chariot virtuel de magasin en ligne.<br />
Les acheteurs sélectionnent <strong>des</strong> éléments et les placent dans un chariot<br />
virtuel. Ils peuvent quitter quelque temps le site, revenir et ajouter<br />
d’autres achats à leur chariot. A tout moment, les acheteurs peuvent voir<br />
les éléments contenus dans leur chariot. Lorsqu’ils ont fini, ils paient les<br />
éléments contenus dans leur chariot.<br />
Vous trouverez le code complet de l’exemple cart dans le répertoire /<br />
Borland/AppServer/examples/ejb/cart.<br />
D é veloppement <strong>des</strong> <strong>beans</strong> session 9-9
Un bean session pour faire vos courses<br />
Fichiers de l’exemple du chariot virtuel<br />
L’exemple du chariot est composé de plusieurs fichiers différents. Cette<br />
section décrit les fichiers que vous auriez pu écrire vous-même et ceux qui<br />
illustrent un aspect particulièrement intéressant <strong>des</strong> <strong>beans</strong> session.<br />
Certains <strong>des</strong> fichiers du répertoire cart sont <strong>des</strong> fichiers générés (stubs,<br />
squelettes, et autre code CORBA) dont nous ne parlerons pas ici.<br />
Voici les principaux fichiers :<br />
• CartHome.java, le fichier définissant l’interface locale du bean session<br />
Cart.<br />
• Cart.java, le fichier définissant l’interface distante du bean session Cart.<br />
• CartBean.java, la classe du bean session.<br />
• Item.java, un fichier élément utilisé par CartBean. Il fournit les métho<strong>des</strong><br />
donnant le prix et l’intitulé <strong>des</strong> éléments placés dans le chariot virtuel.<br />
• Cart.xml, le fichier <strong>des</strong>cripteur de déploiement. Pour EJB 1.1, c’est un<br />
fichier XML qui contient le <strong>des</strong>cripteur de déploiement d’un <strong>enterprise</strong><br />
bean.<br />
• Des fichiers Exception. Ces fichiers définissent les exceptions<br />
spécifiques de l’application déclenchées par CartBean. Il y a trois<br />
exceptions et chacune est définie dans un fichier séparé :<br />
• ItemNotFoundException<br />
• PurchaseProblemException<br />
• CardExpiredException<br />
• CartClient.java, l’application client.<br />
Le bean session Cart<br />
Cette section explique en détail comment vous pouvez implémenter un<br />
bean session comme Cart. Commencez par utiliser l’expert Enterprise<br />
JavaBean. Sur la seconde page de l’expert, tapez le nom de la classe,<br />
CartBean, sélectionnez l’option Bean session stateful et cliquez sur Suivant.<br />
Acceptez les propositions pour le nom de l’interface locale, le nom de<br />
l’interface distante, le nom local du bean et choisissez Terminer. L’expert<br />
crée pour vous le squelette de la classe du bean :<br />
package shoppingcart;<br />
import java.rmi.*;<br />
import javax.ejb.*;<br />
public class CartBean implements SessionBean {<br />
private SessionContext sessionContext;<br />
9-10 Guide du dé veloppeur Enterprise JavaBeans
public void ejbCreate() throws CreateException {<br />
}<br />
public void ejbRemove() throws RemoteException {<br />
}<br />
public void ejbActivate() throws RemoteException {<br />
}<br />
public void ejbPassivate() throws RemoteException {<br />
}<br />
Un bean session pour faire vos courses<br />
public void setSessionContext(SessionContext context) throws RemoteException<br />
{<br />
sessionContext = context;<br />
}<br />
}<br />
Une classe de bean session doit être définie publique. Elle ne peut être<br />
définie finale ni abstraite. La classe du bean doit implémenter l’interface<br />
SessionBean.<br />
Les <strong>beans</strong> session sont <strong>des</strong> objets Java, ils peuvent donc avoir <strong>des</strong> variables<br />
d’instance. CartBean a quatre variables d’instance que vous ajoutez à la<br />
classe. Les quatre variables sont déclarées privées :<br />
private Vector _items = new Vector();<br />
private String _cardHolderName;<br />
private String _creditCardNumber;<br />
private Date _expirationDate;<br />
Placez ces déclarations après la variable sessionContext qui a été ajoutée à<br />
la classe par l’expert Enterprise JavaBean.<br />
La variable _items contient les éléments appartenant à l’objet chariot. C’est<br />
un vecteur, une collection d’éléments. Les trois autres variables d’instance<br />
stockent les informations sur la carte de crédit de l’acheteur en ligne.<br />
Ajout <strong>des</strong> métho<strong>des</strong> nécessaires<br />
Un bean session doit implémenter les quatre métho<strong>des</strong> qui sont définies<br />
par l’interface SessionBean. Le conteneur EJB invoque ces métho<strong>des</strong> sur<br />
l’instance du bean à <strong>des</strong> points précis du cycle de vie d’un bean session. Le<br />
fournisseur du bean doit, au minimum, implémenter ces métho<strong>des</strong> avec<br />
un corps vide. Le fournisseur du bean peut ajouter, si nécessaire, du code<br />
supplémentaire à ces métho<strong>des</strong>. Notre bean session CartBean ne leur ajoute<br />
pas de code. Voici les quatre métho<strong>des</strong> :<br />
public void ejbRemove() {}<br />
public void ejbActivate() {}<br />
public void ejbPassivate() {}<br />
public void setSessionContext(SessionContext context) {}<br />
D é veloppement <strong>des</strong> <strong>beans</strong> session 9-11
Un bean session pour faire vos courses<br />
L’expert Enterprise JavaBean ajoute les quatre métho<strong>des</strong> suivantes. Dans<br />
la méthode setSessionContext(), l’expert assigne la valeur du paramètre<br />
contexte à la variable d’instance sessionContext.<br />
Le conteneur du bean appelle la méthode setSessionContext() pour<br />
associer l’instance du bean à son contexte de session. Le bean peut choisir<br />
de retenir la référence au contexte de session comme partie de son état<br />
conversationnel, mais il n’est pas obligé de le faire. Si vous avez utilisé<br />
l’expert Enterprise JavaBean, la référence au contexte de session est<br />
retenue. Le bean session peut utiliser le contexte de session pour obtenir<br />
<strong>des</strong> informations sur lui-même, comme ses variables d’environnement ou<br />
son interface locale.<br />
Le conteneur appelle la méthode ejbPassivate() sur l’instance du bean<br />
lorsqu’il a besoin de placer l’instance du bean dans un état passif.<br />
Lorsqu’il désactive le bean, le conteneur écrit l’état en cours de celui-ci<br />
dans une zone de stockage secondaire. Il restaure cet état lorsqu’il réactive<br />
le bean ultérieurement. Comme le conteneur appelle la méthode<br />
ejbPassivate() juste avant de désactiver l’instance du bean, en tant que<br />
fournisseur du bean, vous pouvez ajouter du code à cette méthode pour<br />
mettre en cache n’importe quelle variable spéciale. De même, le conteneur<br />
appelle la méthode ejbActivate() sur l’instance du bean juste avant de la<br />
faire passer de l’état passif à l’état actif. Lorsqu’il réactive le bean, il<br />
restaure toutes les valeurs d’état préservées. Vous pouvez choisir<br />
d’ajouter du code à la méthode ejbActivate(). CartBean laisse vi<strong>des</strong> ces<br />
implémentations.<br />
Alors qu’un bean session n’est pas obligé d’implémenter un constructeur,<br />
il doit implémenter au moins une méthode ejbCreate(). Cette méthode sert<br />
de constructeur pour créer une nouvelle instance du bean. Une session<br />
stateful peut implémenter plus d’une méthode ejbCreate(). Chaque<br />
méthode ejbCreate() ne se distingue que par ses paramètres.<br />
L’exemple CartBean déclare une méthode ejbCreate() qui prend trois<br />
paramètres :<br />
public void ejbCreate(String cardHolderName, String creditCardNumber,<br />
Date expirationDate) throws CreateException {<br />
_cardHolderName = cardHolderName;<br />
_creditCardNumber = creditCardNumber;<br />
}<br />
Le conteneur appelle la méthode ejbRemove() juste avant de supprimer<br />
l’instance du bean. Vous pouvez ajouter du code spécifique à l’application<br />
qui s’exécuterait avant la suppression du bean, mais ce n’est pas<br />
obligatoire. L’exemple CartBean laisse vide le corps de la méthode<br />
ejbRemove().<br />
9-12 Guide du dé veloppeur Enterprise JavaBeans
Un bean session pour faire vos courses<br />
Ajout <strong>des</strong> métho<strong>des</strong> métier<br />
Voici quelques règles que doivent respecter vos métho<strong>des</strong> métier :<br />
• Les noms de métho<strong>des</strong> ne doivent pas utiliser le préfixe ejb afin<br />
d’éviter les conflits avec les noms réservés à l’architecture EJB.<br />
• Chaque méthode doit être déclarée publique.<br />
• Aucune méthode ne peut être déclarée finale ou statique.<br />
• Les types <strong>des</strong> paramètres et <strong>des</strong> valeurs renvoyées doivent être vali<strong>des</strong><br />
pour RMI-IIOP.<br />
• La clause throws peut inclure l’exception javax.ejb.EJBException et<br />
définir d’autres exceptions spécifiques à l’application.<br />
Dans l’exemple Cart, cinq métho<strong>des</strong> métier sont implémentées. Les<br />
signatures (nom de la méthode, nombre <strong>des</strong> paramètres, types <strong>des</strong><br />
paramètres et type de la valeur de retour) <strong>des</strong> métho<strong>des</strong> de la classe du<br />
bean session doivent correspondre à celles de l’interface distante. Pour<br />
être sûr qu’il en soit ainsi, vous pouvez utiliser le concepteur de bean pour<br />
placer les métho<strong>des</strong> que vous ajoutez à la classe du bean dans l’interface<br />
distante de celui-ci.<br />
Afin de vous aider à suivre le programme, chaque méthode métier<br />
comprend une ligne de code affichant le nom de la méthode et ce qu’elle<br />
fait.<br />
La méthode addItem() ajoute un élément au vecteur qui contient la liste <strong>des</strong><br />
éléments se trouvant dans le chariot :<br />
public void addItem(Item item) {<br />
System.out.println("\taddItem(" + item.getTitle() + "): " + this);<br />
_items.addElement(item);<br />
}<br />
La méthode removeItem() est plus compliquée. La méthode parcourt dans<br />
une boucle la liste <strong>des</strong> éléments et recherche si la classe et l’intitulé de<br />
l’élément à supprimer correspond à la classe et l’intitulé d’un élément de<br />
la liste. Cette méthode vérifie que vous supprimez bien l’élément souhaité.<br />
Si aucune correspondance n’est trouvée, la méthode déclenche une<br />
ItemNotFoundException.<br />
public void removeItem(Item item) throws ItemNotFoundException {<br />
System.out.println("\tremoveItem(" + item.getTitle() + "): " + this);<br />
Enumeration elements = _items.elements();<br />
while(elements.hasMoreElements()) {<br />
Item current = (Item) elements.nextElement();<br />
// les éléments sont égaux s’ils ont la même classe et le même intitulé<br />
if(item.getClass().equals(current.getClass()) &&<br />
item.getTitle().equals(current.getTitle())) {<br />
_items.removeElement(current);<br />
return;<br />
}<br />
}<br />
D é veloppement <strong>des</strong> <strong>beans</strong> session 9-13
Un bean session pour faire vos courses<br />
La méthode getTotalPrice() initialise le prix total à zéro, puis parcourt<br />
dans une boucle la liste <strong>des</strong> éléments, en ajoutant le prix de chaque<br />
élément au prix total. Elle renvoie le prix total arrondi au centime le plus<br />
proche.<br />
public float getTotalPrice() {<br />
System.out.println("\tgetTotalPrice(): " + this);<br />
float totalPrice = 0f;<br />
Enumeration elements = _items.elements();<br />
while(elements.hasMoreElements()) {<br />
Item current = (Item) elements.nextElement();<br />
totalPrice += current.getPrice();<br />
}<br />
// arrondit au centime le plus bas<br />
return (long) (totalPrice * 100) / 100f;<br />
}<br />
Toutes les types de données passées entre un client et un serveur doivent<br />
être sérialisables. C’est à dire qu’ils doivent implémenter l’interface<br />
java.io.Serializable. Dans l’exemple Cart, le bean renvoie une liste<br />
d’éléments au client. S’il n’y avait pas de restriction de sérialisation, vous<br />
pourriez utiliser _items.elements() pour renvoyer le contenu du vecteur<br />
d’éléments. Mais, _items.elements() renvoie un objet Java Enumeration qui<br />
n’est pas sérialisable. Pour éviter ce problème, le programme implémente<br />
une classe, appelée com.inprise.ejb.util.VectorEnumeration(_items). Cette<br />
classe prend un vecteur et renvoie une véritable énumération, qui est<br />
sérialisable, pour le contenu du vecteur. L’objet CartBean passe ce vecteur<br />
sérialisable au client, et reçoit du côté client un vecteur sérialisable. La<br />
méthode getContents() effectue la conversion entre l’objet Java Enumeration<br />
et l’objet VectorEnumeration sérialisable.<br />
public java.util.Enumeration getContents() {<br />
System.out.println("\tgetContents(): " + this);<br />
return new com.inprise.ejb.util.VectorEnumeration(_items);<br />
}<br />
La méthode purchase() doit accomplir ce qui suit :<br />
1 Obtenir la date du jour.<br />
2 Comparer la date d’expiration de la carte de crédit et la date du jour. Si<br />
la date d’expiration précède la date du jour, la méthode déclenche<br />
l’exception application CardExpiredException.<br />
3 Terminer le processus d’achat, y compris la mise à jour du stock, la<br />
transmission du montant <strong>des</strong> dépenses à la société de crédit et le<br />
lancement de la procédure de livraison. (Aucune de ces fonctions n’est<br />
implémentée dans notre exemple Cart.) Si une erreur se produit à ce<br />
stade, le processus d’achat n’est pas complet et la méthode déclenche<br />
une exception PurchaseProblemException.<br />
public void purchase() throws PurchaseProblemException {<br />
System.out.println("\tpurchase(): " + this);<br />
// vérifie que la carte de crédit n’est pas expirée<br />
9-14 Guide du dé veloppeur Enterprise JavaBeans
Un bean session pour faire vos courses<br />
Date today = Calendar.getInstance().getTime();<br />
if(_expirationDate.before(today)) {<br />
throw new CardExpiredException("Date d’expiration : " +<br />
_expirationDate);<br />
}<br />
// termine le processus d’achat<br />
// déclenche PurchaseProblemException si une erreur se produit<br />
}<br />
CartBean inclut une méthode toString() pour imprimer le CartBean et le nom<br />
du propriétaire de la carte.<br />
// méthode imprimant le CartBean et nom du propriétaire de la carte<br />
public String toString() {<br />
return "CartBean[name=" + _cardHolderName + "]";<br />
}<br />
Classe Item<br />
L’exemple CartBean utilise une classe Item. Item est publique et étend<br />
java.io.Serializable ; <strong>des</strong> données sérialisées peuvent être transmises sur<br />
le câble :<br />
package shoppingcart;<br />
public class Item implements java.io.Serializable {<br />
private String _title;<br />
private float _price;<br />
public Item(String title, float price) {<br />
_title = title;<br />
_price = price;<br />
}<br />
public String getTitle() {<br />
return _title;<br />
}<br />
public float getPrice() {<br />
return _price;<br />
}<br />
}<br />
Exceptions<br />
Il y a trois classes exception dans l’exemple Cart. Toutes sont <strong>des</strong><br />
extensions de la classe Java Exception :<br />
public class ItemNotFoundException extends Exception {<br />
public ItemNotFoundException(String message) {<br />
super(message);<br />
}<br />
}<br />
public class PurchaseProblemException extends Exception {<br />
public PurchaseProblemException(String message) {<br />
super(message);<br />
}<br />
D é veloppement <strong>des</strong> <strong>beans</strong> session 9-15
Un bean session pour faire vos courses<br />
}<br />
public class CardExpiredException extends Exception {<br />
public CardExpiredException(String message) {<br />
super(message);<br />
}<br />
}<br />
Interfaces exigées<br />
Les <strong>enterprise</strong> <strong>beans</strong> ont toujours deux interfaces : une interface locale et<br />
une interface distante. Dans cet exemple le bean session Cart a une<br />
interface distante EJB publique appelée Cart et une interface locale appelée<br />
CartHome.<br />
Lorsque vous utilisez l’expert Enterprise JavaBean, les interfaces locale et<br />
distante sont créées en même temps que la classe du bean. Si vous avez<br />
déjà un bean session, mais pas les interfaces, utilisez l’expert Interfaces<br />
EJB. Pour utiliser l’expert, affichez le code source de votre <strong>enterprise</strong> bean<br />
dans l’éditeur de code et choisissez Experts|Interfaces EJB. Répondez aux<br />
deman<strong>des</strong> de l’expert et il créera l’interface locale et l’interface distante de<br />
votre <strong>enterprise</strong> bean.<br />
Pour plus d’informations sur l’utilisation <strong>des</strong> experts Enterprise JavaBean<br />
et Interfaces EJB, voir Chapitre 3, “Création <strong>des</strong> <strong>enterprise</strong> <strong>beans</strong> avec<br />
JBuilder”.<br />
L’interface locale<br />
Comme toute interface locale, CartHome étend l’interface EJBHome. Alors que<br />
l’interface locale a deux fonctions : créer <strong>des</strong> instances du bean et trouver<br />
<strong>des</strong> instances du bean, les <strong>beans</strong> session n’ont qu’à créer l’instance d’un<br />
bean. Les <strong>beans</strong> session cessent d’exister lorsque la session d’un client se<br />
termine. De ce fait, il n’y a pas à trouver d’instance de CartBean, par<br />
exemple lorsqu’un acheteur entre dans le magasin en ligne, car il n’existe<br />
pas d’instance de CartBean. Seules les interfaces locales <strong>des</strong> <strong>beans</strong> entité<br />
incluent <strong>des</strong> opérations find, car les <strong>beans</strong> entité sont utilisés par plusieurs<br />
clients et vivent aussi longtemps que les entités de données. Voici<br />
l’interface CartHome :<br />
// CartHome.java<br />
public interface CartHome extends javax.ejb.EJBHome {<br />
Cart create(String cardHolderName, String creditCardNumber,<br />
java.util.Date expirationDate)<br />
throws java.rmi.RemoteException,javax.ejb.CreateException;<br />
}<br />
L’interface CartHome est très simple, elle définit une seule méthode create().<br />
Comme il s’agit d’un bean session stateful, il pourrait y avoir plusieurs<br />
métho<strong>des</strong> create(). Dans cet exemple, la méthode create() de l’interface<br />
CartHome accepte trois paramètres : cardHolderName, creditCardNumber et<br />
expirationDate.<br />
9-16 Guide du dé veloppeur Enterprise JavaBeans
Un bean session pour faire vos courses<br />
Le client invoque la méthode create() pour demander un chariot et le<br />
conteneur en crée un particulier pour cet utilisateur. Le client peut utiliser<br />
son chariot de manière intermittente, mais le bean session reste actif pour<br />
ce client-là jusqu’à ce que l’utilisateur s’en aille et que l’instance du bean<br />
soit supprimée.<br />
Un bean session stateful maintient l’état entre les appels de métho<strong>des</strong>, que<br />
ces métho<strong>des</strong> soient ou non incluses dans le contexte d’une transaction.<br />
L’état, ce sont les données transportées par un objet bean. Les données<br />
restent associées à l’objet bean pour la durée de vie de l’objet. Lorsque la<br />
session est terminée, le conteneur efface l’état du bean session de la<br />
mémoire.<br />
La méthode create() suit les règles définies par les spécifications EJB : elle<br />
déclenche une exception remote RMI, java.rmi.RemoteException, et une<br />
exception create EJB, javax.ejb.CreateException. La signature de la<br />
méthode create() doit correspondre à celle de la méthode ejbCreate() de la<br />
classe du bean session quant au nombre et aux types <strong>des</strong> arguments. La<br />
valeur renvoyée par create() est une interface distante Cart. C’est que<br />
l’interface CartHome fonctionne comme une factory pour CartBean. (La<br />
valeur renvoyée par la méthode ejbCreate() correspondante dans la classe<br />
CartBean est void.)<br />
L’interface distante<br />
Le bean session Cart a une interface distante Cart qui étend l’interface<br />
EJBObject. EJBObject est l’interface de base de toutes les interfaces distantes.<br />
Elle définit les métho<strong>des</strong> vous permettant ce qui suit :<br />
• Obtenir les informations sur le bean session.<br />
Vous pouvez tester si l’objet bean est identique à un autre objet<br />
<strong>enterprise</strong> bean. (Vous pouvez aussi obtenir la clé primaire d’un bean<br />
entité, mais cela ne s’applique pas à un bean session.)<br />
• Obtenir une référence ou un handle sur le bean session.<br />
Vous pouvez obtenir une référence à l’interface locale du bean d’un<br />
handle de sérialisation sur l’instance du bean. Vous pouvez stocker le<br />
handle et le retrouver ultérieurement afin de l’utiliser pour retrouver<br />
votre référence à l’instance du bean.<br />
• Supprimer l’instance du bean.<br />
L’interface EJBObject définit la méthode remove() pour supprimer<br />
l’instance du bean.<br />
L’interface distante Cart définit <strong>des</strong> métho<strong>des</strong> métier, en plus d’hériter <strong>des</strong><br />
métho<strong>des</strong> de EJBObject. Ces métho<strong>des</strong> métier sont les métho<strong>des</strong><br />
implémentées dans la classe du bean session CartBean. L’interface distante<br />
Cart ne fait qu’exposer ces métho<strong>des</strong> aux clients. Un client ne peut appeler<br />
D é veloppement <strong>des</strong> <strong>beans</strong> session 9-17
Un bean session pour faire vos courses<br />
que les métho<strong>des</strong> qui sont exposées par l’interface distante de l’<strong>enterprise</strong><br />
bean. Voici les métho<strong>des</strong> métier exposées :<br />
• addItem(), qui ajoute un élément au chariot.<br />
• removeItem(), qui supprime un élément du chariot.<br />
• getTotalPrice(), qui ajoute les prix de tous les éléments et renvoie le<br />
montant total.<br />
• getContents(), qui rassemble les éléments du chariot et les renvoie dans<br />
une liste pouvant être visualisée et imprimée.<br />
• purchaseItems(), qui tente d’acheter les éléments.<br />
Le <strong>des</strong>cripteur de déploiement de Cart<br />
Selon la spécification EJB 1.1, le <strong>des</strong>cripteur de déploiement doit être un<br />
fichier XML. Le fichier XML respecte la DTD (Document Type Definition)<br />
approuvée par Sun Microsystems. Un <strong>des</strong>cripteur de déploiement<br />
contient un ensemble de propriétés qui décrivent comment le conteneur<br />
déploiera l’<strong>enterprise</strong> bean ou l’application.<br />
Pendant que vous utilisez l’expert Enterprise JavaBean pour créer un bean<br />
session, JBuilder crée également pour vous un <strong>des</strong>cripteur de<br />
déploiement. Vous pouvez ensuite utiliser l’éditeur de <strong>des</strong>cripteur de<br />
déploiement pour adapter ce dernier à vos besoins.<br />
Le <strong>des</strong>cripteur de déploiement inclut un jeu de balises et d’attributs dont<br />
les valeurs indiquent les propriétés du bean. Par exemple, voici certaines<br />
<strong>des</strong> balises de l’exemple Cart :<br />
• La balise spécifie que l’<strong>enterprise</strong> bean est un bean session.<br />
Outre la balise , il existe d’autres balises :<br />
• – Le nom de la classe du bean session qui implémente le<br />
bean.<br />
• – Le nom de l’interface locale.<br />
• – Le nom de l’interface locale.<br />
• – Indique si le bean session est stateful ou stateless.<br />
• – Indique si la persistance est gérée par le<br />
conteneur ou par le bean.<br />
• – L’attribut de transaction de chaque méthode.<br />
• – Le délai d’attente pour le bean session.<br />
Voici le fichier <strong>des</strong>cripteur de déploiement pour le bean session cart :<br />
<br />
<br />
<br />
<br />
9-18 Guide du dé veloppeur Enterprise JavaBeans
Un bean session pour faire vos courses<br />
Descripteur de déploiement XML du bean session cart<br />
<br />
cart<br />
CartHome<br />
Cart<br />
CartBean<br />
Stateful<br />
Container<br />
<br />
<br />
<br />
<br />
<br />
cart<br />
*<br />
<br />
NotSupported<br />
<br />
<br />
<br />
cart<br />
purchase<br />
<br />
Required<br />
<br />
<br />
<br />
Le programme CartClient est l’application client qui utilise l’<strong>enterprise</strong><br />
bean Cart. Sa routine main() inclut tous les éléments que toutes les<br />
applications client d’<strong>enterprise</strong> bean doivent implémenter. Elle démontre<br />
comment<br />
• Utiliser JNDI pour localiser l’interface locale du bean.<br />
• Utiliser la méthode create() de l’interface locale pour créer un nouvel<br />
objet Cart distant.<br />
• Invoquer la méthode déclarée dans l’objet Cart.<br />
public static void main(String] args) throws Exception {<br />
// obtient un contexte JNDI en utilisant le service d’annuaire<br />
javax.naming.Context context = new javax.naming.InitialContext();<br />
Object objref = context.lookup("cart");<br />
CartHome home = (CartHome)javax.rmi.PortableRemoteObject.narrow(objref,<br />
CartHome.class);<br />
Cart cart;<br />
{<br />
String cardHolderName = "Jack B. Quick";<br />
String creditCardNumber = "1234-5678-9012-3456";<br />
Date expirationDate = new GregorianCalendar(2001,<br />
Calendar.JULY,1).getTime();<br />
cart = home home.create(cardHolderName, creditCardNumber, expirationDate);<br />
}<br />
D é veloppement <strong>des</strong> <strong>beans</strong> session 9-19
Un bean session pour faire vos courses<br />
Book knuthBook = new Book("The Art of Computer Programming", 49.95f);<br />
cart.addItem(knuthBook);<br />
... // crée CompactDisc et l’ajoute au chariot,<br />
// puis liste le contenu du chariot<br />
summarize(cart)<br />
cart.removeItem(knuthBook);<br />
... // ajoute un autre livre et récapitule le contenu du chariot<br />
try {<br />
cart.purchase();<br />
}<br />
catch(PurchaseProblemException e) {<br />
System.out.println("Impossible d’acheter les items:\n\t" + e);<br />
}<br />
cart.remove();<br />
}<br />
La routine main() commence par un contexte JNDI de recherche d’objets.<br />
Elle construit un contexte initial (un contexte d’annuaire Java). C’est le<br />
code JNDI standard.<br />
main() recherche l’objet de CartHome appelé cart. Recherche un nom avec<br />
JNDI en invoquant un appel du client au service CosNaming pour<br />
chercher le nom dans CosNaming. Le service CosNaming renvoie au<br />
client une référence sur un objet. Dans cet exemple, il renvoie une<br />
référence sur un objet CORBA. Le programme doit effectuer une<br />
opération PortableRemoteObject.narrow() sur la référence à l’objet,<br />
transtyper l’objet renvoyé en type CartHome, et l’assigner à la variable<br />
locale. Cet appel est typique <strong>des</strong> applications distribuées. L’appel utilise<br />
CORBA et IIOP pour accomplir ce qui suit :<br />
• Parler à un serveur.<br />
• Effectuer une recherche CosNaming.<br />
• Obtenir une référence sur un objet CORBA.<br />
• Renvoyer au client la référence à l’objet.<br />
Le programme déclare une référence sur l’objet cart distant, initialise les<br />
trois variables paramètres de create() et crée un nouvel objet cart distant.<br />
Le programme crée deux éléments du chariot de supermarché, un livre et<br />
un disque compact, et les ajoute au contenu du chariot en utilisant la<br />
méthode addItem() de cart.<br />
La routine fait ensuite la liste <strong>des</strong> éléments du chariot en appelant la<br />
fonction summarize(). summarize() extrait les éléments du chariot avec la<br />
méthode getContents() de cart, qui renvoie une Enumeration Java. Elle utilise<br />
ensuite les métho<strong>des</strong> de l’interface Java Enumeration pour lire chaque<br />
élément de Enumeration, en récupérant l’intitulé et le prix de chacun. Voici<br />
le code de la fonction summarize() :<br />
static void summarize(Cart cart) throws Exception {<br />
System.out.println("======== Récapitulatif du chariot =========")’<br />
Enumeration elements = cart.getContents();<br />
while(elements.hasMoreElements()) {<br />
9-20 Guide du dé veloppeur Enterprise JavaBeans
}<br />
Un bean session pour faire vos courses<br />
Item current = (Item) elements.nextElement():<br />
System.out.println("Prix : $" + current.getPrice() + "\t" +<br />
current.getClass().getName() + " titre : " + current.getTitle());<br />
}<br />
System.out.println("Total : $" + cart.getTotalPrice());<br />
System.out.println("===============================");<br />
Le programme appelle ensuite la méthode removeItem() de cart pour retirer<br />
un élément du chariot. Il ajoute un élément différent et récapitule à<br />
nouveau le contenu du chariot.<br />
Finalement, le programme essaie d’acheter les éléments. L’opération<br />
d’achat échoue car elle n’est pas implémentée sur le serveur et déclenche<br />
une exception PurchaseProblemException.<br />
L’utilisateur ayant terminé sa session de shopping, le programme<br />
supprime le chariot. Il n’est pas nécessaire de supprimer le chariot, bien<br />
que la bonne pratique de la programmation nous y incite. Un bean session<br />
existe pour le client qui l’a créé. Lorsque le client termine la session, le<br />
conteneur supprime automatiquement l’objet bean session. Le conteneur<br />
supprime également l’objet bean session lorsqu’il dépasse son délai, bien<br />
que cela ne se produise pas immédiatement.<br />
CartClient inclut du code qui étend la classe générique Item avec deux<br />
types d’éléments : un livre et un disque compact. Book et CompactDisc sont<br />
les classes utilisées dans cet exemple.<br />
D é veloppement <strong>des</strong> <strong>beans</strong> session 9-21
9-22 Guide du dé veloppeur Enterprise JavaBeans
10<br />
Chapitre<br />
Chapitre10Développement<br />
<strong>des</strong><strong>beans</strong>entité<br />
Persistance et <strong>beans</strong> entité<br />
Un bean entité représente directement les données enregistrées dans un<br />
système de stockage permanent comme une base de données. Il<br />
correspond à une ou à plusieurs lignes d’une table dans une base de<br />
données relationnelles, ou à un objet entité dans une base de données<br />
orientée objet. Il peut aussi correspondre à une ou à plusieurs lignes de<br />
plusieurs tables. Dans une base de données, une clé primaire identifie de<br />
façon unique une ligne dans une table. De même, une clé primaire<br />
identifie l’instance d’un bean entité particulier. Chaque colonne d’une<br />
table dans une base de données relationnelles correspond à une variable<br />
d’instance dans le bean entité.<br />
Comme un bean entité représente habituellement <strong>des</strong> données stockées<br />
dans une base de données, il vit aussi longtemps que les données<br />
elles-mêmes. Quelle que soit la durée pendant laquelle un bean entité<br />
reste inactif, le conteneur ne le supprime pas du stockage persistant.<br />
La seule façon de supprimer un bean entité est de le supprimer<br />
explicitement. Un bean entité est supprimé par l’appel de sa méthode<br />
remove(), qui supprime les données sous-jacentes dans la base de données.<br />
Une autre application de l’entreprise peut également supprimer les<br />
données de la base.<br />
Tous les <strong>enterprise</strong> <strong>beans</strong> entité sont persistants ; c’est-à-dire que leur état<br />
est stocké entre les sessions et les clients. En tant que fournisseur du bean,<br />
vous pouvez choisir comment sera implémentée la persistance de votre<br />
bean entité.<br />
D é veloppement <strong>des</strong> <strong>beans</strong> entité 10-1
Persistance et <strong>beans</strong> entité<br />
Vous pouvez implémenter la persistance du bean directement dans la<br />
classe du bean entité, en chargeant le bean de maintenir sa propre<br />
persistance. C’est ce que nous appellerons la persistance gérée par le bean.<br />
Ou alors, vous pouvez déléguer la gestion de la persistance de votre bean<br />
entité au conteneur EJB. C’est ce que nous appellerons la persistance gérée<br />
par le conteneur.<br />
Persistance gérée par le bean<br />
Un bean entité dont la persistance est gérée par le bean contient le code<br />
permettant d’accéder à une base de données et de la mettre à jour. C’est à<br />
vous, en tant que fournisseur du bean, d’écrire les appels accédant à la<br />
base directement dans le bean entité ou ses classes associées.<br />
Habituellement, vous écrirez ces appels en utilisant JDBC.<br />
Les appels accédant à la base de données peuvent se trouver dans les<br />
métho<strong>des</strong> métier du bean entité, ou dans une <strong>des</strong> métho<strong>des</strong> de l’interface<br />
du bean entité. (Bientôt, nous vous en dirons plus sur l’interface d’un bean<br />
entité.)<br />
Habituellement, un bean qui gère sa persistance est plus difficile à écrire<br />
car vous devez écrire en plus le code d’accès aux données. Et, comme vous<br />
pouvez choisir d’intégrer le code d’accès aux données dans les métho<strong>des</strong><br />
du bean, il peut s’avérer difficile d’adapter le bean entité à plusieurs bases<br />
de données ou à différents schémas.<br />
Persistance gérée par le conteneur<br />
Avec les <strong>beans</strong> entités dont la persistance est gérée par le conteneur, vous<br />
n’avez pas à écrire le code qui accède aux bases de données et les met à<br />
jour. En revanche, le bean se repose sur le conteneur pour l’accès et la mise<br />
à jour de la base.<br />
La gestion de la persistance par le conteneur a de nombreux avantages<br />
comparée à la gestion par le bean :<br />
• De tels <strong>beans</strong> sont plus faciles à coder.<br />
• Les détails de la gestion de la persistance peuvent être modifiés sans<br />
changer ni recompiler le bean entité. En effet, le déployeur ou<br />
l’assembleur d’application peut modifier le <strong>des</strong>cripteur de<br />
déploiement.<br />
• La complexité du code diminue, ainsi que le risque d’erreurs.<br />
• En tant que fournisseur du bean, vous pouvez vous concentrer sur la<br />
logique métier du bean et non sur les systèmes sous-jacents.<br />
10-2 Guide du dé veloppeur Enterprise JavaBeans
Clé s primaires <strong>des</strong> <strong>beans</strong> entité<br />
La persistance géré par le conteneur a toutefois quelques limites. Par<br />
exemple, le conteneur peut charger l’état global de l’objet entité dans les<br />
champs de l’instance du bean avant d’appeler la méthode ejbLoad(). Cela<br />
peut créer <strong>des</strong> problèmes de performance si le bean a beaucoup de<br />
champs.<br />
Clés primaires <strong>des</strong> <strong>beans</strong> entité<br />
Chaque instance d’un bean entité doit avoir une clé primaire. Une clé<br />
primaire est une valeur (ou une combinaison de valeurs) identifiant<br />
l’instance de manière unique. Par exemple, une table de base de données<br />
contenant <strong>des</strong> enregistrements sur <strong>des</strong> employés peut utiliser leur numéro<br />
de sécurité sociale comme clé primaire. Le bean entité créé sur cette table<br />
<strong>des</strong> employés peut aussi utiliser le numéro de sécurité sociale comme clé<br />
primaire.<br />
Pour les <strong>enterprise</strong> <strong>beans</strong>, la clé primaire est représentée par un type<br />
String ou Integer, ou une classe Java contenant les données uniques. La<br />
classe de la clé primaire peut être n’importe quelle classe pour autant que<br />
le type de la classe soit valide pour RMI_IIOP. Cela signifie que la classe<br />
doit étendre l’interface java.io.Serializable et implémenter les métho<strong>des</strong><br />
Object.equals(Other other) et Object.hashCode(), dont héritent toutes les<br />
classes Java.<br />
La classe de la clé primaire peut être spécifique à une classe de bean entité<br />
particulière. Chaque bean entité peut donc définir sa propre classe clé<br />
primaire. Ou, plusieurs <strong>beans</strong> entité peuvent partager la même classe clé<br />
primaire.<br />
Ecriture de la classe du bean entité<br />
Pour créer la classe d’un bean entité,<br />
• Créez une classe qui implémente l’interface javax.ejb.EntityBean.<br />
• Implémentez une ou plusieurs métho<strong>des</strong> ejbCreate(). Si vous avez déjà<br />
créé l’interface locale du bean, le bean doit avoir une méthode<br />
ejbCreate(), avec la même signature, pour chaque méthode create() de<br />
l’interface locale.<br />
• Définissez et implémentez les métho<strong>des</strong> métier que votre bean doit<br />
avoir. Si vous avez déjà créé l’interface distante du bean, les métho<strong>des</strong><br />
doivent être définies exactement comme elles le sont dans l’interface<br />
distante.<br />
• Pour les <strong>beans</strong> entité dont la persistance est auto-gérée, implémentez<br />
<strong>des</strong> métho<strong>des</strong> find.<br />
D é veloppement <strong>des</strong> <strong>beans</strong> entité 10-3
Ecriture de la classe du bean entité<br />
L’expert Enterprise JavaBean de JBuilder peut commencer ces tâches à<br />
votre place. Il crée une classe étendant l’interface EntityBean et écrit <strong>des</strong><br />
implémentations vi<strong>des</strong> <strong>des</strong> métho<strong>des</strong> EntityBean. Vous remplissez ces<br />
implémentations si votre bean en a besoin. La section suivante explique<br />
quelles sont ces métho<strong>des</strong> et comment elles sont utilisées.<br />
Si vous voulez construire <strong>des</strong> <strong>beans</strong> entité à partir de tables de bases de<br />
données existantes, utilisez le Modeleur Bean entité EJB de JBuilder. Pour<br />
plus d’informations, voir “Création <strong>des</strong> <strong>beans</strong> entité avec le Modeleur<br />
Bean entité EJB”, page 4-1.<br />
Implémentation de l’interface EntityBean<br />
L’interface EntityBean définit les métho<strong>des</strong> que tous les <strong>beans</strong> entité<br />
doivent implémenter. Elle étend l’interface EnterpriseBean.<br />
public void EntityBean extends EnterpriseBean {<br />
public void setEntityContext(EntityContext ctx) throws EJBException,<br />
RemoteException;<br />
public void unsetEntitycontext() throws EJBException, RemoteException;<br />
void ejbRemove() throws RemoveException, EJBException, RemoteException;<br />
void ejbActivate() throws EJBException, RemoteException;<br />
void ejbPassivate() throws EJBException, RemoteException;<br />
void ejbLoad() throws EJBException, RemoteException;<br />
public void ejbStore() throws EJBException, RemoteException;<br />
}<br />
Les métho<strong>des</strong> de l’interface EntityBean sont intimement associées au cycle<br />
de vie d’un bean entité. Ce tableau explique leur fonction :<br />
Méthode<br />
setEntityContext()<br />
unsetEntityContext()<br />
ejbRemove()<br />
Description<br />
Définit le contexte d’une entité. Le conteneur utilise cette<br />
méthode pour passer à l’instance du bean une référence<br />
vers l’interface EntityContext. L’interface EntityContext<br />
fournit les métho<strong>des</strong> d’accès aux propriétés du contexte<br />
d’exécution du bean entité. L’instance d’un bean entité<br />
qui utilise ce contexte doit le stocker dans une variable<br />
d’instance.<br />
Libère les ressources qui ont été allouées au cours de<br />
l’appel à la méthode setEntityContext(). Le conteneur<br />
appelle cette méthode avant d’interrompre la vie de<br />
l’instance en cours du bean entité.<br />
Supprime l’entrée ou les entrées de la base de données<br />
associées à ce bean entité particulier. Le conteneur<br />
appelle cette méthode lorsqu’un client invoque une<br />
méthode remove().<br />
10-4 Guide du dé veloppeur Enterprise JavaBeans
Ecriture de la classe du bean entité<br />
Méthode<br />
Description<br />
ejbActivate<br />
Signale au bean entité qu’il a été activé. Le conteneur<br />
invoque cette méthode sur l’instance sélectionnée dans le<br />
pool <strong>des</strong> instances disponibles et assignée à l’identité<br />
d’un objet entité spécifique. Lorsque l’instance du bean a<br />
été activée, elle a la possibilité d’acquérir les ressources<br />
supplémentaires dont elle a éventuellement besoin.<br />
ejbPassivate() Signale à un bean entité qu’il va être désactivé —<br />
c’est-à-dire que l’association de l’instance et de l’identité<br />
de l’objet entité va être rompue et que l’instance<br />
reviendra au pool <strong>des</strong> instances disponibles. L’instance<br />
peut alors libérer les ressources allouées avec la méthode<br />
ejbActivate() qu’elle ne souhaite plus gérer lorsqu’elle<br />
sera dans le pool.<br />
ejbLoad()<br />
Rafraîchit à partir de la base les données représentées par<br />
l’objet entité. Le conteneur appelle cette méthode sur<br />
l’instance du bean entité afin que l’instance synchronise<br />
l’état de l’entité mis en cache dans les variables<br />
d’instance avec l’état de l’entité dans la base de données.<br />
ejbStore()<br />
Stocke dans la base de données les données représentées<br />
par l’objet entité. Le conteneur appelle cette méthode sur<br />
l’instance du bean entité afin que l’instance synchronises<br />
l’état dans la base de données avec l’état de l’entité mis<br />
en cache dans les variables d’instance.<br />
Déclaration et implémentation <strong>des</strong> métho<strong>des</strong> <strong>des</strong> <strong>beans</strong><br />
entité<br />
Les <strong>beans</strong> entité peuvent avoir trois types de métho<strong>des</strong> :<br />
• Métho<strong>des</strong> Create<br />
• Métho<strong>des</strong> Find<br />
• Métho<strong>des</strong> métier<br />
Création <strong>des</strong> métho<strong>des</strong> Create<br />
Si vous utilisez l’expert Enterprise JavaBean pour commencer à créer votre<br />
<strong>enterprise</strong> bean, vous verrez que l’expert ajoute à la classe du bean une<br />
méthode ejbCreate() et une méthode ejbPostCreate() qui ne prennent pas<br />
de paramètre. Vous pouvez écrire d’autres métho<strong>des</strong> create si votre bean<br />
en a besoin.<br />
N’oubliez pas que les <strong>beans</strong> entité ne sont pas obligés d’avoir <strong>des</strong><br />
métho<strong>des</strong> create. Appeler une méthode create pour un bean entité insère<br />
de nouvelles données dans la base de données. Vous pouvez avoir <strong>des</strong><br />
<strong>beans</strong> entité sans méthode create si les nouvelles instances <strong>des</strong> objets<br />
entité doivent être ajoutées à la base de données uniquement par les mises<br />
à jour du SGBDR ou par une application existante.<br />
D é veloppement <strong>des</strong> <strong>beans</strong> entité 10-5
Ecriture de la classe du bean entité<br />
Méthode ejbCreate()<br />
Si vous choisissez d’ajouter <strong>des</strong> métho<strong>des</strong> ejbCreate() supplémentaires qui<br />
incluent <strong>des</strong> paramètres, respectez les règles suivantes :<br />
• Chaque ejbCreate() doit être déclarée publique.<br />
• Pour les <strong>beans</strong> entité gérés par le conteneur, une méthode ejbCreate()<br />
doit renvoyer null.<br />
Le conteneur a l’entière responsabilité de la création <strong>des</strong> <strong>beans</strong> entité<br />
qu’il gère.<br />
• Pour les <strong>beans</strong> entité auto-gérés, une méthode ejbCreate() doit renvoyer<br />
une instance de la classe clé primaire pour le nouvel objet entité.<br />
Le conteneur utilise cette clé primaire pour créer la référence à la<br />
véritable entité.<br />
• Les paramètres d’une méthode ejbCreate() doivent être en même<br />
nombre et avoir le même type que ceux de la méthode create()<br />
correspondante dans l’interface distante du bean.<br />
• Chaque méthode ejbCreate() doit avoir une méthode ejbPostCreate()<br />
correspondante avec le même nombre de paramètres.<br />
La signature de la méthode ejbCreate() est la même que la persistance du<br />
bean soit gérée par le conteneur ou par le bean. Voici la signature de<br />
toutes les métho<strong>des</strong> ejbCreate() d’un bean entité :<br />
public ejbCreate( )<br />
// implémentation<br />
}<br />
Lorsque le client appelle la méthode create(), le conteneur exécute en<br />
réponse la méthode ejbCreate() et insère dans la base de données un<br />
enregistrement représentant l’objet entité. Habituellement, les métho<strong>des</strong><br />
ejbCreate() initialisent un certain état de l’entité. De ce fait, elles ont<br />
souvent un ou plusieurs paramètres et leurs implémentations incluent le<br />
code définissant l’état de l’entité à partir <strong>des</strong> valeurs <strong>des</strong> paramètres.<br />
L’exemple bank, traité plus loin dans ce chapitre, a un bean entité compte<br />
chèque dont la méthode ejbCreate() prend deux paramètres, une chaîne et<br />
un nombre flottant. La méthode initialise le nom du compte avec la valeur<br />
chaîne et le solde du compte avec la valeur Float :<br />
public AccountPK ejbCreate(String name, float balance) {<br />
this.name = name;<br />
this.balance = balance;<br />
return null;<br />
}<br />
10-6 Guide du dé veloppeur Enterprise JavaBeans
Ecriture de la classe du bean entité<br />
Méthode ejbPostCreate()<br />
Lorsqu’une méthode ejbCreate() a fini de s’exécuter, le conteneur appelle<br />
la méthode ejbPostCreate() correspondante pour permettre à l’instance de<br />
terminer son initialisation. La méthode ejbPostCreate() ressemble à la<br />
méthode ejbCreate() pour ce qui est de ses paramètres, mais renvoie void :<br />
public void ejbPostCreate( )<br />
// implémentation<br />
}<br />
Respectez ces règles lorsque vous définissez une méthode ejbPostCreate() :<br />
• Elle doit être déclarée publique.<br />
• Elle ne peut être déclarée finale ni statique.<br />
• Le type renvoyé doit être void.<br />
• Sa liste de paramètres doit correspondre à celle de son homologue<br />
ejbCreate().<br />
Utilisez ejbPostCreate() pour accomplir tout processus spécial que votre<br />
bean doit exécuter avant d’être accessible au client. Si votre bean n’a rien<br />
de spécial à faire, laissez vide le corps de la méthode mais n’oubliez<br />
d’inclure une méthode ejbPostCreate() par méthode ejbCreate() dans le cas<br />
d’un bean entité dont la persistance est gérée par le bean.<br />
Création <strong>des</strong> métho<strong>des</strong> Find<br />
Chaque bean entité doit avoir une ou plusieurs métho<strong>des</strong> find. Les<br />
métho<strong>des</strong> find sont utilisées par les clients pour localiser les <strong>beans</strong> entité.<br />
Chaque bean entité auto-géré doit posséder une méthode<br />
ejbFindByPrimaryKey() ayant son homologue findByPrimaryKey() dans<br />
l’interface locale du bean. Voici la signature de la méthode<br />
ejbFindByPrimaryKey() :<br />
public ejbFindByPrimaryKey() {<br />
// implémentation<br />
}<br />
Vous pouvez définir d’autres métho<strong>des</strong> find pour votre bean. Par<br />
exemple, vous pouvez avoir une méthode ejbFindByLastName(). Chaque<br />
méthode find doit respecter les règles suivantes :<br />
• Elle doit être déclarée publique.<br />
• Son nom doit utiliser le préfixe ejbFind.<br />
• Elle ne peut être déclarée finale ni statique.<br />
• Elle doit renvoyer une clé primaire, une collection de clés primaires ou<br />
une Enumeration de clés primaires.<br />
• Les types <strong>des</strong> paramètres et de la valeur renvoyée doivent être vali<strong>des</strong><br />
pour RMI Java.<br />
D é veloppement <strong>des</strong> <strong>beans</strong> entité 10-7
La vie d’ un bean entité<br />
La vie d’un bean entité<br />
Pour les <strong>beans</strong> entité à persistance auto-gérée, chaque méthode find<br />
déclarée dans la classe du bean doit avoir une méthode find<br />
correspondante dans l’interface locale du bean, utilisant les mêmes<br />
paramètres mais renvoyant l’interface distante du bean entité. Le client<br />
localise le bean entité qu’il veut en appelant la méthode find de l’interface<br />
locale, le conteneur invoque ensuite la méthode find correspondante dans<br />
la classe du bean. Voir “Métho<strong>des</strong> find <strong>des</strong> <strong>beans</strong> entité”, page 11-5.<br />
Ecriture <strong>des</strong> métho<strong>des</strong> métier<br />
Dans la classe de votre <strong>enterprise</strong> bean, écrivez les implémentations<br />
complètes <strong>des</strong> métho<strong>des</strong> métier dont a besoin votre bean. Pour rendre ces<br />
métho<strong>des</strong> accessibles à un client, vous devez les déclarer dans l’interface<br />
distante du bean en utilisant exactement la même signature.<br />
Utilisation <strong>des</strong> experts de JBuilder pour créer un bean entité<br />
Vous pouvez utiliser l’expert Enterprise JavaBeans de JBuilder pour<br />
commencer rapidement la création de votre bean entité. Si vous avez <strong>des</strong><br />
tables de base de données à partir <strong>des</strong>quelles vous voulez créer <strong>des</strong><br />
<strong>enterprise</strong> <strong>beans</strong>, démarrez avec l’expert Modeleur Bean entité EJB de<br />
JBuilder. Si vous avez déjà un bean entité, mais pas ses interfaces locale et<br />
distante, faites-les créer par l’expert Interfaces EJB de JBuilder. Modifiez<br />
ensuite le code dans JBuilder avec l’éditeur de code et le concepteur de<br />
bean. Modifiez les <strong>des</strong>cripteurs de déploiement avec l’éditeur de<br />
<strong>des</strong>cripteur de déploiement de JBuilder. Créez une application client de<br />
test avec l’expert Client test EJB et testez vos nouveaux <strong>enterprise</strong> <strong>beans</strong>.<br />
Enfin, utilisez l’expert Déploiement EJB pour simplifier le processus de<br />
déploiement de vos <strong>enterprise</strong> <strong>beans</strong>.<br />
Pour plus d’informations sur l’utilisation <strong>des</strong> outils EJB de JBuilder pour<br />
créer <strong>des</strong> <strong>beans</strong> entité, voir Chapitre 3, “Création <strong>des</strong> <strong>enterprise</strong> <strong>beans</strong><br />
avec JBuilder”, Chapitre 7, “Utilisation de l’éditeur de <strong>des</strong>cripteur de<br />
déploiement”, et Chapitre 6, “Déploiement <strong>des</strong> <strong>enterprise</strong> <strong>beans</strong>”.<br />
Le cycle de vie d’un <strong>enterprise</strong> bean entité est composé de trois états<br />
distincts :<br />
• Inexistant<br />
• En pool<br />
• Prêt<br />
10-8 Guide du dé veloppeur Enterprise JavaBeans
La vie d’ un bean entité<br />
Le diagramme suivant décrit le cycle de vie de l’instance d’un bean entité :<br />
L’état de non existence<br />
Au départ, l’instance du bean entité n’existe pas. Le conteneur EJB crée<br />
une instance d’un bean entité et appelle ensuite la méthode<br />
setEntityContext() sur le bean entité pour passer à l’instance une référence<br />
à son contexte ; c’est-à-dire une référence à l’interface EntityContext.<br />
L’interface EntityContext procure à l’instance un accès aux services fournis<br />
par le conteneur et lui permet d’obtenir <strong>des</strong> informations sur ses clients.<br />
Le bean entité est maintenant dans l’état en pool.<br />
L’état en pool<br />
Chaque type de bean entité a son propre pool. Aucune <strong>des</strong> instances du<br />
pool n’est associée à <strong>des</strong> données. Comme aucune de leurs variables<br />
d’instance n’est définie, les instances n’ont pas d’identité et sont toutes<br />
équivalentes. Le conteneur est libre d’assigner n’importe quelle instance<br />
au client qui demande un tel bean entité.<br />
Lorsqu’une application client appelle une <strong>des</strong> métho<strong>des</strong> find du bean<br />
entité, le conteneur exécute la méthode ejbFind() correspondante sur une<br />
instance arbitraire du pool. L’instance reste dans l’état en pool pendant<br />
l’exécution de la méthode find.<br />
D é veloppement <strong>des</strong> <strong>beans</strong> entité 10-9
La vie d’ un bean entité<br />
Lorsque le conteneur sélectionne une instance qui servira les deman<strong>des</strong><br />
d’un client concernant un objet entité, cette instance passe de l’état en pool<br />
à l’état prêt. Il existe deux façons pour une instance entité de passer de<br />
l’état en pool à l’état prêt :<br />
• Via les métho<strong>des</strong> ejbCreate() et ejbPostCreate().<br />
• Via la méthode ejbActivate().<br />
Le conteneur sélectionne l’instance qui gérera la demande create() d’un<br />
client sur l’interface locale du bean. En réponse à l’appel de create(), le<br />
conteneur crée un objet entité et appelle les métho<strong>des</strong> ejbCreate() et<br />
ejbPostCreate() lorsque l’instance est assignée à l’objet entité.<br />
Le conteneur appelle la méthode ejbActivate() pour activer une instance<br />
de sorte qu’il puisse répondre à une invocation sur un objet entité existant.<br />
Habituellement, le conteneur appelle ejbActivate() lorsqu’il n’existe pas<br />
dans l’état prêt d’instance qui pourrait gérer les appels du client.<br />
L’état prêt<br />
Lorsque l’instance est dans l’état prêt, elle est associée à une clé primaire<br />
spécifique. Les clients peuvent appeler sur le bean entité les métho<strong>des</strong><br />
spécifiques à l’application. Le conteneur appelle les métho<strong>des</strong> ejbLoad() et<br />
ejbStore() pour demander au bean de charger et d’enregistrer ses<br />
données. Elles permettent également à l’instance du bean de synchroniser<br />
son état et celui de l’entité de données sous-jacente.<br />
Retour à l’état en pool<br />
Lorsque l’instance d’un bean entité revient à l’état en pool, l’instance est<br />
découplée <strong>des</strong> données représentées par l’entité. Le conteneur peut<br />
désormais assigner l’instance de tout objet entité dans la même interface<br />
locale du bean entité. Il existe deux façons pour une instance entité de<br />
passer de l’état prêt à l’état en pool :<br />
• Le conteneur appelle la méthode ejbPassivate() pour dissocier<br />
l’instance de sa clé primaire sans supprimer l’objet entité sous-jacent.<br />
• Le conteneur appelle la méthode ejbRemove() pour supprimer l’objet<br />
entité. Il appelle ejbRemove() lorsque l’application client appelle la<br />
méthode remove() locale ou distante du bean.<br />
Pour supprimer du pool une instance non associée, le conteneur appelle la<br />
méthode unsetEntityContext() de l’instance.<br />
10-10 Guide du dé veloppeur Enterprise JavaBeans
Exemple du bean entité bank<br />
Exemple du bean entité bank<br />
L’exemple bank montre comment utiliser <strong>des</strong> <strong>beans</strong> entité. Il inclut deux<br />
implémentations de la même interface distante Account. L’une utilise la<br />
persistance gérée par le bean, l’autre par le conteneur.<br />
Le bean entité SavingsAccount, qui utilise la persistance gérée par le bean,<br />
représente <strong>des</strong> comptes d’épargne. Si vous examinez le code du bean<br />
entité, vous verrez qu’il comprend <strong>des</strong> appels directs à JDBC.<br />
Le bean entité CheckingAccount, qui utilise la persistance gérée par le<br />
conteneur, représente <strong>des</strong> comptes chèques. Il se repose sur le conteneur<br />
pour implémenter la persistance, mais pas vous, le développeur du bean.<br />
Un troisième <strong>enterprise</strong> bean appelé Teller transfère les fonds d’un<br />
compte à l’autre. C’est un bean session stateless qui montre comment les<br />
appels à plusieurs <strong>beans</strong> entité peuvent être regroupés dans la même<br />
transaction gérée par le conteneur. Même si l’opération de crédit se<br />
produit avant l’opération de débit au cours de l’opération de transfert, le<br />
conteneur annule (rollback) la transaction si le débit échoue, et ni le débit<br />
ni le crédit n’est effectif.<br />
Vous trouverez le code complet de l’exemple bank dans le répertoire /<br />
Borland/AppServer/examples/ejb/bank.<br />
L’interface locale d’un bean entité<br />
Plusieurs <strong>beans</strong> entité peuvent partager les mêmes interfaces locale et<br />
distante, même si un bean utilise la persistance gérée par le conteneur et<br />
les autres la persistance gérée par le bean. Les deux <strong>beans</strong> entité<br />
SavingsAccount et CheckingAccount utilisent la même interface locale,<br />
AccountHome. Ils utilisent également la même interface distante Account.<br />
L’interface locale d’un bean entité est très semblable à l’interface locale<br />
d’un bean session. Elles étendent la même interface javax.ejb.EJBHome.<br />
L’interface locale <strong>des</strong> <strong>beans</strong> entité doivent inclure au moins une méthode<br />
find. La méthode create() est facultative.<br />
Voici le code de l’interface AccountHome :<br />
public interface AccountHome extends javax.ejb.EJBHome {<br />
Account create(String name, float balance)<br />
throws java.rmi.RemoteException, javax.ejb.CreateException;<br />
Account findByPrimaryKey(AccountPK primaryKey)<br />
throws java.rmi.RemoteException, javax.ejb.FinderException;<br />
java.util.Enumeration findAccountsLargerThan(float balance)<br />
throws java.rmi.RemoteException, javax.ejb.FinderException:<br />
}<br />
L’interface locale AccountHome implémente trois métho<strong>des</strong>. Alors que la<br />
méthode create() n’est pas obligatoire pour les <strong>beans</strong> entité, l’exemple<br />
D é veloppement <strong>des</strong> <strong>beans</strong> entité 10-11
Exemple du bean entité bank<br />
bank en implémente une. La méthode create() insère un nouvel objet bean<br />
entité dans la base de données sous-jacente. Si vous aviez choisi de<br />
déléguer la création <strong>des</strong> nouveaux objets entité au SGBDR ou à une autre<br />
application, vous ne définiriez pas de méthode create().<br />
La méthode create() nécessite deux paramètres, une chaîne pour le nom<br />
du compte et le montant du solde. L’implémentation de cette méthode<br />
dans la classe du bean entité utilise deux valeurs de paramètres pour<br />
initialiser l’état de l’objet entité — le nom du compte et le solde initial —<br />
lorsqu’elle crée un nouvel objet. La clause throws d’une méthode create()<br />
doit inclure java.rmi.RemoteException et java.ejb.CreateException. Elle doit<br />
également inclure les autres exceptions spécifiques à l’application.<br />
Les <strong>beans</strong> entité doivent posséder la méthode findByPrimaryKey(),<br />
l’interface AccountHome déclare donc cette méthode. Elle prend un<br />
paramètre, la classe clé primaire AccountPK, et renvoie une référence sur<br />
l’interface distante Account. Cette méthode trouve une entité compte<br />
particulière et renvoie une référence vers elle.<br />
Bien que cela ne soit pas obligatoire, l’interface locale déclare une seconde<br />
méthode find, findAccountsLargerThan(). Cette méthode renvoie un objet<br />
Java Enumeration contenant tous les comptes dont le solde est supérieur à<br />
un certain montant.<br />
L’interface distante d’un bean entité<br />
Plusieurs <strong>beans</strong> entité peuvent utiliser la même interface distante, même<br />
lorsqu’ils gèrent leur persistance différemment. Les deux <strong>beans</strong> entité de<br />
l’exemple bank utilisent la même interface distante Account.<br />
L’interface distante étend l’interface javax.ejb.EJBObject et expose les<br />
métho<strong>des</strong> métier accessibles aux clients. Voici le code :<br />
public interface Account extends javax.ejb.EJBObject {<br />
public float getBalance() throws java.rmi.RemoteException;<br />
public void credit(float amount) throws java.rmi.RemoteException;<br />
public void debit(float amount) throws java.rmi.RemoteException;<br />
}<br />
Un bean entité dont la persistance est gérée par le<br />
conteneur<br />
L’exemple bank implémente un bean entité CheckingAccount qui illustre<br />
l’utilisation de la persistance gérée par le conteneur. Sur de nombreux<br />
points, cette implémentation ressemble à l’implémentation d’un bean<br />
10-12 Guide du dé veloppeur Enterprise JavaBeans
Exemple du bean entité bank<br />
session. Mais, il faut noter les éléments suivants sur l’implémentation<br />
d’un bean entité utilisant la persistance gérée par le conteneur :<br />
• Le bean entité n’a pas d’implémentation <strong>des</strong> métho<strong>des</strong> find. C’est le<br />
conteneur EJB qui fournit les implémentations <strong>des</strong> métho<strong>des</strong> find pour<br />
les <strong>beans</strong> entité dont la persistance est gérée par le conteneur. Plutôt<br />
que de fournir l’implémentation dans la classe du bean, le <strong>des</strong>cripteur<br />
de déploiement contient <strong>des</strong> informations qui permettent au conteneur<br />
d’implémenter ces métho<strong>des</strong>.<br />
• Le bean entité déclare publics tous les champs gérés par le conteneur à<br />
la place du bean. Le bean CheckingAccount déclare name et balance comme<br />
champs publics.<br />
• La classe du bean entité implémente ces métho<strong>des</strong>, déclarées dans<br />
l’interface EntityBean : ejbActivate(), ejbPassivate(), ejbLoad(),<br />
ejbStore(), ejbRemove(), setEntityContext() et unsetEntityContext(). Le<br />
bean entité ne doit fournir que les implémentations squelette de ces<br />
métho<strong>des</strong>, mais il est possible d’ajouter du code spécifique à<br />
l’application. Le bean CheckingAccount enregistre le contexte renvoyé par<br />
setEntityContext() et libère la référence dans unsetEntityContext().<br />
Sinon, il n’ajoute aucun code aux métho<strong>des</strong> de l’interface EntityBean.<br />
• CheckingAccount inclut une implémentation de la méthode ejbCreate(),<br />
car cet <strong>enterprise</strong> bean permet aux appelants de créer de nouveaux<br />
comptes chèques. L’implémentation initialise également les deux<br />
variables d’instance, name et balance, avec les valeurs <strong>des</strong> paramètres.<br />
ejbCreate() renvoie une valeur null car, avec la persistance gérée par le<br />
conteneur, le conteneur crée la référence à renvoyer au client.<br />
• CheckingAccount fournit l’implémentation minimale de la méthode<br />
ejbPostCreate() mais cette méthode pourrait effectuer un plus ample<br />
travail d’initialisation si cela était nécessaire. Pour les <strong>beans</strong> dont la<br />
persistance est gérée par le conteneur, vous n’avez besoin que d’une<br />
implémentation minimale de ejbPostCreate() car elle est utilisée comme<br />
callback de notification.<br />
import javax.ejb.*<br />
import java.rmi.RemoteException;<br />
public class CheckingAccount implements EntityBean {<br />
private javax.ejb.EntityContext _context;<br />
public String name;<br />
public float balance;<br />
public float getBalance() {<br />
return balance;<br />
}<br />
public void debit(float amount) {<br />
if(amount > balance) {<br />
// marque la transaction en cours pour le rollback ...<br />
D é veloppement <strong>des</strong> <strong>beans</strong> entité 10-13
Exemple du bean entité bank<br />
_context.setRollbackOnly();<br />
}<br />
else {<br />
balance = balance - amount;<br />
}<br />
}<br />
public void credit(float amount) {<br />
balance = balance + amount;<br />
}<br />
public AccountPK ejbCreate(String name, float balance) {<br />
this.name = name;<br />
this.balance = balance;<br />
return null;<br />
}<br />
public void ejbPostCreate(String name, float balance) {}<br />
public void ejbRemove() {}<br />
public void setEntityContext(EntityContext context) {<br />
_context = context;<br />
}<br />
public void unsetEntityContext() {<br />
context = null;<br />
}<br />
public void ejbActivate() {}<br />
public void ejbPassivate() {}<br />
public void ejbLoad() {}<br />
public void ejbStore() {}<br />
public String toString() {<br />
return"CheckingAccount[name=" + name + ",balance=" + balance +"]";<br />
}<br />
}<br />
Un bean entité dont la persistance est gérée par le bean<br />
L’exemple bank implémente également un bean SavingsAccount, un bean<br />
entité dont la persistance est auto-gérée. Le bean SavingsAccount accède à<br />
une autre table de comptes que le bean CheckingAccount. Bien que les deux<br />
<strong>beans</strong> entité gèrent différemment leur persistance, ils peuvent utiliser les<br />
mêmes interfaces locale et distante. Cependant, les deux implémentations<br />
sont différentes.<br />
L’implémentation d’un bean entité dont la persistance est gérée par le<br />
bean accomplit ce qui suit :<br />
• Il peut déclarer ses variables d’instance comme privées plutôt que<br />
publiques.<br />
Le bean inclut le code nécessaire pour accéder aux variables d’instance,<br />
charger les valeurs issues de la base de données dans ces variables et<br />
10-14 Guide du dé veloppeur Enterprise JavaBeans
Exemple du bean entité bank<br />
stocker leurs modifications dans la base. Ainsi, le bean peut contrôler<br />
l’accès à ces variables comme il l’entend. C’est différent de la<br />
persistance gérée par le conteneur où le bean doit déclarer publiques<br />
toutes les variables gérées par le conteneur afin que celui-ci y accède.<br />
• La méthode ejbCreate() renvoie la classe clé primaire.<br />
Pour le bean SavingsAccount, cette classe est AccountPK. Le conteneur<br />
prend la classe clé primaire renvoyée et l’utilise pour construire une<br />
référence distante sur l’instance du bean entité.<br />
• Comme un bean dont la persistance est gérée par le conteneur, un bean<br />
dont la persistance est auto-gérée peut fournir plus qu’une<br />
implémentation vide de la méthode ejbCreate().<br />
Le bean SavingsAccount n’a pas besoin d’inclure du code d’initialisation<br />
supplémentaire dans cette méthode.<br />
• Il a les implémentations <strong>des</strong> métho<strong>des</strong> ejbLoad() et ejbStore().<br />
Un bean à persistance gérée par le conteneur fournit généralement une<br />
simple implémentation vide de ces métho<strong>des</strong> car c’est le conteneur qui<br />
gère la persistance. Un bean entité à persistance auto-gérée doit fournir<br />
son propre code pour lire les valeurs de la base de données dans ses<br />
variables d’instance avec la méthode ejbLoad() et écrire dans la base les<br />
valeurs modifiées avec la méthode ejbStore().<br />
• Il a les implémentations pour toutes les métho<strong>des</strong> find.<br />
Le bean entité SavingsAccount implémente deux métho<strong>des</strong> find, la<br />
méthode ejbFindByPrimaryKey(), obligatoire, et la méthode<br />
ejbFindAccountsLargerThan(), facultative.<br />
• Un bean entité dont la persistance est auto-gérée doit implémenter la<br />
méthode ejbRemove().<br />
Comme le bean gère l’objet entité de la base de données sous-jacente, il<br />
doit implémenter cette méthode pour pouvoir supprimer de la base de<br />
données l’objet entité. Un bean dont la persistance est gérée par le<br />
conteneur omettra l’implémentation de cette méthode car c’est le<br />
conteneur qui est responsable de la gestion de la base.<br />
• Chaque méthode qui accède à l’objet de la base de données sous-jacente<br />
doit inclure le bon code d’accès à cette base.<br />
Ces métho<strong>des</strong> sont ejbCreate(), ejbRemove(), ejbLoad(), ejbStore,<br />
ejbFindByPrimaryKey(), toutes les autres métho<strong>des</strong> find et les métho<strong>des</strong><br />
métier. Chaque méthode contient le code de connexion à la base de<br />
données, suivi du code de construction puis d’exécution <strong>des</strong><br />
instructions SQL qui accomplissent la fonctionnalité de la méthode.<br />
Quand les instructions SQL sont terminées, la méthode ferme les<br />
instructions et la connexion à la base de données avant de revenir au<br />
programme.<br />
D é veloppement <strong>des</strong> <strong>beans</strong> entité 10-15
Exemple du bean entité bank<br />
L’exemple de code suivant montre les parties intéressantes du code de la<br />
classe d’implémentation de SavingsAccount. L’exemple supprime le code<br />
qui contient simplement les implémentations vi<strong>des</strong> <strong>des</strong> métho<strong>des</strong> <strong>des</strong><br />
interfaces EntityBean, comme ejbActivate(), ejbPassivate(), etc.<br />
Observez d’abord la méthode ejbLoad(), qui accède à l’objet entité de la<br />
base de données, pour voir comment un bean dont la persistance est<br />
auto-gérée implémente l’accès à la base. Notez que toutes les métho<strong>des</strong><br />
implémentées dans la classe SavingsAccount suivent la même approche que<br />
ejbLoad(). La méthode ejbLoad() commence par établir la connexion à la<br />
base de données. Elle appelle la méthode interne getConnection(), qui<br />
utilise un DataSource pour obtenir une connexion JDBC à la base de<br />
données à partir d’un pool de connexions JDBC. Une fois la connexion<br />
établie, ejbLoad() crée un objet PreparedStatement et construit son<br />
instruction SQL d’accès à la base de données. Comme ejbLoad() lit les<br />
valeurs de l’objet entité dans les variables d’instance du bean, elle<br />
construit l’instruction SQL SELECT d’une requête qui sélectionne la<br />
valeur du solde <strong>des</strong> comptes d’épargne dont les noms correspondent à un<br />
modèle. La méthode exécute ensuite la requête. Si la requête renvoie un<br />
résultat, c’est le montant du solde. La méthode ejbLoad() termine en<br />
fermant les objets PreparedStatement, puis la connexion à la base de<br />
données. Notez que la méthode ejbLoad() ne ferme pas réellement la<br />
connexion. A la place, elle renvoie simplement la connexion au pool de<br />
connexions.<br />
import.java.sql.*;<br />
import javax.ejb.*;<br />
import java.util.*;<br />
import java.rmi.RemoteException;<br />
public class SavingsAccount implements EntityBean {<br />
private entitycontext _constext;<br />
private String _name;<br />
private float _balance;<br />
public float getBalance() {<br />
return _balance;<br />
}<br />
public void debit(float amount) {<br />
if(amount > balance) {<br />
// marque la transaction en cours pour le rollback...<br />
_context.setRollbackOnly();<br />
} else {<br />
_balance = _balance - amount;<br />
}<br />
}<br />
public void credit(float amount) {<br />
_balance = _balance + amount;<br />
}<br />
10-16 Guide du dé veloppeur Enterprise JavaBeans
Exemple du bean entité bank<br />
// setEntitycontext(), unsetEntityContext(), ejbActivate(), ejbPassivate(),<br />
// les implémentations squelette de ejbPostCreate() ne sont pas montrées ici<br />
...<br />
public AccountPK ejbCreate(String name, float balance)<br />
throws RemoteException, CreateException {<br />
_name = name;<br />
_balance = balance;<br />
try {<br />
Connection connection = getConnection();<br />
PreparedStatement statement = connection.prepareStatement<br />
("INSERT INTO Savings_Accounts (name, balance) VALUES (,)*);<br />
statement.setString(1, _name);<br />
statement.setFloat(2, _balance);<br />
if(statement.executeUpdate() != 1) {<br />
throw new CreateException("Impossible de créer : " + name);<br />
}<br />
statement.close();<br />
connection.close();<br />
return new AccountPK(name);<br />
} catch(SQLException e) {<br />
throw new RemoteException("Impossible de créer : " + name, 3);<br />
}<br />
}<br />
...<br />
public void ejbRemote() throws RemoteException, RemoveException {<br />
try {<br />
Connection connection = getConnection();<br />
PreparedStatement statement = connection.prepareStatement<br />
("DELETE FROM Savings Account WHERE name = ");<br />
statement.setString(1, _name);<br />
if(statement.executeUpdate() != 1) {<br />
throw new RemoteException("Impossible de supprimer : " + _name, e);<br />
}<br />
statement.close();<br />
connection.close();<br />
} catch(SQLException e) {<br />
throw new RemoteException("Impossible de supprimer : " + _name, e);<br />
}<br />
}<br />
public AccountPK ejbFindByPrimaryKey(AccountPK key) throws RemoteException,<br />
FinderException {<br />
try {<br />
Connection connection = getConnection();<br />
PreparedStatement statement = connection.prepareStatement<br />
("SELECT name FROM Savings_Accounts WHERE name = ");<br />
statement.setString(1, key.name);<br />
ResultSet resultSet = statement.executeQuery();<br />
if(!resultSet.next()) {<br />
throw new FinderException("Impossible de trouver : " + key<br />
statement.close();<br />
connection.close();<br />
return key;<br />
} catch(SQLException e) {<br />
D é veloppement <strong>des</strong> <strong>beans</strong> entité 10-17
Exemple du bean entité bank<br />
}<br />
}<br />
throw new RemoteException("Impossible de trouver : " + key, e);<br />
public java.util.Enumeration ejbFindAccountsLargerThan(float balance)<br />
throws RemoteException, FinderException {<br />
try {<br />
Connection connection = getConnection();<br />
PreparedStatement statement = connection.prepareStatement<br />
("SELECT name FROM Savings_Account WHERE balance > ");<br />
statement.setFloat(1, balance);<br />
ResultSet resultSet = statement.executeQuery();<br />
Vector keys = new Vector();<br />
while(resultSet.next()) {<br />
String name = resultSet.getString(1);<br />
keys.addElement(new AccountPK(name));<br />
}<br />
statement.close();<br />
connection.close();<br />
return keys.elements();<br />
} catch(SQLException 3) {<br />
throw new RemoteException("Impossible findAccountsLargerThan : " +<br />
balance, e);<br />
}<br />
}<br />
public void ejbLoad() throws RemoteException {<br />
// obtient le nom de la clé primaire<br />
_name = (AccountPK) _context.getPrimaryKey()).name;<br />
try {<br />
Connection connection = getConnection();<br />
PreparedStatement statement = connection.prepareStatement<br />
("SELECT balance FROM Savings_Account WHERE name = ");<br />
statement.setString(1, _name);<br />
ResultSet resultSet = statement.executeQuery();<br />
if(!resultSet.next()) {<br />
throw new RemoteException("Compte introuvable : " + _name);<br />
}<br />
_balance = resultSet.getFloat(1);<br />
statement.close();<br />
connection.close();<br />
} catch(SQLException e) {<br />
throw new RemoteException("Impossible de charger : " + _name, e):<br />
}<br />
}<br />
public void ejbStore() throw RemoteException {<br />
try {<br />
Connection connection = getConnection();<br />
PreparedStatement statement = connection.prepareStatement<br />
("UPDATE Savings_Accounts SET balance = WHERE name = ");<br />
statement.setFloat(1, _balance);<br />
statement.setString(2, _name);<br />
statement.executeUpdate();<br />
10-18 Guide du dé veloppeur Enterprise JavaBeans
Exemple du bean entité bank<br />
statement.close();<br />
connection.close();<br />
} catch(SQLException e) {<br />
throw new RemoteException("Impossible de stocker : " + _name, e);<br />
}<br />
}<br />
private connection getconnection() throws SQLException {<br />
Properties properties = _context.getEnvironment();<br />
String url = properties.getProperty("db.url");<br />
String username = properties.getProperty("db.username");<br />
String password = properties.getProperty("db.password");<br />
if(username != null) {<br />
return DriverManager.getConnection(url, username, password);<br />
} else {<br />
return DriverManager.getConnection(url);<br />
}<br />
}<br />
public String toString() {<br />
return "SavingsAccount[name=" + _name + ",balance=" + _balance +"]";<br />
}<br />
}<br />
La classe clé primaire<br />
CheckingAccount et SavingsAccount utilisent tous deux le même champ pour<br />
identifier de manière unique un enregistrement de compte particulier.<br />
Dans ce cas, ils utilisent tous deux la même classe clé primaire, AccountPK,<br />
pour représenter l’identificateur unique de chaque type de compte :<br />
public class AccountPK implements java.io.Serializable {<br />
public String name;<br />
public AccountPK() {}<br />
public AccountPK(String name) {<br />
this.name = name;<br />
}<br />
}<br />
Le <strong>des</strong>cripteur de déploiement<br />
Le <strong>des</strong>cripteur de déploiement de l’exemple bancaire déploie trois sortes<br />
de <strong>beans</strong> : le bean session Teller, le bean entité CheckingAccount, dont la<br />
persistance est gérée par le conteneur, et le bean entité SavingsAccount, dont<br />
la persistance est auto-gérée.<br />
Vous utilisez les propriétés du <strong>des</strong>cripteur de déploiement pour spécifier<br />
<strong>des</strong> informations sur les interfaces <strong>des</strong> <strong>beans</strong> entité, les attributs de<br />
transaction, etc., comme vous le feriez pour les <strong>beans</strong> session. Mais, vous<br />
ajoutez également <strong>des</strong> informations propres uniquement aux <strong>beans</strong> entité.<br />
D é veloppement <strong>des</strong> <strong>beans</strong> entité 10-19
Exemple du bean entité bank<br />
L’exemple de code XML géré par un bean montre les balises de propriété<br />
d’un <strong>des</strong>cripteur de déploiement typique pour un bean entité dont la<br />
persistance est auto-gérée. L’exemple de code XML géré par le conteneur<br />
montre les balises d’un <strong>des</strong>cripteur de déploiement typique pour un bean<br />
entité dont la persistance est gérée par le conteneur. Quand vous<br />
comparez les balises de <strong>des</strong>cripteur <strong>des</strong> deux types de <strong>beans</strong> entité, vous<br />
remarquez que le <strong>des</strong>cripteur de déploiement d’un bean entité dont la<br />
persistance est gérée par le conteneur est plus complexe.<br />
Le type de <strong>des</strong>cripteur de déploiement du bean est défini par .<br />
Remarquez que les premières balises de la section <br />
dans les deux exemples de code spécifient que le bean est un bean entité.<br />
Le <strong>des</strong>cripteur de déploiement d’un bean entité spécifie le type<br />
d’informations suivant :<br />
• Les noms <strong>des</strong> interfaces associées (locale et distante) et la classe<br />
d’implémentation du bean.<br />
Chaque <strong>enterprise</strong> bean spécifie son interface locale en utilisant la<br />
balise , son interface distante en utilisant la balise et<br />
sa classe d’implémentation en utilisant la balise .<br />
• Les noms JNDI sous lesquels le bean entité est enregistré et grâce<br />
auxquels les clients localisent le bean.<br />
• Les attributs de transaction du bean et son niveau d’isolation.<br />
Cela apparaît généralement dans la section du<br />
<strong>des</strong>cripteur de déploiement.<br />
• Le nom de la classe clé primaire du bean entité.<br />
Dans cet exemple, la classe clé primaire est AccountPK et apparaît dans la<br />
balise .<br />
• La persistance utilisée par le bean.<br />
Le bean CheckingAccount utilise la persistance gérée par le conteneur, et<br />
donc le <strong>des</strong>cripteur de déploiement définit la balise <br />
par Container.<br />
• Si le bean est réentrant.<br />
Ni le bean SavingsAccount, ni le bean CheckingAccount ne sont réentrants,<br />
donc la balise est définie à False pour les deux.<br />
• Les champs gérés par le conteneur, si le bean utilise la persistance gérée<br />
par le conteneur.<br />
Un bean qui utilise la persistance auto-gérée ne spécifie aucun champ<br />
relatif à la gestion par le conteneur. Donc, le <strong>des</strong>cripteur de<br />
déploiement du bean SavingsAccount ne spécifie aucun champ relatif à la<br />
gestion par le conteneur. Un bean entité utilisant la persistance gérée<br />
par le conteneur doit spécifier les noms <strong>des</strong> champs ou les variables<br />
10-20 Guide du dé veloppeur Enterprise JavaBeans
Exemple du bean entité bank<br />
d’instances que le conteneur doit gérer. Utilisez une combinaison <strong>des</strong><br />
balises et pour cela. La première balise,<br />
, indique que le champ est géré par le conteneur. A<br />
l’intérieur de cette balise, la balise spécifie le nom du<br />
champ lui-même. Par exemple, le <strong>des</strong>cripteur de déploiement du bean<br />
CheckingAccount indique que le champ du solde est géré par le conteneur<br />
comme ceci :<br />
balance<br />
Des informations sur les champs gérés par le conteneur, pour les <strong>beans</strong><br />
gérés par le conteneur. Le conteneur utilise cette information pour générer<br />
les métho<strong>des</strong> find pour ces champs.<br />
Descripteur de déploiement d’un bean entité dont la persistance est<br />
auto-gérée<br />
L’exemple de code suivant montre les parties principales du <strong>des</strong>cripteur<br />
de déploiement d’un bean entité dont la persistance est auto-gérée.<br />
Comme c’est le bean, et non le conteneur, qui gère ses propres lectures <strong>des</strong><br />
valeurs entité de la base de données et met à jour ces valeurs, le<br />
<strong>des</strong>cripteur ne spécifie pas de champ à gérer par le conteneur. Il n’indique<br />
pas non plus au conteneur comment implémenter ses métho<strong>des</strong> find, car<br />
c’est l’implémentation du bean qui les fournit.<br />
<br />
<br />
Ce bean entité est un exemple de persistance auto-gérée<br />
savings<br />
AccountHome<br />
Account<br />
SavingsAccount<br />
Bean<br />
AccountPK<br />
False<br />
<br />
...<br />
<br />
<br />
<br />
<br />
savings<br />
*<br />
<br />
Required<br />
<br />
<br />
D é veloppement <strong>des</strong> <strong>beans</strong> entité 10-21
Exemple du bean entité bank<br />
Descripteur de déploiement d’un bean entité dont la persistance est<br />
gérée par le conteneur<br />
L’exemple de code suivant montre les parties principales du <strong>des</strong>cripteur<br />
de déploiement d’un bean entité dont la persistance est gérée par le<br />
conteneur. Comme le bean laisse le conteneur gérer les chargements <strong>des</strong><br />
valeurs entité de la base de données et les mises à jour de ces valeurs, le<br />
<strong>des</strong>cripteur spécifie les champs que le conteneur doit gérer.<br />
<br />
<br />
Ce bean entité est un exemple de persistance gérée par le<br />
conteneur<br />
<br />
checking<br />
AccountHome><br />
Account<br />
chkingAccount<br />
Container<br />
AccountPK>/prim-key-class><br />
False<br />
<br />
name<br />
<br />
<br />
<br />
<br />
<br />
<br />
chekcing<br />
*<br />
<br />
<br />
<br />
<br />
10-22 Guide du dé veloppeur Enterprise JavaBeans
11<br />
Chapitre<br />
Chapitre11Création <strong>des</strong><br />
interfaces locales<br />
et distantes<br />
Création de l’interface locale<br />
En tant que fournisseur d’<strong>enterprise</strong> bean, vous devez créer deux<br />
interfaces pour chaque bean : une interface locale et une interface distante.<br />
L’interface locale définit les métho<strong>des</strong> qu’utilise une application client<br />
pour créer, localiser et détruire les instances d’un <strong>enterprise</strong> bean.<br />
L’interface distante définit les métho<strong>des</strong> métier implémentées dans le<br />
bean. Un client accède à ces métho<strong>des</strong> via l’interface distante.<br />
L’interface locale d’un <strong>enterprise</strong> bean contrôle le cycle de vie du bean.<br />
Elle contient la définition <strong>des</strong> métho<strong>des</strong> permettant de créer, trouver et<br />
supprimer l’instance d’un <strong>enterprise</strong> bean.<br />
En tant que fournisseur de bean, vous devez définir l’interface locale, mais<br />
vous ne l’implémentez pas. Le conteneur EJB le fait, en générant un objet<br />
local qui renvoie une référence au bean.<br />
Il est coutumier de donner à l’interface locale le même nom que celui de la<br />
classe du bean suivi du suffixe Home. Par exemple, si l’<strong>enterprise</strong> bean se<br />
nomme Account, l’interface locale de Account sera AccountHome. Par défaut,<br />
une interface locale générée par les experts EJB de JBuilder suit cette<br />
convention, bien que vous ayez la possibilité de changer le nom de<br />
l’interface lorsque vous utilisez cet expert.<br />
Cré ation <strong>des</strong> interfaces locales et distantes 11-1
Cré ation de l’ interface locale<br />
La classe de base EJBHome<br />
Toutes les interfaces locales étendent l’interface javax.ejb.EJBHome. Voici la<br />
définition complète de EJBHome :<br />
package javax.ejb<br />
public interface EJBHome extends java.rmi.Remote {<br />
void remove(Handle handle) throws java.rmi.RemoteException,<br />
RemoveException;<br />
void remove(Object primaryKey) throws java.rmi.RemoteException,<br />
RemoveException;<br />
EJBMetaData getEJBMetaData() throws RemoteException;<br />
HomeHandle getHomeHandle() throws RemoteException;<br />
}<br />
EJBHome possède deux métho<strong>des</strong> remove() pour supprimer les instances <strong>des</strong><br />
<strong>enterprise</strong> <strong>beans</strong>. La première méthode remove() identifie l’instance par un<br />
handle ; la deuxième par une clé primaire.<br />
Un handle, identificateur d’objet bean sérialisable, a la même durée de vie<br />
que l’objet <strong>enterprise</strong> bean qu’il référence. Pour un bean session, le handle<br />
n’existe que le temps de la session. Pour un bean entité, le handle peut<br />
persister et un client peut utiliser un handle sérialisé pour rétablir une<br />
référence à l’objet entité qu’il identifie.<br />
Un client se servira de la deuxième méthode remove() pour supprimer<br />
l’instance d’un bean entité en utilisant sa clé primaire.<br />
getEJBMetaData() renvoie l’interface EJBMetaData de l’objet <strong>enterprise</strong> bean.<br />
Cette interface permet au client d’obtenir les informations de<br />
métadonnées relatives au bean. Son objectif est d’être utilisée par les outils<br />
de développement qui construisent <strong>des</strong> applications utilisant <strong>des</strong><br />
<strong>enterprise</strong> <strong>beans</strong> déployés.<br />
Notez que l’interface EJBHome n’a pas de méthode pour créer ou localiser les<br />
instances d’un <strong>enterprise</strong> bean. A la place, vous devez ajouter ces<br />
métho<strong>des</strong> aux interfaces locales que vous développez pour vos <strong>beans</strong>.<br />
Comme les <strong>beans</strong> session et les <strong>beans</strong> entité ont <strong>des</strong> cycles de vie<br />
différents, les métho<strong>des</strong> définies dans leurs interfaces locales diffèrent.<br />
Création d’une interface locale pour un bean session<br />
Un bean session a presque toujours un seul client (sauf occasionnellement<br />
les <strong>beans</strong> session stateless). Quand un client crée un bean session, cette<br />
instance du bean session n’existe que pour l’utilisation de ce client.<br />
Pour créer une interface locale pour un bean session,<br />
• Déclarez une interface locale qui étend javax.ejb.EJBHome.<br />
• Ajoutez la signature d’une méthode create() pour chaque méthode<br />
ejbCreate() du bean, avec un nombre et <strong>des</strong> types d’arguments<br />
correspondant exactement.<br />
11-2 Guide du dé veloppeur Enterprise JavaBeans
Cré ation de l’ interface locale<br />
Quand vous utilisez l’expert Enterprise JavaBean de JBuilder, ce dernier<br />
crée une interface locale avec une méthode create() en même temps qu’il<br />
crée la classe de l’<strong>enterprise</strong> bean. Vous pouvez alors ajouter d’autres<br />
métho<strong>des</strong> create() à l’interface locale si vous ajoutez d’autres métho<strong>des</strong><br />
ejbCreate() à votre bean. Ou, si vous avez déjà la classe d’un <strong>enterprise</strong><br />
bean existant, utilisez l’expert Interfaces EJB de JBuilder pour créer une<br />
interface locale et une interface distante avec <strong>des</strong> signatures<br />
correspondant à celles de votre classe bean. Pour plus d’informations, voir<br />
Chapitre 3, “Création <strong>des</strong> <strong>enterprise</strong> <strong>beans</strong> avec JBuilder”.<br />
Si vous choisissez de commencer le développement de votre EJB en créant<br />
une interface distante, vous pouvez utiliser le Créateur de bean EJB pour<br />
générer le squelette de la classe du bean et l’interface locale. Pour plus<br />
d’informations sur le Créateur de bean EJB, voir “Génération de la classe<br />
du bean à partir d’une interface distante”, page 3-12.<br />
Métho<strong>des</strong> create() <strong>des</strong> <strong>beans</strong> session<br />
L’interface locale d’un bean session fonctionne comme une factory de<br />
bean session, car elle doit définir une ou plusieurs métho<strong>des</strong> create().<br />
Quand le client appelle create(), une nouvelle instance du bean est créée.<br />
En accord avec la spécification EJB, chaque méthode create() définie dans<br />
l’interface locale doit<br />
• Renvoyer le type d’interface distante du bean session.<br />
• S’appeler create().<br />
• Correspondre à une méthode ejbCreate() de la classe du bean session.<br />
Le nombre et les types d’arguments de chaque méthode create() doit<br />
concorder avec sa méthode ejbCreate() correspondante dans la classe<br />
du bean session.<br />
• Déclencher l’exception java.rmi.RemoteException.<br />
• Déclencher l’exception javax.ejb.CreateException.<br />
• Utiliser ses paramètres, s’il y en a, pour initialiser le nouvel objet bean<br />
session.<br />
Vous pouvez utiliser les experts EJB pour être sûr que ses règles seront<br />
suivies.<br />
L’exemple de code suivant montre deux métho<strong>des</strong> create() possibles de<br />
l’interface locale d’un bean session. Les parties en gras sont obligatoires :<br />
public interface AtmHome extends javax.ejb.EJBHome {<br />
Atm create()<br />
throws java.rmi.RemoteException, javax.ejb.CreateException;<br />
Atm create(Profile preferredProfile)<br />
throws java.rmi.RemoteException, javax.ejb.CreateException;<br />
}<br />
Cré ation <strong>des</strong> interfaces locales et distantes 11-3
Cré ation de l’ interface locale<br />
Création d’une interface locale pour un bean entité<br />
Un bean entité est <strong>des</strong>tiné à servir plusieurs clients. Quand un client crée<br />
une instance de bean entité, n’importe quel autre client peut également<br />
l’utiliser.<br />
Pour créer une interface locale pour un bean entité,<br />
• Déclarez une interface qui étend javax.ejb.EJBHome.<br />
• Ajoutez la signature d’une méthode create() pour chaque méthode<br />
ejbCreate() du bean, avec les signatures correspondant exactement.<br />
• Ajoutez la signature d’une méthode find pour chaque méthode find du<br />
bean, avec les signatures correspondant exactement.<br />
Quand vous utilisez l’expert Enterprise JavaBean ou le Modeleur Bean<br />
entité EJB de JBuilder, ce dernier crée une interface locale avec une<br />
méthode create() en même temps qu’il crée la classe de l’<strong>enterprise</strong> bean.<br />
Vous pouvez alors ajouter d’autres métho<strong>des</strong> create() à l’interface locale si<br />
vous ajoutez d’autres métho<strong>des</strong> ejbCreate() à votre bean. Ou, si vous avez<br />
déjà la classe d’un <strong>enterprise</strong> bean existant, utilisez l’expert Interfaces EJB<br />
de JBuilder pour créer une interface locale et une interface distante avec<br />
<strong>des</strong> signatures correspondant à celles de votre classe bean. Pour plus<br />
d’informations, voir Chapitre 3, “Création <strong>des</strong> <strong>enterprise</strong> <strong>beans</strong> avec<br />
JBuilder”.<br />
Si vous choisissez de commencer le développement de votre EJB en créant<br />
une interface distante, vous pouvez utiliser le Créateur de bean EJB pour<br />
générer le squelette de la classe du bean et l’interface locale. Pour plus<br />
d’informations sur le Créateur de bean EJB, voir “Génération de la classe<br />
du bean à partir d’une interface distante”, page 3-12.<br />
Métho<strong>des</strong> create() <strong>des</strong> <strong>beans</strong> entité<br />
Comme l’interface locale d’un bean session, l’interface locale d’un bean<br />
entité fonctionne comme une factory de bean entité, car elle doit définir<br />
une ou plusieurs métho<strong>des</strong> create(). En accord avec la spécification EJB,<br />
chaque méthode create() définie doit<br />
• Déclencher l’exception java.rmi.RemoteException.<br />
• Déclencher l’exception javax.ejb.CreateException.<br />
• Renvoyer le type d’interface distante du bean entité.<br />
• S’appeler create().<br />
• Correspondre à une méthode ejbCreate() de la classe du bean session.<br />
Le nombre et les types d’arguments de chaque méthode create() doit<br />
concorder avec sa méthode ejbCreate() correspondante dans la classe<br />
du bean session.<br />
11-4 Guide du dé veloppeur Enterprise JavaBeans
Cré ation de l’ interface locale<br />
• Doit inclure dans les exceptions de la clause throws toutes les<br />
exceptions déclenchées par les métho<strong>des</strong> ejbCreate() et ejbPostCreate()<br />
correspondantes de la classe du bean entité. En d’autres termes,<br />
l’ensemble <strong>des</strong> exceptions de la méthode create() doit être un<br />
sur-ensemble de la réunion <strong>des</strong> exceptions <strong>des</strong> deux métho<strong>des</strong><br />
ejbCreate() et ejbPostCreate(). Le type de renvoi de la méthode<br />
ejbCreate() est la classe clé primaire.<br />
• Utiliser ses paramètres, s’il y en a, pour initialiser le nouvel objet bean<br />
entité.<br />
Métho<strong>des</strong> find <strong>des</strong> <strong>beans</strong> entité<br />
Comme les <strong>beans</strong> entité ont généralement une longue durée de vie et<br />
peuvent être utilisés par plusieurs clients, une instance du bean entité<br />
existe probablement déjà lorsqu’une application client en a besoin. Dans<br />
ce cas, le client n’a pas besoin de créer une instance du bean entité, mais il<br />
a besoin de localiser celle qui existe. C’est pourquoi l’interface locale d’un<br />
bean entité définit une ou plusieurs métho<strong>des</strong> find.<br />
Les <strong>beans</strong> session n’ont pas besoin de méthode find puisqu’ils servent un<br />
seul client, l’application qui a créé le bean. Le client n’a pas besoin de<br />
trouver l’instance du bean session — il sait déjà où elle se trouve.<br />
L’interface locale d’un bean entité doit définir la méthode find par défaut,<br />
findByPrimaryKey(). Elle permet à un client de localiser un objet entité<br />
utilisant une clé primaire :<br />
findByPrimaryKey( key)<br />
throws java.rmi.RemoteException, FinderException;<br />
findByPrimaryKey() a un seul argument, la clé primaire. Son type de renvoi<br />
est l’interface distante du bean entité. Dans le <strong>des</strong>cripteur de déploiement<br />
du bean, vous indiquez au conteneur le type de la clé primaire.<br />
findByPrimaryKey() renvoie toujours un seul objet entité.<br />
Vous pouvez définir d’autres métho<strong>des</strong> find dans l’interface locale.<br />
Chaque méthode find doit avoir une implémentation correspondante<br />
dans la classe d’un bean entité dont la persistance est gérée par le bean.<br />
Pour la persistance gérée par le conteneur, c’est le conteneur qui<br />
implémente les métho<strong>des</strong> find. Chaque méthode find doit respecter les<br />
conventions suivantes :<br />
• Le type de renvoi doit être le type de l’interface distante, ou, pour les<br />
métho<strong>des</strong> find qui renvoient plus d’un objet entité, un type de<br />
collection dont le type de contenu est le type de l’interface distante. Les<br />
types corrects de collection Java sont java.util.Enumeration et<br />
java.util.Collection.<br />
• Le nom de la méthode find doit toujours commencer par le préfixe<br />
find. Le nom de la méthode find correspondante dans la classe du bean<br />
entité doit commencer par le préfixe ejbFind.<br />
Cré ation <strong>des</strong> interfaces locales et distantes 11-5
Cré ation de l’ interface distante<br />
• La méthode doit déclencher l’exception java.rmi.RemoteException.<br />
• La méthode doit déclencher l’exception javax.ejb.FinderException.<br />
• La clause throws de la méthode find de l’interface locale doit<br />
correspondre à la clause throws de la méthode ejbFind<br />
correspondante dans la classe du bean entité.<br />
L’exemple d’interface locale suivant contient deux métho<strong>des</strong> create() et<br />
deux métho<strong>des</strong> find. Les parties en gras sont obligatoires :<br />
Création de l’interface distante<br />
public interface AccountHome extends javax.ejb.EJBHome {<br />
}<br />
Account create(String accountID)<br />
throws java.rmi.RemoteException, javax.ejb.CreateException;<br />
Account create(String accountID, float initialBalance)<br />
throws java.rmi.RemoteException, javax.ejb.CreateException;<br />
Account findByPrimaryKey(String key)<br />
throws java.rmi.RemoteException, javax.ejb.FinderException;<br />
Account findBySocialSecurity(String socialSecurityNumber)<br />
throws java.rmi.RemoteException, javax.ejb.FinderException;<br />
L’interface distante que vous créez pour votre <strong>enterprise</strong> bean décrit les<br />
métho<strong>des</strong> métier qu’une application client peut appeler. Pendant que<br />
vous définissez les métho<strong>des</strong> dans l’interface distante, vous implémentez<br />
ces mêmes métho<strong>des</strong> dans la classe de l’<strong>enterprise</strong> bean. Les clients d’un<br />
<strong>enterprise</strong> bean n’ont jamais accès directement au bean. Ils accèdent à ses<br />
métho<strong>des</strong> via l’interface distante.<br />
Pour créer une interface distante,<br />
• Déclarez une interface qui étend javax.ejb.EJBObject.<br />
• Déclarez dans l’interface distante chaque méthode métier qu’une<br />
application client pourra appeler dans l’<strong>enterprise</strong> bean, dont les<br />
signatures correspondent exactement à celles de la classe du bean.<br />
Lorsque vous utilisez les experts EJB de JBuilder, JBuilder crée pour vous<br />
une interface distante qui étend EJBObject. Vous pouvez utiliser le<br />
concepteur de bean pour spécifier quelles métho<strong>des</strong> métier de votre bean<br />
apparaîtront dans l’interface distante.<br />
Chaque méthode définie dans l’interface distante doit suivre ces règles,<br />
qui sont les mêmes pour les <strong>beans</strong> session et pour les <strong>beans</strong> entité :<br />
• Elle doit être publique.<br />
11-6 Guide du dé veloppeur Enterprise JavaBeans
Cré ation de l’ interface distante<br />
• Elle doit déclencher l’exception java.rmi.RemoteException.<br />
• Sa valeur de renvoi et tous ses arguments doivent être <strong>des</strong> types vali<strong>des</strong><br />
pour RMI-IIOP.<br />
• Une méthode doit exister dans l’interface distante pour chaque<br />
méthode de la classe de l’<strong>enterprise</strong> bean que le client pourra appeler.<br />
Les métho<strong>des</strong> de l’interface distante et du bean lui-même doivent<br />
porter le même nom, avoir le même nombre d’arguments de mêmes<br />
types, avoir le même type de valeur de renvoi, et elles doivent<br />
déclencher les mêmes exceptions ou un sous-ensemble <strong>des</strong> exceptions<br />
<strong>des</strong> métho<strong>des</strong> de l’interface distante.<br />
L’exemple de code suivant montre l’interface distante appelée Atm d’un<br />
bean session ATM. L’interface distante Atm définit une méthode métier<br />
appelée transfer(). Les parties en gras sont obligatoires :<br />
public interface Atm extends javax.ejb.EJBObject{<br />
}<br />
public void transfer(String source, String target, float amount)<br />
throws java.rmi.RemoteException, InsufficientFundsException;<br />
La méthode transfer() déclarée dans l’interface Atm déclenche deux<br />
exceptions : l’exception obligatoire java.rmi.RemoteException et<br />
InsufficientFundsException, qui est une exception spécifique à une<br />
application.<br />
L’interface EJBObject<br />
L’interface distante étend l’interface javax.ejb.EJBObject. Voici le code<br />
source de EJBObject :<br />
package javax.ejb;<br />
public interface EJBObject extends java.rmi.Remote (<br />
public EJBHome getEJBHome() throws java.rmi.RemoteException;<br />
public Object getPrimaryKey() throws java.rmi.RemoteException;<br />
public void remove() throws java.rmi.RemoteException,<br />
java.rmi.RemoveException;<br />
public Handle getHandle() throws java.rmi.RemoteException;<br />
boolean isIdentical (EJBObject other) throws java.rmi.RemoteException;<br />
}<br />
La méthode getEJBHome() permet à une application d’obtenir l’interface<br />
locale du bean. Si le bean est un bean entité, la méthode getPrimaryKey()<br />
renvoie la clé primaire du bean. La méthode remove() supprime<br />
l’<strong>enterprise</strong> bean. getHandle() renvoie un handle persistant à l’instance du<br />
bean. Utilisez isIdentical() pour comparer deux <strong>enterprise</strong> <strong>beans</strong>.<br />
Le conteneur EJB crée une interface EJBObject pour l’<strong>enterprise</strong> bean.<br />
Comme l’interface distante étend l’interface EJBObject, l’interface EJBObject<br />
créée par le conteneur inclut les implémentations de toutes les métho<strong>des</strong><br />
Cré ation <strong>des</strong> interfaces locales et distantes 11-7
Cré ation de l’ interface distante<br />
de l’interface EJBObject ainsi que les métho<strong>des</strong> métier que vous définissez<br />
dans l’interface distante. L’interface EJBObject instanciée est visible sur le<br />
réseau et agit comme un proxy pour le bean. Elle possède un stub et un<br />
squelette. Le bean lui-même n’est pas visible sur le réseau.<br />
11-8 Guide du dé veloppeur Enterprise JavaBeans
12<br />
Chapitre<br />
Chapitre12Développement <strong>des</strong> clients<br />
<strong>des</strong> <strong>enterprise</strong> <strong>beans</strong><br />
Le client d’un <strong>enterprise</strong> bean est une application — application<br />
autonome, servlet ou applet — ou un autre <strong>enterprise</strong> bean. Dans tous les<br />
cas, le client doit effectuer les opérations suivantes pour utiliser un<br />
<strong>enterprise</strong> bean :<br />
• Localiser l’interface locale du bean. La spécification EJB précise que le<br />
client doit utiliser l’API JNDI (Java Naming and Directory Interface)<br />
pour localiser les interfaces locales.<br />
• Obtenir la référence à l’interface distante d’un objet <strong>enterprise</strong> bean.<br />
Cela implique l’utilisation de métho<strong>des</strong> définies dans l’interface locale<br />
du bean. Vous pouvez soit créer un bean session, soit créer ou trouver<br />
un bean entité.<br />
• Appeler une ou plusieurs métho<strong>des</strong> définies par l’<strong>enterprise</strong> bean. Un<br />
client ne peut pas appeler directement les métho<strong>des</strong> définies par<br />
l’<strong>enterprise</strong> bean. A la place, le client appelle les métho<strong>des</strong> de l’interface<br />
distante de l’objet <strong>enterprise</strong> bean. Les métho<strong>des</strong> définies dans<br />
l’interface distante sont celles que l’<strong>enterprise</strong> bean a exposées aux<br />
clients.<br />
Les sections suivantes décrivent l’application client SortClient.java, qui<br />
appelle le bean session exemple SortBean. SortBean est un bean session<br />
stateless qui implémente un algorithme de fusion et de tri. Voici le code de<br />
SortClient :<br />
// SortClient.java<br />
...<br />
public class SortClient {<br />
...<br />
D é veloppement <strong>des</strong> clients <strong>des</strong> <strong>enterprise</strong> <strong>beans</strong> 12-1
Localisation de l’ interface locale<br />
Localisation de l’interface locale<br />
Obtenir l’interface distante<br />
public static void main(String[] args) throws Exception {<br />
javax.naming.Context context;<br />
{ // obtient un contexte JNDI en utilisant le service d’annuaire<br />
context = new javax.naming.InitialContext();<br />
}<br />
Object objref = context.lookup("sort");<br />
SortHome home = (SortHome) javax.rmi.PortableRemoteObject.narrow(objref,<br />
SortHome.class);<br />
Sort sort = home.create();<br />
... // effectue le travail de tri et de fusion<br />
sort.remove();<br />
}<br />
}<br />
SortClient importe les classes JNDI requises et les interfaces locale et<br />
distante SortBean. Le client utilise l’API JNDI pour localiser l’interface<br />
locale d’un <strong>enterprise</strong> bean. D’abord, le client doit obtenir un contexte<br />
d’annuaire initial JNDI. Le code de SortClient instancie un nouvel objet<br />
javax.naming.Context, qui est appelé InitialContext. Le client utilise alors la<br />
méthode lookup() du contexte pour renvoyer ce nom à une interface locale.<br />
La méthode contextuelle lookup() renvoie un objet de type<br />
java.lang.Object. Votre code doit transtyper l’objet renvoyé dans le type<br />
attendu. Le code SortClient montre une partie du code client de l’exemple<br />
de tri. La routine main() commence par utiliser le service d’annuaire JNDI<br />
et la méthode lookup() de son contexte pour localiser l’interface locale.<br />
Vous passez le nom de l’interface distante, qui est dans ce cas sort, à la<br />
méthode context.lookup(). Notez que le programme transtype<br />
éventuellement les résultats de la méthode context.lookup() en SortHome,<br />
qui est le type de l’interface locale.<br />
Une fois que vous avez l’interface locale d’un <strong>enterprise</strong> bean, il vous faut<br />
une référence à l’interface distante du bean. Pour cela, utilisez les<br />
métho<strong>des</strong> create ou find de l’interface locale. La méthode à utiliser dépend<br />
du type d’<strong>enterprise</strong> bean et <strong>des</strong> métho<strong>des</strong> que le fournisseur du bean a<br />
défini dans l’interface locale.<br />
Beans session<br />
Si l’<strong>enterprise</strong> bean est un bean session, le client utilise une méthode create<br />
pour renvoyer l’interface distante. Les <strong>beans</strong> session n’ont pas de méthode<br />
find. Si le bean session est stateless, il aura juste une méthode create(), et il<br />
12-2 Guide du dé veloppeur Enterprise JavaBeans
Obtenir l’ interface distante<br />
sera donc le seul que le client devra appeler pour obtenir l’interface<br />
distante. La méthode create() par défaut n’a pas de paramètre. Donc, pour<br />
l’exemple de code SortClient, l’appel pour obtenir l’interface distante<br />
ressemble à ceci :<br />
Sort sort = home.create();<br />
L’exemple du chariot traité au Chapitre 9, “Développement<br />
<strong>des</strong> <strong>beans</strong> session”, d’autre part, utilise un bean session stateful et son<br />
interface locale, CartHome, implémente plusieurs métho<strong>des</strong> create(). Une de<br />
ses métho<strong>des</strong> create() prend trois paramètres, qui ensemble identifient<br />
l’acheteur du contenu du chariot, et renvoie une référence à l’interface<br />
distante Cart. CartClient définit les valeurs <strong>des</strong> trois paramètres —<br />
cardHolderName, creditCardNumber, et expirationDate — puis appelle la<br />
méthode create(). Voici le code :<br />
Cart cart;<br />
{<br />
String cardHolderName = "Jack B. Quick";<br />
String creditCardNumber = "1234-5678-9012-3456";<br />
Date expirationDate = new GregorianCalendar(2001, Calendar.JULY,<br />
1).getTime();<br />
cart = home.create(cardHolderName, creditCardNumber, expirationDate);<br />
}<br />
Beans entité<br />
S’il s’agit d’un bean entité, utilisez soit une méthode create, soit une<br />
méthode find pour obtenir l’interface distante. Comme un objet entité<br />
représente <strong>des</strong> données sous-jacentes stockées dans une base de données,<br />
et que ces données sont persistantes, les <strong>beans</strong> entité ont généralement une<br />
longue durée de vie. Donc, le client a la plupart du temps seulement<br />
besoin de trouver le bean entité qui représente les données plutôt que de<br />
créer un nouvel objet entité, qui voudrait créer et stocker de nouvelles<br />
données dans la base sous-jacente.<br />
Un client utilise une opération de recherche (find) pour localiser un objet<br />
entité existant, comme une ligne spécifique à l’intérieur d’une table dans<br />
une base de données relationnelle. C’est-à-dire que les opérations de<br />
recherche localisent les entités de données qui ont été préalablement<br />
insérées dans un stockage de données. Les données peuvent avoir été<br />
ajoutées au datastore par un bean entité ou avoir été ajoutées à l’extérieur<br />
du contexte EJB, par exemple directement depuis un SGBD (système de<br />
gestion de bases de données). Ou, dans le cas de systèmes existants, les<br />
données peuvent avoir existé avant l’installation du conteneur EJB.<br />
Un client utilise la méthode create() d’un objet bean entité pour créer une<br />
nouvelle entité <strong>des</strong> données qui sera stockée dans la base de données<br />
sous-jacente. La méthode create() d’un bean entité insère l’état entité dans<br />
D é veloppement <strong>des</strong> clients <strong>des</strong> <strong>enterprise</strong> <strong>beans</strong> 12-3
Obtenir l’ interface distante<br />
la base de données, initialisant les variables de l’entité avec les valeurs <strong>des</strong><br />
paramètres de la méthode create().<br />
Chaque instance d’un bean entité doit avoir une clé primaire qui l’identifie<br />
de manière unique. L’instance d’un bean entité peut aussi avoir <strong>des</strong> clés<br />
secondaires qui peuvent être utilisées pour localiser un objet entité<br />
particulier.<br />
Les métho<strong>des</strong> find et la classe de la clé primaire<br />
La méthode find par défaut d’un bean entité est findByPrimaryKey(), qui<br />
localise l’objet entité en utilisant la valeur de sa clé primaire. Voici sa<br />
signature :<br />
findByPrimaryKey( primaryKey)<br />
Chaque bean entité doit implémenter une méthode findByPrimaryKey(). Le<br />
paramètre primaryKey est la classe d’une clé primaire distincte qui est<br />
définie dans le <strong>des</strong>cripteur de déploiement. <key type> est le type de<br />
la clé primaire et ce doit être un type valide pour RMI-IIOP. La classe de la<br />
clé primaire peut être n’importe quelle classe, comme une classe Java ou<br />
une classe que vous avez vous-même écrite.<br />
Par exemple, supposons que vous ayez un bean entité Account pour lequel<br />
vous avez défini la classe de clé primaire AccountPK. AccountPK, de type<br />
String, contient l’identificateur du bean Account. Pour obtenir une référence<br />
à une instance spécifique du bean entité Account, définissez AccountPK par<br />
l’identificateur de compte et appelez la méthode findByPrimaryKey()<br />
comme indiqué ici :<br />
AccountPK accountPK = new AccountPK("1234-56-789");<br />
Account source = accountHome.findByPrimaryKey(accountPK);<br />
Les fournisseurs de <strong>beans</strong> peuvent définir d’autres métho<strong>des</strong> find que les<br />
clients puissent utiliser.<br />
Métho<strong>des</strong> create et remove<br />
Un client peut également créer <strong>des</strong> <strong>beans</strong> entité en utilisant <strong>des</strong> métho<strong>des</strong><br />
create définies dans l’interface locale. Quand un client invoque une<br />
méthode create pour un bean entité, la nouvelle instance de l’objet entité<br />
est enregistré dans le datastore. Le nouvel objet entité a toujours une<br />
valeur de clé primaire qui est son identificateur. Son état peut être<br />
initialisé par les valeurs transmises comme paramètres à la méthode<br />
create.<br />
N’oubliez pas qu’un bean entité existe aussi longtemps qu’il y a <strong>des</strong><br />
données dans la base de données. La vie du bean entité ne se limite pas à<br />
la session du client. Le bean entité peut être supprimé par l’appel d’une<br />
<strong>des</strong> métho<strong>des</strong> remove du bean. Ces métho<strong>des</strong> suppriment le bean et la<br />
représentation sous-jacente <strong>des</strong> données entité de la base de données. Il est<br />
également possible de supprimer directement un objet entité, par exemple<br />
12-4 Guide du dé veloppeur Enterprise JavaBeans
Appel <strong>des</strong> métho<strong>des</strong><br />
Appel <strong>des</strong> mé tho<strong>des</strong><br />
en supprimant un enregistrement de la base de données par le biais du<br />
SGBD ou d’une application existante.<br />
Une fois que le client détient une référence à l’interface distante du bean, il<br />
peut invoquer les métho<strong>des</strong> définies pour le bean dans l’interface distante.<br />
Le client est particulièrement intéressé par les métho<strong>des</strong> incorporant la<br />
logique métier du bean.<br />
Par exemple, le code suivant est extrait d’un client qui accède au bean<br />
session de l’exemple du chariot (cart). Le code montré ici commence au<br />
point où il a créé une nouvelle instance du bean session pour un détenteur<br />
de chariot et récupéré une référence Cart à l’interface distante. Le client est<br />
prêt à invoquer les métho<strong>des</strong> du bean :<br />
...<br />
Cart cart;<br />
{<br />
...<br />
// obtient une référence à l’interface distante du bean<br />
cart = home.create(cardHolderName, creditCardNumber, expirationDate);<br />
}<br />
// crée un nouvel objet livre<br />
Book knuthBook = new Book("The Art of Computer Programming", 49.95f);<br />
// ajoute le nouvel article livre au chariot<br />
cart.addItem(knuthBook);<br />
...<br />
// liste les articles actuellement dans le chariot<br />
summarize(cart);<br />
cart.removeItem(knuthBook);<br />
...<br />
Le client crée d’abord un nouvel objet livre, en définissant ses paramètres<br />
title (titre) et price (prix). Ensuite, il invoque la méthode métier addItem()<br />
de l’<strong>enterprise</strong> bean pour ajouter l’objet livre à un chariot. Le bean session<br />
Cart définit la méthode addItem() et l’interface distante Cart la rend<br />
publique. Le client ajoute d’autres articles (qui ne figurent pas ici), puis<br />
appelle sa propre méthode summarize() pour faire la liste <strong>des</strong> articles se<br />
trouvant dans le chariot. Enfin, la méthode remove() supprime l’instance<br />
du bean. Notez qu’un client appelle les métho<strong>des</strong> d’un <strong>enterprise</strong> bean de<br />
la même façon qu’il appelle n’importe quelle méthode, telle sa propre<br />
méthode summarize().<br />
D é veloppement <strong>des</strong> clients <strong>des</strong> <strong>enterprise</strong> <strong>beans</strong> 12-5
Suppression <strong>des</strong> instances de <strong>beans</strong><br />
Suppression <strong>des</strong> instances de <strong>beans</strong><br />
La méthode remove() opère différemment pour les <strong>beans</strong> session et pour<br />
les <strong>beans</strong> entité. Comme un objet session existe pour un seul client et n’est<br />
pas permanent, le client d’un bean session doit appeler la méthode<br />
remove() quand il en a terminé avec l’objet session. Deux métho<strong>des</strong><br />
remove() s’offrent à lui : le client peut supprimer l’objet session avec la<br />
méthode javax.ejb.EJBObject.remove() ou le handle de session avec la<br />
méthode javax.ejb.EJBHome.remove(Handle handle). Pour plus<br />
d’informations, voir “Référencement d’un bean avec son handle”,<br />
page 12-6.<br />
Bien qu’il ne soit pas obligatoire qu’un client supprime un objet session,<br />
c’est une bonne habitude à prendre. Si un client ne supprime pas un objet<br />
bean session stateful, le conteneur supprimera éventuellement l’objet<br />
après un certain temps, spécifié par un délai d’attente. La valeur du délai<br />
d’attente est une propriété du déploiement. Un client peut cependant<br />
garder un handle sur la session pour y faire référence plus tard.<br />
Les clients <strong>des</strong> <strong>beans</strong> entité n’ont pas ces problèmes parce que les <strong>beans</strong><br />
entité ne leurs sont associés que pour la durée d’une transaction et que le<br />
conteneur prend en charge leur durée de vie, y compris leur activation et<br />
leur désactivation. Le client d’un bean entité n’appelle la méthode remove()<br />
du bean que si l’objet entité doit être supprimé de la base de données<br />
sous-jacente.<br />
Référencement d’un bean avec son handle<br />
Un handle est une autre façon de référencer un <strong>enterprise</strong> bean. Un handle<br />
est une référence sérialisable à un bean. Vous pouvez obtenir un handle<br />
depuis l’interface distante du bean. Une fois que vous avez le handle, vous<br />
pouvez l’écrire dans un fichier (ou dans tout autre stockage persistant).<br />
Plus tard, vous pourrez récupérer le handle depuis son stockage et<br />
l’utiliser pour établir à nouveau une référence à l’<strong>enterprise</strong> bean.<br />
Cependant, vous ne pouvez utiliser le handle de l’interface distante que<br />
pour recréer la référence au bean. Vous ne pouvez pas l’utiliser pour<br />
recréer le bean lui-même. Si un autre processus a supprimé le bean ou si le<br />
système a supprimé l’instance du bean, alors une exception est déclenchée<br />
au moment où le client tente de rétablir la référence à ce bean.<br />
Quand vous n’êtes pas sûr que l’instance du bean existera toujours, plutôt<br />
que d’utiliser un handle vers l’interface distante, vous pouvez stocker le<br />
handle local du bean et recréer l’objet bean plus tard en invoquant la<br />
méthode create ou la méthode find du bean.<br />
Une fois que le client a créé une instance du bean, il peut utiliser la<br />
méthode getHandle() pour obtenir un handle sur cette instance. Une fois<br />
12-6 Guide du dé veloppeur Enterprise JavaBeans
Gestion <strong>des</strong> transactions<br />
Gestion <strong>des</strong> transactions<br />
qu’il a le handle, il peut l’écrire dans un fichier sérialisé. Plus tard, le<br />
programme client peut lire le fichier sérialisé et transtyper l’objet lu en<br />
type Handle. Ensuite, il appelle la méthode getEJBObject() sur le handle<br />
pour obtenir la référence au bean, en réduisant les résultats de<br />
getEJBObject() en un type valide pour le bean.<br />
Par exemple, le programme CartClient pourrait faire ceci pour utiliser un<br />
handle sur le bean session Cart :<br />
import java.io;<br />
import javax.ejb.Handle;<br />
...<br />
Cart cart;<br />
...<br />
cart = home.create(cardHolderName, creditCardNumber, expirationDate);<br />
// appelle getHandle() sur l’objet chariot pour obtenir son handle<br />
cartHandle = cart.getHandle();<br />
// écrit le handle dans un fichier sérialisable<br />
FileOutputStream f = new FileOutputStream ("carthandle.ser");<br />
ObjectOutputStream o = new ObjectOutputStream(f);<br />
o.writeObject(myHandle);<br />
o.flush();<br />
o.close();<br />
...<br />
// lit ultérieurement le handle dans le fichier<br />
FileInputStream fi = new FileInputStream ("carthandle.ser");<br />
ObjectInputStream oi = new ObjectInputStream(fi);<br />
//lit l’objet dans le fichier et change son type en Handle<br />
cartHandle = (Handle)oi.readObject();<br />
oi.close();<br />
...<br />
// Utilise le handle pour faire référence à l’instance du bean<br />
Cart cart = (Cart)<br />
javax.rmi.PortableRemoteObject.narrow(cartHandle.getEJBObject(),<br />
Cart class);<br />
...<br />
Quand il en a terminé avec le handle du bean session, le client peut le<br />
supprimer en appelant la méthode javax.ejb.EJBHome.remove(Handle<br />
handle).<br />
Un programme client peut gérer ses propres transactions au lieu de laisser<br />
l’<strong>enterprise</strong> bean (ou son conteneur) le faire. Un client qui gère ses propres<br />
transactions le fait exactement de la même manière qu’un bean session.<br />
D é veloppement <strong>des</strong> clients <strong>des</strong> <strong>enterprise</strong> <strong>beans</strong> 12-7
D é couvrir les informations sur le bean<br />
Quand un client gère ses propres transactions, il est responsable <strong>des</strong><br />
limites de la transaction. C’est-à-dire qu’il doit explicitement démarrer la<br />
transaction et terminer (valider ou annuler) la transaction.<br />
Un client utilise l’interface javax.transaction.UserTransaction pour gérer ses<br />
propres transactions. Il doit d’abord obtenir un référence à l’interface<br />
UserTransaction, en utilisant JNDI pour cela. Une fois qu’il a le contexte<br />
UserTransaction, le client utilise la méthode UserTransaction.begin() pour<br />
démarrer la transaction, suivie plus tard de la méthode<br />
UserTransaction.commit() pour valider et terminer la transaction (ou de<br />
UserTransaction.rollback() pour annuler et terminer la transaction). Entre<br />
les deux, le client accède aux objets EJB, etc.<br />
Le code suivant montre comment un client pourrait gérer ses propres<br />
transactions ; le code spécifique à la gestion <strong>des</strong> transactions par le client<br />
est en gras :<br />
...<br />
import javax.naming.InitialContext;<br />
import javax.transaction.UserTransaction;<br />
...<br />
public class clientTransaction {<br />
public static void main (String[] argv) {<br />
InitialContext initContext = new InitialContext();<br />
UserTransaction ut = null;<br />
ut = (UserTransaction)initContext.lookup("java:comp/UserTransaction");<br />
// démarre une transaction<br />
ut.begin();<br />
// fait un travail de transaction<br />
...<br />
// valide ou annule la transaction<br />
ut.commit(); // ou ut.rollback();<br />
...<br />
}<br />
}<br />
Pour plus d’informations sur les transactions, voir Chapitre 13, “Gestion<br />
<strong>des</strong> transactions”.<br />
Découvrir les informations sur le bean<br />
Les informations sur un <strong>enterprise</strong> bean sont <strong>des</strong> métadonnées. Un client<br />
peut obtenir <strong>des</strong> métadonnées sur un bean en utilisant la méthode<br />
getMetaData() de l’interface locale de l’<strong>enterprise</strong> bean.<br />
La méthode getMetaData() est le plus souvent utilisée dans les<br />
environnements de développement et chez les constructeurs d’outils qui<br />
ont besoin de découvrir les informations sur un <strong>enterprise</strong> bean, par<br />
12-8 Guide du dé veloppeur Enterprise JavaBeans
Cré ation d’ un client avec JBuilder<br />
exemple pour lier ensemble <strong>des</strong> <strong>beans</strong> qui ont déjà été installés. Les scripts<br />
<strong>des</strong> clients peuvent également vouloir obtenir les métadonnées relatives<br />
au bean.<br />
Une fois que le client a récupéré la référence à l’interface locale, il peut<br />
appeler sa méthode getEJBMetaData(). Ensuite, le client peut appeler les<br />
métho<strong>des</strong> de l’interface EJBMetaData pour extraire <strong>des</strong> informations<br />
comme :<br />
• L’interface locale EJBHome du bean, en utilisant la méthode<br />
EJBMetaData.getEJBHome().<br />
• L’objet classe de l’interface locale du bean, y compris ses interfaces,<br />
classes, champs et métho<strong>des</strong>, en utilisant la méthode<br />
EJBMetaData.getHomeInterfaceClass().<br />
• L’objet classe de l’interface distante du bean, y compris toutes les<br />
informations de classe, en utilisant la méthode<br />
EJBMetaData.getRemoteInterfaceClass().<br />
• L’objet classe de la clé primaire du bean, en utilisant la méthode<br />
EJBMetaData.getPrimaryKeyClass().<br />
• Si le bean est un bean session ou un bean entité, en utilisant la méthode<br />
EJBMetaData.isSession(). La méthode renvoie true s’il s’agit d’un bean<br />
session.<br />
• Si le bean session est stateless ou stateful, en utilisant la méthode<br />
EJBMetaData.isStatelessSession(). La méthode renvoie true si le bean est<br />
stateless.<br />
Voici l’interface EJBMetaData dans sa totalité :<br />
package javax.ejb;<br />
public interface EJBMetaData {<br />
EJBHome getEJBHome();<br />
Class getHome InterfaceClass();<br />
Class getRemoteInterfaceClass();<br />
Class getPrimaryKeyClass();<br />
boolean isSession();<br />
boolean isStatelessSession();<br />
}<br />
Création d’un client avec JBuilder<br />
Vous pouvez utiliser JBuilder pour commencer la création de votre client<br />
dans les meilleures conditions. JBuilder offre un expert Client Test EJB<br />
pour créer une application client simple permettant de tester votre<br />
<strong>enterprise</strong> bean. Vous pouvez également l’utiliser pour commencer à<br />
construire votre application client réelle. Indiquez à l’expert le nom de<br />
l’un de vos <strong>enterprise</strong> <strong>beans</strong> auquel le client doit accéder, et l’expert écrira<br />
D é veloppement <strong>des</strong> clients <strong>des</strong> <strong>enterprise</strong> <strong>beans</strong> 12-9
Cré ation d’ un client avec JBuilder<br />
le code permettant d’obtenir un contexte d’annuaire, localisera l’interface<br />
locale du bean et donnera une référence sécurisée à son interface distante.<br />
Votre client est susceptible d’appeler plusieurs <strong>beans</strong>, c’est pourquoi vous<br />
devez effectuer ces étapes dans votre code client pour les autres <strong>beans</strong><br />
qu’il devra accéder. Et vous ajouterez vous-même à votre code client les<br />
appels permettant d’accéder à la logique métier <strong>des</strong> <strong>enterprise</strong> <strong>beans</strong>.<br />
Pour plus d’informations sur l’utilisation de l’expert Client test EJB, voir<br />
“Création d’un client de test”, page 5-1.<br />
12-10 Guide du dé veloppeur Enterprise JavaBeans
13<br />
Chapitre<br />
Chapitre13Gestion <strong>des</strong><br />
transactions<br />
Vous pouvez bénéficier du développement d’applications sur <strong>des</strong><br />
plates-formes comme Java 2 Enterprise Edition (J2EE) qui supportent les<br />
transactions. Un système basé sur les transactions facilite le<br />
développement <strong>des</strong> applications car il vous libère, vous le développeur,<br />
<strong>des</strong> questions complexes comme la récupération après panne et la<br />
programmation multi-utilisateur. Les transactions ne sont pas limitées à<br />
une seule base de données ni à un seul site. Les transactions distribuées<br />
peuvent mettre à jour simultanément plusieurs bases de données sur<br />
plusieurs sites.<br />
Un développeur divise habituellement la totalité du travail d’une<br />
application en une série d’unités. Chaque unité de travail est une<br />
transaction distincte. Au fil de la progression de l’application, le système<br />
sous-jacent garantit que chaque unité de travail, chaque transaction, se<br />
termine complètement sans l’interférence d’un autre processus. Si ce n’est<br />
pas le cas, le système annule la transaction et renverse totalement le travail<br />
qu’a effectué la transaction de sorte que l’application se retrouve dans<br />
l’état précédant cette transaction.<br />
Caractéristiques <strong>des</strong> transactions<br />
Habituellement, on appelle transactions les opérations d’accès à une base<br />
de données. Tous les accès à la base de données se produisent dans le<br />
contexte d’une transaction. Toutes les transactions partagent les<br />
caractéristiques suivantes, connues sous l’abréviation ACID :<br />
• Atomicité<br />
Généralement, une transaction est constituée de plusieurs opérations<br />
simples. L’atomicité exige que toutes les opérations d’une transaction<br />
réussissent pour que la transaction soit considérée comme terminée. Si<br />
Gestion <strong>des</strong> transactions 13-1
Support <strong>des</strong> transactions dans le conteneur<br />
toutes les opérations d’une transaction ne peuvent être effectuées, alors<br />
aucune d’entre elles ne pourra l’être.<br />
• Cohérence<br />
Il s’agit de la cohérence de la base de données. Une transaction doit<br />
faire passer la base de données d’un état cohérent à un autre et doit<br />
préserver l’intégrité sémantique et physique de la base.<br />
• Isolation<br />
L’isolation exige que chaque transaction apparaisse comme la seule<br />
opération manipulant à un certain moment les données de la base. Bien<br />
que d’autres transactions puissent être exécutées simultanément, une<br />
transaction ne doit pas voir ces manipulations tant qu’elles ne sont pas<br />
complètement terminées et que le travail n’est pas validé. En raison de<br />
l’interdépendance <strong>des</strong> mises à jour, une transaction pourrait avoir une<br />
vue incohérente <strong>des</strong> données et voir juste un sous-ensemble <strong>des</strong> mises à<br />
jour d’une autre transaction. L’isolation protège de ce type<br />
d’incohérence.<br />
L’isolation est liée à la simultanéité <strong>des</strong> transactions. Il existe trois<br />
niveaux d’isolation. Le plus haut niveau d’isolation limite l’étendue de<br />
la simultanéité. Le plus haut niveau d’isolation se produit lorsque<br />
toutes les transactions peuvent être sérialisées. C’est-à-dire, que le<br />
contenu de la base de données apparaît comme si chaque transaction<br />
s’exécutait seule jusqu’à la fin avant que ne commence la transaction<br />
suivante. Certaines applications, cependant, peuvent supporter un<br />
niveau d’isolation réduit afin d’autoriser un plus haut degré de<br />
simultanéité. Généralement, ces applications exécutent un grand<br />
nombre de transactions simultanées, même si ces transactions lisent <strong>des</strong><br />
données qui peuvent être partiellement mises à jour et peut-être<br />
incohérentes.<br />
• Durabilité<br />
La durabilité signifie que les mises à jour effectuées par <strong>des</strong> transactions<br />
validées persistent même en cas de panne. La durabilité garantit que les<br />
mises à jour validées resteront dans la base de données malgré les<br />
pannes qui pourraient survenir après la validation, et que la base de<br />
données pourra être récupérée après une panne du système ou d’un<br />
support.<br />
Support <strong>des</strong> transactions dans le conteneur<br />
Un conteneur EJB supporte les transactions simples, mais pas les<br />
transactions imbriquées. Il propage également les transactions<br />
implicitement. Cela signifie que vous n’avez pas besoin de transmettre<br />
explicitement le contexte de la transaction par le biais d’un paramètre, car<br />
le conteneur s’en charge pour garantir la transparence au client.<br />
13-2 Guide du dé veloppeur Enterprise JavaBeans
Enterprise <strong>beans</strong> et transactions<br />
N’oubliez pas que les JSP et les servlets, bien qu’ils puissent agir en tant<br />
que clients, sont conçus pour être <strong>des</strong> composants transactionnels. Utilisez<br />
<strong>des</strong> <strong>enterprise</strong> <strong>beans</strong> pour effectuer le travail transactionnel. Quand vous<br />
invoquez un <strong>enterprise</strong> bean pour effectuer le travail transactionnel, le<br />
bean et le conteneur configurent la transaction correctement.<br />
Enterprise <strong>beans</strong> et transactions<br />
Les <strong>enterprise</strong> <strong>beans</strong> et le conteneur EJB simplifient considérablement la<br />
gestion <strong>des</strong> transactions. Grâce aux <strong>enterprise</strong> <strong>beans</strong>, une application peut<br />
mettre à jour <strong>des</strong> données dans plusieurs bases de données en une seule<br />
transaction, et ces bases de données peuvent résider sur plusieurs<br />
serveurs EJB.<br />
Traditionnellement, une application responsable de la gestion <strong>des</strong><br />
transactions doit effectuer les tâches suivantes :<br />
• Créer l’objet transaction<br />
• Démarrer explicitement la transaction<br />
• Garder la trace du contexte de la transaction<br />
• Valider la transaction quand toutes les mises à jour sont faites<br />
Une telle application exigerait un développeur très doué et <strong>des</strong> erreurs<br />
pourraient s’y glisser facilement.<br />
Si vous utilisez <strong>des</strong> <strong>enterprise</strong> <strong>beans</strong>, le conteneur gère pour vous la<br />
plupart, sinon tous, <strong>des</strong> aspects de la transaction. Il commence et termine<br />
la transaction et maintient son contexte tout au long de la vie de l’objet<br />
transaction. Vos responsabilités sont considérablement réduites, en<br />
particulier pour les transactions dans <strong>des</strong> environnements distribués.<br />
Les attributs de transaction d’un <strong>enterprise</strong> bean sont déclarés au moment<br />
du déploiement. Ces attributs de transaction indiquent si le conteneur<br />
gère les transactions du bean ou si le bean gère ses propres transactions, et<br />
jusqu’où.<br />
Comparaison entre les transactions gérées par le bean et<br />
celles gérées par le conteneur<br />
Lorsqu’un <strong>enterprise</strong> bean effectue par programme sa propre démarcation<br />
<strong>des</strong> transactions au sein de ses métho<strong>des</strong> métier, on parle de transactions<br />
gérées par le bean. (Démarquer une transaction signifie indiquer où une<br />
transaction commence et où elle se termine.) Lorsqu’un bean délègue<br />
toutes les démarcations de transactions à son conteneur EJB, le conteneur<br />
effectue la démarcation <strong>des</strong> transactions selon les instructions de<br />
déploiement de l’assembleur de l’application. On parle ici de transactions<br />
gérées par le conteneur.<br />
Gestion <strong>des</strong> transactions 13-3
Enterprise <strong>beans</strong> et transactions<br />
Les <strong>beans</strong> session stateful et stateless peuvent tous deux utiliser l’un ou<br />
l’autre type de transaction. Cependant, un bean ne peut pas utiliser les<br />
deux types de gestion <strong>des</strong> transactions en même temps. Le fournisseur du<br />
bean décide quel type le bean session utilisera. Un bean entité ne peut<br />
utiliser que les transactions gérées par le conteneur<br />
Vous pourriez souhaiter qu’un bean gère ses propres transactions si vous<br />
vouliez démarrer une transaction en tant que partie d’une opération et la<br />
terminer en tant que partie d’une autre opération. Cependant, vous<br />
rencontreriez <strong>des</strong> problèmes si une opération appelait la méthode qui<br />
démarre la transaction et qu’aucune opération n’appelait la méthode qui<br />
la termine.<br />
Chaque fois que c’est possible, écrivez <strong>des</strong> <strong>enterprise</strong> <strong>beans</strong> qui utilisent<br />
les transactions gérées par le conteneur. Ils exigent moins de travail de<br />
votre part et amènent moins d’erreurs. De plus, il est plus facile de<br />
personnaliser un bean utilisant les transactions gérées par le conteneur et<br />
de s’en servir pour composer d’autre <strong>beans</strong>.<br />
Attributs <strong>des</strong> transactions<br />
Les <strong>enterprise</strong> <strong>beans</strong> qui utilisent <strong>des</strong> transactions gérées par le conteneur<br />
ont <strong>des</strong> attributs de transaction associés à chaque méthode du bean ou au<br />
bean lui-même. La valeur d’un attribut indique au conteneur comment il<br />
doit gérer les transactions concernant le bean. Il existe six attributs de<br />
transaction différents que l’assembleur de l’application, ou celui qui la<br />
déploie, peut associer à chacune <strong>des</strong> métho<strong>des</strong> du bean :<br />
• Required<br />
Garantit que le travail effectué par la méthode associée se trouve dans<br />
un contexte de transaction globale. Si l’appelant a déjà un contexte de<br />
transaction, le conteneur utilise le même contexte. Si l’appelant n’a pas<br />
de contexte de transaction, le conteneur commence automatiquement<br />
une nouvelle transaction. L’utilisation de cet attribut permet de<br />
composer plusieurs <strong>beans</strong> et de coordonner facilement le travail de tous<br />
ces <strong>beans</strong> en utilisant la même transaction globale.<br />
• RequiresNew<br />
Utilisé quand vous ne voulez pas la méthode associée à une transaction<br />
existante. Il garantit que le conteneur commence toujours une nouvelle<br />
transaction.<br />
• Supports<br />
Permet à la méthode d’éviter d’utiliser une transaction globale.<br />
N’utilisez cet attribut que lorsque la méthode d’un bean accède à une<br />
seule ressource de transaction, ou à aucune, et si la méthode n’invoque<br />
pas un autre <strong>enterprise</strong> bean. Comme cet attribut épargne le coût <strong>des</strong><br />
transactions globales, son utilisation optimise votre bean. Si cet attribut<br />
13-4 Guide du dé veloppeur Enterprise JavaBeans
Enterprise <strong>beans</strong> et transactions<br />
est défini et qu’une transaction globale existe déjà, le conteneur<br />
invoque la méthode et joint la transaction globale existante. S’il n’existe<br />
aucune transaction globale, le conteneur démarre une transaction locale<br />
pour la méthode et la transaction se termine à la fin de la méthode.<br />
• NotSupported<br />
Permet également au bean d’éviter d’utiliser une transaction globale. Si<br />
un client appelle la méthode avec un contexte de transaction, le<br />
conteneur la suspend. A la fin de la méthode, la transaction globale<br />
reprend.<br />
• Mandatory<br />
Le client qui appelle une méthode avec cet attribut de transaction doit<br />
déjà être associé à une transaction. Sinon, le conteneur déclenche une<br />
javax.transaction.TransactionRequiredException. Cet attribut rend moins<br />
souple l’utilisation du bean puisqu’il part d’hypothèses sur la<br />
transaction de l’appelant.<br />
• Never<br />
Le client qui appelle une méthode avec cet attribut de transaction ne<br />
doit pas avoir de contexte de transaction. S’il en a un, le conteneur<br />
déclenche une exception.<br />
Transactions locales et globales<br />
Lorsqu’une seule connexion à une base de données existe, l’<strong>enterprise</strong><br />
bean peut contrôler directement la transaction en appelant commit() ou<br />
rollback() sur la connexion. Ce type de transaction est une transaction<br />
locale. Dans le cas <strong>des</strong> transactions globales, toutes les connexions à la<br />
base de données sont enregistrées avec le service de transaction globale<br />
qui gère la transaction. Pour une transaction globale, l’<strong>enterprise</strong> bean ne<br />
fait jamais d’appels directs à la connexion à une base de données<br />
elle-même.<br />
Un bean pratiquant la démarcation <strong>des</strong> transactions gérées par le bean<br />
utilise l’interface javax.transaction.UserTransaction pour identifier les<br />
limites d’une transaction globale. Quand un bean utilise la démarcation<br />
gérée par le conteneur, ce dernier interrompt chaque appel de client pour<br />
contrôler la démarcation de la transaction, en utilisant l’attribut de<br />
transaction défini dans le <strong>des</strong>cripteur de déploiement du bean par<br />
l’assembleur de l’application. L’attribut de transaction détermine<br />
également si la transaction est locale ou globale.<br />
Pour les transactions gérées par le conteneur, ce dernier suit certaines<br />
règles pour déterminer s’il doit faire une transaction locale ou globale.<br />
Généralement, un conteneur appelle la méthode dans une transaction<br />
locale après avoir vérifié qu’il n’existe pas déjà une transaction globale. Il<br />
vérifie également qu’on n’attend pas qu’il démarre une nouvelle<br />
Gestion <strong>des</strong> transactions 13-5
Utilisation de l’ API de transaction<br />
transaction globale et que les attributs de transaction sont définis pour les<br />
transactions gérées par le conteneur. Le conteneur enveloppe<br />
automatiquement un appel de méthode à l’intérieur d’une transaction<br />
locale si une <strong>des</strong> conditions suivantes est vrai :<br />
• L’attribut de transaction est défini par NotSupported et le conteneur<br />
détecte que les ressources de bases de données ont été accédées.<br />
• L’attribut de transaction est défini par Supports et le conteneur détecte<br />
que la méthode n’a pas été invoquée depuis l’intérieur d’une<br />
transaction globale.<br />
• L’attribut de transaction est défini par Never et le conteneur détecte<br />
que les ressources de bases de données ont été accédées.<br />
Utilisation de l’API de transaction<br />
Toutes les transactions utilisent l’API JTA (Java Transaction API). Lorsque<br />
les transactions sont gérées par le conteneur, la plate-forme gère la<br />
démarcation <strong>des</strong> transactions et le conteneur utilise l’API JTA. Vous<br />
n’avez jamais besoin d’utiliser cette API dans le code de votre bean.<br />
Si votre bean gère lui-même ses transactions, il doit utiliser l’interface JTA<br />
javax.transaction.UserTransaction. Cette interface permet à un client ou à<br />
un composant de démarquer les limites <strong>des</strong> transactions. Les <strong>enterprise</strong><br />
<strong>beans</strong> dont les transactions sont gérées par le bean utilisent la méthode<br />
EJBContext.getUserTransaction().<br />
De plus, tous les clients transactionnels utilisent JNDI pour consulter<br />
l’interface UserTransaction. Vous faites cela en construisant un<br />
InitialContext JNDI à l’aide du service d’annuaire JNDI, comme indiqué<br />
ici :<br />
javax.naming.Context context = new javax.naming.InitialContext();<br />
Une fois que le bean a obtenu l’objet InitialContext, il peut utiliser<br />
l’opération JNDI lookup() pour obtenir l’interface UserTransaction :<br />
javax.transaction.UserTransaction utx = (javax.transaction.UserTransaction)<br />
context.lookup("java:comp/UserTransaction")<br />
Notez qu’un <strong>enterprise</strong> bean peut obtenir une référence à l’interface<br />
UserTransaction depuis l’objet EJBContext. Le bean peut simplement utiliser<br />
la méthode EJBContext.getUserTransaction() au lieu de chercher à obtenir<br />
un objet InitialContext et d’utiliser ensuite la méthode JNDI lookup().<br />
Mais, si le client transactionnel n’est pas un <strong>enterprise</strong> bean, il doit utiliser<br />
l’approche de recherche JNDI.<br />
Quand le bean ou le client détient la référence à l’interface UserTransaction,<br />
il peut alors initier et gérer ses propres transactions. C’est-à-dire que vous<br />
pouvez utiliser les métho<strong>des</strong> de l’interface UserTransaction pour<br />
commencer et valider (ou annuler) <strong>des</strong> transactions. Vous utilisez la<br />
13-6 Guide du dé veloppeur Enterprise JavaBeans
Utilisation de l’ API de transaction<br />
méthode begin() pour commencer la transaction, puis la méthode commit()<br />
pour renvoyer les modifications dans la base de données. Ou alors, vous<br />
utilisez la méthode rollback() pour annuler toutes les modifications<br />
effectuées dans la transaction et restaurer la base de données dans l’état<br />
qu’elle avait avant le début de la transaction. Entre les métho<strong>des</strong> begin() et<br />
commit(), vous insérez le code qui effectue le travail de la transaction. Voici<br />
un exemple :<br />
public class NewSessionBean implements SessionBean {<br />
EJBContext ejbContext;<br />
public void doSomething(...) {<br />
javax.transaction.UserTransaction utx;<br />
javax.sql.DataSource dataSource1;<br />
javax.sql.DataSource dataSource2;<br />
java.sql.Connection firstConnection;<br />
java.sql.Connection secondConnection;<br />
java.sql.Statement firstStatement;<br />
java.sql Statement secondStatement;<br />
java.naming.Context context = new javax.naming.InitialContext();<br />
dataSource1 = (javax.sql.DataSource)<br />
context.lookup("java:comp/env/jdbcDatabase1");<br />
firstConnection = dataSource1.getConnection();<br />
firstStatement = firstConnection.createStatement();<br />
dataSource2 = (javax.sql.DataSource)<br />
context.lookup("java:comp/env/jdbcDatabase2");<br />
secondConnection = dataSource2.getConnection();<br />
secondStatement = secondConnection.createStatement();<br />
utx = ejbContext.getUserTransaction();<br />
utx.begin();<br />
firstStatement.executeQuery(...);<br />
firstStatement.executeUpdate(...);<br />
secondStatement.executeQuery(...);<br />
secondStatement.executeUpdate(...);<br />
utx.commit();<br />
firstStatement.close;<br />
secondStatement.close<br />
firstConnection.close();<br />
secondConnection.close();<br />
}<br />
...<br />
Gestion <strong>des</strong> transactions 13-7
Gestion <strong>des</strong> exceptions dans les transactions<br />
Gestion <strong>des</strong> exceptions dans les transactions<br />
Les <strong>enterprise</strong> <strong>beans</strong> peuvent déclencher <strong>des</strong> exceptions au niveau de<br />
l’application et/ou du système, s’ils rencontrent <strong>des</strong> erreurs pendant la<br />
gestion <strong>des</strong> transactions. Les exceptions au niveau de l’application sont<br />
dues à <strong>des</strong> erreurs dans la logique métier. L’application appelante doit les<br />
gérer. Les exceptions au niveau du système, comme les erreurs<br />
d’exécution, dépassent l’application elle-même et peuvent être gérées par<br />
l’application, l’<strong>enterprise</strong> bean ou le conteneur du bean.<br />
L’<strong>enterprise</strong> bean déclare les exceptions au niveau de l’application et<br />
celles au niveau du système dans les clauses throws de ses interfaces Home et<br />
Remote. Vous devez contrôler les exceptions “vérifiées” dans le bloc try/<br />
catch de votre application client lorsque vous appelez les métho<strong>des</strong> du<br />
bean.<br />
Exceptions au niveau du système<br />
Un <strong>enterprise</strong> bean déclenche une exception au niveau du système<br />
(généralement une java.ejb.EJBException, mais ce peut être une<br />
java.rmi.RemoteException) pour indiquer une panne inattendue du système.<br />
Par exemple, il déclenche une exception s’il ne peut pas ouvrir une<br />
connexion à une base de données. java.ejb.EJBException est une exception<br />
d’exécution et n’a pas besoin de figurer dans la clause throws <strong>des</strong> métho<strong>des</strong><br />
métier du bean.<br />
Les exceptions au niveau du système nécessitent généralement<br />
l’annulation de la transaction. Souvent, c’est le conteneur qui gère le bean<br />
qui effectue l’annulation. Parfois, le client doit annuler la transaction, en<br />
particulier quand les transactions sont gérées par le bean.<br />
Exceptions au niveau de l’application<br />
Le bean déclenche une exception au niveau de l’application pour indiquer<br />
<strong>des</strong> conditions d’erreurs spécifiques à l’application. Ce sont <strong>des</strong> erreurs de<br />
logique métier et non <strong>des</strong> problèmes du système. Les exceptions du<br />
niveau de l’application sont <strong>des</strong> exceptions autres que<br />
java.ejb.EJBException. Ce sont <strong>des</strong> exceptions “vérifiées”, ce qui signifie<br />
que vous devez les vérifier quand vous appelez une méthode qui a la<br />
possibilité de déclencher cette exception.<br />
Les métho<strong>des</strong> métier du bean utilisent les exceptions au niveau de<br />
l’application pour rapporter <strong>des</strong> conditions anormales dans l’application,<br />
comme <strong>des</strong> valeurs saisies inacceptables ou <strong>des</strong> montants au-delà <strong>des</strong><br />
limites valables. Par exemple, une méthode dans un bean qui débite un<br />
compte peut déclencher une exception au niveau de l’application pour<br />
signaler que le solde du compte est insuffisant pour permettre cette<br />
13-8 Guide du dé veloppeur Enterprise JavaBeans
Gestion <strong>des</strong> exceptions dans les transactions<br />
opération. Un client peut souvent réparer ces erreurs au niveau de<br />
l’application sans avoir besoin d’annuler la transaction toute entière.<br />
L’application ou le programme appelant obtient en retour la même<br />
exception que celle qui a été déclenchée, ce qui permet au programme<br />
appelant de connaître la nature précise du problème. Quand une<br />
exception survient au niveau de l’application, l’instance de l’<strong>enterprise</strong><br />
bean n’annule pas automatiquement la transaction du client. Le client<br />
connaît maintenant le message d’erreur et a l’opportunité de l’évaluer, de<br />
prendre les décisions nécessaires pour corriger la situation et de réparer la<br />
transaction. Ou alors, il peut annuler la transaction.<br />
Gestion <strong>des</strong> exceptions au niveau de l’application<br />
Comme les exceptions au niveau de l’application signalent <strong>des</strong> erreurs<br />
dans la logique métier, c’est à votre client de les gérer. Bien que ces<br />
exceptions puissent nécessiter l’annulation de la transaction, elles ne<br />
marquent pas automatiquement la transaction pour annulation (rollback).<br />
Le client peut tenter à nouveau la transaction, bien que la plupart du<br />
temps il doive l’abandonner et l’annuler.<br />
En tant que fournisseur du bean, vous devez vous assurer que l’état du<br />
bean est tel que si le client continue la transaction, l’intégrité <strong>des</strong> données<br />
sera maintenue. Si vous ne pouvez pas le garantir, vous devrez marquer la<br />
transaction pour annulation (rollback).<br />
Annulation de la transaction<br />
Quand votre client obtient une exception au niveau de l’application, il faut<br />
vérifier d’abord si la transaction en cours a été marquée pour annulation<br />
(rollback) seulement. Par exemple, un client peut recevoir une<br />
javax.transaction.TransactionRolledbackException. Cette exception indique<br />
que l’<strong>enterprise</strong> bean helper a échoué et que la transaction a été<br />
abandonnée ou marquée pour annulation (rollback) seulement.<br />
Généralement le client ne connaît pas le contexte de la transaction dans<br />
laquelle l’<strong>enterprise</strong> bean a opéré. Le bean peut avoir opéré dans son<br />
propre contexte de transaction, distinct de celui du programme appelant,<br />
ou dans le contexte du programme appelant.<br />
Si l’<strong>enterprise</strong> bean a opéré dans le même contexte de transaction que le<br />
programme appelant, alors le bean lui-même (ou son conteneur) a déjà<br />
marqué la transaction pour annulation (rollback). Quand un conteneur<br />
EJB marque une transaction pour annulation (rollback), le client doit<br />
arrêter tout travail de la transaction. Habituellement, un client utilisant les<br />
transactions déclaratives obtient une exception appropriée, comme<br />
javax.transaction.TransactionRolledbackException. Notez que les<br />
transactions déclaratives sont celles où le conteneur gère les détails de la<br />
transaction.<br />
Gestion <strong>des</strong> transactions 13-9
Gestion <strong>des</strong> exceptions dans les transactions<br />
Un client qui est lui-même un <strong>enterprise</strong> bean doit appeler la méthode<br />
javax.ejbEJBContext.getRollbackOnly() pour déterminer si sa propre<br />
transaction a été marquée pour annulation (rollback).<br />
Pour les transactions gérées par le bean — transactions gérées<br />
explicitement par le client — le client doit annuler la transaction en<br />
appelant la méthode rollback() depuis l’interface<br />
java.transaction.userTransaction.<br />
Options pour continuer une transaction<br />
Quand une transaction n’est pas marquée pour annulation (rollback), le<br />
client dispose <strong>des</strong> options suivantes :<br />
• Annuler la transaction.<br />
Quand un client reçoit une exception vérifiée pour une transaction non<br />
marquée pour annulation, le plus sûr est d’annuler la transaction. Le<br />
client le fait soit en marquant la transaction pour annulation (rollback)<br />
seulement, soit, si le client a démarré la transaction, en appelant la<br />
méthode rollback() pour annuler réellement la transaction.<br />
• Transférer la responsabilité en déclenchant une exception vérifiée ou en<br />
déclenchant à nouveau l’exception initiale.<br />
Le client peut aussi déclencher sa propre exception vérifiée ou en<br />
déclencher à nouveau l’exception initiale. En déclenchant une<br />
exception, le client laisse les autres programmes impliqués dans la<br />
transaction décider d’annuler ou non la transaction. Mais, en général, il<br />
vaut mieux que ce soit le code ou le programme le plus près de<br />
l’occurrence du problème qui prenne la décision de poursuivre ou non<br />
la transaction.<br />
• Essayer à nouveau et continuer la transaction. Cela peut impliquer de<br />
réessayer <strong>des</strong> parties de la transaction.<br />
Le client peut continuer la transaction. Le client peut évaluer le<br />
message de l’exception et décider si appeler à nouveau la méthode avec<br />
d’autres paramètres a <strong>des</strong> chances de réussir. N’oubliez pas, cependant,<br />
que retenter une transaction est potentiellement dangereux. Votre code<br />
ne sait pas si l’<strong>enterprise</strong> bean a correctement nettoyé son état.<br />
Les clients qui appellent <strong>des</strong> <strong>beans</strong> session stateless peuvent cependant<br />
retenter la transaction s’ils sont capables de déterminer le problème à<br />
partir de l’exception déclenchée. Comme le bean appelé est stateless, il<br />
n’y a pas à se préoccuper de son état.<br />
Si vous utilisez Borland AppServer, lisez le chapitre “Transaction<br />
Management”, dans l’Enterprise JavaBeans Programmer’s Guide de<br />
Borland AppServer, pour avoir <strong>des</strong> informations complémentaires sur les<br />
transactions et sur le conteneur Borland.<br />
13-10 Guide du dé veloppeur Enterprise JavaBeans
Index<br />
A<br />
activation<br />
<strong>beans</strong> entité 10-4<br />
<strong>beans</strong> session 9-7<br />
experts EJB 2-1<br />
Activer l’intégration, option 2-1<br />
administrateur système<br />
rôle EJB 1-4<br />
afterBegin() 9-9<br />
afterCompletion() 9-9<br />
ajout de métho<strong>des</strong> métier aux EJB 3-9<br />
ajout de propriétés aux EJB 3-9<br />
annulation <strong>des</strong> transactions 13-9<br />
API JTA (Java Transaction API) 13-6<br />
application EJB, rôles 1-3<br />
applications client EJB exemple<br />
SortClient 12-1<br />
applications distribuées<br />
EJB 1-1<br />
applications multiniveaux<br />
pour systèmes distribués 1-2<br />
architecture<br />
Enterprise JavaBeans 1-5<br />
assembleur d’applications<br />
rôle EJB 1-3<br />
attributs<br />
transaction 13-3<br />
B<br />
bean, gestion de la persistance du bean 7-12, 10-1,<br />
10-2<br />
inconvénients 10-2<br />
bean, gestion <strong>des</strong> transactions 13-3, 13-6<br />
<strong>beans</strong> entité 1-7<br />
clés primaires 10-3, 12-4<br />
create() 11-4, 12-3<br />
définition 10-1<br />
écriture 10-3<br />
état d’inexistence 10-9<br />
état en pool 10-9<br />
état prêt 10-10<br />
états 10-8<br />
exemple 10-11, 10-12, 10-14<br />
fourniture <strong>des</strong> données 8-1<br />
interface distante 10-12<br />
interface locale 10-11, 11-4<br />
métho<strong>des</strong> 10-5<br />
métho<strong>des</strong> find 7-14, 11-5, 12-3<br />
partage <strong>des</strong> interfaces locale et distante 10-11<br />
persistance 10-1<br />
référencement 12-3<br />
résolution <strong>des</strong> données 8-1<br />
sources de données 7-21<br />
suppression 10-1<br />
<strong>beans</strong> session 1-7, 9-1<br />
create() 11-3<br />
création avec JBuilder 9-4<br />
cycle de vie 9-5<br />
écriture 9-2<br />
état prêt pour la méthode 9-6<br />
exemple 9-9<br />
exemple Cart 9-10<br />
implémentation <strong>des</strong> métho<strong>des</strong> nécessaires 9-11<br />
interface locale 11-2<br />
interface SessionSynchronization 9-8<br />
métho<strong>des</strong> create 12-2<br />
pool stateless 9-5<br />
référencement 12-2<br />
remove() 12-6<br />
stateful 9-1, 12-2<br />
stateless 9-2, 12-2<br />
types 9-1<br />
<strong>beans</strong> stateful<br />
cycle de vie 9-6<br />
<strong>beans</strong> stateless<br />
cycle de vie 9-5<br />
BeansExpress<br />
exposition <strong>des</strong> métho<strong>des</strong> EJB 3-11<br />
beforeCompletion() 9-9<br />
bibliothèques<br />
fichiers du serveur d’applications 2-2<br />
Borland<br />
contacter 1-9<br />
serveur d’applications cible 2-1<br />
Borland Online 1-9<br />
C<br />
Cart, exemple de bean 9-10<br />
chariot de supermarché<br />
exemple de bean session 9-9<br />
checkExistenceBeforeCreate, propriété 7-15<br />
classe de clé primaire 10-3, 12-4<br />
exigences <strong>des</strong> <strong>beans</strong> entité 10-3<br />
classes <strong>des</strong> <strong>beans</strong> entité<br />
écriture 10-3<br />
exigences 10-3<br />
classes <strong>des</strong> <strong>beans</strong> session<br />
exigences 9-2<br />
clé primaire<br />
bean entité 12-4<br />
Index I-1
localisation <strong>des</strong> objets entité 11-5<br />
obtention 11-7<br />
clients<br />
création avec JBuilder 12-9<br />
<strong>enterprise</strong> bean 12-1<br />
gestion <strong>des</strong> transactions 12-7<br />
invocation de métho<strong>des</strong> métier 12-5<br />
localisation de l’interface locale 12-2<br />
obtention de l’interface distante 12-2<br />
suppression <strong>des</strong> instances de <strong>beans</strong> 12-6<br />
clients de test<br />
création EJB 5-1<br />
déclaration d’une instance de 5-3<br />
exécution EJB 5-5<br />
utilisation EJB 5-3<br />
composants client EJB 8-2<br />
composants DataExpress pour EJB 8-1<br />
composants EJB 8-1<br />
composants serveur EJB 8-2<br />
concepteur de Bean<br />
page Métho<strong>des</strong> 3-11<br />
page Propriétés 3-9<br />
Configuration Entreprise, commande 2-1<br />
configurations d’exécution<br />
Client et Serveur 5-5<br />
contacter Borland 1-9<br />
groupes de discussion 1-10<br />
World Wide Web 1-9<br />
conteneur EJB<br />
activation <strong>des</strong> <strong>beans</strong> session 9-7<br />
conteneur, gestion de la persistance du<br />
bean 10-2<br />
création de EJBObject 11-7<br />
cycle de vie <strong>des</strong> <strong>beans</strong> entité 10-8<br />
cycle de vie <strong>des</strong> <strong>beans</strong> stateful 9-6<br />
cycle de vie <strong>des</strong> <strong>beans</strong> stateless 9-5<br />
définition 1-6<br />
désactivation <strong>des</strong> <strong>beans</strong> session 9-7<br />
fournisseur 1-3<br />
implémentation de l’interface locale 11-1<br />
support <strong>des</strong> transactions 13-2<br />
conteneur, gestion de la persistance du bean 7-12,<br />
10-2, 10-22<br />
avantages 10-2<br />
limites 10-3<br />
sans classe clé primaire 10-6<br />
contexte d’annuaire<br />
obtention 12-2<br />
conventions de la documentation 1-11<br />
conventions <strong>des</strong> plates-formes 1-12<br />
create()<br />
<strong>beans</strong> entité 11-4<br />
<strong>beans</strong> session 11-3<br />
exceptions 11-3, 11-4<br />
CreateException, exception 11-3, 11-4<br />
Créateur d’interface EJB, expert 3-15<br />
Créateur de Bean EJB, expert 3-12<br />
Créer IIOP, option 3-17<br />
D<br />
dé-déploiement d’un JAR EJB 6-11<br />
déploiement<br />
<strong>enterprise</strong> <strong>beans</strong> 6-1, 6-6<br />
<strong>enterprise</strong> <strong>beans</strong> sur WebLogic 6-1, 6-9<br />
<strong>enterprise</strong> <strong>beans</strong> sur WebSphere 6-1, 6-9<br />
JAR EJB 6-6<br />
JAR EJB sur un conteneur en exécution 6-11<br />
déploiement dynamique<br />
<strong>enterprise</strong> <strong>beans</strong> 6-11<br />
Déploiement EJB, expert 6-6<br />
déploiement, rôle EJB 1-4<br />
déployeur<br />
rôle EJB 1-4<br />
désactivation<br />
instances <strong>des</strong> <strong>beans</strong> session 9-7<br />
<strong>des</strong>cripteurs de déploiement<br />
ajout d’informations au nouveau bean 7-4<br />
bean session 9-18<br />
création 6-2, 7-1<br />
édition 3-20<br />
exemple de bean entité 10-21, 10-22<br />
fichier XML 3-20<br />
informations contenues 6-3<br />
informations structurelles 6-4<br />
informations sur l’assemblage de<br />
l’application 6-4<br />
insertion dans un groupe EJB 3-17<br />
métho<strong>des</strong> find 7-14<br />
modification 7-1<br />
modification <strong>des</strong> informations du bean 7-5<br />
niveaux d’isolation <strong>des</strong> transactions 7-23<br />
objectif 6-2<br />
permissions de métho<strong>des</strong> 7-26<br />
persistance 7-12<br />
politiques transactionnelles 7-20<br />
propriétés 7-15<br />
propriétés d’environnement 7-7<br />
propriétés <strong>des</strong> sources de données 7-23<br />
références <strong>des</strong> ressources 7-10<br />
références EJB 7-8<br />
rôles de sécurité 7-9, 7-25<br />
sources de données 7-21<br />
vérification 7-28<br />
visualisation 7-2<br />
développeur de <strong>beans</strong><br />
rôle EJB 1-3<br />
tâches 1-6<br />
I-2 Guide du dé veloppeur Enterprise JavaBeans
E<br />
éditeur de <strong>des</strong>cripteur de déploiement 7-1<br />
affichage 7-2<br />
niveaux d’isolation <strong>des</strong> transactions 7-23<br />
panneau Data Source 7-21<br />
panneau EJB References 7-8<br />
panneau Environment 7-7<br />
panneau Finders 7-14<br />
panneau Main 7-5<br />
panneau Persistence 7-12<br />
panneau Properties 7-15<br />
panneau Resource References 7-10<br />
panneau Security Role References 7-9<br />
permissions de métho<strong>des</strong> 7-26<br />
propriétés <strong>des</strong> sources de données 7-23<br />
rôles de sécurité 7-25<br />
vérification <strong>des</strong> <strong>des</strong>cripteurs 7-28<br />
EJB 1-1<br />
Voir aussi Enterprise JavaBeans<br />
EJB 1.1, serveur d’applications 2-4<br />
EJB, conteneurs 1-6<br />
Voir aussi conteneur EJB<br />
EJB, rôles 1-3<br />
ejbActivate() 9-3, 10-4<br />
ejbCreate() 10-5<br />
appelée par le conteneur 10-6<br />
exemple 10-6<br />
exigences 9-3, 10-6<br />
ejbFindByPrimaryKey() 10-7<br />
EJBHome, classe de base<br />
étendue par l’interface locale 11-2<br />
ejb-jar.xml 3-20<br />
ejbLoad() 10-5<br />
EJBMetaData, interface 12-8<br />
EJBObject, interface 11-7<br />
étendue par l’interface distante 11-6<br />
ejbPassivate() 9-3, 10-5<br />
ejbPostCreate() 10-7<br />
ejbRemove() 9-3, 10-4<br />
ejbStore() 10-5<br />
élimination<br />
instances EJB 11-2<br />
<strong>enterprise</strong> <strong>beans</strong> 1-1<br />
client de test 5-1<br />
comparaison 11-7<br />
compilation 3-17<br />
création à l’aide d’experts 3-4<br />
déploiement 6-1, 6-6<br />
déploiement dynamique 6-11<br />
déploiement sur serveur WebLogic 6-9<br />
déploiement sur serveur WebSphere 6-9<br />
développement avec JBuilder 1-8<br />
entité 1-7<br />
exécution 5-5<br />
fonctionnement 1-6<br />
génération à partir d’une interface distante 3-12<br />
gestion <strong>des</strong> ressources 9-3<br />
métho<strong>des</strong> métier 10-8<br />
obtenir <strong>des</strong> informations 12-8<br />
options de déploiement 6-10<br />
propriétés de construction 3-17<br />
session 1-7<br />
suppression d’instances 11-7<br />
test 5-5<br />
test <strong>des</strong> métho<strong>des</strong> distantes 5-1<br />
transactions 13-3<br />
types 1-7<br />
Enterprise JavaBean, expert 3-4<br />
Enterprise JavaBeans 1-1<br />
1.1 specification 1-1<br />
activation <strong>des</strong> experts 2-1<br />
architecture 1-5<br />
développement 1-1<br />
rôles 1-3<br />
types 1-7<br />
usage 1-2<br />
EnterpriseBean, interface<br />
étendue par EntityBean 10-4<br />
étendue par SessionBean 9-2<br />
EntityBean, interface<br />
implémentation 10-4<br />
implémentations <strong>des</strong> <strong>beans</strong> entité 10-3<br />
métho<strong>des</strong> 10-4<br />
état d’inexistence<br />
<strong>beans</strong> entité 10-9<br />
état en pool<br />
<strong>beans</strong> entité 10-9<br />
retour du <strong>beans</strong> entité 10-10<br />
état prêt<br />
<strong>beans</strong> entité 10-10<br />
état prêt pour la méthode<br />
dans une transaction 9-7<br />
définition 9-6<br />
état prêt pour la transaction 9-9<br />
exceptions<br />
au niveau de l’application 13-8, 13-9<br />
au niveau du système 13-8<br />
transaction 13-8<br />
exemple de bean entité<br />
CheckAccount 10-12<br />
SavingsAccount 10-14<br />
exemple de bean session<br />
Cart 9-9<br />
Expert Client Test EJB 5-1<br />
experts<br />
activation EJB 2-1<br />
Client test EJB 5-1<br />
Créateur d’interface EJB 3-15<br />
Créateur de Bean EJB 3-12<br />
Index I-3
Déploiement EJB 6-6<br />
Enterprise JavaBean 3-4<br />
Groupe EJB depuis <strong>des</strong>cripteurs 3-3<br />
Groupe EJB vide 3-2<br />
Modeleur Bean entité EJB 4-1<br />
Utilisation d’un client Test 5-3<br />
experts EJB<br />
activation 2-1<br />
Client test 5-1<br />
Créateur d’interface EJB 3-15<br />
Créateur de Bean EJB 3-12<br />
Enterprise JavaBean 3-4<br />
Groupe EJB depuis <strong>des</strong>cripteurs 3-3<br />
Groupe EJB vide 3-2<br />
Modeleur de Bean entité 4-1<br />
Utilisation d’un client Test 5-3<br />
F<br />
fichiers du serveur d’applications<br />
ajout à un projet 2-2<br />
findByPrimaryKey() 11-5, 12-4<br />
FinderException, exception 11-5<br />
fournisseur de <strong>beans</strong><br />
rôle EJB 1-3<br />
tâches 1-6<br />
fournisseur de conteneurs<br />
rôle EJB 1-3<br />
fournisseur de serveurs<br />
EJB 1-3<br />
rôle EJB 1-3<br />
fourniture <strong>des</strong> données<br />
<strong>beans</strong> entité 8-1<br />
G<br />
getEJBHome()<br />
EJBObject 11-7<br />
getEJBMetaData() 11-2<br />
EJBHome 11-2<br />
getHandle()<br />
EJBObject 11-7<br />
getHomeHandle()<br />
EJBHome 11-2<br />
getMetaData()<br />
<strong>enterprise</strong> bean 12-8<br />
getPrimaryKey()<br />
EJBObject 11-7<br />
getPrimaryKeyAfterInsertSql, propriété 7-15<br />
getPrimaryKeyBeforeInsertSql, propriété 7-15<br />
getRollbackOnly() 13-9<br />
Groupe EJB depuis <strong>des</strong>cripteurs, expert 3-3<br />
Groupe EJB vide, expert 3-2<br />
groupes de discussion 1-10<br />
Borland 1-10<br />
groupes EJB<br />
H<br />
copie <strong>des</strong> <strong>des</strong>cripteurs de déploiement 3-17<br />
création 3-2<br />
définition 3-1, 3-2<br />
depuis <strong>des</strong>cripteurs de déploiement 3-3<br />
extensions de fichiers 3-1<br />
insertion de <strong>des</strong>cripteurs de déploiement 3-17<br />
propriétés de construction 3-17<br />
types 3-1<br />
vide 3-2<br />
handles<br />
EJB 11-2<br />
obtention d’<strong>enterprise</strong> <strong>beans</strong> 11-7<br />
I<br />
iaspt.ini, fichier 7-29<br />
ignoreColumnsOnInsert, propriété 7-15<br />
infrastructure EJB, rôles 1-3<br />
InitialContext 13-6<br />
interface distante 11-6<br />
<strong>beans</strong> entité 10-12<br />
création 11-6<br />
création pour un bean existant 3-15<br />
définition 11-1<br />
exemple de bean session 11-7<br />
exigences 11-6<br />
extension de EJBObject 11-7<br />
génération <strong>des</strong> EJB à partir de 3-12<br />
métho<strong>des</strong> métier 3-11<br />
obtention d’une référence par le client 12-1<br />
référence 12-2<br />
référence à un bean entité. 12-3<br />
référence à un bean session 12-2<br />
interface locale<br />
<strong>beans</strong> entité 10-11, 11-4<br />
<strong>beans</strong> session 11-2<br />
création 11-1, 11-2<br />
création pour un <strong>enterprise</strong> bean existant 3-15<br />
définition 11-1<br />
exemple de bean entité 11-6<br />
exemple de bean session 11-3<br />
exigences <strong>des</strong> <strong>beans</strong> entité 11-4<br />
exigences <strong>des</strong> <strong>beans</strong> session 11-3<br />
extension de EJBHome 11-2<br />
localisation par le client 12-1, 12-2<br />
métho<strong>des</strong> create 12-2, 12-4<br />
métho<strong>des</strong> find 11-5, 12-2<br />
métho<strong>des</strong> remove 12-4<br />
nom 11-1<br />
interface locale et distante<br />
partage par les <strong>beans</strong> entité 10-11<br />
interfaces<br />
distante 11-6<br />
I-4 Guide du dé veloppeur Enterprise JavaBeans
locale 11-1<br />
isIdentical()<br />
EJBObject 11-7<br />
J<br />
JAR EJB déployés<br />
liste 6-11<br />
jdbcAccesserFactory, propriété 7-15<br />
JNDI<br />
API 12-2<br />
service d’annuaire 12-2, 13-6<br />
L<br />
liste <strong>des</strong> JAR déployés 6-11<br />
localisation<br />
<strong>enterprise</strong> <strong>beans</strong> avec clé primaire 11-7<br />
lookup() 12-2<br />
M<br />
Mandatory, attribut <strong>des</strong> transactions 13-4<br />
métadonnées<br />
définition 12-8<br />
métho<strong>des</strong> create<br />
bean entité 10-5, 12-3<br />
bean session 12-2<br />
métho<strong>des</strong> distantes<br />
test 5-1<br />
métho<strong>des</strong> find 7-14, 10-5, 11-5, 12-2, 12-3<br />
<strong>beans</strong> entité 10-3<br />
création 10-7<br />
défaut 12-4<br />
exigences 10-7<br />
préfixe 11-5<br />
métho<strong>des</strong> métier 10-8<br />
ajout à un <strong>enterprise</strong> bean 3-9<br />
<strong>beans</strong> entité 10-5<br />
écriture 9-3<br />
exposition EJB 3-11<br />
interface distante 3-11, 11-6<br />
invoquées par le client 12-1, 12-5<br />
modèles de conception<br />
bean session enveloppe bean entité 8-1<br />
Modeleur Bean entité EJB, expert 4-1<br />
modification <strong>des</strong> <strong>des</strong>cripteurs de déploiement 7-1<br />
N<br />
Never, attribut <strong>des</strong> transactions 13-4<br />
niveaux d’isolation 7-23<br />
NotSupported, attribut <strong>des</strong> transactions 13-4<br />
O<br />
opération, rôle EJB 1-4<br />
options de déploiement<br />
EJB 6-10<br />
options de déploiement EJB<br />
configuration 6-10<br />
P<br />
Paramètres de déploiement, boîte de dialogue 6-1<br />
partage <strong>des</strong> interfaces locale et distante 10-11<br />
passivité 9-7, 10-5<br />
permissions de métho<strong>des</strong> 6-5, 7-26<br />
persistance 1-7<br />
avantages de la gestion par le conteneur 10-2<br />
<strong>beans</strong> entité 7-12, 10-1<br />
gérée par le bean 7-12, 10-1, 10-2<br />
gérée par le conteneur 7-12, 10-2<br />
gérées par le conteneur 10-2<br />
gestion par le conteneur et gestion par le<br />
bean 10-2<br />
inconvénients de la gestion par le bean 10-2<br />
inconvénients de la gestion par le<br />
conteneur 10-3<br />
persistance gérée par le bean 10-21<br />
métho<strong>des</strong> find 10-3<br />
polices<br />
conventions de la documentation 1-11<br />
ports<br />
SmartAgent VisiBroker 2-3<br />
primaryKeyGenerator, propriété 7-15<br />
propriétés<br />
<strong>des</strong>cripteur de déploiement 7-15<br />
EJB 7-15<br />
sources de données 7-23<br />
propriétés d’environnement<br />
EJB 7-7<br />
propriétés de construction<br />
groupes EJB 3-17<br />
Propriétés de construction, boîte de dialogue 3-20<br />
R<br />
recherche d’objets entité<br />
clé primaire 11-7<br />
redéploiement<br />
JAR EJB 6-11<br />
référencement <strong>des</strong> <strong>enterprise</strong> <strong>beans</strong><br />
métho<strong>des</strong> create 12-2, 12-3<br />
métho<strong>des</strong> find 12-2, 12-4<br />
utilisation de handles 12-6<br />
références<br />
EJB 7-8<br />
références <strong>des</strong> ressources<br />
EJB 7-10<br />
Index I-5
éférences <strong>des</strong> rôles de sécurité 6-5<br />
réflexion<br />
byte-code 7-29<br />
RemoteException, exception 11-3, 11-4, 11-5, 11-6<br />
remove()<br />
EJBHome 11-2<br />
EJBObject 11-7<br />
Required, attribut <strong>des</strong> transactions 13-4<br />
RequiresNew, attribut <strong>des</strong> transactions 13-4<br />
résolution <strong>des</strong> données<br />
<strong>beans</strong> entité 8-1<br />
ressources en ligne 1-9<br />
Retirer les fichiers stubs lors <strong>des</strong> modifications du<br />
serveur d’applications, option 3-17<br />
rôles<br />
application EJB 1-3<br />
déploiement 1-4<br />
EJB 1-3<br />
infrastructure EJB 1-3<br />
opération 1-4<br />
rôles de sécurité 6-5<br />
création 7-25<br />
EJB 7-9, 7-25<br />
rollback() 13-10<br />
S<br />
serveur d’applications<br />
cible Borland 2-1<br />
cible WebLogic 2-1<br />
cible WebSphere 2-1<br />
définition de la cible 2-1<br />
EJB 1.1 2-4<br />
sélection 2-4<br />
serveur d’applications cible 2-1<br />
serveur EJB<br />
définition 1-5<br />
fournisseur 1-3<br />
serveurs<br />
EJB 1-5<br />
exécution EJB 5-5<br />
SessionBean, interface<br />
extension 9-2<br />
métho<strong>des</strong> 9-3<br />
SessionContext, interface 9-9<br />
SessionSynchronization, interface<br />
<strong>beans</strong> session stateful 9-8<br />
métho<strong>des</strong> 9-9<br />
setEntityContext() 10-4<br />
setRollbackOnly() 9-9<br />
setSessionContext() 9-3<br />
SmartAgent 2-3<br />
sources de données<br />
EJB 7-21<br />
niveaux d’isolation <strong>des</strong> transactions 7-23<br />
propriétés 7-23<br />
stubs<br />
génération client 3-17<br />
stubs client<br />
génération 3-17<br />
support aux développeurs 1-9<br />
support technique 1-9<br />
Supports, attribut <strong>des</strong> transactions 13-4<br />
suppression<br />
<strong>enterprise</strong> <strong>beans</strong> 11-7<br />
instances de <strong>beans</strong> entité 12-4<br />
instances <strong>des</strong> <strong>beans</strong> session 12-6<br />
instances EJB 11-2<br />
JAR EJB déployé 6-11<br />
suppression <strong>des</strong> instances de <strong>beans</strong> 10-1<br />
T<br />
test <strong>des</strong> <strong>enterprise</strong> <strong>beans</strong> 5-5<br />
test <strong>des</strong> métho<strong>des</strong> <strong>des</strong> <strong>enterprise</strong> <strong>beans</strong> 5-1<br />
Toujours créer un JAR lors de la construction du<br />
projet, option 3-17<br />
transaction<br />
attributs 13-4<br />
démarcation 13-3<br />
limites 12-7, 13-6<br />
politique 7-20<br />
transactions<br />
annulation 13-9<br />
attributs 13-3<br />
caractéristique atomicité 13-1<br />
caractéristique concurrence 13-1<br />
caractéristique durabilité 13-1<br />
caractéristique isolation 13-1<br />
caractéristiques 13-1<br />
cohérence 13-1<br />
démarcation 13-6<br />
et <strong>enterprise</strong> <strong>beans</strong> 13-3<br />
exceptions 13-8<br />
gérées par le bean 13-3<br />
gérées par le client 12-7<br />
gérées par le conteneur 7-20, 13-3, 13-5<br />
globales 13-5<br />
locales 13-5<br />
niveaux d’isolation 7-23<br />
transactions gérées par le conteneur 13-3<br />
ajout 7-20<br />
U<br />
unsetEntityContext() 10-4<br />
Usenet, groupes de discussion 1-10<br />
UserTransaction, interface 12-7, 13-5, 13-6<br />
Utilisation d’un client Test EJB, expert 5-3<br />
I-6 Guide du dé veloppeur Enterprise JavaBeans
V<br />
vérification<br />
<strong>des</strong>cripteurs de déploiement 7-28<br />
VisiBroker<br />
ORB, accessible à JBuilder 2-3<br />
SmartAgent 2-3<br />
W<br />
WebLogic<br />
boîte de dialogue Paramètres de<br />
déploiement 6-6<br />
<strong>des</strong>cripteurs de déploiement 3-20<br />
serveur d’applications cible 2-1<br />
WebLogic EJB, propriétés<br />
visualisation et modification 7-27<br />
WebLogic, serveur<br />
déploiement sur 6-9<br />
weblogic-ejb-jar.xml 3-20<br />
WebSphere<br />
boîte de dialogue Paramètres de<br />
déploiement 6-6<br />
serveur d’applications cible 2-1<br />
WebSphere EJB, propriétés<br />
visualisation et modification 7-27<br />
WebSphere, serveur<br />
déploiement sur 6-9<br />
Index I-7
I-8 Guide du dé veloppeur Enterprise JavaBeans