Création d'un premier EJB avec Eclipse et JOnAS

stessy delcroix

Ce document est destiné à expliquer la création, le déploiement et le test d'un EJB.
Cette application sera développée avec Eclipse.

- Titre : Création d'un premier EJB avec Eclipse et JOnAS

- Auteur : stessy delcroix

- Parution : 26 mai 2004

- Mise à jour : 23 mars 2020

- Licence : Ce document est issu de https://www.developpez.com et reste la propriété exclusive de son auteur. La copie, modification et/ou distribution par quelque moyen que ce soit est soumise à l'obtention préalable de l'autorisation de l'auteur.

Sommaire

- Avant-propos

- I. Installation des différents outils

- I-A. Installation d'Eclipse

- I-B. Installation de JOnAS

- I-C. Installation du plugin Jope

- II. Configuration d'Eclipse

- II-A. Configuration des différents plugins

- II-A-1. Configuration des préférences

- II-A-2. Configuration de la perspective

- III. Développement de l'application

- III-A. Création du projet

- III-B. Création de l'EJB

- III-C. Code généré

- III-D. Modification du code

- IV. Création de l'archive, déploiement de l'application et test de l'EJB

- IV-A. Création de l'archive

- IV-B. Déploiement de l'EJB

- IV-C. Test de notre EJB

Avant-propos

Je tiens tout d'abord à remercier les membres de Developpez.com, pour la correction apportée à mon article tant au niveau du fond que de la forme.

Cet article fait suite à mon envie de découvrir le développement d'EJB avec Eclipse. Je découvre tout comme vous le développement d'EJB. Donc toute remarque constructive pour améliorer le côté pédagogique ainsi que le côté technique est la bienvenue.

Voici les différents outils utilisés pour le développement de l'application

La version de java utilisée est la J2SE 1.4.2_03.

La version d'Eclipse utilisée est la version 2.1.3.

La version de JOnAS est la version 3.3.6. Cette Version intègre Tomcat comme conteneur web qui est indispensable pour faire tourner notre première application.

La version du plugin Jope utilisée pour la création et le déploiement d'application sur le serveur d'application JOnAS est la version 1.1.2.

La première partie de mon article expliquera la mise en place de l'environnement de travail nécessaire pour le développement de l'application.

La deuxième partie traitera de la configuration d'Eclipse pour faire fonctionner les différents plugins utilisés pour permettre de gérer et déployer l'application.

La troisième partie parlera du développement de l'application.

La quatrième partie montrera comment déployer et mettre en production l'application à l'aide des outils fournis.

I - Installation des différents outils

I-A - Installation d'Eclipse

Pour l'installation d'Eclipse, je vous conseille de lire l'excellent didacticiel rédigé par Jean-Michel Doudoux.
Vous le trouverez à l'adresse suivante : https://jmdoudoux.developpez.com/java/Eclipse/.

I-B - Installation de JOnAS

Pour l'installation de JOnAS je vous renvoie vers l'excellent article écrit par Debernad pour l'installation de JOnAS sur plateforme Windows et Linux.
Vous les trouverez aux adresses suivantes :
Installation de JOnAS sur plateforme Linux ;
Installation de JOnAS sur plateforme Windows.

I-C - Installation du plugin Jope

Pour cette partie, rien de plus simple. Il suffit de dézipper le plugin dans le répertoire

$Eclipse_HOME/plugins

où Eclipse_HOME représente le répertoire d'installation d'Eclipse.

II - Configuration d'Eclipse

Vous pouvez dès à présent lancer Eclipse.
Voici normalement ce que vous devriez avoir comme représentation graphique.

II-A - Configuration des différents plugins

II-A-1 - Configuration des préférences

Nous allons commencer par configurer les préférences. Nous devons aller dans l'onglet « Window --> Preferences ».

La configuration à mettre en place pour utiliser le plugin Jope est très simple.
Il vous suffit de spécifier le répertoire d'installation de JOnAS dans les champs « jonas root » et « jonas server ». Ne vous préoccupez pas pour l'instant de la configuration de la datasource. Comme nous n'utilisons pas pour l'instant d'accès à une base de données, nous n'en aurons tout simplement pas besoin.

II-A-2 - Configuration de la perspective

Nous allons dès à présent configurer la perspective pour nous permettre :

- de créer un projet ;

- de gérer ce projet ;

- de pouvoir démarrer et stopper JonAS ;

- d'ajouter le support de struts à ce projet ;

- …

Comme vous pouvez le constater, ces plugins permettent la gestion complète d'une application.
Aussi bien une application web qu'une application j2ee complète.

Passons maintenant à la configuration proprement dite de cette perspective.
Nous devons aller dans l'onglet « Window --> Customize Perspective ».

Selectionnez « File > New ».

Cochez les cases suivantes :

- Jonas project ;

- Jonas EJB.

Selectionnez « Other ».
Cochez la case suivante :

- Jonas.

Validez vos choix.
Vous devriez normalement voir apparaître un nouveau menu ainsi que de nouvelles icônes dans la barre d'outils.

Nous en avons terminé avec la configuration d'Eclipse.

III - Développement de l'application

III-A - Création du projet

La configuration étant à présent terminée, nous allons pouvoir rentrer dans le vif du sujet, c'est-à-dire le développement de notre premier EJB.

La première chose à faire est de créer un nouveau projet.
Pour ce faire, nous devons aller dans le menu « File --> New --> Project ».

- Choisissez « Jonas Project ».

- Cliquez sur « next ».

- Choisissez le nom du projet : par exemple FirstEJB.

- Cliquez sur « next ».

- Cochez la case « Create a web application ».

- Cliquez sur « Finish ».

Voici normalement à quoi ressemblera l'arborescence de votre projet.

III-B - Création de l'EJB

Nous allons créer notre premier EJB à l'aide du plugin Jope.

- Allez dans le menu « File --> New --> Jonas EJB »

- Entrez le nom du package. Par exemple « helloWorld ».

- Entrez le nom de l'EJB. Par exemple « HelloWorld ».

- Entrez le nom de l'archive. Par exemple « helloWorld ».

- Cochez la case « Remote ».

Vous remarquerez que les différentes classes nécessaires ainsi que le client ont été créés.

III-C - Code généré

Je vais vous présenter le code généré par le plugin.

Premièrement voici l'interface distante.
Cette interface va contenir toutes les méthodes métier qu'un client peut invoquer sur notre EJB

HelloWorld.java

// HelloWorld.java
package helloWorld;

import java.rmi.RemoteException;
import javax.ejb.EJBObject;

/**
* HelloWorld remote interface
*/
public interface HelloWorld extends EJBObject {
public void method1() throws RemoteException;
public void method2(java.lang.String s) throws RemoteException;

}

L'interface d'accueil.
Cette interface définit les méthodes qu'un client peut invoquer pour :

- créer des objets EJB ;

- trouver les objets EJB existants (pour les beans entité) ;

- supprimer les objets EJB.

HelloWorldHome.java

// HelloWorldHome.java

package helloWorld;

import java.rmi.RemoteException;
import java.util.Collection;
import javax.ejb.CreateException;
import javax.ejb.EJBHome;
import javax.ejb.FinderException;

/**
* Home interface for the bean HelloWorld
*/
public interface HelloWorldHome extends EJBHome {
HelloWorld create() throws CreateException, RemoteException;
}

L'EJB qui va contenir toutes les méthodes métier de notre application.

HelloWorldEJB.java

// HelloWorldEJB.java
// Stateless Session bean

package helloWorld;

import java.rmi.RemoteException;
import java.sql.Connection;
import java.sql.SQLException;
import java.sql.Statement;
import javax.ejb.CreateException;
import javax.ejb.EJBException;
import javax.ejb.RemoveException;
import javax.ejb.EJBObject;
import javax.ejb.SessionBean;
import javax.ejb.SessionContext;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;
import javax.sql.DataSource;

/**
*
*/
public class HelloWorldEJB implements SessionBean {

SessionContext ejbContext;

// ------------------------------------------------------------------
// SessionBean implementation
// ------------------------------------------------------------------

public void setSessionContext(SessionContext ctx) {
ejbContext = ctx;
}

public void ejbRemove() {
}

public void ejbCreate() throws CreateException {
}

public void ejbPassivate() {
}

public void ejbActivate() {
}

// ------------------------------------------------------------------
// HelloWorld implementation
// ------------------------------------------------------------------

/**
* method1
*/
public void method1() {
}

/**
* method2
*/
public void method2(java.lang.String s) {
}
}

Le client de l'EJB.

HelloWorldClient.java

// HelloWorldClient.java
// mini Client for accessing bean HelloWorld

package helloWorld;

import java.rmi.RemoteException;
import java.util.Collection;
import java.util.Properties;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;
import javax.rmi.PortableRemoteObject;

/**
*
*/
public class HelloWorldClient {

static Context ctx = null;
static HelloWorldHome home = null;

public static void main(String[] arg) {

// Get InitialContext
try {
ctx = getInitialContext();
} catch (NamingException e) {
e.printStackTrace();
System.exit(2);
}

// Lookup bean home
String bName = "HelloWorldHome";
try {
home = (HelloWorldHome) PortableRemoteObject.narrow(ctx.lookup(bName), HelloWorldHome.class);
HelloWorld bean = home.create();
bean.method1();
} catch(Exception e) {
e.printStackTrace();
System.exit(2);
}

// ...
}

/**
* Using a Properties object will work on JDK 1.1.x and Java2
* clients
*/
static private Context getInitialContext() throws NamingException {
String url = "rmi://localhost:1099";

try {
// Get an InitialContext
Properties h = new Properties();
h.put(Context.INITIAL_CONTEXT_FACTORY,
"com.sun.jndi.rmi.registry.RegistryContextFactory");
h.put(Context.PROVIDER_URL, url);
return new InitialContext(h);
} catch (NamingException ne) {
ne.printStackTrace();
throw ne;
}
}

}

Le descripteur de déploiement qui va reprendre les conditions que doivent remplir les composants telles que :

- la gestion du cycle de vie des beans ;

- la persistance ;

- le paramétrage des transactions ;

- …

helloWorld.xml

<!DOCTYPE ejb-jar PUBLIC
"-//Sun Microsystems, Inc.//DTD Enterprise JavaBeans 2.0//EN"
"http://java.sun.com/dtd/ejb-jar_2_0.dtd">

<ejb-jar>

<description>Describe here the content of this file</description>
<display-name>helloWorld</display-name>

<enterprise-beans>
<session>
<description>Describe here the session bean HelloWorld</description>
<display-name>helloWorld/HelloWorldEJB</display-name>
<ejb-name>HelloWorldEJB</ejb-name>
<home>helloWorld.HelloWorldHome</home>
<remote>helloWorld.HelloWorld</remote>
<ejb-class>helloWorld.HelloWorldEJB</ejb-class>
<session-type>Stateless</session-type>
<transaction-type>Container</transaction-type>
<env-entry>
<env-entry-name>name1</env-entry-name>
<env-entry-type>java.lang.String</env-entry-type>
<env-entry-value>value1</env-entry-value>
</env-entry>
<resource-ref>
<res-ref-name>jdbc/mydb</res-ref-name>
<res-type>javax.sql.DataSource</res-type>
<res-auth>Application</res-auth>
</resource-ref>
</session>
</enterprise-beans>

<assembly-descriptor>

<container-transaction>
<method>
<ejb-name>HelloWorldEJB</ejb-name>
<method-name>*</method-name>
</method>
<trans-attribute>Supports</trans-attribute>
</container-transaction>

</assembly-descriptor>

</ejb-jar>

Le fichier propre à chaque conteneur d'EJB qui est un fichier xml reprenant des fonctions qui ne sont pas traitées par la spécification EJB.

jonas-helloWorld.xml

<!DOCTYPE jonas-ejb-jar PUBLIC
"-//ObjectWeb//DTD JOnAS 3.2//EN"
"http://www.objectweb.org/jonas/dtds/jonas-ejb-jar_3_2.dtd">

<jonas-ejb-jar>

<jonas-session>
<ejb-name>HelloWorldEJB</ejb-name>
<jndi-name>HelloWorldHome</jndi-name>
<jonas-resource>
<res-ref-name>jdbc/mydb</res-ref-name>
<jndi-name>jdbc_1</jndi-name>
</jonas-resource>
</jonas-session>

</jonas-ejb-jar>

III-D - Modification du code

Nous allons à présent modifier les différentes classes pour que notre client puisse afficher « Hello World » dans la console d'Eclipse.
Commençons par modifier l'EJB, en lui ajoutant une méthode qui va retourner un String. Remplacez les deux méthodes actuelles.

/**
* method1
*/
public void method1() {
}

/**
* method2
*/
public void method2(java.lang.String s) {
}

par cette méthode

public String hello()
{
return "Hello World";
}

Nous allons également modifier l'interface distante pour que le client puisse appeler la méthode hello(). Remplacez les deux lignes actuelles

public void method1() throws RemoteException;
public void method2(java.lang.String s) throws RemoteException;

par cette ligne.

public String hello() throws RemoteException;

Modification du client pour qu'il appelle la méthode de l'EJB qui va permettre d'afficher « Hello World ».
Remplacez la méthode

bean.method1();

par cette ligne.

System.out.println(bean.hello());

Une personne m'a judicieusement fait remarquer qu'une NamingException était capturée et affichée deux fois, ce qui est inutile.
Remplacez simplement cette méthode

static private Context getInitialContext()throws NamingException{
String url = "rmi://localhost:1099";

try
{
// Get an InitialContext
Properties h = new Properties();
h.put(Context.INITIAL_CONTEXT_FACTORY,
"com.sun.jndi.rmi.registry.RegistryContextFactory");
h.put(Context.PROVIDER_URL, url);
return new InitialContext(h);
}
catch(NamingException ne)
{
ne.printStackTrace();
throw ne;
}
}

par celle-ci.

static private Context getInitialContext()throws NamingException{
String url = "rmi://localhost:1099";

// Get an InitialContext
Properties h = new Properties();
h.put(Context.INITIAL_CONTEXT_FACTORY,
"com.sun.jndi.rmi.registry.RegistryContextFactory");
h.put(Context.PROVIDER_URL, url);
return new InitialContext(h);
}

Il ne reste plus enfin qu'à enlever certaines lignes inutiles dans les descripteurs de déploiement.

- Les balises décrivant les propriétés d'environnement dans le fichier helloWorld.xml.

<env-entry>
<env-entry-name>name1</env-entry-name>
<env-entry-type>java.lang.String</env-entry-type>
<env-entry-value>value1</env-entry-value>
</env-entry>

- Les balises déclarant les références à la fabrique de ressources dans le fichier helloWorld.xml. Inutile dans notre cas puisque nous n'utilisons pas par exemple de connexion JDBC

<resource-ref>
<res-ref-name>jdbc/mydb</res-ref-name>
<res-type>javax.sql.DataSource</res-type>
<res-auth>Application</res-auth>
</resource-ref>

- Les balises déclarant la ressource qui est mentionnée dans le code de notre EJB.
Comme nous n'avons pas déclaré de ressources dans notre code, cette balise ne sert strictement à rien.

<jonas-resource>
<res-ref-name>jdbc/mydb</res-ref-name>
<jndi-name>jdbc_1</jndi-name>
</jonas-resource>

Votre EJB est enfin prêt.

IV - Création de l'archive, déploiement de l'application et test de l'EJB

IV-A - Création de l'archive

Pour générer l'EJB de notre application, le plugin utilise ant qui est une sorte de make pour Java.
L'outil va par la même occasion créer les stubs et skeleton qui vont nous permettre de communiquer au travers du réseau.

- Choisissez votre projet dans l'arborescence.

- Faites un clic droit.

- Choisissez « Jonas Project --> Create and export all EJB JAR files to Jonas »

Si tout s'est bien passé, voici ce que la console vous a normalement affiché.

Buildfile: D:\Development\Eclipse\workspace\FirstEJB\components\build.xml

install:
Trying to override old definition of task ejbjar

init:
[mkdir] Created dir: D:\Development\Eclipse\workspace\FirstEJB\output
[mkdir] Created dir: D:\Development\Eclipse\workspace\FirstEJB\output\ejbjars

jonasejbjar:
[ejbjar] building helloWorld.jar with 5 files
[genic] GenIC for JOnAS 3.3.6: Beans 'HelloWorldEJB' generation ...
[genic] Stubs and Skels successfully generated for rmi/jrmp
[genic] Stubs and Skels successfully generated with rmi/jeremie

install:
[copy] Copying 1 file to D:\Development\jonas\ejbjars
BUILD SUCCESSFUL
Total time: 34 seconds

IV-B - Déploiement de l'EJB

Voici la marche à suivre pour déployer l'EJB.

- Démarrez JOnAS en cliquant sur le 2e bouton fourni par le plugin.

Si tout s'est bien passé, Eclipse a changé de perspective et est passé en mode debug.

Démarrez la console d'administration de JOnAS.

- Démarrez votre navigateur.

- Tapez l'adresse suivante http://localhost:8080/jonasAdmin/

- Entrez « jonas » comme « user name » et « jonas » comme « password »

Voici la page principale pour administrer JOnAS

- Cliquez sur le lien « deployements --> EJB Modules (JAR) ».

- Choisissez notre EJB : « helloWorld.jar ».

- Cliquez sur « deploy » et ensuite sur « apply ».

Cliquez ensuite sur confirm.
Voilà, votre EJB est déployé.

IV-C - Test de notre EJB

Pour pouvoir tester notre client depuis Eclipse, nous allons devoir ajouter des archives au classpath, ainsi que des arguments pour la JVM.
Dans Eclipse, choisissez le bouton pour démarrer le client.

- Choisissez « Run … ». Il va rechercher dans l'arborescence une classe main

- Allez ensuite dans l'onglet « Arguments » et ajoutez les arguments ci-dessous dans « Program arguments »

-Djavax.rmi.CORBA.PortableRemoteObjectClass=org.objectweb.carol.rmi.multi.MultiPRODelegate
-Djava.naming.factory.initial=org.objectweb.carol.jndi.spi.MultiOrbInitialContextFactory
-Dorg.omg.PortableInterceptor.ORBInitializerClass.org.objectweb.jonas_tm.ots.OTSORBInitializer
-Dorg.omg.PortableInterceptor.ORBInitializerClass.org.objectweb.jonas.security.interceptors.iiop.SecurityInitializer
-Djava.security.auth.login.config=D:\Development\jonas\conf\jaas.config helloWorld.HelloWorldClient

Pensez à remplacer le répertoire d'installation de JOnAS dans la dernière ligne d'arguments de la JVM.

- Allez ensuite dans « classpath » et ajoutez l'archive « client.jar » et l'archive de notre EJB

- Cliquez sur le bouton « Apply ».

- Cliquez ensuite sur le bouton « Run ».

Si tout s'est bien passé, la console d'Eclipse doit vous afficher un beau petit « Hello World »