Introduction aux scénarios d'application de Spring Data jpa (détails)

Cet article vous apporte une introduction aux scénarios d'application de spring data jpa (détaillé). Il a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer.

Parlons brièvement du concept de JPA

 : JPA (Java Persistence API) est la spécification de persistance Java officiellement proposée par Sun. Il fournit aux développeurs Java un outil de mappage d'objets/associations pour gérer les données relationnelles dans les applications Java.

Influence : Son apparition vise principalement à simplifier le travail de développement de persistance existant et à intégrer la technologie ORM, mettant fin aux actuels Hibernate, TopLink, JDO et d'autres frameworks ORM sont dans des situations distinctes

Pour en venir au fait

Spring DATA JPA

　1. Concept : Il s'agit d'un ensemble de framework d'application JPA basé sur le framework ORM et l'encapsulation de spécifications JPA, qui permet aux développeurs d'accéder et d'exploiter les données avec un minimum de code. Il fournit des fonctions comprenant l'ajout, la suppression, la modification et la requête, etc. Couramment utilisé. fonctions et facile à étendre! L'apprentissage et l'utilisation de Spring Data JPA peuvent améliorer considérablement l'efficacité du développement.

2. Avantages : spring data jpa nous libère du fonctionnement de la couche DAO, en gros tous les CRUD peuvent s'appuyer dessus pour réaliser

　3. Implémentation :

Introduction Maven :

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>

introduction du diplôme :

compile('org.springframework.boot:spring-boot-starter-data-jpa')

　Implémentation : Créer une interface pour implémenter l'une des interfaces suivantes

　3.1 : Référentiel

Présentation : est juste un identifiant, indiquant que tout ce qui en hérite est une classe d'interface d'entrepôt, ce qui permet à Spring de l'analyser et de l'identifier automatiquement. Cette interface est l'interface la plus basique. Il s'agit simplement d'une interface iconique et ne définit aucune méthode.

Il s'agit de l'interface de niveau supérieur et d'une interface vide. Le but est d'unifier tous les types de référentiels et de permettre aux composants d'être automatiquement reconnus lors de l'analyse.

　Avantages : Par exemple, nous avons certaines méthodes que nous ne voulons pas fournir au monde extérieur. Par exemple, nous voulons uniquement fournir des méthodes d'ajout et de modification, mais pas de méthodes de suppression. . Ensuite, les interfaces suivantes sont Si cela n'est pas possible, pour le moment, nous pouvons hériter de cette interface puis copier les méthodes correspondantes de l'interface CrudRepository vers l'interface Repository.

3.2 : CrudRepository

Présentation : Sous-interface du référentiel, fournissant des méthodes liées au CRUD

Méthode principale :

保存
    <S extends T> S save(S entity);
批量保存
    <S extends T> Iterable<S> save(Iterable<S> entities);
根据id查询一个对象
    T findOne(ID id)
判断对象是否存在
    boolean exists(ID id)
查询所有的对象
    Iterable<T> findAll()
根据id列表查询所有的对象
    Iterable<T> findAll(Iterable<ID> ids)
计算对象的总个数
    long count()
根据id删除
    void delete(ID id)
删除对象
    void delete(T entity);
批量删除
    void delete(Iterable<? extends T> entities);
删除所有
    void deleteAll()

3.3 : PagingAndSortingRepository

Présentation : La sous-interface de CrudRepository, ajoute un groupe de tri de pagination lié Méthodes

Méthode principale :

不带分页的排序
    Iterable<T> findAll(Sort sort)
带分页的排序
    Page<T> findAll(Pageable pageable)

3.4 : JpaRepository

Présentation : PagingAndSortingRepository sub -interface, ajoutez un ensemble de méthodes liées à la spécification JPA

Méthodes principales :

查询所有对象，不排序
    List<T> findAll()
查询所有对象，并排序
    List<T> findAll(Sort sort)
批量保存
    <S extends T> List<S> save(Iterable<S> entities);
强制缓存与数据库同步
    void flush()
保存并强制同步
    T saveAndFlush(T entity)
批量删除
    void deleteInBatch(Iterable<T> entities)
删除所有
    void deleteAllInBatch();

　3.5 : JpaSpecificationExecutor

Présentation : Ceci est assez spécial et n'appartient pas au système Repository. Il implémente un ensemble de méthodes liées aux requêtes JPA Criteria, principalement une interface (interface auxiliaire) utilisée pour effectuer des requêtes complexes.

Remarque : Cette interface est très spéciale et n'appartient pas au système de référentiel Spring Data JPA ne l'analysera pas et ne l'identifiera pas automatiquement, il signalera donc que le bean correspondant est introuvable. .Il nous suffit d'hériter de n'importe quelle sous-interface A qui hérite du référentiel ou hérite directement de l'interface du référentiel, Spring Data JPA l'analysera et l'identifiera automatiquement et effectuera une gestion unifiée

　4.Méthode personnalisée :

Prérequis : Implémenter l'une des interfaces ci-dessus

4.1 : Utiliser @Query pour créer une requête

4.1.1 : Utilisation

L'utilisation de l'annotation @Query est très simple. Il suffit de marquer l'annotation sur la méthode déclarée et de fournir une instruction de requête JP QL

.

Par exemple :

@Query("select u from User u where u.name = :name")
User findUserByName(@Param("name") String name);

4.1.2 : Paramètres

4.1.2.1 : Paramètres nommés

Description : Cette méthode est recommandée, vous pouvez ignorer la position du paramètre

@Query("select u from User u where u.name = :name")
User findUserByName(@Param("name") String name);

4.1.2.2 : Paramètre d'index

Description : Utiliser l'espace réservé

@Query("select u from User u where u.email = ?1")// 1表示第一个参数User findUserByEmail(String email);

4.1.2.3 : Expression SPEL (je viens de l'écrire brièvement ici, vous pouvez consulter la documentation si vous êtes intéressé)

Description : À partir de la version Spring Data JPA 1.4, nous prenons en charge la définition manuelle de la requête pour utiliser l'expression de modèle SpEL restreinte @Query　

@Query("select u from User u where u.name = :name")
User findUserByName(@Param("name") String name);

Variables prises en charge dans les modèles de requête basés sur SpEL

变量
    entityName
用法
    select x from #{#entityName} x
描述
    插入entityName与给定存储库关联的域类型。该entityName解决如下：如果域类型已设置的name属性@Entity注解那么它将被使用。否则，将使用域类型的简单类名称。
注意
    该entityName可以通过自定义@Entity的注释。orm.xmlSpEL表达式不支持自定义。
    引用#entityName将会把用户类的潜在的未来重映射转换成一个不同的实体名称（例如通过使用@Entity(name = "MyUser")

4.1.3 : Classification

　　 4.1.3.1 : REQUÊTE

　Par exemple :

@Query("select u from User u where u.name = :name")
User findUserByName(@Param("name") String name);

　Remarque :

1. Utilisez @Query pour spécifier une requête locale, définissez simplement nativeQuery sur true, par exemple :

@Query(value="select * from tbl_user where name like %?1" ,nativeQuery=true)public List<UserModel> findByUuidOrAge(String name);

2. La version actuelle de la requête locale ne prend pas en charge le changement de page et la dynamique tri

Catégorie (il y a aussi de nombreuses requêtes dans Query)

　　1、使用@Query在查询方法中声明查询

 @Query("select u from User u where u.emailAddress = ?1")
  User findByEmailAddress(String emailAddress);

　　2、使用高级LIKE表达式

@Query("select u from User u where u.firstname like %?1")
  List<User> findByFirstnameEndsWith(String firstname);

　　3、使用@Query在查询方法中声明本地计数查询以进行分页

 @Query(value = "SELECT * FROM USERS WHERE LASTNAME = ?1",
    countQuery = "SELECT count(*) FROM USERS WHERE LASTNAME = ?1",
    nativeQuery = true)
  Page<User> findByLastname(String lastname, Pageable pageable);

4.1.3.1：修改查询

　　比如：

@Modifying
@Query(value="update UserModel o set o.name=:newName where o.name like %:nn")public int findByUuidOrAge(@Param("nn") String name,@Param("newName") String newName)

　　注意：可以通过使用 @Query 来执行一个更新操作，为此，我们需要在使用 @Query 的同时，* 用 @Modifying 来将该操作标识为修改查询，这样框架最终会生成一个更新的操作，而非查询操作。

　　4.2：@NamedQueries创建查询

　　概念：命名查询是 JPA 提供的一种将查询语句从方法体中独立出来，以供多个方法共用的功能

　　用法：用户只需要按照 JPA 规范在 orm.xml 文件或者在代码中使用 @NamedQuery（或 @NamedNativeQuery）定义好查询语句，唯一要做的就是为该语句命名时，需要满足”DomainClass.methodName()”的 命名规则

　　比如：

编写接口：
public interface FindUserByNamedQueryRepository extends JpaRepository<User, Integer> {
User findUserWithName(@Param("name") String name);
}
编写类：
@Entity
@NamedQueries(value={
@NamedQuery(name="User.findUserWithName",query="select u from User u where u.name = :name")
})
以下是实体类
......

　　注意：

　　1、@NamedQuery中的name属性的值要和接口中的方法名称一样。

　　2、此处如果是多个方法，那么需要使用@NamedQueries，如果只有一个方法，则可以使用@NamedQuery，写法如下：

@NamedQuery(name="User.findUserWithName",query="select u from User u where u.name = :name")

　　4.3：通过解析方法名创建查询

　　概念：顾名思义，就是根据方法的名字，就能创建查询

　　定义规则：

　　　说明：按照Spring data 定义的规则，查询方法以find|read|get开头涉及条件查询时，条件的属性用条件关键字连接，要注意的是：条件属性首字母需大写（参数名大写，条件名首字母大写，并且接口名中参数出现的顺序必须和参数列表中的参数顺序一致）

　　　例如：

//参数名大写，条件名首字母大写，并且接口名中参数出现的顺序必须和参数列表中的参数顺序一致
User findByNameAndEmail(String name, String email);　　//相当于发送了一条SQL:select u from User u where u.name = :name and u.email = :email
  
List<User> findByNameOrPassword(String name, String password);　　//相当于发送了一条SQL:select u from User u where u.name = ?1 or u.password = ?2

List<User> findByNameOrPassword(String name, String password);　　//相当于发送了一条SQL:select u from User u where u.name = ?1 or u.password = ?2

List<User> findByIdBetween(Integer start, Integer end);　　//相当于发送了一条SQL:select u from User u where u.id between ?1 and ?2

List<User> findByIdLessThan(Integer end);　　//相当于发送了一条SQL:select u from User u where u.id < ?1
...

解析：框架在进行方法名解析时，会先把方法名多余的前缀截取掉，比如 find、findBy、read、readBy、get、getBy，然后对剩下部分进行解析。并且如果方法的最后一个参数是 Sort 或者 Pageable 类型，也会提取相关的信息，以便按规则进行排序或者分页查询。在创建查询时，我们通过在方法名中使用属性名称来表达，比如 findByIdIn()。框架在解析该方法时，首先剔除 findBy，然后对剩下的属性进行解析

一些条件查询的关键字：

框架在进行方法名解析时，会先把方法名多余的前缀截取掉，比如 find、findBy、read、readBy、get、getBy，然后对剩下部分进行解析。
并且如果方法的最后一个参数是 Sort 或者 Pageable 类型，也会提取相关的信息，以便按规则进行排序或者分页查询。在创建查询时，我们通过在方法名中使用属性名称来表达
，比如 findByIdIn()。框架在解析该方法时，首先剔除 findBy，然后对剩下的属性进行解析

And --- 等价于 SQL 中的 and 关键字，比如 findByUsernameAndPassword(String user, Striang pwd)

Or --- 等价于 SQL 中的 or 关键字，比如 findByUsernameOrAddress(String user, String addr)

Between --- 等价于 SQL 中的 between 关键字，比如 findBySalaryBetween(int max, int min)

LessThan --- 等价于 SQL 中的 "<"，比如 findBySalaryLessThan(int max)

GreaterThan --- 等价于 SQL 中的">"，比如 findBySalaryGreaterThan(int min)

IsNull --- 等价于 SQL 中的 "is null"，比如 findByUsernameIsNull()

IsNotNull --- 等价于 SQL 中的 "is not null"，比如 findByUsernameIsNotNull()

NotNull --- 与 IsNotNull 等价

Like --- 等价于 SQL 中的 "like"，比如 findByUsernameLike(String user)

NotLike --- 等价于 SQL 中的 "not like"，比如 findByUsernameNotLike(String user)

OrderBy ---等价于 SQL 中的 "order by"，比如 findByUsernameOrderBySalaryAsc(String user)

Not --- 等价于 SQL 中的 "！ ="，比如 findByUsernameNot(String user)

In --- 等价于 SQL 中的 "in"，比如 findByUsernameIn(Collection userList) ，方法的参数可以是 Collection 类型，也可以是数组或者不定长参数

NotIn --- 等价于 SQL 中的 "not in"，比如 findByUsernameNotIn(Collection userList) ，方法的参数可以是 Collection 类型，也可以是数组或者不定长参数

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!