Ficha de revisão: Introduction à Java EE et persistance

📋 Plan du Cours

1. Rôle et architecture de la plateforme Java EE (Jakarta EE)
2. Fonctionnement et utilité des serveurs d’applications Java EE
3. Structure en couches et conteneurs dans une application Java EE
4. Syntaxe et usage des annotations en Java EE
5. Définition et annotation des entités persistantes avec @Entity
6. Mappage objet-relationnel par défaut des entités vers les tables
7. Gestion des entités avec Entity Manager et opérations CRUD
8. Concept et création d’une unité de persistance avec EntityManagerFactory
9. Gestion transactionnelle explicite et bonnes pratiques de fermeture en persistance

📖 1. Rôle et architecture de la plateforme Java EE (Jakarta EE)

🔑 Notions clés & Définitions

• Chapitre I : Première section du cours consacrée à l'architecture de Java EE, détaillant la composition en conteneurs, composants et services.
• Exemple : Illustration d'utilisation des technologies Java EE telles que JSF et API REST (JAX-RS) pour créer des services web et afficher des pages dynamiques.
• Java EE (Jakarta EE) : Extension de la plateforme Java SE, renommée Jakarta EE à partir de la version 9, permettant de développer des applications d’entreprise performantes, sécurisées, scalables et à haute disponibilité.
• Enterprise Java Beans : Composants métier avancés basés sur Jakarta Enterprise Beans, intégrés dans la couche métier de Java EE, offrant disponibilité, tolérance aux pannes et gestion des transactions.

📝 Points essentiels

• L’architecture Java EE est composée de conteneurs, composants et services, organisés en couches distinctes (client, présentation, métier, données).
• Java EE est une extension de Java SE permettant de développer des applications d’entreprise performantes, sécurisées, scalables et à haute disponibilité.
• Architecture JEE ..........................................................................................................

💡 À retenir

L’architecture Java EE est composée de conteneurs, composants et services, organisés en couches distinctes (client, présentation, métier, données).

📖 2. Fonctionnement et utilité des serveurs d’applications Java EE

🔑 Notions clés & Définitions

• Sécurité : Ensemble des mécanismes mis en œuvre par le serveur d’applications Java EE pour garantir l’intégrité et la protection des données lors des échanges via le protocole HTTP.
• Requêtes HTTP : Messages envoyés par un client, comme un navigateur, au serveur pour demander des ressources ou déclencher des actions, qui sont traités par le serveur d’applications Java EE.
• Apache Tomcat : Le cœur de cette plateforme est le serveur (Glassfish, Apache Tomcat, WildFly, Etc.).

📝 Points essentiels

• GlassFish est l’implémentation de référence complète de Java EE, tandis qu’Apache Tomcat est un conteneur web ne supportant pas toute la spécification Java EE (notamment pas d’EJB par défaut).
• Le serveur d’applications Java EE gère les requêtes HTTP, les sessions, la sécurité, l’injection de dépendances, les transactions et les connexions aux bases de données.
• Il faut un conteneur web / serveur d’application pour :
  • Gérer les requêtes HTTP
  • Gérer les sessions
  • Gérer la sécurité
  • Gérer l’injection de dépendances
  • Gérer les transactions
  • Gérer les connexions à la base de données.
• Il ne supporte pas toute la spécification Java EE (pas d'EJB par défaut), mais il est le plus utilisé pour le web.

💡 À retenir

Le serveur d’applications Java EE gère les requêtes HTTP, les sessions, la sécurité, l’injection de dépendances, les transactions et les connexions aux bases de données.

📖 3. Structure en couches et conteneurs dans une application Java EE

🔑 Notions clés & Définitions

• Conteneur EJB : Un environnement d'exécution qui gère les Enterprise Java Beans, assurant leur cycle de vie, sécurité, transactions et accès, utilisé notamment pour la logique métier pouvant être invoquée localement ou à distance.
• Couche Métier : La couche qui traite la logique métier de l'application, applique les règles métier et interagit avec la couche de persistance, sans communiquer directement avec le client.
• Base de données : Un système de stockage des données persistantes de l'application, accessible via la couche de persistance par des composants comme JPA ou DAO.
• Architecture 3-tiers : Une application JEE est basée sur une architecture en couches (architecture 3-tiers ou n- tiers).

📝 Points essentiels

• Une application Java EE est organisée en couches : client (navigateur), présentation, métier, et persistance, pour modulariser et séparer les responsabilités.
• Le choix des conteneurs (web, EJB, etc.) dépend des exigences fonctionnelles de l’application, par exemple une application web peut utiliser uniquement le conteneur web ou aussi le conteneur EJB pour les beans distants.
• Elle est composée de : Client (Navigateur) ↓ Couche Présentation (Web) ↓ Couche Métier (Business) ↓ Couche Persistance (Base de données) I.1.
• Vous choisissez le ou les composants en fonction des exigences de l’application à développer.

💡 À retenir

Une application Java EE est organisée en couches : client (navigateur), présentation, métier, et persistance, pour modulariser et séparer les responsabilités.

📖 4. Syntaxe et usage des annotations en Java EE

🔑 Notions clés & Définitions

• Annotation de classe : Une annotation de classe est une déclaration placée au-dessus de la déclaration d'une classe en Java EE, utilisée pour spécifier un comportement ou une configuration particulière de cette classe.
• Avoir plusieurs annotations pour une : Une seule classe, attribut ou méthode peut porter plusieurs annotations successives, permettant de configurer différents aspects ou comportements.
• Plusieurs annotations pour une classe : Une classe en Java EE peut comporter plusieurs annotations, chacune positionnée au-dessus de la déclaration de la classe, pour définir diverses configurations ou comportements.

📝 Points essentiels

• Toute annotation Java EE commence par le symbole @.
• L’annotation de classe précède la déclaration de la classe, celle d’un attribut précède l’attribut, et celle d’une méthode précède la méthode.
• Une classe, un attribut ou une méthode peut porter plusieurs annotations, chaque annotation étant placée au-dessus de l’élément annoté.
• L’annotation déclarative correspondante est @NamedQuery, et c’est une annotation de classe.
• Celle d’un attribut est placée au-dessus de l’attribut et celle de la méthode est placée au-dessus e la méthode.

💡 À retenir

Maîtriser la syntaxe et la position des annotations permet de configurer efficacement les composants Java EE.

📖 5. Définition et annotation des entités persistantes avec @Entity

🔑 Notions clés & Définitions

• Annotation @Entity : Une annotation utilisée pour indiquer qu'une classe Java est une entité persistante éligible à la persistance dans Java EE.
• Constructeur par défaut : Un constructeur sans argument nécessaire dans une entité pour permettre la création d'instances par le framework de persistance.

📝 Points essentiels

• La clé primaire d’une entité doit être explicitement signalée avec l’annotation @Id.
• La notation @Entity transforme une classe Java en entité persistante éligible à la persistance.
• Une entité doit posséder au moins un constructeur sans argument (constructeur par défaut).
• Une entité ne doit pas être une classe finale ni contenir d’attributs ou méthodes finals.
• • La notation @Id doit explicitement être utilisée pour signaler la clé primaire.
• Notion d’Entités Pour rendre une classe potentiellement éligible dans Java EE, il faudrait associer la notation de classe @Entity.

💡 À retenir

Comprendre les règles essentielles pour définir une entité persistante valide en Java EE.

📖 6. Mappage objet-relationnel par défaut des entités vers les tables

🔑 Notions clés & Définitions

• Le problème : La difficulté réside dans la correspondance entre les objets en programmation orientée objet et les tables dans les bases de données relationnelles, notamment pour identifier les tables, les champs et respecter les contraintes associées.
• Configuration par exception : Un mécanisme de mappage par défaut où une entité est associée à une table portant le même nom que la classe, chaque attribut est lié à une colonne du même nom, et les types sont mappés selon les règles JDBC spécifiques à chaque base de données.
• Mappage Objet relationnel : Un processus qui établit la correspondance entre les classes et les tables, ainsi qu'entre les attributs et les colonnes, permettant la gestion automatique de la persistance des données.
• Mapping objet relationnel : L'association par défaut d'une classe à une table portant le même nom, avec chaque attribut mappé à une colonne correspondante, et la conversion des types Java en types SQL selon les règles JDBC propres à chaque base de données.

📝 Points essentiels

• Les types Java sont mappés aux types SQL selon les règles JDBC propres à chaque base de données.
• Le mappage par défaut dépend du gestionnaire de base de données utilisé et doit être consulté pour chaque base spécifique.
• Elle stipule que l’Entité est mappé à une table de même nom, que chaque attribut est mappé au champ de la table de même nom.
• Il faut donc consulter les pour chaque base de données pour connaitre le mappage des types primitifs java avec le gestionnaire de base de données en ce qui concerne l’API Java Persistance.

💡 À retenir

Les types Java sont mappés aux types SQL selon les règles JDBC propres à chaque base de données.

📖 7. Gestion des entités avec Entity Manager et opérations CRUD

🔑 Notions clés & Définitions

• JPQL : Langage de requête orienté objet utilisé pour interroger et manipuler les entités dans Jakarta Persistence API, très proche du SQL standard.
• Entity Manager : Fois l’unité de persistance crée, on peut créer l’instance Entity Manager EntityManager em = emf.createEntityManager();

📝 Points essentiels

• L'Entity Manager permet d’effectuer toutes les opérations CRUD sur les entités.
• La méthode persist() de l’Entity Manager est utilisée pour enregistrer une nouvelle entité en base et peut aussi être utilisée pour la mise à jour.
• Entity Manager permet également d’exécuter des requêtes JPQL avec filtres pour récupérer des enregistrements spécifiques.
• Les requêtes nommées facilitent la réutilisation et la gestion des requêtes JPQL, notamment en permettant la liaison de paramètres nommés ou indexés.
• Les principales méthodes d’Entity Manager sont : void Persist (Entity Object) : Cette méthode permet de réaliser des opérations relatives à la création d’enrégistrement (INSERT) ainsi que la mise à jour (UPDATE).
• Entity Manager ..............................................................................................................

💡 À retenir

Utiliser Entity Manager comme interface centrale pour manipuler les entités persistantes et exécuter des requêtes JPQL, en tirant parti des opérations CRUD et des requêtes nommées.

📖 8. Concept et création d’une unité de persistance avec EntityManagerFactory

🔑 Notions clés & Définitions

📝 Points essentiels

• L’unité de persistance est créée via l’instanciation d’un EntityManagerFactory par la méthode Persistence.createEntityManagerFactory().
• EntityManagerFactory est un factory qui produit des instances d’EntityManager.
• Le fichier persistence.xml est un descripteur de déploiement contenant les paramètres de connexion à la base de données, tels que l’hôte, le port et le type.
• Une fois ceci fait, un fichier Persistence.xml, qui est un descripteur de déploiement est créé.
• Unité de Persistance .................................................................................................

💡 À retenir

La création et la configuration de l’unité de persistance reposent sur l’instanciation d’un EntityManagerFactory via Persistence.createEntityManagerFactory(), en utilisant les paramètres définis dans le fichier persistence.xml, base essentielle pour la gestion des entités.

📖 9. Gestion transactionnelle explicite et bonnes pratiques de fermeture en persistance

🔑 Notions clés & Définitions

• Transaction explicite : Un mécanisme de gestion des opérations de persistance où le début et la fin de la transaction sont contrôlés manuellement via un objet EntityTransaction, garantissant que les modifications sont validées ou annulées de manière cohérente.
• Select L from : RechercherTout", query
• NamedQuery (name : RechercherTout", query

📝 Points essentiels

• Il est conseillé d’encapsuler toutes les opérations de persistance dans un bloc transactionnel explicite en utilisant EntityTransaction.
• Le cycle typique inclut : début de transaction (tx.begin()), opérations de persistance, validation (tx.commit()), puis fermeture des ressources.

💡 À retenir

Adopter une gestion rigoureuse des transactions et des ressources pour assurer la cohérence et la performance en persistance.

📊 Tableaux de Synthèse

Comparatif des Conteneurs Java EE

Type de conteneur	Fonctionnalités principales
Web	Gestion des requêtes HTTP, sécurité, sessions
EJB	Gestion du cycle de vie, sécurité, transactions, accès à la logique métier

⚠️ Pièges & Confusions Fréquentes

1. Confusion entre conteneurs web et EJB, notamment leur rôle et leur portée.
2. Oublier que l’architecture en couches doit respecter la séparation des responsabilités.
3. Mauvaise utilisation ou compréhension des annotations, notamment @Entity, @Id, @NamedQuery.
4. Confusion dans le mappage par défaut entre classes et tables, ou types Java et SQL.
5. Négliger la gestion transactionnelle explicite, entraînant des incohérences ou fuites de ressources.
6. Omettre la fermeture des EntityManager ou la gestion correcte des transactions.
7. Utiliser des requêtes JPQL incorrectes ou mal formulées.

✅ Checklist Examen

1. Vérifier la déclaration de l’entité avec @Entity.
2. S’assurer que chaque entité possède un constructeur par défaut.
3. Confirmer que la clé primaire est annotée avec @Id.
4. Vérifier le mappage par défaut entre classes et tables.
5. Utiliser EntityManager pour les opérations CRUD.
6. Créer l’unité de persistance via Persistence.createEntityManagerFactory().
7. Gérer explicitement les transactions avec EntityTransaction.
8. Utiliser JPQL pour les requêtes sur les entités.
9. Configurer le fichier persistence.xml avec les paramètres de connexion.
10. Respecter le cycle de vie des transactions : begin, commit, rollback.
11. Éviter les opérations dans un contexte transactionnel non géré.