Copyright © 2005 Sun Microsystems, Inc. All rights reserved. · 2009. 11. 8. · d'Enterprise Java...

Guide Pratique EDI NetBeansCopyright © 2005 Sun Microsystems, Inc. All rights reserved.

Table des matièresAssistant type de Projet EJB.............................................................................................................2Structure Module EJB.......................................................................................................................5Ajout d'EJB, Fichiers et Bibliothèques à votre Module EJB..............................................................6Ajout de la Logique Métier à un Enterprise Java Bean.....................................................................9

Méthodes de Bean.......................................................................................................................9Ajout d'une Simple Méthode Métier................................................................................................12Descripteurs 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)

[nl] Les méthodes métiers des Enterprise Java Beans peuvent être sécurisés déclarativement, sans modification de code source.

[nl] 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é.

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”.


[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)


[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.


Structure Module EJBLes 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'adressehttps://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 ProjectsReprésentation dans la 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 (ejb-jar.xml, webservices.xml)

Noeud Configuration Files Répertoire src/conf Dossier META-INF

Fichier de configuration du contexte et Descripteurs de déployement serveurs d'Application (sun-ejb-jar.xml, sun-cmp-mapping.xml, others)

répertoire src/conf Dossier META-INF


https://conventions.dev.java.net/

Contenu Représentation dans la fenêtre Projects

Représentation dans la 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 lorsque des ressources J2EE existent)

répertoitre Setup N/A. Les ressources dans ce dossier sont enregistrés automatiquement au moment du déployement pour le Serveur d'Application de Sun.

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.

Test classpath entries noeud Test Libraries répertoire test N/A

project metadata including build script

Project Properties dialog box, which you can open by right-clicking the project's node and choosing Properties.

build.xml file, nbproject folder

N/A

Ejb Module build area (*.class files)

Pas visible dans la fenêtre Projects

Build et build/generated Contenu principal pour le fichier d'archive du module EJB.

Ajout d'EJB, Fichiers et Bibliothèques à votre Module EJBUne 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 cliquez-

droit 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”:


[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:


[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:


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 BeanDans 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):


[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


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.


[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.


[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:


[nl] 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),

[nl] Met à Jour le fichier de descripteur de déployement J2EE en rajoutant des éléments EJB-REF ou RESOURCE-REF correspondants.

[nl] 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.

[lb] 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).

[lb] 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.


[lb] Pour vous rendre dans la vue XML du fichier, sélectionnez le bouton XML situé en haut de l'Éditeur Visuel:


[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.


Copyright © 2005 Sun Microsystems, Inc. All rights reserved. · 2009. 11. 8. · d'Enterprise Java...

Documents

Transcript of Copyright © 2005 Sun Microsystems, Inc. All rights reserved. · 2009. 11. 8. · d'Enterprise Java...