Td n° et Mise en oeuvre d’un serveur d’applications : jonas mise en place de l’environnement

Département Télécommunications, Services & Usages, INSA Lyon 24/07/18

TD n° 5 et 6

Mise en oeuvre d’un serveur d’applications : JONAS

1. Mise en place de l’environnement

JONAS est un serveur d’applications Web conforme aux spécifications EJB 2.0. Il est open source développé dans le cadre du projet ObjectWeb. Il est écrit en Java et tourne à l’aide d’une machine virtuelle Java (JVM). Il est alors nécessaire d’avoir un JDK installé sur la machine.

1) Installation et configuration :

- JONAS est installé sous le répertoire /opt/jonas-3-3-1.
- Pour une utilisation personnalisée par étudiant il faut copier le fichier jonas.tgz dans votre répertoire home. Le fichier se trouve dans le répertoire /home/partage/enseignants/Info/TP-Frenot/sid/
- Décompactez le fichier dans votre répertoire home :
$ gunzip jonasUtilisateur.tgz

$ tar –tvxf gunzip jonasUtilisateur.tgz

Question 1 : Quels sont les répertoires et les fichiers générés ? à quoi servent-ils ?
- Avant de pouvoir lancer le serveur il faut configurer quatre variables d’environnement dans votre fichier .bash_profile

PATH= ……:/opt/jonas-3-3-1

export JAVA_ROOT=/opt/jonas-3-3-1

export Java_Base=$HOME/jonas

export XTRA_CLASSPATH=$HOME/jonas/classes

2) Démarrer le serveur jonas et survoler la console d’administration :

- Démarrer le serveur avec la commande :

$ jonas start
- Lancez la console d’administration de jonas avec un navigateur web :

http://localhost:8080/JonasAdmin

(par défaut :l’utilisateur est jonas et le mot de passe est jonas)
Question 2 : Quelles sont les parties principales de la console ?
- Changez le mot de passe de l’utilisateur jonas et choisissez votre propre mot de passe

3) Les commandes principales :

- jonas start // démarrer le serveur

- jonas stop // arrêter le serveur

- jonas check // vérifier l’installation de jonas

- jonas version //afficher la version

II) Exploitation du service de nommage JNDI

Un service de nommage permet d'associer un nom unique à un objet et facilite ainsi l'obtention de cet objet.

JNDI est l'acronyme de Java Naming and Directory Interface. Cet API fournit une interface unique pour utiliser différents services de nommages ou d'annuaires:

LDAP, DNS, RMI Registry, etc ...

Il est possible de voir les objets existants dans le JNDI depuis la console d’administration de jonas (l’onglet Registry).

1. L’API JNDI

Les classes les plus utilisées sont :
javax.naming.Context

Une interface qui défini les méthodes pour chercher un objet java par son nom (lookup), lier un nom à un objet java (bind/rebind), et créer/détruire un sous-context (creatSubcontext/destroySubcontext)

javax.naming.InitialContext

Tous les opérations de nommage sont relatifs à un context. La classe InitialContext concrétise l’interface Context et fourni le point de départ pour la résolution des noms.

javax.naming.NamingException (une classe d’exception de nommage)

Une classe d’Exception levée par les diverses opérations liées à JNDI.

2) La manipulation du service JNDI

JNDI est un service important de J2EE car il est utilisé par les différents composants de J2EE comme les EJBs, RMI, JDBC et JMS.

Jonas fournit son propre service JNDI avec la librairie carol.jar. Comme le service JNDI peut avoir plusieurs implantations selon le fournisseur de service, une application client qui utilise le service doit initialiser quelques variables d’environnement selon l’implantation du fournisseur.

- Pour utiliser le service JNDI de jonas il faut que l’application :

1. initialise la variable Context.INITIAL_CONTEXT_FACTORY de l’interface

Context avec "org.objectweb.carol.jndi.spi.MultiOrbInitialContextFactory"

2. inclure le fichier carol.jar dans le classpath

- Il y a plusieurs manières pour l’initialisation de l’INITIAL_CONTEXT_FACTORY:

• 
  En passant un objet Properties (qui contient le nom de la variable avec sa valeur) au constructeur de l’objet InitialContext
  
• 
  En passant un objet HashTable (qui contient le noms de la variable et sa valeur) au constructeur de l’objet InitialContext
  
• 
  En le spécifiant dans un fichier indépendant appelé jndi.properties
  

Question 3 : Servez vous de la documentation des classes Properties, Context, et InitialContextFactory pour completer le code suivant qui permet d’accéder au service JNDI :
import ……….. ;

import ……….. ;

import ……….. ;

import ……….. ;

public class ClientJNDI{
public static void main(String str[]){

try{

Properties prop = new Properties();

prop.put(………………………,………………………..);

Context ctx=new ………………..;

Object obj=ctx.lookup(“nomJndiD’unObjet”);

}

catch(………… ex){

ex.printStackTrace();

}

}

}
Question 4 : Ecrivez deux classes java s'échangeant des objets en passant par le service JNDI de jonas.

• 
  La première classe réalise le "binding" d’un objet dans le service de nommage du serveur. Cet objet est une instance de la classe CarnetAdresse (la classe existe dans votre répertoire jonas/question4). La classe doit utiliser la méthode rebind() pour réaliser cette action.
  
• 
  La deuxième classe doit récupérer les entrées avec la fonction lookup() sur les objets déposés (sans l’utilisation des méthodes list() ou listBindings()).
  

Pour utiliser le service JNDI depuis un programme il faut :

1. 
   importer les classes : javax.naming.Context
   

javax.naming.InitialContext

javax.naming.NamingException

2. 
   Instancier un objet InitialContext
   
3. 
   Initialiser la variable INITIAL_CONTEXT_FACTORY
   

- Après l’exécution de la première classe vous pouvez voir l’objet de la classe AdresseBook dans le registre de jonas depuis la console d’administration.

Remarques importantes :

• 
  Les objets à déposer avec le service JNDI doivent implanter deux interfaces : java.rmi.Remote, et java.io.Serializable
  
• 
  L'accès au contexte initial est une méthode que vous allez réutiliser dans la suite des tp. Elle permet d'obtenir une connexion sur le service de nommage (comme une connexion sur une base de données).
  

III) L’intégration de composants EJB

Un serveur d’applications permet de déployer rapidement une application. Le déploiement d’une application consiste à installer le bean dans le serveur d’applications.

Après avoir déployé l’application, un programme client peut exploiter le service offert par l’application.

1) Déploiement d’un bean

Nous utiliserons un Enterprise Java Bean de gestion d’e-panier (ShoppingCart). L’EJB ShoppingCart est un composant qu’un site Web peut utiliser pour le suivi des éléments achetés par un client. C’est un bean de type statefull session car il faut pouvoir suivre l’évolution du panier d’achat du client. L’EJB ShoppingCart utilise également la classe ShoppingCartItem (une classe sérialisable) pour créer les objets du panier.
La première étape consiste à déployer le bean sur le serveur d’application afin que le client puisse l’exploiter.

• 
  Le bean ShoppingCart est implanté, compilé et packagé avec les autres beans qu’il utilise et les fichiers de description dans le jar cmescoursesDep.jar qui se trouve dans l’archive : /home/Partage/enseignants/Info/TP-Frenot/sid/td_sujet_jonas.tgz
  

• 
  Extraire le jar cmescourses.jar du fichier td_sujet_jonas.tgz
  

Question 5 : décrivez le contenue de du jar, quels répertoires contient il ? et quels fichiers ?

• 
  Déployer le jar. Deux manières existent pour déploiement :
  

1. 
   Utiliser la console web d’administration :
   

1. 
   déposer le jar dans le répertoire jonas/ejbjars
   
2. 
   entrer dans l’espace de déploiement dans la console : 
   

Server JonAS (jonas) > Deployments > Containers EJB (JAR)

3. 
   choisir le jar, et activer le deploiement (Deploy, Apply, Confirm)
   

2. 
   Utiliser la commande :
   

jonas admin –a cmescourses.jar
Vous utiliserez le mécanisme de déploiement de la console. Vous vérifierez que le bean est bien déployé en vérifiant que le stub de manipulation de l'usine se trouve bien dans le service de nommage (l’onglet Registry).

2) Ecriture d’un client

Après avoir déployé le bean, il peut être utilisé par un client.

Question6 : Ecrire une classe cliente. Elle doit :

1. 
   Créer trois instances de la classe ShoppingCartItem.
   
2. 
   Créer une instance de l’EJB ShoppingCart et placer les éléments crées dans l'EJB à l’aide de la méthode addItem() de l’interface remote de l’EJB
   
3. 
   Après avoir placé les Eléments dans le panier vérifier leur nombre en utilisant la méthode getItemCount()
   
4. 
   Extraire le second élément du bean en utilisant la méthode getItem(). Afficher son descriptif en utilisant ses accesseurs.
   
5. 
   Retirer un des éléments en utilisant la méthode removeItem()
   
6. 
   Interroger le bean afin de lui demander le nombre d’articles restant.
   

Méthodes de l’interface remote de ShoppingCartBean :

void addItem(ShoppingCartItem i) ;

ShoppingCartItem getItem(int i) ;

int getItemCount() ;

void removeItem(ShoppingCartItem i) ;

L’interface home du bean possède les méthodes de création suivantes :

ShoppingCart create() ;

Un élément de la ShoppingCart possède les méthodes suivantes :

ShoppingCartItem(double prix, String desc, String numSerie) ;

String getDesc() ;

double getPrice() ;

String getSerialNum() ;

IV) Packaging d’un Bean

Pour déployer un bean il faut packager celui-ci afin que le conteneur d’EJB soit capable de l’instancier facilement en mémoire. Le bean ShoppingCart vous a été fourni préalablement packagé. Pour packager vos propres beans il faut suivre les étapes suivantes :

1. 
   Développer le bean (home, remote et l’implantation)
   

Vous trouvez un bean déjà développé dans le fichier td_sujet_jonas.tgz que vous avez décompacté. Le bean possède les caractéristiques suivantes :

Type : Stateful Session

Interface Remote : lego.LegoBlocksSession

Interface Home : lego.LegoBlocksSessionHome

Classe de l’EJB : lego.LegoBlocksSessionBean

2. 
   Compiler les fichiers
   

3. 
   Définir les deux fichiers de description du bean dans un répertoire META-INF
   

• 
  Le fichier ejb-jar.xml est propre aux spécifications EJB. Il doit définir les informations nécessaires sur le bean pour que le conteneur puisse l’exécuter. (Le nom, Le type, les services de sécurité, transaction, persistance..)
  
• 
  Le fichier jonas-ejb-jar.xml est propre au serveur d’application jonas. Il permet une configuration personnalisée de la manipulation de l’EJB. (le nom JNDI de l’instance du bean, le nombre max d’instances à créer dans le pool)
  

Suivre l’exemple de deux fichiers (ejb-jar.xml et jonas-ejb-jar.xml) fournis avec le bean ShopingCart.

4. 
   Créer le jar contenant tous les fichiers créers
   

jar –cvf legoBlock.jar lego/*.class lego/*.java META-INF/*.xml

(Remarque : il n’est pas indispensable de packager les fichiers source java)

5. 
   Générer les stub et les skeleton nécessaires avec l’outil GenIC de jonas
   

GenIC legoBlock.jar

(les stubs et les skels seront ajoutés automatiquement au jar) 

6. 
   Le bean est enfin prêt à être déployé et utilisé sur le serveur d’applications.
   

TP MID

Conception et implantation d'un

système de gestion de ventes en ligne
L'objectif du TP est de concevoir, implanter et déployer un service de gestion de vente en ligne. Les éléments entrant en jeu dans un mécanisme de vente sont :

2. 
   Le gestionnaire de vente
   
3. 
   L'élément en vente
   
4. 
   Le vendeur
   
5. 
   Les acheteurs
   

L'objectif est de réaliser le service sous la forme d'un EJB.

• I) Conception du système

Définir le ou les EJB qui interviennent dans le système. (Il y a plusieurs architectures possibles).

Définir le mode de fonctionnement du système. (interaction avec d'autres services : nommage, base de données).

• II) Développement, Déploiement et implantation du service

Concevoir et implanter les classes réalisant le service. Il est possible de réaliser plusieurs versions du système : client java, client jsp/html.

• III) Travail à rendre

Schéma des classes et interaction entre les composants. Service pré-packagé sous forme de bean, testable sur n'importe quel serveur d'applications

Stéphane Frenot, Nada Almasri TDs MID