Présentation, étape par étape, de Spring-DATA-JPA

Ce billet présente une démo pour illustrer, étape par étape, comment utiliser Spring-Data-JPA.

Ce billet peut être considéré traitant le même thème que Construction de requêtes en Java : comment faire le bon choix ?.

Nous détaillons, dans une première partie, la prise en main du "framework" Spring-Data-JPA avant de progresser dans notre compréhension.

Le projet Spring-Data-JPA est l'un des projets de Spring reposant sur Spring-Data.

Spring-Data réduit considérablement le coût économique de la couche d'accès aux données relationnelles ou NoSQL.

Il simplifie l'accès aux bases de données SGBDR ou de type NoSQL.

Spring-Data peut-être combiné avec le framework QueryDSL (Domain Driven Design) afin de réaliser des requêtes complexes.

Avec Spring-Data-JPA, le développeur bénéficie d'un certain nombre de méthodes d'accès à la base sans écrire une ligne de code d'implémentation.

Le projet Spring-Data-JPA vise à améliorer la mise en œuvre de la couche d'accès aux données en réduisant considérablement l'effort d'écriture du code d'implémentation en particulier pour les méthodes CRUD et de recherche.

La notion centrale dans Spring-Data-JPA est la notion "Repository". Le repository est une interface à écrire par le développeur.

Il déclare, dans cette interface, les méthodes utiles d'accès aux données et Spring-Data-JPA fournit les implémentations nécessaires.

Notez que la même approche est appliquée à des contextes autres que JPA comme pour les bases non relationnelles.

Vous pouvez télécharger les sources de la démo1 ici.

Avec Spring-Data, écrire des méthodes de requête à la base se fait en 3+1 étapes:

  • Déclarer une interface Repository,
  • Ecrire la signature de la méthode de requête (CRUD ou de recherche),
  • Configurer Spring pour la génération automatique,
  • Appeler dans le client (ou test unitaire) les méthodes du Repository

C'est aussi facile!

Mais là on n'a fait que survoler la surface de Spring-Data.

Nous allons détailler ces étapes ci-après dans la démo.

La démo se décompose en deux parties:

  • La première partie permet à tout à chacun la prise en main de Spring-Data-JPA avec un cas d'utilisation simple.
  • La seconde permet d'introduire QueryDSL pour rajouter des requêtes complexes.

PREMIERE PARTIE: DEMO1

La seule entité de notre domaine, dans cette première démo, est Client :

@Entity
public class Client {
	@Id	@GeneratedValue(strategy = GenerationType.AUTO)
	private Long id;
	private String prenom;
	private String nom;

Les getters/setters sont omis. Notez que l'id est un Long.

ETAPE1: Déclarer l'interface Repository

Nous souhaitons donc écrire les méthodes CRUD et de recherche standard dans la base.

Pour cela, nous écrivons l'interface nommée ClientRepository qui hérite de JpaRepository :

public interface ClientRepository extends JpaRepository<Client, Long>
{
    /* List<Client> findByNomLike(String nom);*/
}

Nous héritons de JpaRepository car c'est la solution Jpa qui a été retenue pour cette démo, sinon l'interface hérite de Repository ou l'interface appropriée.

Avec cet héritage de JpaRepository, nous disposons de plein de méthodes CRUD et de recherche standard comme illustré ci-dessous :

methodes_crud_jpa_repository.PNG

Sachez que JpaRepository hérite des interfaces CrudRepository, PagingAndSortingRepository.

Vous disposez de l'ensemble des méthodes de ces interfaces.

Sachez qu'il est possible de se restreindre à certaines méthodes CRUD.

ETAPE2: Déclarer la méthode de requête

Nous avons rajouté notre (propre) méthode de recherche nommée findByNomLike(String nom). Pensez à décommenter la ligne dans l'interface ClientRepository.

En respectant la convention de nommage , Spring-Data-JPA génère aussi l'implémentation de cette méthode pour nous.

Dans le test JUnit plus loin, nous faisons appel à la méthode findByNomLike pour vérification.

ETAPE3: Configurer Spring pour la génération automatique

Mais comment Spring-Data-JPA active la génération automatique des implémentations ?

Pour ce faire, il faudrait ajouter au fichier de Spring la ligne suivante:

<jpa:repositories base-package="NOM_DE_VOTRE_PACKAGE_DES_REPOSITORIES />

ETAPE4: Ecrire le test JUnit
Notre classe JUnit se nomme TestClientRepositoryTest :

import ....

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations={
               "classpath*:config/applicationContext.xml" })
@TransactionConfiguration(
               transactionManager="transactionManager",
               defaultRollback=true)
public class TestClientRepositoryTest
{
    @Autowired ClientRepository clientRepo;	

   @Test public void tstFindClientByNom(){
		final Client client1=new Client();		
		client1.setNom("TOTO");
		client1.setPrenom("titi");
		Client client=clientRepo.save(client1);
		Assert.assertTrue(client.getId()>0);

		List<Client> founds=clientRepo.findByNomLike("TOT%");		
		Assert.assertTrue(founds.size()>0);
	}
}

Observez la valeur de l'attribut defaultRollback de l'annotation TransactionConfiguration.
Dans ce test nous appelons deux méthodes :
- la méthode save de CrudRepository,
- notre (propre) méthode findByNomLike.

Entraînez vous en téléchargeant le projet.

@Bientôt pour la seconde partie avec QueryDSL.

4 commentaires

Laisser un commentaire

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *

Captcha *

Ce site utilise Akismet pour réduire les indésirables. En savoir plus sur comment les données de vos commentaires sont utilisées.