Java EE (Jakarta EE)

Java EE : rebaptisé Jakarta EE depuis son transfert à la fondation Eclipse en 2018 : est l'ensemble de spécifications qui permet de construire des applications d'entreprise en Java : sites marchands, applications bancaires, intranets, services web. Là où Java SE fournit le langage et les bibliothèques de base, Java EE ajoute tout ce qui manque pour le web et le travail en réseau : gestion des requêtes HTTP, accès aux bases de données, transactions, sécurité et injection de dépendances.

1. Le principe : une architecture en couches

Une application Java EE se découpe en couches indépendantes. Chacune a une responsabilité unique et ne communique qu'avec sa voisine. C'est le point le plus souvent demandé en examen, et celui qu'il faut savoir redessiner de mémoire.

Pourquoi découper ? Parce qu'un changement reste local. Si vous passez de MySQL à PostgreSQL, seule la couche persistance bouge : la logique métier et les pages JSP ne sont pas touchées. C'est exactement l'argument attendu dans une question de cours.

2. Les briques à connaître

La Servlet : le point d'entrée

Une Servlet est une classe Java qui reçoit une requête HTTP et produit une réponse. C'est la brique fondatrice : tout le reste (JSP, JSF) est construit au-dessus.

@WebServlet("/salutation")
public class SalutationServlet extends HttpServlet {

    @Override
    protected void doGet(HttpServletRequest requete, HttpServletResponse reponse)
            throws ServletException, IOException {

        String nom = requete.getParameter("nom");
        if (nom == null || nom.isEmpty()) {
            nom = "visiteur";
        }

        requete.setAttribute("message", "Bonjour " + nom + " !");
        requete.getRequestDispatcher("/WEB-INF/vues/salutation.jsp")
               .forward(requete, reponse);
    }
}

Trois points à retenir : l'annotation @WebServlet remplace la déclaration dans web.xml ; doGet() traite les requêtes GET et doPost() les POST ; le forward transmet le traitement à une JSP sans nouvelle requête du navigateur.

JPA : faire correspondre objets et tables

JPA (Java Persistence API) établit la correspondance entre vos classes Java et les tables de la base. Une classe devient une table, un attribut devient une colonne, une instance devient une ligne.

@Entity
@Table(name = "etudiants")
public class Etudiant {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(nullable = false, length = 80)
    private String nom;

    @Column(unique = true)
    private String matricule;

    @ManyToOne
    @JoinColumn(name = "filiere_id")
    private Filiere filiere;

    // constructeurs, getters et setters
}

Les annotations de cardinalité reviennent sans cesse aux évaluations : @OneToOne, @OneToMany, @ManyToOne et @ManyToMany. Sachez les justifier : un étudiant appartient à une seule filière, mais une filière compte plusieurs étudiants, d'où @ManyToOne côté étudiant.

CDI : l'injection de dépendances

Plutôt que d'écrire new ServiceEtudiant() dans votre Servlet, vous laissez le serveur fournir l'instance. Le code devient testable et faiblement couplé.

@Inject
private ServiceEtudiant serviceEtudiant;

EJB : le composant métier transactionnel

Un EJB (Enterprise JavaBean) est un composant géré par le serveur, qui prend notamment en charge les transactions. Avec @Stateless, chaque méthode s'exécute dans une transaction : si une exception survient, tout est annulé automatiquement.

@Stateless
public class ServiceInscription {

    @PersistenceContext
    private EntityManager em;

    public void inscrire(Etudiant e, Cours c) {
        em.persist(e);          // si la ligne suivante echoue,
        c.ajouterEtudiant(e);   // l'insertion precedente est annulee
    }
}

3. Le trajet d'une requête

Savoir raconter ce parcours dans l'ordre vaut souvent plusieurs points :

1. Le navigateur envoie GET /salutation?nom=Awa.
2. Le serveur d'applications (GlassFish, WildFly, Payara, TomEE) reçoit la requête.
3. Il identifie la Servlet associée à l'URL et appelle doGet().
4. La Servlet sollicite la couche métier (EJB ou CDI).
5. La couche métier interroge la base via JPA.
6. Les données sont placées dans la requête, puis transmises à la JSP.
7. La JSP produit le HTML, renvoyé au navigateur.

Attention à la confusion classique : Tomcat seul n'est pas un serveur Java EE complet. C'est un conteneur de Servlets. Il exécute Servlets et JSP, mais pas les EJB. Pour une application Java EE complète, il faut WildFly, Payara, GlassFish ou TomEE.

4. Les pièges qui coûtent des points

• Confondre JSP et Servlet. La JSP sert à l'affichage, la Servlet au contrôle. Mettre du code métier dans une JSP est une faute d'architecture.
• Oublier que JPA est une spécification. Hibernate, EclipseLink et OpenJPA en sont des implémentations. On programme contre l'interface, pas contre Hibernate.
• Placer les JSP hors de WEB-INF. Dans WEB-INF, elles ne sont pas accessibles directement par URL : le passage par la Servlet devient obligatoire.
• Croire que @Stateless interdit tout attribut. Il signifie que le serveur ne garantit aucun état conversationnel entre deux appels d'un même client.
• Négliger la différence forward / sendRedirect. Le premier reste côté serveur (l'URL ne change pas), le second provoque une nouvelle requête du navigateur.

5. S'entraîner

La théorie seule ne suffit pas : ce sont les sujets d'examen qui révèlent ce qui n'est pas encore acquis. Commencez par un sujet, cherchez sans la correction, puis comparez.

• Tous les examens Java EE : la collection complète
• Examen Java EE – Test 02 et sa correction détaillée
• Examen Java EE – Test 03 et sa correction
• Test 04, Test 05, Test 06 et Test 08
• Un aperçu complet du Java EE : article de fond

Trois exercices pour commencer

1. Servlet de calcul. Écrivez une Servlet /somme qui reçoit deux paramètres a et b, en affiche la somme, et gère le cas où un paramètre est absent ou n'est pas un nombre.
2. Modèle JPA. Modélisez Cours, Enseignant et Étudiant. Un cours a un enseignant ; un étudiant suit plusieurs cours. Posez les annotations et justifiez chaque cardinalité.
3. Transaction. Écrivez un EJB inscrire() qui enregistre un étudiant et décrémente le nombre de places. Expliquez ce qui se passe si la seconde opération échoue.

En résumé

Retenez la répartition des rôles : la Servlet contrôle, la JSP affiche, JPA persiste, l'EJB porte la logique métier et les transactions, CDI assemble le tout. Si vous savez placer ces cinq éléments sur un schéma en couches et expliquer le trajet d'une requête, vous tenez l'essentiel de ce qui est évalué.

Rédigé par Joël_Yk : Contact WhatsApp : +237 652027193