-
Bien que l'euro soit devenue notre monnaie officielle, tout système informatique doit être capable de donner le montant indicatif en Franc d'un article ou d'un devis. Afin de répondre à ce besoin, nous allons développer un EJB qui aura comme seule méthode : euroToFranc().
Nous implémenterons dans l'Enterprise JavaBean nos règles de conversion, ainsi, tous les composants de notre système n'auront pas à se poser la question : "Comment fait-on la conversion en franc ? Quelles règles doit-on observer ?", ils auront juste à invoquer la méthode euroToFranc() de notre EJB.
Pour réaliser l'exemple de ce chapitre, créez, à la racine de "c:\java\dev", un répertoire "Convertisseur" dans lequel vous mettrez tous vos fichiers.
-
-
Etant donné que notre composant doit fournir une conversion de l'euro vers le franc, nous allons déclarer dans l'interface distante une méthode fonctionnelle qui va prendre en paramètre le montant en euro et va retourner un float qui sera la conversion de ce montant en Franc.
ConvertisseurEuro.java
|
1
2
3
4
5
6
7
8
9
10
|
package convertisseurs;
import javax.ejb.EJBObject;
import java.rmi.RemoteException;
public interface ConvertisseurEuro extends EJBObject {
public double euroToFranc(float montantEnFranc) throws RemoteException;
}
|
|
Java2html
|
-
Cette interface n'est pas différente de celle du chapitre précédent. Elle définit la méthode que le client peut utiliser pour créer l'EJB.
ConvertisseurEuroHome.java
|
1
2
3
4
5
6
7
8
9
10
11
12
|
package convertisseurs;
import java.io.Serializable;
import java.rmi.RemoteException;
import javax.ejb.CreateException;
import javax.ejb.EJBHome;
public interface ConvertisseurEuroHome extends EJBHome {
ConvertisseurEuro create() throws RemoteException, CreateException;
}
|
|
Java2html
|
-
Pour ne pas compliquer notre code, notre fonction va se contenter de faire une simple division mais nous aurions pu rajouter ici nos règles d'arrondis.
ConvertisseurEuroBean.java
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
|
package convertisseurs;
import java.rmi.RemoteException;
import javax.ejb.SessionBean;
import javax.ejb.SessionContext;
import java.math.*;
import java.text.*;
import java.util.*;
public class ConvertisseurEuroBean implements SessionBean {
// Combien de francs fait un euro
private static final double UN_EURO_EN_FRANC = 6.55957;
public double euroToFranc(float montantEnFranc) {
return montantEnFranc / UN_EURO_EN_FRANC;
}
public void ejbCreate() {}
public void ejbRemove() {}
public void ejbActivate() {}
public void ejbPassivate() {}
public void setSessionContext(SessionContext sc) {}
}
|
|
Java2html
|
-
-
Comme nous l'avons vu précédemment, notre descripteur de déploiement décrit notre EJB : son nom, son interface home, son interface distante, la classe du composant et les transactions sur les méthodes.
| ejb-jar.xml |
|
<?xml version="1.0" encoding="ISO-8859-1"?>
<!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>Descripteur de déploiement du convertisseur euro</description>
<display-name>Convertisseur Euro</display-name>
<enterprise-beans>
<session>
<description>Convertisseur Euro</description>
<display-name>ConvertisseurEuro</display-name>
<ejb-name>ConvertisseurEuro</ejb-name>
<home>convertisseurs.ConvertisseurEuroHome</home>
<remote>convertisseurs.ConvertisseurEuro</remote>
<ejb-class>convertisseurs.ConvertisseurEuroBean</ejb-class>
<session-type>Stateless</session-type>
<transaction-type>Container</transaction-type>
</session>
</enterprise-beans>
<assembly-descriptor>
<container-transaction>
<method>
<ejb-name>ConvertisseurEuro</ejb-name>
<method-name>*</method-name>
</method>
<trans-attribute>Required</trans-attribute>
</container-transaction>
</assembly-descriptor>
</ejb-jar>
|
-
Le fichier ci-dessous spécifie que MyConvertisseurEuro sera le nom JNDI de l'objet qui est l'interface Home de l'Enterprise JavaBean. Ce nom sera utilisé par notre client pour trouver l'interface home de notre EJB.
| jonas-ejb-jar.xml |
|
<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE jonas-ejb-jar PUBLIC "-//ObjectWeb//DTD JOnAS 2.4//EN" "http://www.objectweb.org/jonas/dtds/jonas-ejb-jar_2_4.dtd">
<jonas-ejb-jar>
<jonas-session>
<ejb-name>ConvertisseurEuro</ejb-name>
<jndi-name>MyConvertisseurEuro</jndi-name>
</jonas-session>
</jonas-ejb-jar>
|
-
Notre EJB doit être packagé dans une archive JAR qui devra contenir :
- Les classes de l'EJB.
- Les deux descripteurs de déploiements (
ejb-jar.xml et jonas-ejb-jar.xml ).
-
Pour déployer notre EJB sous JOnAS, notre fichier ejb-jar doit posséder les classes d'interposition interfacant notre Entreprise JavaBean avec les services offerts par notre conteneur. Ces classes vont être crées à l'aide de l'utilitaire GenIC fourni avec JOnAS.
Ensuite, pour déployer notre EJB dans JOnAS, il suffira de copier le fichier .jar vers le répertoire "C:\java\plateforme\jonas\ejbjars".
-
Comme dans notre précédent exemple, notre client va :
- Trouver l'interface locale à l'aide de JNDI.
- Créer une instance d'un objet du même type que
ConvertisseurEuro.
- Invoquer les méthodes de notre EJB.
Notre application cliente va demander à l'utilisateur d'entrer un montant euro et va lui retourner la conversion de ce montant en franc. Voici le code source :
ConvertisseurEuroClient.java
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
|
package convertisseurs;
import java.util.Properties;
import javax.naming.InitialContext;
import javax.naming.Context;
import javax.transaction.UserTransaction;
import javax.rmi.PortableRemoteObject;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
public class ConvertisseurEuroClient {
public static void main(String args[]) {
try {
// Recherche de l'interface home de l'EJB
Context initialContext = new InitialContext();
Object objref = initialContext.lookup("MyConvertisseurEuro");
// Référence à l'EJB
ConvertisseurEuroHome home = (ConvertisseurEuroHome)PortableRemoteObject.narrow(objref, ConvertisseurEuroHome.class);
ConvertisseurEuro myConvertisseurEuro = home.create();
// On va lire les valeurs que l'utilisateur va entrer en ligne
InputStreamReader isr = new InputStreamReader ( System.in );
BufferedReader br = new BufferedReader ( isr );
String valeurEnFranc = null;
System.out.println("Entrez la valeur en Euros : ");
valeurEnFranc = br.readLine ();
while ( ! valeurEnFranc.equals("fin") ) {
float valeurEnFranceFloat = Float.valueOf(valeurEnFranc.trim()).floatValue();
System.out.println("-> " + valeurEnFranc + " Fr = " + myConvertisseurEuro.euroToFranc(valeurEnFranceFloat) + " Euros");
System.out.println("Entrez la valeur en Euros : ");
valeurEnFranc = br.readLine ();
}
} catch (Exception e) {
System.err.println("Erreur : " + e);
System.exit(2);
}
}
}
|
|
Java2html
|
-
Pour réaliser la compilation, le packaging et le déploiement, nous allons utiliser le script suivant :
build.bat
|
@Echo off
REM Spécifie que les SET qui seront faits dans ce fichier ne seront valable que pendant l'éxecution de ce fichier
setlocal
echo ************************************************************************************
echo Compilation de l'Enterprise JavaBeans ConvertisseurEuro
echo ************************************************************************************
echo.
echo.
echo ************************************************************************************
echo Mets en place les variables d'environnement
call %JONAS_ROOT%\bin\nt\setenv.bat
Set BUILD_DIR=C:\java\dev\build
echo ************************************************************************************
echo.
echo ************************************************************************************
echo Modifie le classpath
set CLASSPATH=%CLASSPATH%;%BUILD_DIR%
set CLASSPATH=%CLASSPATH%;%J2EE_HOME%\lib\j2ee.jar
set CLASSPATH=%CLASSPATH%;%JONAS_ROOT%\lib\common\j2ee\ejb.jar
echo ************************************************************************************
echo.
echo ************************************************************************************
echo Compile les fichiers sources de l'EJB et les mets dans le répertoire de construction
%JAVAC% -d %BUILD_DIR% ConvertisseurEuro.java ConvertisseurEuroHome.java ConvertisseurEuroBean.java
echo ************************************************************************************
echo.
echo ************************************************************************************
echo Compile le Client de l'EJB et le mets dans le répertoire de construction
%JAVAC% -d %BUILD_DIR% ConvertisseurEuroClient.java
echo ************************************************************************************
echo.
echo ************************************************************************************
echo Construit l'EJB
copy ejb-jar.xml %BUILD_DIR%\META-INF\ejb-jar.xml
copy jonas-ejb-jar.xml %BUILD_DIR%\META-INF\jonas-ejb-jar.xml
cd %BUILD_DIR%
jar cvf convertisseurs\ConvertisseurEuro.jar META-INF\ejb-jar.xml META-INF\jonas-ejb-jar.xml convertisseurs\ConvertisseurEuro.class convertisseurs\ConvertisseurEuroBean.class convertisseurs\ConvertisseurEuroHome.class
del META-INF\ejb-jar.xml META-INF\jonas-ejb-jar.xml
echo ************************************************************************************
echo.
echo ************************************************************************************
echo Génère les classes d'interposition avec GenIC
call %JONAS_ROOT%\bin\nt\GenIC.bat -classpath C:\java\dev\build -d %BUILD_DIR% -keepgenerated %BUILD_DIR%\convertisseurs\convertisseurEuro.jar
echo ************************************************************************************
echo.
echo ************************************************************************************
echo Installation notre EJB
copy %BUILD_DIR%\convertisseurs\ConvertisseurEuro.jar %JONAS_ROOT%\ejbjars\ConvertisseurEuro.jar
echo ************************************************************************************
echo.
cd C:\java\dev\Convertisseur
|
Le fichier précédent effectuera la compilation, le packaging et le déploiement de notre ejb ainsi que la compilation de notre client.
Vous devrez ensuite éditer le fichier jonas.properties qui se trouve dans le répertoire "C:\java\plateforme\jonas\config" pour modifier la ligne jonas.service.ejb.descriptors et y ajouter convertisseurEuro.jar.
-
Voici la marche à suivre :
- cd C:\java\dev\Convertisseur
- build
- jonas start
- cd C:\java\dev\build
- jclient convertisseurs.ConvertisseurEuroClient
Vous pouvez ensuite entrer les valeurs à convertir, par exemple 100 ou 10. Pour quitter le programme, tapez : "fin" puis "Entrée".
-
Nous avons développé dans ce chapitre un EJB de type session sans état. Comme vous l'avez constaté, ce genre d'EJB est utilisé pour effectuer des tâches ( lorsque celles ci n'impliquent pas un besoin de garder des valeurs entre plusieurs appels de méthodes ).
Les étapes du développement d'un Enterprise JavaBean doivent maintenant être pour vous un automatisme. Nous avons toujours le même schéma :
- Ecriture du composant
- Ecriture de l'interface distante
- Ecriture de l'interface locale
- Ecriture de l'Enterprise JavaBean
- Rédaction des descripteurs de déploiement
- Packaging de notre Enterprise JavaBean
- Déploiement dans le conteneur
Dans les chapitres suivants, nous ne nous attarderons plus à détailler toutes ces étapes, nous nous concentrerons sur le code et sur les fonctionnalités qu'offre le serveur d'application.
D'ores et déjà, vous avez pu constater certains des avantages des EJB :
- Les EJB contiennent les règles métiers
Toutes les applications clientes et tous les composants du système informatique utilisent notre EJB. Ce qui permet une économie de code et une réduction des risques d'erreurs.
- Les EJB sont réutilisables
Une fois développé, notre Enterprise JavaBean peut être déployé et utilisé n'importe où.
|
|
