Guide Pratique EDI NetBeans

Transcription

Guide Pratique EDI
NetBeans
Copyright © 2005 Sun Microsystems, Inc. All rights reserved.
Table des matières
Assistant type de Projet EJB.............................................................................................................2
Structure Module EJB.......................................................................................................................5
Ajout d'EJB, Fichiers et Bibliothèques à votre Module EJB..............................................................6
Ajout de la Logique Métier à un Enterprise Java Bean.....................................................................9
Méthodes de Bean.......................................................................................................................9
Ajout d'une Simple Méthode Métier................................................................................................12
Descripteurs de Déployement EJB Bean .......................................................................................14
Etendre des
Applications Web
avec de la Logique
Métier: Introduction
aux Composants
EJB
Pour la plupart des utilisateurs de NetBeans, ainsi que pour les développeurs d'applications
Web, le concept d'Enterprise JavaBeans peut être nouveau ou apparemment complexe, comme
c'est la première fois que l'EDI NetBeans 4.1 expose les assistants et fonctionnalités nécessaires
pour créer facilement des EJB et leur ajouter des méthodes Métiers. Une fois que ces méthodes
Métiers sont implémentées (en Java), elles peuvent être appelée sui depuis d'autres EJB, ou
depuis des servlettes d'applications Web, ou des classes utilitaires. Les avantages d'encapsuler le
code de l'application dans des méthodes métiers d'EJB sont nombreux:
[nl]
Les Enterprise JavaBeans supporte les transactions, le mécanisme qui gére les
accès concurrentiels à des objets partagés. Le paramétrage de Transaction est
déclaratif, via les fichiers de descripteur de déployement.
Guide Pratique EDI NetBeans, Extention Applications Web avec Logique Métier: Introduction aux
Composants EJB, 1
[nl]
Enterprise Java Beans peuvent être utilisés par plusieurs clients, sur différentes
machines, ou non (accès local et/ou distant)
Les méthodes métiers des Enterprise Java Beans peuvent être sécurisés
déclarativement, sans modification de code source.
Enterprise Java Beans accèdent aux ressources externes, comme les bases de
données, les message queues, les mail sessions, services Web, déclarativement,
via JNDI: Java Naming and Directory Interface (JNDI). JNDI permet aux
composants de localiser d'autres composants et ressources. Pour localiser une
ressource JDBC, par exemple, un Enterprise JavaBean invoque la méthode
lookup du JNDI. JNDI maintient un ensemble d'associations entre un nom et
un objet. La méthode lookup passe un nom JNDI comme paramètre et retourne
l'objet associé.
[nl]
[nl]
Voir Tableau 8-1 pour une liste de tous les types d'EJB.
Types
d'Enterprise Java
Bean
Description
Session
Exécute une tâche pour un client; implémente un service Web. Un Session
Bean peut être stateful pour la gestion de la conversation entre le client
(l'utilisateur de la logique métier) et le Serveur, ou stateless.
Entity
Représente un objet d'entité metier qui existen dans un stockage persistant.
Typiquement, une base de données SQL (mais il existe d'autres possibilités)
Message-Driven Agit comme un listener pour un Java Message Service API, traitant les
messages de façon asynchrone.
Assistant type de Projet EJB.
La première chose à faire pour développer des EJB est de créer un projet EJB Module qui peut
contenir un ou plusieurs Enterprise JavaBeans. Pour donner une analogie avec le concept
d'application Web, tandis qu'une application Web est un composant J2EE déployable, contenant
un ensemble de servlettes, pages web, et JSP, un module EJB est également un composant
J2EE déployable, contenant un ensemble d'Enterprise Java Beans.
[lb]
Pour créer un projet EJB Module dans l'EDI NetBeans 4.1, choisissez le
type de projet “Ejb Module” qui est dans la catégorie “Enterprise”.
Composants EJB, 2
[lb]
Vous pouvez alors spécifier l'emplacement du projet, son nom, et si oui ou non
vous désirez rajouter ce composant J2EE à une application J2EE existante
(projet EAR). Vous pouvez toujours faire cela lorsque vous aurez créé un projet
d'Application J2EE.
[lb]
Votre projet est créé et visible dans la fenêtre Projects. Il ne contient pas de
composant Enterprise JavaBeans, aussi, votre première tâche sera d'en rajouter
un (voir section suivante)
Composants EJB, 3
[lb]
Vous pouvez sélectionner la fenêtre Files pour voir les répertoires et fichiers qui
ont été créés sur disque. La section suivante décrit la convention utilisée pour
cette structure.
Composants EJB, 4
Structure Module EJB
Les J2EE Blueprints fournissent des guidelines sur la façon de structurer
vos applications J2EE et modules EJB pour s'assurer qu'ils fonctionnent
proprement avec les différents serveurs d'application. Lorsque vous
créez un projet dans l'EDI, cette convention de structure J2EE Blueprints
est respectée.
Ce qui suit est une description rapide des éléments structurels du module
EJB généré:
[lb]
Le dossier src/java qui contient tous les fichiers sources Java dans
l'application.
[lb]
src/conf qui contient les descripteurs de déployement J2EE et les
descripteurs de déployement spécifiques aux serveurs d'application
[lb]
Le répertoire de setup qui contient les fichiers de ressources spécifiques
au serveur
Vous pouvez trouver des informations supplémentaires sur ces
conventions à l'adresse
https://conventions.dev.java.net/
Voir le Tableau 8-2 pour des informations sur comment les nombreux
éléments sources d'un Module EJB correspondent avec leur
représentation dans l'EDI et où ils finissent dans le composant déployé.
Tableau 8-2:
Contenu
Représentation dans la
fenêtre Projects
fenêtre Files
Emplacement dans le
Fichier EJB JAR Généré
(situé dans le dossier dist)
EJBs
Noeud Enterprise
JavaBeans
Répertoire src/java
Racine du fichier
Fichiers sources Java,
classes d'aide, fichiers Java
EJB, etc.
Noeud Source Packages
Répertoire src/java
Package structure for the
JAR file
Tests unitaires
Noeud Test Packages
Répertoire test
N/A
Descripteurs de
déployement (ejbjar.xml,
Noeud Configuration Files
Répertoire src/conf
Dossier META-INF
répertoire src/conf
Dossier META-INF
webservices.xml)
Fichier de configuration du
contexte et Descripteurs de
déployement serveurs
d'Application (sun-
ejb-jar.xml, suncmp-mapping.xml,
others)
Composants EJB, 5
Contenu
fenêtre Projects
fenêtre Files
Emplacement dans le
Fichier EJB JAR Généré
(situé dans le dossier dist)
Ressources ou scripts
spécifiques au serveur
d'application (SQL,...)
Configuration Files (visible répertoitre Setup
lorsque des ressources J2EE
existent)
Web services
Noeud Web services
src area (Java code)
libraries
Noeud Libraries
Répertoire Location
of the libraries
Fichiers Jar inclus dans le
jar du module EJB, à la
racine.
répertoire test
N/A
N/A. Les ressources dans ce
dossier sont enregistrés
automatiquement au
moment du déployement
pour le Serveur
d'Application de Sun.
Test classpath entries
noeud Test Libraries
project metadata including
build script
Project Properties dialog
build.xml file, nbproject
box, which you can open by folder
right-clicking the project's
node and choosing
Properties.
N/A
Ejb Module build area
(*.class files)
Pas visible dans la fenêtre
Projects
Contenu principal pour le
fichier d'archive du module
EJB.
Build et build/generated
Ajout d'EJB, Fichiers et Bibliothèques à votre Module EJB
Une fois que vous avez créé un projet de module EJB via l'assistant New Project, vous
pouvez commencer à y mettre des nouveaux EJBs et des classes “helper” Java.
La façon la plus directe de créer des fichiers est d'ouvrir la fenêtre Projects et de cliquezdroit sur le noeud où vous désirez placer le fichier et choisir New et ensuite un modèle depuis le
sous-menu. Un assistant apparait pour le modèle vous permettant de définir le nom et d'autres
caractéristiques du fichier.
[lb]
Choisissez le modèle “Session Bean”:
Composants EJB, 6
[lb]
L'assistant va créer un Session Bean et l'ajoutera au module EJB. Vous pouvez
spécifier le nom du Bean, le paquetage (assurez-vous que vous choisissez ou
créer un paquetage ici, et non de choisir le paquetage sans nom.) Vous pouvez
spécifier si ce Session Bean aura une interface locale et/ou distante (local est le
défaut), et si le Bean est un Session Bean de type “Stateful”. Vous pouvez
accepter les valeurs par défaut pour créer un Session Bean de type Stateless et
local:
Composants EJB, 7
[lb]
Notez la nouvelle vue logique dans la fenêtre Projects, sous le noeud “Enterprise
JavaBeans”. Ce composant EJB est un ensemble de fichiers Java(4 pour un
simple Session Bean):
[nl]
L'interface local (XXXlocal.java)
[nl]
L'interface local home (XXXLocalHome.java)
[nl]
L'implémentation du Bean en lui-même (XXXBean.java)
[nl]
L'interface métier (XXXLocalBusiness.java)
[lb]
La vue logique du projet cache la complexité de ces EJB en n'exposant qu'un
seul noeud qui expose quelques méthodes importantes pour le bean, comme les
méthodes locales:
Composants EJB, 8
Conseil EDI NetBeans
“Où sont mes Fichiers Java?” La vue logique cache les fichiers Java par
défaut. Mais vous pouvez voir la structure entière du paquetage et toutes
les classes de l'EJB sous le noeud “Source Packages”. Souvenez-vous
qu'un Enterprise JavaBeans est un ensemble de fichiers Java, ainsi que
des entrées dans certains fichiers de descripteur de déployement.
NetBeans va garder tous ces fichiers automatiquement synchronisés
lorsque vous interagissez avec la vue logique.
Ajout de la Logique Métier à un Enterprise Java Bean
Dans cette section, vous apprendrez les différentes types de méthodes que vous pouvez
ajouter à un Enterprise JavaBean. Souvenez-vous que NetBeans offre les assistants nécessaires
qui vont grandement simplifier le travail d'encodage de la logique métier dans les Enterprise
JavaBeans.
Méthodes de Bean
Une application J2EE réalise son travail via des méthodes que le client appele sur un Bean..
La liste suivante de types de méthodes sont soit générées automatiquement via l'assistant avec
l'implémentation par défaut, ou peut être rajouté via les actions du menu contextuel dans la vue
project local de la fenêtre de l'Éditeur Java pour une classe d'implémentation d'un EJB. La
génération supplémentaire nécessaire est prise en charge par l'EDI (c'est-à-dire, mise à jour des
interfaces local et distant, avec la signature correcte):
Composants EJB, 9
Composants EJB, 10
[nl]
Méthodes Métiers. Un client appele des méthodes métiers d'un Bean via
l'interface distant du Bean (ou l'interface local si c'est applicable).
Le développeur ajoute explicitement des méthodes métiers au Bean; L'EDI ne génère pas de
déclarations de méthode métier par défaut. Cependant, lorsque le développeur spécifie une
méthode métier, l'EDI place les déclarations de méthodes correspondantes dans la classe du
Bean et dans les interfaces distant, local ou les deux (distant et local).
Les méthodes métiers sont les méthodes les plus importantes pour un EJB. Ce sont celles qui
sont appelées par d'autres EJB ou des composants de la couche Web comme des JSP ou des
Servlets. Un assistant spécial NetBeans est disponible pour simplier le codage d'appel d'une
méthode métier d'un EJB. Depuis l'Éditeur Java de la Servlette ou d'un autre EJB, activez le
menu contextuel et choisissez le menu “Enterprise Resources” et le sous-menu Call EJB .
TIP
Méthodes Cycle de Vie. Le containeur appele certaines méthodes pour gérer le
cycle de vie d'un Enterprise Java Bean. Dépendant du type de Bean, le
containeur travaille via les méthodes de façon légèrement différente. Le
Composants EJB, 11
développeur a la possibilité de spécifier des paramètres pour quelques unes de
ces méthodes.
L'EDI génère automatiquement les déclarations de méthodes de cycle de vie appropriées pour
chacun des types de bean et les place dans la classe du Bean.
[nl]
Méthodes de Recherche. Le client passe par l'interface home pour trouver une
instance d'un Entity Bean par sa clef primaire. Le développeur peut également
rajouter d'autres méthodes de recherche.
NetBeans génère automatiquement une déclaration de méthode findByPrimaryKey dans
l'interface local home de chaque Entity Bean (et dans l'interface home du Bean, s'il en a une).
L'EDI place également une déclaration de méthode ejbFindByPrimaryKey correspondante
dans la classe de Bean de chaque Entity Bean qui gère sa propre persistence (c'est à dire, un
“Bean-Managed Persistent Entity Bean”, ou BMP Entity Bean). Si le développeur ajoute une autre
méthode de recherche, l'EDI place automatiquement les déclarations de méthodes
correspondantes dans l'interface local home (et home) et, pour les BMP Entity Beans, dans la
classe du Bean.
Un Entity Bean qui délègue sa persistence au containeur est appelé un Container-Managed
Persistent Entity Bean, ou un CMP Entity Bean. Les méthodes de recherche qui sont rajoutée aux
CMP Entity Beans incluent des instructions d'EJB Query Language (EJB QL), que le plugin du
serveur d'application du bean convertit automatiquement en une sorte de code SQL que le
serveur a besoin.
[nl]
Méthodes de Création. Le containeur initialise l'instance de l'Enterprise Bean,
en utilisant les arguments de la méthode create.
[nl]
Méthodes Home. Un Entity Bean peut utiliser une méthode home pour une
opération légère qui ne requiert pas l'accès à une instance particulière du bean.
(Par contraste, une méthode métier requiert un accès à une instance particulière.)
Le développeur ajoute explicitement une méthode home, et l'EDI génère la
déclaration de méthode correspondante dans la classe du bean, et l'interface
home ou local home du bean. Un Entity Bean peut avoir autant de méthodes
home.
[nl]
Méthodes de Sélection. Un CMP Entity Bean peut utiliser une méthode select.
Comme une méthode de recherche, une méthode de sélection peut intérroger la
base de données et retourner une interface locale ou distante ou une collection.
De plus, une méthode de sélection peut interroger un Entity Bean situé dans le
même module EJB et retourner des valeurs depuis ses champs persistants. Les
méthodes de sélections ne sont pas exposées dans les interfaces de type distant et
ne peuvent être invoquées par un client.
[nl] Méthodes OnMessage. Un client envoye un message via une destination
Java Message Service (JMS) pour appeler un méthode onMessage sur un
message-driven bean.
Ajout d'une Simple Méthode Métier
[lb]
Choisissez le menu contextuel “Add Business Method” soit depuis le noeud
logique ou depuis l'Éditeur Java pour un code d'implémentation d'un Bean.
Introduisez un nom de méthode, une liste de paramètres, et leur type, ainsi que
les possibles exceptions qui pourraient être rejetées par cette méthode métier.
Composants EJB, 12
[lb]
Notez le changement dans le fichier Java implémentant le Bean; il contient
maintenant le corps de la nouvelles méthode métier et vous pouvez maintenant
utiliser les capacités de l'éditeur Java de l'EDI pour terminer l'implémentation de
la méthode.
Composants EJB, 13
[lb]
Lorsque vous avez fini de coder la méthode, choisissez le menu“Build” de votre
projet pour lancer la compilation des fichiers Java et la création des archives EJB
(dans le répertoire “dist”).
Descripteurs de Déployement EJB Bean
L'un des buts de l'EDI NetBeans est de cacher autant que possible les fichiers Descripteurs
de Déployement au développeur. Ce but est atteint avec le concept de configuration zéro
implémenté dans l'EDI: lorsque le développeur utilise l'assistant fournit comme “Call EJB”, ou
“Use Database”, ou “Call Message”, ou “Call Web service operation”, l'EDI effectue les tâches
suivantes:
Composants EJB, 14
[nl]
[nl]
[nl]
[lb]
[lb]
Génère le bout de code Java pour le lookup JNDI dans le fichier appelant. Si le
Projet J2EE utilise un Service Locator Object (se référer à l'assistant Server
Location),
Met à Jour le fichier de descripteur de déployement J2EE en rajoutant des
éléments EJB-REF ou RESOURCE-REF correspondants.
Modifie le projet J2EE pour rajouter les dépendances de Projets nécessaires, si
l'appel est cross-projects. Le packaging qui en résulte doit utiliser le type de
Projet J2EE Application pour s'assurer que tous les modules J2EE soient
correctement assemblée dans l'Archive d'Application J2EE (EAR) avant le
déployement.
Bien sûr, le développeur a également la possibilité d'éditer ces Descripteurs de
Déployement et ici aussi, NetBeans offre une facilité d'utilisation grâce à
l'édition bidirectionnel (Éditeur XML avec completion de Code et validation en
ligne, ainsi que Édition Visuelle).
L'Éditeur Visuel pour le fichier Descripteur de Déployement est activé en
double-cliquant sur le noeud du fichier DD dans la fenêtre Projects. Un ensemble
de vues sont disponibles: par exemple, pour un module J2EE EJB, les vues
Overview ou XML sont possibles. Une liste déroulante permet également de
sauter directement dans une section particulière dans le fichier de DD.
Composants EJB, 15
[lb]
Pour vous rendre dans la vue XML du fichier, sélectionnez le bouton XML situé
en haut de l'Éditeur Visuel:
Composants EJB, 16
[lb]
Ci-dessus, l'éditeur XML, affichant la possibilité de completion de code. Notez
la barre d'outils dans cet éditeur. La dernière icône active l'action de validation
XML, pour qu'un développeur puisse vérifier la conformité du fichier de
descripteur de déployement par rapport au DTD ou au Schéma.
Composants EJB, 17

Guide Pratique EDI NetBeans

Transcription

Documents pareils

Jonathan Weisberg

les vacances de mr bean les vacances de mr bean

Développement J2EE

Formation perfectionnement

TP – Mise en œuvre d`un serveur d`applications (JBoss) : intégration

Etude des serveurs d`applications EJB Cas particulier

Les vacances de Mr. Bean

OFC Flow Manager

Ingénieur en Java/J2EE

Pour télécharger le programme détaillé du cours