Université Mohammed 1er

École Nationale de l’Intelligence

Artificielle et du Digitale - Berkane

TP 07 : EJB

Module : Ateliers de programmation avancés Année Universitaire :

Filière : Génie Informatique 2024/2025
Par : Pr. ALAMI Nabil

TP7 : EJB
Objectifs
• Comprendre les concepts d'EJB Session (Stateless et Stateful).
• Manipuler les entités avec JPA.
• Intégrer les EJB et JPA dans une application complète.
• Implémenter des opérations CRUD (Create, Select, Update, Delete).

Introduction
Vous devez créer une application Java EE permettant de gérer des comptes bancaires. Les
fonctionnalités suivantes doivent être implémentées :

1. Ajouter un compte bancaire.

2. Consulter les détails d'un compte.
3. Effectuer des dépôts et des retraits.
4. Transférer de l'argent entre deux comptes.
5. Consulter la liste des comptes avec leur solde.

Partie 1
Étape 1 : Préparation de l’environnement
1. Créer un projet Java EE
Créer un projet EJB de préférence Maven:

1. Créer un nouveau projet Java EE :

o Dans Eclipse :
1. Allez dans File > New > EJB Project.
2. Donnez un nom au projet, par exemple BankManagement.
3. Choisissez un runtime approprié (WildFly ou GlassFish).
4. Terminez la configuration.
o Dans IntelliJ IDEA :
1. Allez dans File > New Project.
2. Sélectionnez Java Enterprise.
3. Configurez le serveur d’applications (WildFly ou GlassFish).
4. Ajoutez les dépendances nécessaires (Jakarta EE, JPA).
 5. Cliquez sur Finish.
2. Ajouter les dépendances nécessaires : Si vous utilisez Maven, ajoutez les dépendances
suivantes dans le fichier [Link] :

2. Création d’un projet Maven

1. Avec Eclipse :
o Allez dans File > New > Maven Project.
o Sélectionnez Create a simple project (skip archetype selection).
o Donnez un Group Id et un Artifact Id, par exemple :
▪ Group Id : [Link]
▪ Artifact Id : BankManagementEJB
o Cliquez sur Finish.
2. Avec IntelliJ IDEA :
o Allez dans File > New > Project.
o Sélectionnez Maven et configurez le SDK.
o Donnez un Group Id et un Artifact Id, par exemple :
▪ Group Id : [Link]
▪ Artifact Id : BankManagementEJB
o Cliquez sur Finish.

2. Configurer le fichier [Link]

Ajoutez les dépendances et plugins nécessaires pour un projet EJB :

<project xmlns="[Link]
xmlns:xsi="[Link]
xsi:schemaLocation="[Link]
[Link]
<modelVersion>4.0.0</modelVersion>
<groupId>[Link]</groupId>
<artifactId>BankManagementEJB</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>ejb</packaging>

<dependencies>
<!-- Jakarta EE API -->
<dependency>
<groupId>[Link]</groupId>
<artifactId>[Link]-api</artifactId>
<version>10.0.0</version>
<scope>provided</scope>
</dependency>

<!-- Hibernate JPA Provider -->

<dependency>
<groupId>[Link]</groupId>
<artifactId>hibernate-core</artifactId>
<version>[Link]</version>
</dependency>

2
 <!-- MySQL Connector -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.33</version>
</dependency>
</dependencies>

<build>
<plugins>
<!-- Plugin Maven pour EJB -->
<plugin>
<groupId>[Link]</groupId>
<artifactId>maven-ejb-plugin</artifactId>
<version>3.1.0</version>
<configuration>
<ejbVersion>3.2</ejbVersion>
</configuration>
</plugin>
</plugins>
</build>
</project>

2. Configurer un serveur d’applications Wildfly

1. Installer le serveur :
o Téléchargez et installez WildFly ([Link]
2. Ajouter le serveur à l’IDE :
o Dans Eclipse :
1. Allez dans Window > Preferences > Server > Runtime Environments.
2. Cliquez sur Add... et choisissez WildFly ou GlassFish.
3. Configurez le chemin d’installation du serveur.
o Dans IntelliJ IDEA :
1. Allez dans File > Settings > Build, Execution, Deployment >
Application Servers.
2. Cliquez sur le bouton + pour ajouter WildFly.
3. Démarrer le serveur :
o Lancez le serveur pour vérifier qu’il fonctionne correctement.
o Vous pouvez accéder à la console d’administration via : [Link]

3. Configurer la base de données

1. Installer la base de données :

o Téléchargez et installez MySQL ou H2.
o Si vous utilisez MySQL, connectez-vous avec un client comme MySQL Workbench.
2. Créer la base de données et la table :
o Dans MySQL Workbench ou via un terminal SQL, exécutez la commande suivante pour
créer une base de données :

CREATE DATABASE bank;

USE bank;

3
 o Créez une table pour les comptes bancaires :

CREATE TABLE Account (

id INT AUTO_INCREMENT PRIMARY KEY,
account_number VARCHAR(20) UNIQUE NOT NULL,
owner_name VARCHAR(50),
balance DOUBLE NOT NULL
);

3. Vérifier la connexion JDBC :

o Téléchargez le fichier JAR MySQL Connector
([Link]
o Placez-le dans le répertoire des bibliothèques de votre projet si vous ne l’utilisez pas avec
Maven.

4. Ajouter les fichiers de configuration

1. Créer le fichier [Link]:

o Créez le dossier suivant dans votre projet Maven :

src/main/resources/META-INF.

o Ajoutez le fichier [Link] avec le contenu suivant :

<persistence xmlns="[Link] version="2.1">
<persistence-unit name="BankPU">
<class>[Link]</class>
<properties>
<!-- Connexion JDBC -->
<property name="[Link]"
value="[Link]"/>
<property name="[Link]"
value="jdbc:mysql://localhost:3306/bank"/>
<property name="[Link]"
value="root"/>
<property name="[Link]"
value="password"/>

<!-- Hibernate JPA Implementation -->

<property name="[Link]"
value="[Link].MySQL8Dialect"/>
<property name="[Link]"
value="update"/>
<property name="hibernate.show_sql" value="true"/>
</properties>
</persistence-unit>
</persistence>

2. Configurer le serveur pour JNDI (optionnel) :

o Configurez un data source pour MySQL dans votre serveur d’applications (WildFly ou
GlassFish).

4
 o Exemple pour WildFly (dans [Link]) :

<datasource jndi-name="java:/jdbc/BankDS" pool-name="BankDS" enabled="true">

<connection-url>jdbc:mysql://localhost:3306/bank</connection-url>
<driver>mysql</driver>
<security>
<user-name>root</user-name>
<password>password</password>
</security>
</datasource>

Étape 2 : Créer l’entité JPA

1. Créer les interfaces local et remot

L'interface locale est annotée avec @Local. Elle définit les méthodes accessibles dans le même
module ou conteneur.

@Local
public interface AccountServiceLocal {
void createAccount(Account account);
List<Account> findAllAccounts();
void deposit(Long accountId, Double amount);
… Ajouter d’autres méthodes ici
}

L'interface distante est annotée avec @Remote. Elle définit les méthodes accessibles à travers le
réseau.

@Remote
public interface AccountServiceRemote {
void createAccount(Account account);
List<Account> findAllAccounts();
void deposit(Long accountId, Double amount);
… Ajouter d’autres méthodes ici

2. Créer une classe Account dans le package [Link]:

package [Link];

import [Link].*;

@Entity
public class Account {
@Id
@GeneratedValue(strategy = [Link])
private Long id;

@Column(unique = true, nullable = false)

private String accountNumber;

5
 private String ownerName;

@Column(nullable = false)
private Double balance;

// Getters et setters
public Long getId() { return id; }
public void setId(Long id) { [Link] = id; }

public String getAccountNumber() { return accountNumber; }

public void setAccountNumber(String accountNumber) {
[Link] = accountNumber; }

public String getOwnerName() { return ownerName; }

public void setOwnerName(String ownerName) { [Link] =
ownerName; }

public Double getBalance() { return balance; }

public void setBalance(Double balance) { [Link] = balance; }
}

Étape 3 : Créer l’EJB Session

1. Créer un Stateless Session Bean AccountService dans le package [Link]:

package [Link];

import [Link];

import [Link];
import [Link];
import [Link];
import [Link];

@Stateless
public class AccountService implements …{

@PersistenceContext(unitName = "BankPU")
private EntityManager em;

public void createAccount(Account account) {

[Link](account);
}

public Account findAccountById(Long id) {

return [Link]([Link], id);
}

public List<Account> findAllAccounts() {

return [Link]("SELECT a FROM Account a",
[Link]).getResultList();
}

public void deposit(Long id, Double amount) {

Account account = [Link]([Link], id);

6
 if (account != null) {
[Link]([Link]() + amount);
[Link](account);
}
}

public void withdraw(Long id, Double amount) throws Exception {

Account account = [Link]([Link], id);
if (account != null) {
if ([Link]() >= amount) {
[Link]([Link]() - amount);
[Link](account);
} else {
throw new Exception("Solde insuffisant.");
}
}
}

public void transfer(Long fromId, Long toId, Double amount) throws

Exception {
withdraw(fromId, amount);
deposit(toId, amount);
}
}
Étape 4 : Créer un client EJB pour le test

1. Créer une classe de test Main dans le package [Link]:

package [Link];

import [Link];
import [Link];

import [Link];
import [Link];
import [Link];
import [Link];

public class Main {

public static void main(String[] args) throws Exception {
Properties props = new Properties();
[Link](Context.INITIAL_CONTEXT_FACTORY,
"[Link]");
[Link](Context.PROVIDER_URL, "http-
remoting://localhost:8080");

Context context = new InitialContext(props);

AccountService accountService = (AccountService)
[Link]("java:module/AccountService");

// Ajouter des comptes

Account account1 = new Account();
[Link]("123456");
[Link]("Nabil Alami");
[Link](5000.0);

7
 [Link](account1);

Account account2 = new Account();

[Link]("789012");
[Link]("Amine Lahcen");
[Link](3000.0);
[Link](account2);

// Dépôt
[Link]([Link](), 1000.0);

// Retrait
[Link]([Link](), 500.0);

// Transfert
[Link]([Link](), [Link](),
200.0);

// Liste des comptes

List<Account> accounts = [Link]();
for (Account account : accounts) {
[Link]([Link]() + " - " +
[Link]() + " : " + [Link]());
}
}
}

1. Création du projet client

• Donnez un nom au projet, par exemple EJBClientProject.

• Configurez le fichier [Link] comme suit pour inclure les dépendances nécessaires :

<project xmlns="[Link]
xmlns:xsi="[Link]
xsi:schemaLocation="[Link]
[Link]
<modelVersion>4.0.0</modelVersion>
<groupId>[Link]</groupId>
<artifactId>EJBClientProject</artifactId>
<version>1.0-SNAPSHOT</version>

<dependencies>
<!-- Jakarta EE API -->
<dependency>
<groupId>[Link]</groupId>
<artifactId>[Link]-api</artifactId>
<version>10.0.0</version>
<scope>provided</scope>
</dependency>

<!-- WildFly EJB Client -->

<dependency>
<groupId>[Link]</groupId>
<artifactId>wildfly-ejb-client</artifactId>

8
 <version>[Link]</version>
</dependency>

<!-- WildFly Naming Client -->

<dependency>
<groupId>[Link]</groupId>
<artifactId>wildfly-naming-client</artifactId>
<version>[Link]</version>
</dependency>
</dependencies>
</project>

2. Configuration nécessaire

1. Créez un fichier nommé [Link] dans le répertoire src/main/resources

de votre projet.
2. Ajoutez la configuration suivante pour connecter le client au serveur WildFly où l’EJB est
déployé :

<configs xmlns="urn:jboss-client-configuration:1.0">
<config>
<connection-selector selector="random"/>
<connections>
<connection endpoint-name="wildfly-server">
<uri value="remote+[Link]
</connection>
</connections>
</config>
</configs>

• uri : Adresse du serveur WildFly. Modifiez localhost:8080 selon votre configuration.

• Ce fichier permet au client de savoir comment se connecter au serveur distant.

3. Code du client pour accéder à l’EJB

Voici un exemple de code pour le client, qui utilise JNDI pour rechercher et appeler un EJB
distant :

package [Link];

import [Link];
import [Link];
import [Link];
import [Link]; // Interface distante

public class EJBClient {

public static void main(String[] args) {
try {
// Configuration JNDI
Properties props = new Properties();
[Link](Context.INITIAL_CONTEXT_FACTORY,
"[Link]");
[Link](Context.PROVIDER_URL, "http-remoting://localhost:8080");

9
 // Initialiser le contexte
Context context = new InitialContext(props);

// Rechercher l'EJB via JNDI

AccountServiceRemote accountService =
(AccountServiceRemote)
[Link]("ejb:/BankApp/BankModule//AccountService![Link]
tServiceRemote");

// Utiliser l'EJB
[Link]("123456", "Mohammed Hakimi", 5000.0);
[Link]("789012", "Amine Sellami", 3000.0);

[Link]("Liste des comptes :");

[Link]().forEach([Link]::println);
} catch (Exception e) {
[Link]();
}
}
}

Explication des étapes :

1. Configuration de la connexion JNDI :

Properties props = new Properties();

[Link](Context.INITIAL_CONTEXT_FACTORY,
"[Link]");
[Link](Context.PROVIDER_URL, "http-remoting://localhost:8080");

o INITIAL_CONTEXT_FACTORY : Définit l'implémentation de la fabrique de contexte. Ici,

WildFlyInitialContextFactory est utilisé pour se connecter à un serveur WildFly.
o PROVIDER_URL : Indique l'URL du serveur d'applications. http-
remoting://localhost:8080 signifie que le serveur est hébergé localement sur le port
8080, utilisant le protocole HTTP Remoting pour JNDI.
2. Création du contexte JNDI :

Context context = new InitialContext(props);

o Le Context permet de rechercher des ressources (comme des EJB) dans le serveur
d'applications.
3. Recherche de l'EJB avec lookup:

AccountService accountService = (AccountService)

[Link]("java:module/AccountService");

o La méthode lookup permet de localiser l'EJB déployé sur le serveur avec son nom JNDI.
o Le nom dépend de l'environnement et du type de déploiement. Dans ce cas :
▪ java:module/AccountService : Utilisé pour un accès local ou simple dans le
même module.

10
 ▪ ejb: ou autres namespaces : Utilisé dans des configurations plus complexes
(par ex., accès distant, module distinct).

AccountServiceRemote accountService =
(AccountServiceRemote)
[Link]("ejb:/BankApp/BankModule//AccountService![Link].
AccountServiceRemote");

o Nom JNDI : Ce nom suit la convention suivante pour WildFly :

ejb:/<ApplicationName>/<ModuleName>/<DistinctName>/<EJBName>!<Full
yQualifiedRemoteInterface>

▪ ApplicationName : Nom de l’application EAR (vide si non utilisé).

▪ ModuleName : Nom du fichier JAR contenant l’EJB.
▪ DistinctName : Souvent vide.
▪ EJBName : Nom de la classe EJB.
▪ FullyQualifiedRemoteInterface : Nom complet de l'interface distante.

Compiler et exécuter le client

Étape 1 : Compiler le projet Maven

Exécutez la commande suivante dans le répertoire du projet client :

mvn clean install

Étape 2 : Démarrer le serveur WildFly

1. Assurez-vous que le serveur WildFly est démarré.

2. Déployez le projet serveur contenant l’EJB (le fichier .jar ou .ear).

Étape 3 : Exécuter le client

Exécutez la classe principale contenant le Main

Étape 4 : Utilisation des méthodes de l'EJB :

Créer un compte :

Account account1 = new Account();

[Link]("123456");
[Link]("Nabil Alami");
[Link](5000.0);
[Link](account1);

Ici, un objet Account est créé, puis sauvegardé en base via la méthode createAccount. Les
méthodes distantes sont appelées comme si elles étaient locales :

[Link]("123456", "Nabil Alami", 5000.0);

11
 [Link]("789012", "Amine Lahcen", 3000.0);

o Les données sont gérées sur le serveur où l’EJB est déployé.

Affichage des résultats :

o Exemple d’affichage des comptes récupérés depuis le serveur :

[Link]().forEach([Link]::println);

Effectuer un dépôt :

[Link]([Link](), 1000.0);

Ici on dépose 1000 dans le compte en utilisant la méthode deposit.

Lister les comptes :

List<Account> accounts = [Link]();

for (Account account : accounts) {
[Link]([Link]() + " - " +
[Link]() + " : " + [Link]());
}

▪ Récupère tous les comptes avec findAllAccounts et affiche leurs détails.

Le paramètre name dans lookup :

La méthode lookup de la classe Context en Java est utilisée pour rechercher et obtenir une ressource
ou un objet (comme un EJB, un DataSource, ou une Queue JMS) dans le contexte de nommage
JNDI (Java Naming and Directory Interface).
Contexte de la méthode lookup
• JNDI (Java Naming and Directory Interface) est une API standard de Java EE permettant
d'accéder à des ressources en utilisant un annuaire de noms.
• Lorsque vous déployez une application sur un serveur d'applications Java EE (comme
WildFly ou GlassFish), les ressources (par exemple, des EJB, DataSources, etc.) sont
enregistrées dans un annuaire JNDI.
• La méthode lookup permet de récupérer ces ressources à l'exécution en utilisant leur nom
JNDI.

• Paramètre :
o name
: Le nom JNDI de l'objet que vous souhaitez rechercher. Ce nom suit une
convention qui dépend du type de ressource et du serveur d'applications.
• Retour :

12
 o
L'objet associé au nom JNDI, typiquement casté dans le type attendu (par
exemple, une interface EJB, une DataSource, etc.).
• Exception :
o NamingException : Levée si l'objet n'existe pas ou si le serveur JNDI n'est pas
accessible.

Cas de java:module

• Utilisation : Approprié pour des clients locaux ou simples dans un même module ou une
application.
• Syntaxe : "java:module/<NomEJB>" est le namespace standard pour les EJB locaux dans
le module actuel.

Cas de ejb:

• Utilisation : Nécessaire pour un client distant (remote client) ou dans un projet où l'EJB
est déployé dans un module distinct.
• Syntaxe :

"ejb:<ApplicationName>/<ModuleName>/<DistinctName>/<NomEJB>!<InterfaceFQN>"

o ApplicationName : Nom de l'application EAR, si applicable (vide si non EAR).

o ModuleName : Nom du fichier JAR ou WAR contenant l'EJB.
o DistinctName : Optionnel, souvent vide.
o NomEJB : Nom de la classe de l'EJB.
o InterfaceFQN : Nom complet de l'interface distante de l'EJB.

Exemple pour un EJB distant :

AccountService accountService = (AccountService)

[Link]("ejb:/BankApp/BankModule//AccountService![Link]
tServiceRemote");

Partie 2 :
Maintenant, on souhaite créer une application qui permet de gérer des comptes bancaire avec des
fonctionnalité avancées et un accès à travers un navigateur web.
• Chaque compte est défini par un numéro, un solde et une date de création
• Un compte courant est un compte qui possède en plus un découvert
• Un compte épargne est un compte qui possède en plus un taux d’intérêt.
• Chaque compte appartient à un client et créé par un employé.
• Chaque client est défini par son code et son nom
• Un employé est défini par son code et sont solde.
• Chaque employé possède un supérieur hiérarchique.
• Chaque employé peut appartenir à plusieurs groupes (ou agence)

13
 • Chaque groupe, défini par un code et un nom, peut contenir plusieurs employés.
• Chaque compte peut subir plusieurs opérations.
• Il existe deux types d’opérations :Versement et Retrait
• Chaque opération est effectuée par un employé.
• Une opération est définie par un numéro d’opération, une date et un montant.
Voici le diagramme de classe de cette application :

Le MLD est le suivant :

• T_CLIENTS (CODE_CLI, NOM_CLI)
• T_EMPLOYES (NUM_EMP, NOM_EMP, #NUM_EMP_SUP)
• T_GROUPES (NUM_GR, NOM_GR )
• T_EMP_GR (#NUM_EMP, #NUM_GR )
• T_COMPTES (NUM_CPTE,TYPE_PTE, DATE_CR, SOLDE, #NUM_EMP,
• #CODE_CLI)
• T_OPERATIONS (NUM_OP,TYPE_OP, DATE_OP, MONTANT, #NUM_EMP,
• #NUM_CPTE)

Travail à faire :
Décomposez votre application en deux projets :
1. Créer un premier projet métier qui contient :
• Couche données :
o Créer la base de données « Bank » de type MySQL
o Saisir quelques enregistrements de test

14
 • Couche métier ( package metier) :
o Créer les classe persistantes sous forme d’EJB entity
o Créer les classe des business méthodes sous forme d’EJB session
2. Les fonctionnalités suivantes doivent être implémentées :
o Ajouter un compte bancaire.
o Consulter les détails d'un compte.
o Effectuer des dépôts et des retraits.
o Transférer de l'argent entre deux comptes.
o Consulter la liste des comptes avec leur solde.

3. Créer un deuxième projet qui contient :

• Couche présentation : Créer une application web qui permet :
o de saisir les informations d’un compte et l’ajouter à la BDD.
o Effectuer un virement sur un compte
o Fournir des interfaces pour les opérations citées ci-dessus dans le projet métier.

15