Java >> Java Tutorial >  >> Tag >> Spring

Spring Data JPA Tutorial:Erstellen von Datenbankabfragen mit benannten Abfragen

Im vorherigen Teil dieses Tutorials wurde beschrieben, wie wir Datenbankabfragen mit der Annotation @Query erstellen können.

Dieses Tutorial hat nun zwei der drei Methoden behandelt, mit denen wir Abfragemethoden mit Spring Data JPA erstellen können. Dieser Blogbeitrag beschreibt die letzte Methode. Wir werden lernen, Datenbankabfragen zu erstellen, indem wir benannte Abfragen verwenden.

Wir werden auch eine Suchfunktion implementieren, die zwei Anforderungen hat:

  • Es muss Aufgabeneinträge zurückgeben, deren Titel oder Beschreibung den angegebenen Suchbegriff enthält.
  • Bei der Suche muss die Groß-/Kleinschreibung beachtet werden.

Fangen wir an.

Benannte Abfragen mit Spring Data JPA verwenden

Bevor wir unsere Suchfunktion implementieren können, müssen wir verstehen, wie wir benannte Abfragen mit Spring Data JPA verwenden können. Mit anderen Worten, wir müssen die Antworten auf diese Fragen finden:

  1. Wie können wir benannte Abfragen erstellen?
  2. Wie können wir die Abfragemethoden erstellen, die unsere benannten Abfragen aufrufen?

Beginnen wir damit, die Antwort auf die erste Frage herauszufinden.

Benannte Abfragen erstellen

Wir können benannte Abfragen mit Spring Data JPA angeben, indem wir eine Eigenschaftendatei, Anmerkungen oder die orm.xml verwenden Datei.

Bevor wir uns diese Methoden genauer ansehen können, müssen wir einige Regeln lernen, die wir befolgen müssen, wenn wir die Namen unserer benannten Abfragen angeben. Diese Regeln sind:

  • Wenn wir die Standard-Benennungsstrategie von Spring Data JPA verwenden wollen, müssen wir den Namen der benannten Abfrage mit dieser Syntax angeben:[Name der Entitätsklasse].[Name der aufgerufenen Abfragemethode] .
  • Wenn wir eine andere Syntax verwenden möchten, müssen wir den Namen der benannten Abfrage konfigurieren, wenn wir die Abfragemethode erstellen, die sie aufruft. Wir können dies tun, indem wir den Namen verwenden Attribut der @Query Anmerkung.

Wir können jetzt benannte Abfragen mit Spring Data JPA erstellen. Beginnen wir damit, unsere benannten Abfragen in eine Eigenschaftendatei einzufügen.

Eine Eigenschaftsdatei verwenden

Wir können benannte Abfragen deklarieren, indem wir sie in jpa-named-queries.properties einfügen Datei, die aus der META-INF gefunden wird Ordner unseres Klassenpfads.

Wir können eine neue benannte Abfrage deklarieren, indem wir diesen Schritten folgen:

  1. Legen Sie den Namen der benannten Abfrage als Namen der Eigenschaft fest.
  2. Legen Sie die aufgerufene Abfrage als Wert der Eigenschaft fest.

Mit anderen Worten, unsere Eigenschaftendatei muss das folgende Format verwenden:

name=query

Beispiel:

Wir möchten eine benannte Abfrage mit dem Namen „Todo.findByTitleIs“ erstellen '. Es gibt alle Todo-Einträge zurück, deren Titel 'title' ist.

Wenn wir JPQL verwenden wollen, müssen wir die folgende Zeile in unsere Eigenschaftendatei einfügen:

Todo.findByTitleIs=SELECT t FROM Todo t WHERE t.title = 'title'

Wenn wir SQL verwenden wollen, müssen wir die folgende Zeile in unsere Properties-Datei einfügen:

Todo.findByTitleIs=SELECT * FROM todos t WHERE t.title = 'title'

Lassen Sie uns weitermachen und herausfinden, wie wir benannte Abfragen mithilfe von Anmerkungen deklarieren können.

Anmerkungen verwenden

Wir können benannte Abfragen deklarieren, indem wir unsere Entitäten mit den folgenden Anmerkungen versehen:

  • Wenn wir eine JPQL-Abfrage erstellen wollen, müssen wir unsere Entität mit @NamedQuery annotieren Anmerkung.
  • Wenn wir eine SQL-Abfrage erstellen wollen, müssen wir unsere Entität mit @NamedNativeQuery annotieren Anmerkung.

Beispiel:

Wir möchten eine benannte Abfrage mit dem Namen „Todo.findByTitleIs“ erstellen '. Es gibt alle Todo-Einträge zurück, deren Titel 'title' ist.

Wenn wir eine JPQL-Abfrage erstellen möchten, müssen wir die folgenden Schritte ausführen:

  1. Kommentieren Sie die Entität mit @NamedQuery Anmerkung.
  2. Legen Sie den Namen der benannten Abfrage fest (Todo.findByTitleIs ) als Wert von @NamedQuery Name der Anmerkung Attribut.
  3. Stellen Sie die JPQL-Abfrage ein (SELECT t FROM Todo t WHERE t.title ='title' ) als Wert von @NamedQuery Abfrage der Anmerkung Attribut.

Der relevante Teil unserer Entität sieht wie folgt aus:

import javax.persistence.Entity;
import javax.persistence.NamedQuery;
import javax.persistence.Table;

@Entity
@NamedQuery(name = "Todo.findByTitleIs",
        query = "SELECT t FROM Todo t WHERE t.title = 'title'" 
)
@Table(name = "todos")
final class Todo {
	
}

Wenn wir eine SQL-Abfrage erstellen möchten, müssen wir die folgenden Schritte ausführen:

  1. Kommentieren Sie die Entität mit @NamedNativeQuery Anmerkung.
  2. Legen Sie den Namen der benannten Abfrage fest (Todo.findByTitleIs ) als Wert von @NamedNativeQuery Name der Anmerkung Attribut.
  3. Legen Sie die SQL-Abfrage fest (SELECT * FROM todos t WHERE t.title ='title' ) als Wert von @NamedNativeQuery Name der Anmerkung Attribut.
  4. Legen Sie die zurückgegebene Entitätsklasse fest (Todo.class ) als Wert von @NamedNativeQuery resultClass der Annotation Attribut.

Der relevante Teil unserer Entität sieht wie folgt aus:

import javax.persistence.Entity;
import javax.persistence.NamedNativeQuery;
import javax.persistence.Table;

@Entity
@NamedNativeQuery(name = "Todo.findByTitleIs”,
        query="SELECT * FROM todos t WHERE t.title = 'title'",
        resultClass = Todo.class
)
@Table(name = "todos")
final class Todo {
	
}

Lassen Sie uns herausfinden, wie wir benannte Abfragen mithilfe der orm.xml erstellen können Datei.

Verwendung der orm.xml-Datei

Wir können benannte Abfragen deklarieren, indem wir sie in die orm.xml einfügen Datei, die aus der META-INF gefunden wird Ordner unseres Klassenpfads. Wir müssen eines dieser beiden XML-Elemente verwenden:

  • Wenn wir eine JPQL-Abfrage erstellen wollen, müssen wir die named-query verwenden Element.
  • Wenn wir eine SQL-Abfrage erstellen wollen, müssen wir die named-native-query verwenden Element.

Beispiel:

Wir möchten eine benannte Abfrage mit dem Namen „Todo.findByTitleIs“ erstellen '. Es gibt alle Todo-Einträge zurück, deren Titel 'title' ist.

Wenn wir eine JPQL-Abfrage erstellen möchten, müssen wir die folgenden Schritte ausführen:

  1. Fügen Sie eine benannte Abfrage hinzu -Element in die orm.xml Datei.
  2. Legen Sie den Namen der benannten Abfrage fest (Todo.findByTitleIs ) als Wert der benannten Abfrage Name des Elements Attribut.
  3. Fügen Sie eine Abfrage hinzu -Element als untergeordnetes Element der benannten Abfrage -Element und setzen Sie die aufgerufene JPQL-Abfrage (SELECT t FROM Todo t WHERE t.title ='title' ) als Wert der Abfrage Element.

Der relevante Teil der orm.xml Datei sieht wie folgt aus:

<?xml version="1.0" encoding="UTF-8"?>
<entity-mappings
        xmlns="http://java.sun.com/xml/ns/persistence/orm"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm http://java.sun.com/xml/ns/persistence/orm_2_0.xsd"
        version="2.0">

    <named-query name="Todo.findByTitleIs">
        <query>SELECT t FROM Todo t WHERE t.title = 'title'</query>
    </named-query>
</entity-mappings>

Wenn wir eine SQL-Abfrage erstellen möchten, müssen wir die folgenden Schritte ausführen:

  1. Fügen Sie eine benannte native Abfrage hinzu -Element in die orm.xml Datei.
  2. Legen Sie den Namen der benannten Abfrage fest (Todo.findByTitleIs ) als Wert der named-native-query Name des Elements Attribut.
  3. Legen Sie den Typ des zurückgegebenen Objekts fest (net.petrikainulainen.springdata.jpa.todo.Todo ) als Wert der named-native-query Ergebnisklasse des Elements Attribut.
  4. Fügen Sie eine Abfrage hinzu -Element als untergeordnetes Element der named-native-query -Element und setzen Sie die aufgerufene SQL-Abfrage (SELECT * FROM todos t WHERE t.title ='title' ) als Wert der Abfrage Element.

Der relevante Teil der orm.xml Datei sieht wie folgt aus:

<?xml version="1.0" encoding="UTF-8"?>
<entity-mappings
        xmlns="http://java.sun.com/xml/ns/persistence/orm"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm http://java.sun.com/xml/ns/persistence/orm_2_0.xsd"
        version="2.0">

    <named-native-query name="Todo.findByTitleIs"
                        result-class="net.petrikainulainen.springdata.jpa.todo.Todo">
        <query>SELECT * FROM todos t WHERE t.title = 'title'</query>
    </named-native-query>
</entity-mappings>

Lassen Sie uns weitermachen und herausfinden, wie wir die Abfragemethoden erstellen können, die unsere benannten Abfragen aufrufen.

Erstellen der Abfragemethoden

Wir können die Abfragemethode erstellen, die eine bestimmte benannte Abfrage aufruft, indem wir diesen Schritten folgen:

  1. Fügen Sie eine Abfragemethode zu unserer Repository-Schnittstelle hinzu und befolgen Sie diese Regeln:
    • Wenn unsere benannte Abfrage die standardmäßige Benennungsstrategie von Spring Data JPA verwendet, müssen wir sicherstellen, dass der Name der Abfragemethode die aufgerufene benannte Abfrage identifiziert.
    • Wenn unsere benannte Abfrage nicht die Standard-Benennungsstrategie verwendet, müssen wir die Abfragemethode mit @Query annotieren Anmerkung und konfigurieren Sie den Namen der aufgerufenen benannten Abfrage, indem Sie den Namen verwenden Attribut der @Query Anmerkung.
  2. Wenn die aufgerufene benannte Abfrage eine SQL-Abfrage ist, müssen wir die Abfragemethode mit @Query annotieren -Anmerkung und legen Sie den Wert ihrer nativeQuery fest Attribut auf true .
  3. Fügen Sie der Abfragemethode die richtigen Methodenparameter hinzu.
  4. Geben Sie den Rückgabetyp der Abfragemethode an.

Beispiel 1:

Wir möchten eine Abfragemethode erstellen, die die benannte Abfrage aufruft, deren Name lautet:Todo.findByTitleIs . Da diese benannte Abfrage Aufgabeneinträge zurückgibt, deren Titel „Titel“ lautet, hat sie keine Parameter.

Wenn die aufgerufene benannte Abfrage eine JPQL-Abfrage ist, müssen wir die folgende Abfragemethode zu unserer Repository-Schnittstelle hinzufügen:

import org.springframework.data.repository.Repository;

import java.util.List;

interface TodoRepository extends Repository<Todo, Long> {

	public List<Todo> findByTitleIs();
}

Wenn die aufgerufene benannte Abfrage eine SQL-Abfrage ist, müssen wir die folgende Abfragemethode zu unserer Repository-Schnittstelle hinzufügen:

import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.Repository;

import java.util.List;

interface TodoRepository extends Repository<Todo, Long> {

	@Query(nativeQuery = true)
	public List<Todo> findByTitleIs();
}

Beispiel 2:

Wir möchten die Abfragemethode erstellen, die die benannte Abfrage aufruft, deren Name lautet:Todo.findByDesc . Diese benannte Abfrage hat einen benannten Parameter namens Beschreibung .

Wenn die aufgerufene Abfrage eine JPQL-Abfrage ist, müssen wir die folgende Abfragemethode zu unserer Repository-Schnittstelle hinzufügen:

import org.springframework.data.repository.Repository;
import org.springframework.data.repository.query.Param;

import java.util.List;

interface TodoRepository extends Repository<Todo, Long> {

	public List<Todo> findByDesc(@Param("description") String description);
}

Wenn die aufgerufene Abfrage eine SQL-Abfrage ist, müssen wir die folgende Abfragemethode zu unserer Repository-Schnittstelle hinzufügen:

 
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.Repository;
import org.springframework.data.repository.query.Param;

import java.util.List;

interface TodoRepository extends Repository<Todo, Long> {

	@Query(nativeQuery=true)
	public List<Todo> findByDesc(@Param("description") String description);
}

Wir sind jetzt bereit, unsere Suchfunktion zu implementieren. Lassen Sie uns herausfinden, wie wir es tun können.

Implementieren der Suchfunktion

Wir können unsere Suchfunktion folgendermaßen implementieren:

  1. Erstellen Sie die JPQL- und SQL-Abfragen, bei denen die Groß-/Kleinschreibung nicht beachtet wird, und geben Sie Aufgabeneinträge zurück, deren Titel oder Beschreibung den angegebenen Suchbegriff enthält.
  2. Erstellen Sie die benannten Abfragen, die die erstellten JPQL- und SQL-Abfragen aufrufen.
  3. Erstellen Sie die Abfragemethoden, die unsere benannten Abfragen aufrufen.

Fangen wir an.

Datenbankabfragen erstellen

Unsere Suchfunktion muss zwei Anforderungen erfüllen:

  • Es muss Aufgabeneinträge zurückgeben, deren Titel oder Beschreibung den angegebenen Suchbegriff enthält.
  • Groß- und Kleinschreibung muss beachtet werden.

Dieser Abschnitt beschreibt die JPQL- und SQL-Abfragen, die diese Anforderungen erfüllen.

Zuerst , sieht die JPQL-Abfrage, die unsere Anforderungen erfüllt, wie folgt aus:

SELECT t FROM Todo t WHERE 
	LOWER(t.title) LIKE LOWER(CONCAT('%',:searchTerm, '%')) OR 
	LOWER(t.description) LIKE LOWER(CONCAT('%',:searchTerm, '%'))

Zweiter , sieht die SQL-Abfrage, die unsere Anforderungen erfüllt, wie folgt aus:

SELECT * FROM todos t WHERE
	LOWER(t.title) LIKE LOWER(CONCAT('%',:searchTerm, '%')) OR
	LOWER(t.description) LIKE LOWER(CONCAT('%',:searchTerm, '%'))

Fahren wir fort und erstellen unsere benannten Abfragen.

Erstellen der benannten Abfragen

Dieser Abschnitt beschreibt, wie wir die erforderlichen benannten Abfragen mithilfe einer Eigenschaftendatei, Anmerkungen und der orm.xml angeben können Datei. Wir müssen zwei benannte Abfragen erstellen:

  • Der Todo.findBySearchTermNamed ist eine benannte Abfrage, die JPQL verwendet.
  • Der Todo.findBySearchTermNamedNative ist eine benannte Abfrage, die SQL verwendet.

Fangen wir an.

Eine Eigenschaftsdatei verwenden

Nachdem wir beide benannten Abfragen hinzugefügt haben (Todo.findBySearchTermNamed und Todo.findBySearchTermNamedNative ) in die META-INF/jpa-named-queries.properties Datei, sieht ihr Inhalt wie folgt aus:

Todo.findBySearchTermNamed=SELECT t FROM Todo t WHERE LOWER(t.title) LIKE LOWER(CONCAT('%', :searchTerm, '%')) OR LOWER(t.description) LIKE LOWER(CONCAT('%', :searchTerm, '%'))
Todo.findBySearchTermNamedNative=SELECT * FROM todos t WHERE LOWER(t.title) LIKE LOWER(CONCAT('%',:searchTerm, '%')) OR LOWER(t.description) LIKE LOWER(CONCAT('%',:searchTerm, '%'))

Fahren wir fort und deklarieren diese benannten Abfragen mithilfe von Anmerkungen.

Anmerkungen verwenden

Nachdem wir beide benannten Abfragen erstellt haben (Todo.findBySearchTermNamed und Todo.findBySearchTermNamedNative ) mithilfe von @NamedQuery und die @NamedNativeQuery Annotationen sieht der relevante Teil unserer Entitätsklasse wie folgt aus:

import javax.persistence.Entity;
import javax.persistence.NamedNativeQuery;
import javax.persistence.NamedQuery;
import javax.persistence.Table;

@Entity
@NamedNativeQuery(name = "Todo.findBySearchTermNamedNative",
        query="SELECT * FROM todos t WHERE " +
                "LOWER(t.title) LIKE LOWER(CONCAT('%',:searchTerm, '%')) OR " +
                "LOWER(t.description) LIKE LOWER(CONCAT('%',:searchTerm, '%'))",
        resultClass = Todo.class
)
@NamedQuery(name = "Todo.findBySearchTermNamed",
        query = "SELECT t FROM Todo t WHERE " +
                "LOWER(t.title) LIKE LOWER(CONCAT('%', :searchTerm, '%')) OR " +
                "LOWER(t.description) LIKE LOWER(CONCAT('%', :searchTerm, '%'))"
)
@Table(name = "todos")
final class Todo {

}

Lassen Sie uns herausfinden, wie wir diese benannten Abfragen mithilfe der orm.xml deklarieren können Datei.

Verwendung der orm.xml-Datei

Nachdem wir beide benannten Abfragen erstellt haben (Todo.findBySearchTermNamed und Todo.findBySearchTermNamedNative ) mithilfe der benannten Abfrage und die named-native-query Elemente, die META-INF/orm.xml Datei sieht wie folgt aus:

<?xml version="1.0" encoding="UTF-8"?>
<entity-mappings 
        xmlns="http://java.sun.com/xml/ns/persistence/orm" 
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
        xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm http://java.sun.com/xml/ns/persistence/orm_2_0.xsd" 
        version="2.0">

    <named-query name="Todo.findBySearchTermNamedOrmXml">
        <query>SELECT t FROM Todo t WHERE LOWER(t.title) LIKE LOWER(CONCAT('%', :searchTerm, '%')) OR LOWER(t.description) LIKE LOWER(CONCAT('%', :searchTerm, '%'))</query>
    </named-query>

    <named-native-query name="Todo.findBySearchTermNamedNativeOrmXml"
                        result-class="net.petrikainulainen.springdata.jpa.todo.Todo">
        <query>SELECT * FROM todos t WHERE LOWER(t.title) LIKE LOWER(CONCAT('%',:searchTerm, '%')) OR LOWER(t.description) LIKE LOWER(CONCAT('%',:searchTerm, '%'))</query>
    </named-native-query>
</entity-mappings>

Fahren wir fort und erstellen die Abfragemethoden, die diese benannten Abfragen aufrufen.

Erstellen der Abfragemethoden

Wir können die Abfragemethoden erstellen, die unsere benannten Abfragen aufrufen, indem wir diesen Schritten folgen:

  1. Erstellen Sie die Abfragemethode, die die JPQL-Abfrage aufruft (Todo.findBySearchTermNamed ) indem Sie diesen Schritten folgen:
    1. Erstellen Sie eine Abfragemethode namens findBySearchTermNamed() .
    2. Setzen Sie den Rückgabetyp der Abfragemethode auf List .
    3. Fügen Sie der Abfragemethode einen Methodenparameter hinzu und konfigurieren Sie den Namen des benannten Parameters (searchTerm ), indem Sie den Methodenparameter mit @Param annotieren Anmerkung.
  2. Erstellen Sie die Abfragemethode, die die SQL-Abfrage aufruft (Todo.findBySearchTermNamedNative ) indem Sie diesen Schritten folgen:
    1. Erstellen Sie eine Abfragemethode namens findBySearchTermNamedNative() .
    2. Kommentieren Sie die Methode mit @Query Annotation und Set-Wert seiner nativeQuery Attribut auf true .
    3. Setzen Sie den Rückgabetyp der Abfragemethode auf List .
    4. Fügen Sie der Abfragemethode einen Methodenparameter hinzu und konfigurieren Sie den Namen des benannten Parameters (searchTerm ), indem Sie den Methodenparameter mit @Param annotieren Anmerkung.

Der Quellcode unserer Repository-Schnittstelle sieht wie folgt aus:

import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.Repository;
import org.springframework.data.repository.query.Param;

import java.util.List;

interface TodoRepository extends Repository<Todo, Long> {

    List<Todo> findBySearchTermNamed(@Param("searchTerm") String searchTerm);

    @Query(nativeQuery = true)
    List<Todo> findBySearchTermNamedNative(@Param("searchTerm") String searchTerm);
}

Lassen Sie uns weitermachen und herausfinden, wann wir unsere Datenbankabfragen erstellen sollten, indem wir benannte Abfragen verwenden.

Wann sollten wir benannte Abfragen verwenden?

Benannte Abfragen haben die folgenden Vorteile:

  • Benannte Abfragen unterstützen sowohl JPQL als auch SQL.
  • Wenn wir eine vorhandene Anwendung haben, die benannte Abfragen verwendet, ist es einfach, sie so umzugestalten, dass sie Spring Data JPA verwendet (wenn wir möchten).
  • Benannte Abfragen bieten Unterstützung für die Zuordnung von SQL-Ergebnismengen. Das bedeutet, dass wir komplexe SQL-Abfragen schreiben und die Abfrageergebnisse Objekten zuordnen können.

Benannte Abfragen haben die folgenden Nachteile:

  • Wir können die aufgerufene Datenbankabfrage von der Repository-Schnittstelle nicht sehen.
  • Es gibt keine Unterstützung für dynamische Abfragen.
  • Wenn wir benannte Abfragen mithilfe von Annotationen spezifizieren, "verunreinigen" sie den Quellcode unserer Entitätsklassen.

Wenn wir über die Vor- und Nachteile von benannten Abfragen nachdenken, wird deutlich, dass die Abfragemethoden, die benannte Abfragen verwenden, nicht so einfach zu lesen oder zu schreiben sind wie die Abfragemethoden, die entweder die Abfragegenerierung aus der Methodennamenstrategie oder die @Abfrage Anmerkung.

Benannte Abfragen haben jedoch zwei Vorteile:

  1. Wir können komplexe SQL-Abfragen schreiben und die Abfrageergebnisse Objekten zuordnen.
  2. Wenn wir eine vorhandene Anwendung umgestalten müssen, um Spring Data JPA zu verwenden, müssen wir ihre benannten Abfragen nicht in unsere Repository-Schnittstellen verschieben.

Daher denke ich, dass wir unsere Abfragemethoden erstellen sollten, indem wir die Abfragegenerierung aus der Methodennamenstrategie oder @Query verwenden Anmerkung.

Wenn wir die Abfragemethode jedoch nicht mit diesen beiden Methoden erstellen können, können wir benannte Abfragen verwenden.

Wenn wir eine vorhandene Anwendung für die Verwendung von Spring Data JPA umgestalten, ist die Verwendung ihrer vorhandenen benannten Abfragen ein Kinderspiel, da uns dies eine Menge Arbeit ersparen kann.

Fahren wir fort und fassen zusammen, was wir aus diesem Blogpost gelernt haben.

Zusammenfassung

Dieser Blogbeitrag hat uns vier Dinge gelehrt:

  • Wir können benannte Abfragen erstellen, indem wir eine Eigenschaftendatei, Anmerkungen oder die orm.xml verwenden Datei.
  • Benannte Abfragen unterstützen sowohl JPQL als auch SQL.
  • Wenn wir komplexe SQL-Abfragen erstellen müssen, können wir die Abfrageergebnisse mithilfe der SQL-Ergebnissatzzuordnung Objekten zuordnen.
  • Wir sollten benannte Abfragen nur verwenden, wenn wir keine Wahl haben ODER wir eine vorhandene Anwendung umgestalten, um Spring Data JPA zu verwenden.

Der nächste Teil dieses Tutorials beschreibt, wie wir mithilfe der JPA Criteria API dynamische Abfragen erstellen können.

P.S. Sie können die Beispielanwendung dieses Blogbeitrags von Github erhalten.


Java-Tag