Spring data jpa

Dans l'article, je décrirai l'utilisation de Spring Data.

Spring Data est un mécanisme supplémentaire pratique pour interagir avec les entités de base de données, les organiser dans un référentiel, récupérer les données, changer, dans certains cas, pour cela, il suffira de déclarer une interface et une méthode, sans implémentation.

Contenu:

1. Dépôt Spring
2. Demander des méthodes au nom de la méthode
3. Configuration et installation
4. Traitement des paramètres spéciaux
5. Implémentations de référentiel personnalisées
6. Référentiel de base personnalisé
7. Méthodes de requête - Requête

1. Spring Repository

Le concept de base de Spring Data est le référentiel. Ce sont plusieurs interfaces qui utilisent l'entité JPA pour interagir avec elle. Ainsi, par exemple, une interface
public interface CrudRepository<T, ID extends Serializable> extends Repository<T, ID>
fournit des opérations de base pour rechercher, enregistrer, supprimer des données (opérations CRUD)

 T save(T entity); Optional findById(ID primaryKey); void delete(T entity); 

et autres opérations.

Il existe d'autres abstractions, telles que PagingAndSortingRepository.

C'est-à-dire si la liste fournie par l'interface est suffisante pour interagir avec l'entité, vous pouvez développer directement l'interface de base de votre entité, la compléter avec vos méthodes de requête et effectuer des opérations. Je vais maintenant montrer brièvement les étapes nécessaires pour le cas le plus simple (sans être distrait jusqu'à présent par la configuration, l'ORM, la base de données).

1. Créez une entité

 @Entity @Table(name = "EMPLOYEES") public class Employees { private Long employeeId; private String firstName; private String lastName; private String email; // . . . 

2. Hérité de l'une des interfaces Spring Data, par exemple de CrudRepository

 @Repository public interface CustomizedEmployeesCrudRepository extends CrudRepository<Employees, Long> 

3. Utiliser dans le client (service) une nouvelle interface pour les opérations de données

 @Service public class EmployeesDataService { @Autowired private CustomizedEmployeesCrudRepository employeesCrudRepository; @Transactional public void testEmployeesCrudRepository() { Optional<Employees> employeesOptional = employeesCrudRepository.findById(127L); //.... } 

Ici, j'ai utilisé la méthode findById prête à l'emploi. C'est-à-dire si rapidement et facilement, sans implémentation, nous obtenons une liste prête à l'emploi d'opérations de CrudRepository:

  S save(S var1); Iterable<S> saveAll(Iterable<S> var1); Optional<T> findById(ID var1); boolean existsById(ID var1); Iterable<T> findAll(); Iterable<T> findAllById(Iterable<ID> var1); long count(); void deleteById(ID var1); void delete(T var1); void deleteAll(Iterable<? extends T> var1); void deleteAll(); 

Il est clair que cette liste n'est probablement pas suffisante pour interagir avec l'entité, et ici vous pouvez étendre votre interface avec des méthodes de requête supplémentaires.

2. Interroger les méthodes à partir du nom de la méthode

Les demandes à l'entité peuvent être générées directement à partir du nom de la méthode. Pour cela, les préfixes find ... By, read ... By, query ... By, count ... By et get ... By sont utilisés, plus loin du préfixe de la méthode, il commence à analyser le reste. La phrase introductive peut contenir des expressions supplémentaires, par exemple Distinct. Ensuite, le premier By agit comme un délimiteur pour indiquer le début des critères réels. Vous pouvez définir des conditions pour les propriétés d'entité et les combiner à l'aide de Et et Ou. Des exemples

 @Repository public interface CustomizedEmployeesCrudRepository extends CrudRepository<Employees, Long> { //    firstName And LastName Optional<Employees> findByFirstNameAndLastName(String firstName, String lastName); //   5  FirstName       FirstName List<Employees> findFirst5ByFirstNameStartsWithOrderByFirstName(String firstNameStartsWith); 

La documentation définit la liste entière et les règles d'écriture de la méthode. Le résultat peut être une entité T, facultative, liste, flux. Dans un environnement de développement, comme Idea, il existe une astuce pour écrire des méthodes de requête.


Il suffit de définir une méthode de cette manière, sans implémentation, et Spring préparera une requête pour l'entité.

 @SpringBootTest public class DemoSpringDataApplicationTests { @Autowired private CustomizedEmployeesCrudRepository employeesCrudRepository; @Test @Transactional public void testFindByFirstNameAndLastName() { Optional<Employees> employeesOptional = employeesCrudRepository.findByFirstNameAndLastName("Alex", "Ivanov"); 

3. Configuration et installation

L'ensemble du projet est disponible sur github
github DemoSpringData

Ici, je ne parlerai que de certaines fonctionnalités.

Les beans TransactionManager, dataSource et entityManagerFactory sont définis dans context.xml. Il est important d’y indiquer également

 <jpa:repositories base-package="com.example.demoSpringData.repositories"/> 

chemin où les référentiels sont définis.

EntityManagerFactory est configuré pour fonctionner avec Hibernate ORM, et c'est, à son tour, avec la base de données Oracle XE, ici d'autres options sont possibles, dans context.xml tout cela est visible. Le fichier pom a toutes les dépendances.

4. Traitement spécial des paramètres

Dans les méthodes de requête, dans leurs paramètres, vous pouvez utiliser des paramètres spéciaux Pageable, Sort, ainsi que des restrictions Top et First.

Par exemple, comme ceci, vous pouvez prendre la deuxième page (index avec -0), la taille de trois éléments et triée par firstName, après avoir spécifié le paramètre Pageable dans la méthode du référentiel, les critères du nom de la méthode seront également utilisés - «Recherche par FirstName commençant par%„

 @Repository public interface CustomizedEmployeesCrudRepository extends CrudRepository<Employees, Long> { List<Employees> findByFirstNameStartsWith(String firstNameStartsWith, Pageable page); //.... } //   @Test @Transactional public void testFindByFirstNameStartsWithOrderByFirstNamePage() { List<Employees> list = employeesCrudRepository .findByFirstNameStartsWith("A", PageRequest.of(1,3, Sort.by("firstName"))); list.forEach(e -> System.out.println(e.getFirstName() + " " +e.getLastName())); } 

5. Implémentations personnalisées pour le référentiel

Supposons que vous ayez besoin d'une méthode dans le référentiel qui ne puisse pas être décrite par le nom de la méthode, alors vous pouvez l'implémenter en utilisant votre propre interface et sa classe d'implémentation. Dans l'exemple ci-dessous, je vais ajouter au référentiel une méthode pour obtenir des employés avec un salaire maximum.

Déclarer l'interface

 public interface CustomizedEmployees<T> { List<T> getEmployeesMaxSalary(); } 

Implémente l'interface. En utilisant HQL (SQL) j'obtiens des employés avec un salaire maximum, d'autres implémentations sont possibles.

 public class CustomizedEmployeesImpl implements CustomizedEmployees { @PersistenceContext private EntityManager em; @Override public List getEmployeesMaxSalary() { return em.createQuery("from Employees where salary = (select max(salary) from Employees )", Employees.class) .getResultList(); } } 

Et également étendre les employés de Crud Repository avec CustomizedEmployees.

 @Repository public interface CustomizedEmployeesCrudRepository extends CrudRepository<Employees, Long>, CustomizedEmployees<Employees> 

Il y a une caractéristique importante ici. L'interface d'implémentation de classe doit se terminer (postfix) sur Impl , ou dans la configuration dont vous avez besoin pour mettre votre postfix

 <repositories base-package="com.repository" repository-impl-postfix="MyPostfix" /> 

Vérification du fonctionnement de cette méthode via le référentiel

 public class DemoSpringDataApplicationTests { @Autowired private CustomizedEmployeesCrudRepository employeesCrudRepository; @Test @Transactional public void testMaxSalaryEmployees() { List<Employees> employees = employeesCrudRepository.getEmployeesMaxSalary(); employees.stream() .forEach(e -> System.out.println(e.getFirstName() + " " + e.getLastName() + " " + e.getSalary())); } 

Un autre cas où il est nécessaire de modifier le comportement d'une méthode existante dans l'interface Spring, par exemple, supprimer dans CrudRepository, j'ai besoin qu'au lieu de supprimer de la base de données, un signe de suppression soit défini. La technique est exactement la même. Voici un exemple:

 public interface CustomizedEmployees<T> { void delete(T entity); // ... } //  CustomizedEmployees public class CustomizedEmployeesImpl implements CustomizedEmployees { @PersistenceContext private EntityManager em; @Transactional @Override public void delete(Object entity) { Employees employees = (Employees) entity; employees.setDeleted(true); em.persist(employees); } 

Maintenant, si vous appelez delete dans employeesCrudRepository, l'objet sera uniquement marqué comme supprimé.

6. Référentiel de la base d'utilisateurs

Dans l'exemple précédent, j'ai montré comment redéfinir le référentiel de suppression d'une entité dans Crud, mais si vous devez le faire pour toutes les entités de projet, rendez votre propre interface pas si bonne pour chacune ... puis dans les données Spring, vous pouvez configurer votre référentiel de base. Pour ce faire:
Une interface est déclarée et en elle une méthode de substitution (ou commune à toutes les entités du projet). Ici, pour toutes mes entités, j'ai introduit mon interface BaseEntity (ce n'est pas nécessaire), pour la commodité d'appeler des méthodes communes, ses méthodes coïncident avec les méthodes de l'entité.

 public interface BaseEntity { Boolean getDeleted(); void setDeleted(Boolean deleted); } //  Employees @Entity @Table(name = "EMPLOYEES") public class Employees implements BaseEntity { private Boolean deleted; @Override public Boolean getDeleted() { return deleted; } @Override public void setDeleted(Boolean deleted) { this.deleted = deleted; } //    @NoRepositoryBean public interface BaseRepository <T extends BaseEntity, ID extends Serializable> extends JpaRepository<T, ID> { void delete(T entity); } //    BaseRepository public class BaseRepositoryImpl <T extends BaseEntity, ID extends Serializable> extends SimpleJpaRepository<T, ID> implements BaseRepository<T, ID> { private final EntityManager entityManager; public BaseRepositoryImpl(JpaEntityInformation<T, ?> entityInformation, EntityManager entityManager) { super(entityInformation, entityManager); this.entityManager = entityManager; } @Transactional @Override public void delete(BaseEntity entity) { entity.setDeleted(true); entityManager.persist(entity); } } 

Dans la configuration, vous devez spécifier ce référentiel de base, il sera commun à tous les référentiels de projet

  <jpa:repositories base-package="com.example.demoSpringData.repositories" base-class="com.example.demoSpringData.BaseRepositoryImpl"/> 

Désormais, le référentiel des employés (et d'autres) doit être développé à partir de BaseRepository et déjà l'utiliser dans le client.

 public interface EmployeesBaseRepository extends BaseRepository <Employees, Long> { // ... } 

Vérification des employésBaseRepository

 public class DemoSpringDataApplicationTests { @Resource private EmployeesBaseRepository employeesBaseRepository; @Test @Transactional @Commit public void testBaseRepository() { Employees employees = new Employees(); employees.setLastName("Ivanov"); // Query by Example (QBE) Example<Employees> example = Example.of(employees); Optional<Employees> employeesOptional = employeesBaseRepository.findOne(example); employeesOptional.ifPresent(employeesBaseRepository::delete); } 

Maintenant, comme précédemment, l'objet sera marqué comme supprimé, et cela sera effectué pour toutes les entités qui étendent l'interface BaseRepository. Dans l'exemple, la méthode de recherche - Requête par exemple (QBE) a été appliquée, je ne la décrirai pas ici, l'exemple montre ce qu'elle fait, simple et pratique.

7. Méthodes de requête - Requête

Plus tôt, j'ai écrit que si vous avez besoin d'une méthode spécifique ou de son implémentation, qui ne peut pas être décrite à l'aide du nom de la méthode, cela peut être fait via une interface personnalisée (CustomizedEmployees) et effectuer une implémentation de calcul. Et vous pouvez aller dans l'autre sens, en indiquant la requête (HQL ou SQL), comment calculer cette fonction.
Pour mon exemple avec getEmployeesMaxSalary, cette option d'implémentation est encore plus simple. Je vais le compliquer avec le paramètre d'entrée de salaire. C'est-à-dire il suffit de déclarer la méthode de calcul et de demander dans l'interface.

 @Repository public interface CustomizedEmployeesCrudRepository extends CrudRepository<Employees, Long>, CustomizedEmployees<Employees> { @Query("select e from Employees e where e.salary > :salary") List<Employees> findEmployeesWithMoreThanSalary(@Param("salary") Long salary, Sort sort); // ... } 

Vérification

 @Test @Transactional public void testFindEmployeesWithMoreThanSalary() { List<Employees> employees = employeesCrudRepository.findEmployeesWithMoreThanSalary(10000L, Sort.by("lastName")); 

Je mentionnerai simplement qu'il peut y avoir des demandes de modification, pour cela une annotation @Modifying supplémentaire leur est ajoutée

 @Modifying @Query("update Employees e set e.firstName = ?1 where e.employeeId = ?2") int setFirstnameFor(String firstName, String employeeId); 

Une autre des grandes fonctionnalités des annotations de requête est la substitution du type de domaine d'entité dans la requête à l'aide du modèle # {# entityName} , via des expressions SpEL.

Ainsi, par exemple, dans mon exemple hypothétique, lorsque j'ai besoin d'avoir le signe «supprimé» pour toutes les entités, je ferai une interface de base avec une méthode pour obtenir une liste d'objets avec le signe «supprimé» ou «actif»

 @NoRepositoryBean public interface ParentEntityRepository<T> extends Repository<T, Long> { @Query("select t from #{#entityName} t where t.deleted = ?1") List<T> findMarked(Boolean deleted); } 

De plus, tous les référentiels d'entités peuvent être étendus à partir de celui-ci. Les interfaces qui ne sont pas des référentiels, mais qui se trouvent dans le dossier de configuration "package de base", annotez @NoRepositoryBean.

Référentiel des employés

 @Repository public interface EmployeesEntityRepository extends ParentEntityRepository <Employees> { } 

Maintenant, lorsque la demande est exécutée, le nom d'entité T sera substitué dans le corps de la demande pour un référentiel spécifique qui étendra le ParentEntityRepository, dans ce cas, les employés.

Vérifier

 @SpringBootTest public class DemoSpringDataApplicationTests { @Autowired private EmployeesEntityRepository employeesEntityRepository; @Test @Transactional public void testEntityName() { List<Employees> employeesMarked = employeesEntityRepository.findMarked(true); // ... 

Matériaux
Spring Data JPA - Documentation de référence
Projet sur github .