Dans le chapitre précédent, nous avons abordé ce que sont JPA et Hibernate. Dans ce chapitre, nous allons intégrer une base de données à notre application et essayer d'effectuer des opérations CRUD (Créer, Lire, Mettre à jour, Supprimer).

Exemple de travail avec une base de données :

Personnalisation du modèle

La première étape consiste à annoter le modèle afin que Hibernate puisse l'utiliser et déterminer à quelle table il appartient.

Dans l'annotation @Entity(name = "books"), le paramètre name permet de spécifier le nom de l'entité, qui par défaut correspond au nom de la classe.

L'annotation @Table est utilisée pour définir des paramètres spécifiques pour la table associée à l'entité.

Dans notre cas, cette table est créée via des migrations, il n'est donc pas nécessaire de la créer manuellement.

Nous avons également besoin que notre entité génère automatiquement un ID afin de lui attribuer une valeur unique dans la base de données. Pour cela, il est possible d'utiliser l'annotation @Id sur le champ représentant notre ID, ainsi que l'annotation @GeneratedValue.

@Id
@GeneratedValue(strategy = GenerationType.UUID)
private String id;

Les annotations @Id et @GeneratedValue(strategy = GenerationType.UUID) indiquent que le champ id est une clé primaire qui est générée automatiquement au format UUID.

Cela garantit des identifiants de chaîne uniques pour chaque enregistrement dans la table, ce qui est avantageux pour les systèmes distribués et assure l’unicité globale des identifiants. Les UUID sont stockés sous forme de chaînes.

Ajout du référentiel

Actuellement, notre référentiel simule une base de données en stockant toutes les entités dans une List. Mais si je vous disais qu'utiliser une vraie base de données est en réalité bien plus simple !

Pour interagir avec une vraie base de données, il est possible d'utiliser l'interface JpaRepository, qui offre un large éventail de méthodes intégrées pour la gestion des données.

Dans JpaRepository<Book, String>, nous passons deux paramètres : Book, qui représente le type d'entité avec lequel le repository va travailler, et String, qui est le type de données de la clé primaire (ID) pour l'entité Book.

Et c'est tout ce dont nous avons besoin ! Nous disposons maintenant d'un repository entièrement fonctionnel !

Principales méthodes de JpaRepository

Création de requêtes SQL personnalisées

Spring Data JPA peut générer automatiquement des requêtes si la méthode est nommée selon un schéma qui correspond à la structure des données. Cela s'effectue à l'aide de mots-clés spécifiques qui indiquent comment la requête doit être construite.

Résumé court de la vidéo

List<Book> findBookByAuthor(String author);

Cette méthode génère automatiquement une requête SQL qui recherche tous les livres du author spécifié. La requête générée sera la suivante :

SELECT * FROM book WHERE author = ?;

Fonctionnement

Le nom de la méthode findBookByAuthor(String author) est construit comme suit : il commence par le préfixe findBook, indiquant que la méthode effectue une recherche. Ensuite vient ByAuthor, qui représente le champ dans l’entité Book qui sera utilisé pour la recherche.

Lorsque cette méthode est appelée, Spring Data JPA génère automatiquement une requête qui recherche les enregistrements où le champ author correspond au paramètre fourni.

Génération de requêtes SQL avec @Query

L’annotation @Query dans Spring Data JPA permet d’utiliser à la fois JPQL et le SQL natif, offrant ainsi une flexibilité dans le choix de l’approche appropriée.

JPQL

JPQL (Java Persistence Query Language) fonctionne avec des objets et leurs propriétés.

@Query("SELECT b FROM book b WHERE b.author = :author")
List<Book> findBookByAuthor(String author);

Cette requête recherche tous les objets Book dont le champ author correspond à la valeur fournie. JPQL est plus abstrait et reflète la structure du modèle de données.

SQL natif

SQL natif interagit directement avec les tables de la base de données.

@Query(value = "SELECT * FROM books WHERE author = :author", nativeQuery = true)
List<Book> findBookByAuthor(String author);

Dans ce cas, la requête s'exécute sur la table book, permettant l'utilisation de fonctions SQL spécifiques et d'optimisations.

Choix d'une approche

Pour une requête simple qui correspond au modèle de données, utiliser JPQL. Si une requête complexe ou des fonctions spécifiques à la base de données sont nécessaires, privilégier SQL natif.

Ainsi, @Query offre la flexibilité de passer facilement d'une approche à l'autre selon les besoins.