Skip to main content

Introduction aux EJB

Les EJB pour Enterprise Java Beans sont un standard de la pateforme JavaEE pour créer des composants serveur.

Serveur d'application

Dans un premier temps, pour exécuter des EJBs il est nécessaire de disposer d'un serveur d'application JavaEE disposant d'un container EJB. Nous allons ici utiliser Wildfly (évolution de JBoss). Commencez donc par télécharger Wildfly 21 sur ce lien. Décompressez ensuite le ZIP téléchargé et placez le à l'emplacement où vous rangez vos outils.

Projet serveur

Création du projet

Pour créer le projet serveur, lancez IntelliJ IDEA et créer un nouveau projet en utilisant le template Java Entreprise.

Capture-d’écran-2020-10-31-125540.png

Dans le choix des dépendances, cochez ensuite Enterprise Java Beans (EJB) ainsi que Servlet :

Capture-d’écran-2020-10-31-125749.png

Terminez ensuite la création de votre projet en renseignant et un nom et un GroupId.

Création de la configuration de déploiement

Créez une nouvelle Run Config à partir du template JBoss Server > Local :

Capture-d’écran-2020-10-31-130424.png

Configurez votre serveur d'application Wildfly dans la rubrique Application Server de votre Run Config. Ensuite dans la rubrique Before Launch ajoutez une action Build Artifact et séléctionnez l'artéfact war exploded de votre projet.

Création des EJBs

Maintenant que le serveur est configuré nous pouvons créer notre premier EJB. Pour ce faire créez un package sessionBeans. Dans ce package créez une interface pour votre EJB :

@Remote
public interface GestionContactRemote {
    public String coucouContact(String nomContact);
}

Créez ensuite votre classe EJB qui implémente cette interface :

@Stateless(mappedName="ContactBean")
public class GestionContactBean implements GestionContactRemote {
    public String coucouContact(String nomContact) {
        return "Coucou, "+nomContact;
    }
}

Une fois ceci fait, lancez votre projet à l'aide de la Run Config créée plus tôt. Regardez ensuite les logs du serveur Wildfly dans l'interface d'IntelliJ IDEA, vous devriez y voir une ligne affirmant que votre EJB a bien été detecté et ajouté à l'annuaire JNDI. Copiez l'URL qui commence par EJB et gardez là dans un bloc note, elle sera utile plus tard.

Capture-d’écran-2020-10-31-135413.png

Projet Client EJB

Configuration du projet

Pour le client EJB, créez un nouveau projet IntelliJ, cette fois en utilisant le template Maven et en utilisant l'archétype Quickstart. Une fois votre projet généré, rajoutez la dépendance suivante dans votre fichier pom.xml :

<dependency>
  <groupId>org.wildfly</groupId>
  <artifactId>wildfly-ejb-client-bom</artifactId>
  <version>21.0.0.Final</version>
  <type>pom</type>
</dependency>

Mettez à jours vos dépendances Maven, puis ajoutez une Run Config d'application Java normale.

Récupérer les EJB

Dans un premier temps, il faut créer un package sessionBean directement dans le dossier de sources java. Dans ce package, copiez votre interface GestionContactRemote et retirez lui l'annotation @Remote.

Dans la méthode Main ajoutez d'abord le code suivant, afin de configurer la connexion EJB :

final Hashtable<String, String> jndiProperties = new Hashtable<>();
jndiProperties.put(Context.INITIAL_CONTEXT_FACTORY, "org.wildfly.naming.client.WildFlyInitialContextFactory");
if(Boolean.getBoolean("http")) {
  jndiProperties.put(Context.PROVIDER_URL,"http://localhost:8080/wildfly-services");
} else {
  jndiProperties.put(Context.PROVIDER_URL,"remote+http://localhost:8080");
}
final Context context = new InitialContext(jndiProperties);

Ensuite pour récupérer votre EJB, ajouter ce code, en modifiant la string passée à la méthode lookup() par l'URL ejb que nous avons noté tout à l'heure :

final GestionContactRemote ejb = (GestionContactRemote) context.lookup("ejb:/efrei-m1-jakartaee-tp4-ejb-1.0-SNAPSHOT/GestionContactBean!sessionBeans.GestionContactRemote");

Vous pouvez enfin tester votre EJB :

System.out.println(ejb.coucouContact("test"));

Si tout s'est bien passé, vous devriez observer les logs du client EJB dans votre console ainsi que votre afichage :

Capture-d’écran-2020-10-31-140516.png

Persistence avec JPA

Base de donnée embarquée H2

Dans votre projet serveur, ajoutez les dépendances Maven suivantes :

<dependency>
  <groupId>jakarta.persistence</groupId>
  <artifactId>jakarta.persistence-api</artifactId>
  <version>2.2.3</version>
</dependency>

<dependency>
  <groupId>org.hibernate</groupId>
  <artifactId>hibernate-core</artifactId>
  <version>5.4.22.Final</version>
</dependency>

<dependency>
  <groupId>org.hibernate</groupId>
  <artifactId>hibernate-entitymanager</artifactId>
  <version>5.4.22.Final</version>
</dependency>

Créez ensuite un nouveau package entityBeans et dedans la classe contact :

@Entity
public class Contact {
  @Id
  @GeneratedValue(strategy= GenerationType.AUTO)
  private long id;
  private String firstName;
  private String lastName;
  private String email;
  public long getId() {return id;}
  public void setId(long l) {id = l;}
  public String getEmail() {return email;}
  public String getFirstName() {return firstName; }
  public String getLastName() {return lastName; }
  public void setEmail(String string) {email = string; }
  public void setFirstName(String string) {firstName = string; }
  public void setLastName(String string) {lastName = string; }
}

Il faut maintenant modifier nos EJB session pour interagir avec la source de données. Modifier votre interface GestionContactRemote (dans le serveur et le client) tel que :

@Remote
public interface GestionContactRemote {
    public String coucouContact(String nomContact);
    public void addContact(String fname, String lname, String email);
    public String findContactNameById(long id);
}

Et dans le serveur modifiez la classe GestionContactBean ainsi :


@Stateless(mappedName="ContactBean")
public class GestionContactBean implements GestionContactRemote {
    @PersistenceContext
    EntityManager em;

    public void addContact(String fname, String lname, String email) {
        Contact contact = new Contact();
        contact.setFirstName(fname);
        contact.setLastName(lname);
        contact.setEmail(email);
        em.persist(contact);
    }

    public String findContactNameById(long id) {
        Contact contact=em.find(Contact.class, id);
        return contact.getLastName() +", "+contact.getFirstName();
    }

    public String coucouContact(String nomContact) {
        return "Coucou, "+nomContact;
    }
}

Ensuite, il faut configurer la source de donnée sur la base embarquée de Wildfly. Pour ce faire, créez un dossier classes dans le dossier WEB-INF et dans ce dossier classes, un dossier META-INF. Enfin dans le dossier META-INF, créer le fichier persistence.xml avec le contenu suivant :

<?xml version="1.0" encoding="UTF-8"?>
<persistence xmlns="http://java.sun.com/xml/ns/persistence"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://java.sun.com/xml/ns/persistence
http://java.sun.com/xml/ns/persistence/persistence_1_0.xsd"
             version="1.0">
    <persistence-unit name="EJB3_Entity">
        <jta-data-source>java:jboss/datasources/ExampleDS</jta-data-source>
        <properties>
            <property name="hibernate.hbm2ddl.auto" value="create-drop"/>
        </properties>
    </persistence-unit>
</persistence>

Vous pouvez maintenant déployer votre projet serveur sur votre serveur d'application Wildfly.

Enfin, modifier le code de votre client pour interagir avec les nouvelles méthodes de l'EJB :

ejb.addContact("John","Shepard","john.shepard@n7.citadel" );
System.out.println(ejb.findContactNameById(1));
Back to top