Apprendre les bases de l'API de persistance Java (JPA) et du framework Hibernate en utilisant Spring et Spring Boot.

Description
Dans ce cours, vous découvrirez l'API JPA, JPQL (Java Persistence query language), l'API Java Persistence Criteria API et comment vous pouvez exécuter l'ORM (Object Relational Mapping) avec JPA.  Dans ce cours, vous apprendrez à connaître l'API JPA, JPQL (Java Persistence query language), l'API Java Persistence Criteria et comment vous pouvez réaliser l'ORM (Object Relational Mapping) avec JPA.

Hibernate est l'implémentation la plus populaire de JPA, c'était l'option de framework ORM la plus populaire avant l'apparition de JPA et elle fournit des fonctionnalités supplémentaires en plus de JPA.
Au cours de ce cours

Vous apprendrez les bases de JPA et d'Hibernate - Entités, Relations, Mappings et Annotations.
Vous comprendrez les approches pour interroger les données en utilisant JPA et Hibernate - JPQL, Criteria API et Native Queries.
Vous comprendrez les relations JPA et Hibernate en profondeur - One to One, Many to One et Many to Many to Many.
Vous utiliserez une variété de démarreurs de démarrage de printemps - Spring Boot Starter Web, Starter Data Jpa, Starter Test, Starter Test, Starter Test, etc.................................................................................................................................................................
Vous apprendrez les bases de l'optimisation des performances de votre application JPA avec Hibernate - Solve N+1 Queries Issue.
Vous apprendrez les bases de la mise en cache - First Level Cache et Second Level Cache avec EhCache.
Vous comprendrez les bases de Spring Data JPA et Spring Data REST.
Vous trouverez ci-dessous les détails, étape par étape, des sections importantes du cours :

Voyage de JDBC à JPA

Etape01 - Mise en place d'un projet avec JDBC, JPA, H2 et dépendances Web.
Étape02 - Lancement de la console H2
Étape03 - Création d'une table de base de données dans H2
Étape04 - Remplir les données dans la table des personnes
Étape05 - Mettre en uvre la méthode de recherche de toutes les personnes Spring JDBC Query Method
Etape06 - Exécuter la méthode findAll à l'aide de CommandLineRunner.
Étape07 - Un examen rapide - JDBC vs Spring JDBC JDBC
Étape08 - Qu'est-ce qui se trouve en arrière-plan ? la compréhension de l'autoconfiguration de Spring Boot.
Étape09 - Mise en uvre de la méthode de requête findById Spring JDBC Query Method
Étape 10 - Mise en uvre de la méthode de mise à jour JDBC du printemps de deleteById.
Étape 11 - Mise en uvre de l'insertion et mise à jour des méthodes de mise à jour Spring JDBC.
Étape 12 - Création d'un Spring JDBC RowMapper JDBC personnalisé
Étape 13 - Introduction rapide à l'APP
Étape 14 - Définir l'entité personne-entité
Étape 15 - Mise en uvre de la méthode findById JPA Repository Method
Étape 16 - Mise en uvre de l'insertion et mise à jour des méthodes de référentiel JPA
Étape 17 - Mise en uvre de la méthode d'archivage deleteById JPA Repository Method
Étape 18 - Mise en uvre de findAll à l'aide de JPQL Named Query (requête nommée JPQL)
JPA/Hibernate en profondeur

Étape01 - Créer un projet JPA avec H2 et Spring Boot.
Étape02 - Créer un cours sur les entités de l'APP
Étape03 - Créer findById à l'aide de JPA Entity Manager.
Etape04 - Configuration des propriétés de l'application pour activer la console H2 et l'enregistrement supplémentaire.
Étape05 - Écriture d'un test d'unité d'écriture pour la méthode findById
Etape06 - Ecriture d'une méthode deleteByID pour supprimer une Entité
Étape07 - Écriture d'un test d'unité d'écriture pour la méthode deleteById
Etape08 - Ecriture d'une méthode d'enregistrement pour mettre à jour et insérer une Entité
Étape09 - Écriture d'un test unitaire pour la méthode de sauvegarde
Étape 10 - Révision rapide et conseils de débogage
Étape 11 - Jouer avec Entity Manager
Étape 12 - Méthodes de gestion des entités - Effacer et détacher
Étape 13 - Méthodes de gestion des entités - rafraîchissement
Étape 14 - Examen rapide du gestionnaire de l'entité
Étape 15 - JPQL - Notions de base
Étape 16 - Annotations JPA et Hibernate - @Table
Étape 17 - Annotations JPA et Hibernate - @Column
Étape 18 - Annotations JPA et Hibernate - @UpdateTimestamp et @CreationTimestamp.
Étape 19 - Annotations JPA et Hibernate - @NamedQuery et @NamedQueries
Étape 20 - Requêtes autochtones - Notions de base
Étape 21 - Entités et relations - Aperçu général
Étape 22 - Définir les entités - Étudiant, passeport et révision
Étape 23 - Introduction à la relation un à un
Étape 24 - OneToOne Mapping - Insérez l'élève avec passeport.
Étape 25 - OneToOne Mapping - Récupérer l'élève avec un passeport et aller chercher l'élève.
Étape 26 - OneToOne Mapping - Lazy Fetch
Étape 27 - Session vs Transaction
Étape 28 - OneToOne Mapping - Relation bidirectionnelle - Partie 1
Étape 29 - OneToOne Mapping - Relation bidirectionnelle - Partie 2
Etape 30 - ManyToOne Mapping - Conception de la base de données
Etape 31 - ManyToOne Mapping - Récupérer et insérer des révisions pour le cours.
Etape32 - ManyToOne Mapping - Généraliser les révisions d'insertions.
Étape 33 - ManyToOne Mapping - Envelopper le tout
Étape34 - ManyToMany Mapping - Conception de table
Etape35 - ManyToMany Mapping - Ajout d'annotations sur les entités
Etape36 - ManyToMany Mapping - Correction d'un problème avec deux tables de jointure
Etape37 - ManyToMany Mapping - Personnalisation de la table Join Table
Etape38 - ManyToMany Mapping - Insérer des données et écrire une requête d'assemblage de données.
Etape39 - ManyToMany Mapping - Récupérer des données à l'aide des relations JPA
Étape 40 - ManyToMany Mapping - Insertion de l'étudiant et du cours
Étape 41 - Relations entre les entités de l'APP - Un résumé
Étape42 - Introduction aux hiérarchies et aux mappages de l'héritage
Étape43 - Hiérarchies et mappages de l'héritage JPA - Mise en place d'entités
Etape44 - Hiérarchies et mappages de l'héritage JPA - Configurer un référentiel
Étape 45 - Hiérarchies et mappages de l'héritage JPA - Table unique
Étape 46 - Hiérarchies et mappages de l'héritage JPA - Tableau par classe
Etape 47 - Hiérarchies et mappages de l'héritage JPA - Rejoints
Étape 48 - Hiérarchies d'héritage et mappages JPA - Super classe Mapped Super Class
Étape 49 - Hiérarchies d'héritage et mappings JPA - Comment choisir ?
Étape 50 - JPQL - Cours sans étudiants
Etape51 - JPQL - Cours avec au moins 2 Etudiants et commander par
Step52 - JPQL - Cours comme 100 étapes
Etape 53 - JPQL - Utiliser les jointures
Étape54 - Requête sur les critères - Récupération de tous les cours
Étape55 - Requête sur les critères - Cours comme 100 Étapes
Étape56 - Demande de critères - Cours sans étudiants
Étape 57 - Requête sur les critères - Utilisation des jointures
Étape58 - Introduction à la gestion des transactions
Étape59 - Gestion des transactions - Propriétés ACID
Étape 60 - Comprendre les lectures sales, phanthomiques et non répétitives.
Étape61 - Comprendre 4 niveaux d'isolement
Étape62 - Choix entre les niveaux d'isolement
Étape63 - Mise en uvre de la gestion des transactions - 3 choses à décider
Étape64 - Introduction aux données printanières JPA
Etape65 - Tester le dépôt de données Spring Data JPA avec findById.
Étape 66 - Dépôt de données de printemps JPA - CRUD Methosd
Étape67 - Tri à l'aide de Spring Data JPA Repository.
Étape68 - Pagination à l'aide de Spring Data JPA Repository (en anglais seulement)
Étape69 - Requêtes personnalisées à l'aide de Spring Data JPA Repository .
Étape 70 - Données du ressort REST
Étape71 - Introduction à la mise en cache
Étape72 - Mise en cache Hibernate et JPA - Cache de premier niveau
Étape73 - Mise en cache Hibernate et JPA - Notions de base de la mise en cache de deuxième niveau avec EhCache.
Étape74 - Mise en cache Hibernate et JPA - Deuxième niveau de mise en cache Partie 2
Étape75 - Conseils sur l'hibernation - Hibernate Soft Deletes - @SQLDelete et @Where.
Étape 76 - Hibernate Soft Deletes - Partie 2
Étape77 - Méthodes de cycle de vie des entités de l'APP
Étape78 - Utiliser Embedded et Embeddable avec JPA
Étape79 - Utilisation d'Enums avec JPA
Étape80 - Conseil JPA - Soyez prudent avec les implémentations de la méthode toString.
Étape81 - Conseil JPA - Quand utilisez-vous JPA ?
Étape82 - Réglage de la performance - Mesurer avant l'accordage
Étape83 - Réglage de la performance - Indexes
Étape84 - Optimisation des performances - Utiliser la mise en cache appropriée
Step85 - Performance Tuning - Eager vs Lazy Fetch (en anglais seulement)
Étape86 - Réglage des performances - Éviter les problèmes N+1.
Trucs et astuces Hibernate
Quand Hibernate envoie-t-il des mises à jour à la base de données ?
Quand avons-nous besoin de @Transactional dans un test unitaire ?
Les méthodes en lecture seule nécessitent-elles une transaction ?
Pourquoi utilisons-nous @DirtiesContext dans un test unitaire ?
Comment se connecter à une autre base de données avec Spring Boot ?
Comment aborder la conception de grandes applications avec JPA ?
Bonnes pratiques pour l'élaboration des demandes d'APP

CLIQUEZ ICI pour accéder à ce cours