Enterprise Java Beans (EJB)

Ce laboratoire présente la technologie Enterprise Java Beans (EJB), une architecture de composants Java côté serveur utilisée pour développer des applications distribuées. Il permet de comprendre les différents types d’EJB, leur cycle de vie, ainsi que le processus de développement, déploiement et utilisation d’un EJB, illustré par un exemple concret d’une calculatrice. Pour réaliser ce TP, il est nécessaire de disposer d’un environnement J2EE avec un serveur d’application supportant les EJB, ainsi que d’un IDE Java capable de compiler et exécuter des applications Java EE.

Objectifs

• Comprendre la définition et le rôle des Enterprise Java Beans (EJB).
• Identifier les différents types d’EJB : Session, Entity, Message Driven.
• Développer un EJB Session (Stateless) simple avec ses interfaces Remote et RemoteHome.
• Déployer un EJB dans un serveur d’application via un fichier de descripteur.
• Utiliser un EJB depuis un client Java en accédant au bean via JNDI.
• Connaître les simplifications apportées par EJB 3 avec les annotations.

Prérequis et configuration

• Connaissances de base en Java et programmation orientée objet.
• Compréhension des architectures distribuées et du modèle client-serveur.
• Environnement J2EE avec un serveur d’application compatible EJB (ex : GlassFish, JBoss).
• IDE Java avec support J2EE pour écrire, compiler et déployer les beans et clients.
• Familiarité avec les concepts RMI et JNDI pour la communication distante.

Définition et présentation des EJB

Les Enterprise Java Beans (EJB) sont des composants logiciels Java destinés à s’exécuter côté serveur dans une architecture distribuée. Ils sont des extensions des Java Beans, conçus pour construire des applications d’entreprise modulaires et réutilisables. Un EJB est une brique applicative qui facilite la création d’applications trois tiers ou plus, où :

• Le client léger gère la saisie et l’affichage des données.
• Les objets métiers, souvent des EJB, contiennent la logique métier et les traitements.
• Une base de données assure la persistance des données.

Un container EJB, qui s’exécute sur un serveur d’application, fournit l’environnement d’exécution des beans, en assurant des services essentiels tels que la gestion du cycle de vie, la sécurité, la persistance, la gestion des transactions et le nommage.

Les types d’EJB

Il existe trois types principaux d’EJB :

• EJB Session : réalise une tâche pour un client. Il peut être :
• Stateless (sans état) : une instance peut servir plusieurs clients sans conserver d’état.
• Stateful (avec état) : une instance est liée à un client et conserve des données entre les appels.
• Singleton : une seule instance unique pour toutes les connexions, avec accès concurrent.
• EJB Entity : représente des données persistantes, par exemple des lignes dans une base de données.
• EJB Message Driven : traite des messages asynchrones déclenchés par des événements.

Cycle de vie d’un EJB Session

Le cycle de vie diffère selon le type :

• Stateful : le client invoque les méthodes create et remove. Le conteneur peut "passiver" le bean (sauvegarde temporaire) en cas de besoin de mémoire, puis le réactiver.
• Stateless : le cycle est similaire mais sans passivation ni activation, car le bean ne conserve pas d’état.

Les états possibles sont : Inexistant, Créé (create), Prêt, Passif (passivate), Activé (activate), et Supprimé (remove).

Utilisation d’un EJB

Chaque EJB fournit deux interfaces d’accès distant :

• Remote : définit les services métiers (méthodes) fournis par le bean.
• RemoteHome : gère le cycle de vie du bean (création, recherche, destruction).

Le client doit localiser le bean via JNDI, puis utiliser les interfaces RemoteHome et Remote pour interagir avec le bean. Depuis EJB 2.0, des interfaces locales sont également possibles pour des clients hébergés dans le même conteneur, offrant de meilleures performances.

Processus de développement d’un EJB Session

Le développement suit ces étapes :

1. Écrire l’interface RemoteHome (gestion du bean).
2. Écrire l’interface Remote (services métiers).
3. Écrire la classe d’implémentation du bean (implémente SessionBean).
4. Compiler les classes et interfaces.
5. Construire le descripteur de déploiement (fichier XML).
6. Créer l’archive .jar contenant le bean et le descripteur.
7. Déployer le bean sur le serveur d’application.
8. Écrire, compiler et exécuter le client qui utilise le bean.

Exemple pratique : EJB Calculatrice (EJB 2)

Interface Remote

package p;
import javax.ejb.*;
import java.rmi.*;

public interface CalculatriceRemote extends EJBObject {
  public double add(double v1, double v2) throws RemoteException;
  public double sub(double v1, double v2) throws RemoteException;
  public double mul(double v1, double v2) throws RemoteException;
  public double div(double v1, double v2) throws RemoteException;
}

Cette interface définit les méthodes métiers du bean. Elle étend javax.ejb.EJBObject et chaque méthode doit déclarer qu’elle peut lever une RemoteException conformément aux spécifications RMI.

Interface RemoteHome

package p;
import javax.ejb.*;
import java.rmi.*;

public interface CalculatriceRemoteHome extends EJBHome {
  public CalculatriceRemote create() throws RemoteException, CreateException;
}

L’interface Home gère le cycle de vie du bean. Elle étend javax.ejb.EJBHome et définit la méthode create() qui crée une instance du bean.

Classe d’implémentation du bean

package p;
import javax.ejb.*;

public class CalculatriceBean implements SessionBean {

  /* Méthodes de l'interface Remote */
  public double add(double v1, double v2) { return v1 + v2; }
  public double sub(double v1, double v2) { return v1 - v2; }
  public double mul(double v1, double v2) { return v1 * v2; }
  public double div(double v1, double v2) { return v1 / v2; }

  /* Méthodes de l'interface RemoteHome */
  public void ejbCreate() throws CreateException {}

  /* Méthodes de l'interface SessionBean */
  public void ejbActivate() {}
  public void ejbPassivate() {}
  public void ejbRemove() {}
  public void setSessionContext(SessionContext sc) {}
}

Cette classe implémente les méthodes métiers et les méthodes du cycle de vie du bean.

Descripteur de déploiement (extrait)

<enterprise-beans>
  <session>
    <ejb-name>MaCalculatrice</ejb-name>
    <home>p.CalculatriceHome</home>
    <remote>p.CalculatriceRemote</remote>
    <ejb-class>p.CalculatriceBean</ejb-class>
    <type>Stateless</session-type>
    <transaction-type>Container</transaction-type>
  </session>
</enterprise-beans>

Ce fichier XML configure le bean pour le déploiement dans le serveur d’application.

Client Java utilisant le bean

import javax.naming.*;
import javax.ejb.*;

public class Client {
  public static void main(String args[]) throws Exception {
    // Création du contexte JNDI
    Context ic = new InitialContext();

    // Recherche du bean via JNDI
    Object obj = ic.lookup("java:global/ProjetEjb/MaCalculatrice");

    // Récupération de l'interface Home
    CalculatriceRemoteHome home = (CalculatriceRemoteHome) 
      javax.rmi.PortableRemoteObject.narrow(obj, CalculatriceRemoteHome.class);

    // Création de l'instance du bean
    CalculatriceRemote b = home.create();

    // Appel d'une méthode métier
    double res = b.add(3, 6);
    System.out.println("Résultat de 3 + 6 = " + res);
  }
}

Le client localise le bean via JNDI, crée une instance et appelle une méthode métier.

Simplification avec EJB 3

EJB 3 simplifie le développement :

• La suppression de l’interface Home, remplacée par des annotations.
• Le descripteur de déploiement devient facultatif, remplacé par des annotations dans le bean.
• Un seul fichier Java contient l’interface métier et l’implémentation.

Exemple d’interface Remote simplifiée

package monpaquet.EJB;
import javax.ejb.Remote;

@Remote
public interface CalculatriceRemote {
  public double add(double v1, double v2);
  public double sub(double v1, double v2);
  public double mul(double v1, double v2);
  public double div(double v1, double v2);
}

Classe bean simplifiée

package monpaquet.EJB;
import javax.ejb.*;

@Stateless
public class CalculatriceBean implements CalculatriceRemote {

  public double add(double v1, double v2) { return v1 + v2; }
  public double sub(double v1, double v2) { return v1 - v2; }
  public double mul(double v1, double v2) { return v1 * v2; }
  public double div(double v1, double v2) { return v1 / v2; }
}

Client avec injection d’EJB

import monpaquet.EJB.*;
import javax.ejb.*;

public class Client {
  // Injection automatique du bean
  @EJB
  static CalculatriceRemote b;

  public static void main(String args[]) throws Exception {
    double res = b.add(3, 6);
    System.out.println("Résultat de 3 + 6 = " + res);
  }
}

L’annotation @EJB permet d’injecter automatiquement le bean, évitant la recherche JNDI explicite.

Résultats attendus

• Le bean calculatrice doit correctement effectuer les opérations add, sub, mul, div.
• Le client doit afficher le résultat attendu, par exemple : "Résultat de 3 + 6 = 9.0".
• Le déploiement doit se faire sans erreur, et le bean doit être accessible via JNDI.
• En EJB 3, l’injection doit fonctionner sans configuration XML supplémentaire.

Pièges courants

• Ne pas déclarer RemoteException dans les méthodes des interfaces Remote (EJB 2).
• Oublier d’implémenter les méthodes du cycle de vie dans la classe bean (EJB 2).
• Erreur dans le nom JNDI lors de la recherche du bean, empêchant la récupération.
• Confusion entre interfaces Remote et RemoteHome, notamment pour la création des beans.
• Passer à EJB 3 sans adapter le code : l’interface Home disparaît, ce qui peut causer des erreurs.
• Diviser par zéro dans la méthode div sans gestion d’exception.
• Ne pas déployer correctement le fichier .jar contenant le bean et son descripteur.