Einführung in Anwendungsszenarien von Spring Data JPA (Details)

Dieser Artikel bietet Ihnen eine Einführung in die Anwendungsszenarien von Spring Data JPA (ausführlich). Ich hoffe, dass er für Freunde in Not hilfreich ist.

Lassen Sie uns kurz über das Konzept von JPA sprechen

: JPA (Java Persistence API) ist die von Sun offiziell vorgeschlagene Java-Persistenzspezifikation. Es stellt Java-Entwicklern ein Objekt-/Assoziations-Mapping-Tool zur Verwaltung relationaler Daten in Java-Anwendungen zur Verfügung.

Einfluss: Sein Auftritt dient hauptsächlich der Vereinfachung der bestehenden Persistenzentwicklungsarbeit und der Integration der ORM-Technologie, wodurch der aktuelle Hibernate, TopLink, JDO beendet wird und andere ORM-Frameworks befinden sich in unterschiedlichen Situationen

Auf den Punkt gebracht

Spring DATA JPA

　1. Konzept: Es handelt sich um eine Reihe von JPA-Anwendungsframeworks, die auf dem ORM-Framework und der JPA-Spezifikationskapselung basieren und es Entwicklern ermöglichen, mit minimalem Code auf Daten zuzugreifen und diese zu bearbeiten. Es bietet Funktionen wie Hinzufügen, Löschen, Ändern und Abfragen usw. Wird häufig verwendet Funktionen und einfach erweiterbar! Das Erlernen und Verwenden von Spring Data JPA kann die Entwicklungseffizienz erheblich verbessern.

2. Vorteile: spring data jpa befreit uns vom Betrieb der DAO-Schicht, im Grunde kann sich jedes CRUD darauf verlassen, um

zu erreichen

　3. Implementierung:

Maven-Einführung:

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

Gradle-Einführung:

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

　Implementierung: Erstellen Sie eine Schnittstelle, um eine der folgenden Schnittstellen zu implementieren

　3.1: Repository

Übersicht: Das ist es lediglich eine Kennung, die angibt, dass alles, was sie erbt, eine Warehouse-Schnittstellenklasse ist, was für Spring praktisch ist, um sie automatisch zu scannen und zu identifizieren. Diese Schnittstelle ist die einfachste Schnittstelle. Sie ist lediglich eine ikonische Schnittstelle und definiert keine Methoden.

Es handelt sich um die Schnittstelle der obersten Ebene und eine leere Schnittstelle. Der Zweck besteht darin, alle Repository-Typen zu vereinheitlichen und die automatische Erkennung von Komponenten beim Scannen zu ermöglichen.

　Vorteile: Zum Beispiel haben wir einige Methoden, die wir der Außenwelt nicht zur Verfügung stellen möchten. Beispielsweise möchten wir nur Methoden zum Hinzufügen und Ändern bereitstellen, aber keine Methoden zum Löschen Dann sind die folgenden Schnittstellen vorhanden. Wenn dies zu diesem Zeitpunkt nicht möglich ist, können wir diese Schnittstelle erben und dann die entsprechenden Methoden in der CrudRepository-Schnittstelle in die Repository-Schnittstelle kopieren.

3.2: CrudRepository

Übersicht: Unterschnittstelle des Repositorys, die CRUD-bezogene Methoden bereitstellt

Hauptmethoden:

保存
    <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

Übersicht: Die Unterschnittstelle von CrudRepository fügt eine Reihe von Methoden im Zusammenhang mit der Paging-Sortierung hinzu

Hauptmethoden:

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

3.4: JpaRepository

Übersicht: Unterschnittstelle von PagingAndSortingRepository , Fügen Sie eine Reihe von Methoden hinzu, die sich auf die JPA-Spezifikation beziehen

Hauptmethode:

查询所有对象，不排序
    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

Übersicht : Dies ist etwas ganz Besonderes und gehört nicht zum Repository-System. Es implementiert eine Reihe von JPA-Kriterien-abfragebezogenen Methoden, hauptsächlich eine Schnittstelle (Hilfsschnittstelle), die zum Durchführen komplexer Abfragen verwendet wird.

Hinweis: Diese Schnittstelle ist etwas ganz Besonderes und gehört nicht zum Repository-System. Spring Data JPA scannt und identifiziert sie nicht automatisch und meldet daher, dass die entsprechende Bean nicht gefunden werden kann . Wir müssen nur eine Unterschnittstelle erben, die das Repository erbt oder die Repository-Schnittstelle direkt erbt. Spring Data JPA scannt und identifiziert sie automatisch und führt eine einheitliche Verwaltung durch

　4. Benutzerdefinierte Methode:

Voraussetzung: Implementieren Sie eine der oben genannten Schnittstellen

4.1: Verwenden Sie @Query, um eine Abfrage zu erstellen

4.1. 1: Verwendung

Die Verwendung der @Query-Annotation ist sehr einfach. Markieren Sie einfach die Annotation für die deklarierte Methode und geben Sie eine JP-QL-Abfrageanweisung an

Zum Beispiel:

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

　4.1.2: Parameter

4.1.2.1: Benannte Parameter

Beschreibung: Es wird empfohlen, diese Methode zu verwenden, Sie können sie nicht verwenden. Position des Rohrparameters

　4.1.2.2: Indexparameter

Beschreibung: Verwenden Sie den Platzhalter ?

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

　4.1.2.3: SPEL-Ausdruck (Ich habe ihn hier nur kurz geschrieben. Wenn Sie interessiert sind, können Sie die Dokumentation überprüfen)

Beschreibung: Ab Spring Data JPA Version 1.4 Wir unterstützen die Verwendung eingeschränkter Abfragen durch manuell definierte Abfragen. SpEL-Vorlagenausdruck @Query　

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

In SpEL-basierten Abfragevorlagen unterstützte Variablen

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

4.1.3: Klassifizierung

4.1.3.1: ABFRAGE

Zum Beispiel:

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

Hinweis:

1. Verwenden Sie @Query zur Angabe. Für lokale Abfragen setzen Sie nativeQuery einfach auf „true“, zum Beispiel:

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

2. Die aktuelle Version der lokalen Abfrage unterstützt kein Umblättern und dynamisches Sortieren

Klassifizierung (es gibt auch viele Kategorien in der Abfragesuche in)

　　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 类型，也可以是数组或者不定长参数

Das obige ist der detaillierte Inhalt vonEinführung in Anwendungsszenarien von Spring Data JPA (Details). Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!