TOC

Introduction à Spring Data JPA

Introduction à Spring Data JPA

1. Vue d'ensemble

Cet article se concentrera surintroducing Spring Data JPA into a Spring project et sur la configuration complète de la couche de persistance. Pour une introduction étape par étape sur la configuration du contexte Spring à l'aide de la configuration basée sur Java et du pom Maven de base pour le projet, consultezthis article. [more-838] #

2. Les données Spring ont généré DAO - Plus d'implémentations DAO

Comme nous l'avons vu dans un article précédent,the DAO layer se compose généralement d'un grand nombre de codes standard qui peuvent et doivent être simplifiés. Les avantages d'une telle simplification sont nombreux: réduction du nombre d'artefacts à définir et à gérer, cohérence des modèles d'accès aux données et de la configuration.

Spring Data fait progresser cette simplification etmakes it possible to remove the DAO implementations entirely. L’interface de la DAO est maintenant le seul artefact que nous devons définir explicitement.

Pour commencer à tirer parti du modèle de programmation Spring Data avec JPA, une interface DAO doit étendre l'interfaceRepository spécifique à JPA -JpaRepository. Cela permettra à Spring Data de trouver cette interface et de créer automatiquement une implémentation pour celle-ci.

En étendant l'interface, nous obtenons les méthodes CRUD les plus pertinentes pour l'accès aux données standard disponibles dans un DAO standard.

3. Méthode d'accès et requêtes personnalisées

Comme indiqué,by implementing one of the Repository interfaces, the DAO will already have some basic CRUD methods (and queries) defined and implemented.

Pour définir des méthodes d'accès plus spécifiques, Spring JPA prend en charge de nombreuses options:

  • simplementdefine a new method dans l'interface

  • fournir lesJPQ query réels en utilisant l'annotation@Query

  • utiliser lesSpecification and Querydsl support plus avancés dans Spring Data

  • définircustom queries via des requêtes nommées JPA

Lethird option - les spécifications et la prise en charge de Querydsl - est similaire aux critères JPA mais utilise une API plus flexible et plus pratique. Cela rend l’opération beaucoup plus lisible et réutilisable. Les avantages de cette API deviendront plus prononcés lorsqu'il s'agira de traiter un grand nombre de requêtes fixes, car nous pourrions potentiellement les exprimer de manière plus concise à travers un nombre réduit de blocs réutilisables.

Cette dernière option présente l'inconvénient d'impliquer soit XML, soit de surcharger la classe de domaine avec les requêtes.

3.1. Requêtes personnalisées automatiques

Lorsque Spring Data crée une nouvelle implémentation deRepository, il analyse toutes les méthodes définies par les interfaces et essaie deautomatically generate queries from the method names. Bien que cela présente certaines limites, c'est un moyen très puissant et élégant de définir de nouvelles méthodes d'accès personnalisées avec très peu d'effort.

Prenons un exemple: si l’entité a un champname (et les méthodes standard Java BeangetName etsetName),we’ll define the findByName method in the DAO interface; cela générera automatiquement la requête correcte: 

public interface IFooDAO extends JpaRepository {

   Foo findByName(String name);

}

Ceci est un exemple relativement simple. Le mécanisme de création de requête prend en chargea much larger set of keywords.

Dans le cas où l'analyseur ne peut pas faire correspondre la propriété avec le champ d'objet de domaine, nous verrons l'exception suivante: 

java.lang.IllegalArgumentException: No property nam found for type class org.rest.model.Foo

3.2. Requêtes personnalisées manuelles

Examinons maintenant une requête personnalisée que nous définirons via l'annotation@Query: 

@Query("SELECT f FROM Foo f WHERE LOWER(f.name) = LOWER(:name)")
Foo retrieveByName(@Param("name") String name);

Pour un contrôle encore plus précis de la création de requêtes, comme l'utilisation de paramètres nommés ou la modification de requêtes existantes,the reference est un bon point de départ.

4. Configuration de la transaction

La mise en œuvre réelle du DAO géré par Spring Data est en effet masquée car nous ne travaillons pas directement avec elle. Cependant, c'est une implémentation assez simple - the SimpleJpaRepository – which defines transaction semantics using annotations.

Plus explicitement, cela utilise une annotation@Transactional en lecture seule au niveau de la classe, qui est ensuite remplacée pour les méthodes non en lecture seule. Le reste de la sémantique de la transaction est la valeur par défaut, mais celles-ci peuvent être facilement remplacées manuellement par méthode.

4.1. La traduction d'exception est vivante et bien

La question est maintenant - puisque nous n'utilisons pas les modèles Spring ORM par défaut (JpaTemplate,HibernateTemplate) - perdons-nous la traduction d'exceptions en utilisant Spring Data JPA? N'allons-nous pas faire traduire nos exceptions JPA dans la hiérarchieDataAccessExceptionde Spring?

Bien sûr que non -exception translation is still enabled by the use of the @Repository annotation on the DAO. Cette annotation permet à un postprocesseur de bean Spring de conseiller tous les beans@Repository avec toutes les instancesPersistenceExceptionTranslator trouvées dans le conteneur, et de fournir une traduction d'exception comme auparavant.

Vérifions la traduction des exceptions avec un test d'intégration: 

@Test(expected = DataIntegrityViolationException.class)
public void givenFooHasNoName_whenInvalidEntityIsCreated_thenDataException() {
    service.create(new Foo());
}

Gardez à l'esprit queexception translation is done through proxies. Pour que Spring puisse créer des proxies autour des classes DAO, ceux-ci ne doivent pas être déclarésfinal.

5. Configuration des données Spring

Pour activer le support du référentiel Spring JPA, nous pouvons utiliser l'annotation@EnableJpaRepositories et spécifier le package qui contient les interfaces DAO: 

@EnableJpaRepositories(basePackages = "com.example.jpa.dao")
public class PersistenceConfig { ... }

On peut faire de même avec une configuration XML:

6. La configuration Spring Java ou XML

Nous avons déjà discuté en détail de la façon deconfigure JPA in Spring dans un article précédent. Spring Data tire également parti de la prise en charge de Spring pour l'annotation JPA@PersistenceContext. Il l'utilise pour câbler lesEntityManager dans le bean usine Spring responsable de la création des implémentations DAO réelles -JpaRepositoryFactoryBean.

En plus de la configuration déjà discutée, nous devons également inclure la configuration XML des données Spring - si nous utilisons XML: 

@Configuration
@EnableTransactionManagement
@ImportResource( "classpath*:*springDataConfig.xml" )
public class PersistenceJPAConfig{
   ...
}

7. La dépendance de Maven

En plus de la configuration Maven pour JPA définie dans unprevious article, la dépendancespring-data-jpa est ajoutée: 


   org.springframework.data
   spring-data-jpa
   2.1.6.RELEASE

8. Utilisation de la botte de printemps

Nous pouvons également utiliser la dépendanceSpring Boot Starter Data JPA qui configurera automatiquement la DataSource pour nous.

Nous devons également nous assurer que la base de données que nous voulons utiliser est présente dans le chemin d'accès aux classes. Dans notre exemple, nous avons ajouté la base de données en mémoire H2: 


   org.springframework.boot
   spring-boot-starter-data-jpa
   2.1.3.RELEASE


    com.h2database
    h2
    1.4.197

C’est tout, grâce à ces dépendances, notre application est opérationnelle et nous pouvons l’utiliser pour d’autres opérations de base de données.

La configuration explicite d'une application Spring standard est désormais incluse dans le cadre de la configuration automatique de Spring Boot.

Nous pouvons bien entendu modifier la configuration automatique en ajoutant notre propre configuration explicite.

Spring Boot fournit un moyen simple de le faire en utilisant les propriétés du fichierapplication.properties: 

spring.datasource.url=jdbc:h2:mem:db;DB_CLOSE_DELAY=-1
spring.datasource.username=sa
spring.datasource.password=sa

Dans cet exemple, nous avons modifié l'URL de connexion et les informations d'identification.

9. Conclusion

Cet article traite de la configuration et de la mise en œuvre de la couche de persistance avec Spring 4, JPA 2 et Spring Data JPA (faisant partie du projet parapluie Spring Data), à l'aide d'une configuration basée sur XML et sur Java.

Nous avons discuté des moyens de définir plus deadvanced custom queries, ainsi que d'unconfiguration with the new jpa namespace et de la sémantique transactionnelle. Le résultat final est une nouvelle approche élégante de l'accès aux données avec Spring, qui ne nécessite pratiquement aucun travail de mise en œuvre.

L'implémentation de ce tutoriel Spring Data JPA peut être trouvée dansthe GitHub project.

Related