Sortieren mit JPA

1. Übersicht

Dieser Artikel beschreibt die verschiedenen Möglichkeiten, wie JPA zum Sortieren verwendet werden kann .

2. Sortieren mit JPA / JQL-API

Die Verwendung von JQL zum Sortieren erfolgt mithilfe der Order By- Klausel:

String jql; Query query = entityManager.createQuery (jql);

Basierend auf dieser Abfrage generiert JPA die folgende einfache SQL-Anweisung :

Hibernate: select foo0_.id as id1_4_, foo0_.name as name2_4_ from Foo foo0_ order by foo0_.id

Beachten Sie, dass die SQL-Schlüsselwörter in der JQL-Zeichenfolge nicht zwischen Groß- und Kleinschreibung unterscheiden, die Namen der Entitäten und ihre Attribute jedoch.

2.1. Sortierreihenfolge einstellen

Standardmäßig ist die Sortierreihenfolge aufsteigend , kann jedoch explizit in der JQL-Zeichenfolge festgelegt werden. Genau wie in reinem SQL lauten die Bestelloptionen auf und ab :

String jql = "Select f from Foo as f order by f.id desc"; Query sortQuery = entityManager.createQuery(jql);

Die generierte SQL-Abfrage enthält dann die Bestellrichtung:

Hibernate: select foo0_.id as id1_4_, foo0_.name as name2_4_ from Foo foo0_ order by foo0_.id desc

2.2. Sortieren nach mehr als einem Attribut

Um nach mehreren Attributen zu sortieren, werden diese der oder- by- Klausel der JQL-Zeichenfolge hinzugefügt:

String jql; Query sortQuery = entityManager.createQuery(jql);

Beide Sortierbedingungen werden in der generierten SQL-Abfrageanweisung angezeigt:

Hibernate: select foo0_.id as id1_4_, foo0_.name as name2_4_ from Foo foo0_ order by foo0_.name asc, foo0_.id desc

2.3. Festlegen der Sortierrangfolge von Nullwerten

Die Standardpriorität von Nullen ist datenbankspezifisch, kann jedoch über die Klausel NULLS FIRST oder NULLS LAST in der HQL- Abfragezeichenfolge angepasst werden .

Hier ist ein einfaches Beispiel - Bestellung von Namen von Foo in absteigender Reihenfolge und Platzierung Null s am Ende:

Query sortQuery = entityManager.createQuery ("Select f from Foo as f order by f.name desc NULLS LAST");

Die generierte SQL-Abfrage enthält die Endklausel 1 else 0 (3. Zeile): null.

Hibernate: select foo0_.id as id1_4_, foo0_.BAR_ID as BAR_ID2_4_, foo0_.bar_Id as bar_Id2_4_, foo0_.name as name3_4_,from Foo foo0_ order by case when foo0_.name is null then 1 else 0 end, foo0_.name desc

2.4. Eins zu viele Beziehungen sortieren

Lassen Sie uns nun einen Anwendungsfall betrachten, bei dem Entitäten in einer Eins-zu-Viele-Beziehung sortiert werden - Leiste mit einer Sammlung von Foo- Entitäten.

Wir möchten die Bar- Entitäten und auch ihre Sammlung von Foo- Entitäten sortieren - JPA ist für diese Aufgabe besonders einfach:

  1. Sortieren der Sammlung: Fügen Sie eine OrderBy- Annotation vor der Foo- Sammlung in der Bar- Entität hinzu:
    @OrderBy("name ASC") List  fooList;
  2. Sortieren der Entität, die die Sammlung enthält:
    String jql = "Select b from Bar as b order by b.id"; Query barQuery = entityManager.createQuery(jql); List barList = barQuery.getResultList();

Beachten Sie, dass die @OrderBy Anmerkung ist optional, aber wir sind in diesem Fall verwendet es , weil wir die zu sortierenden Foo Sammlung von jeder Bar .

Schauen wir uns die an das RDMS gesendete SQL-Abfrage an:

Hibernate: select bar0_.id as id1_0_, bar0_.name as name2_0_ from Bar bar0_ order by bar0_.id Hibernate: select foolist0_.BAR_ID as BAR_ID2_0_0_, foolist0_.id as id1_4_0_, foolist0_.id as id1_4_1_, foolist0_.BAR_ID as BAR_ID2_4_1_, foolist0_.bar_Id as bar_Id2_4_1_, foolist0_.name as name3_4_1_ from Foo foolist0_ where foolist0_.BAR_ID=? order by foolist0_.name asc 

Die erste Abfrage sortiert die Mutter Bar Einheit. Die zweite Abfrage wird generiert, um die Sammlung der untergeordneten Foo- Entitäten zu sortieren, die zu Bar gehören .

3. Sortieren mit der JPA Criteria Query Object API

Bei JPA-Kriterien ist die orderBy- Methode eine One-Stop-Alternative zum Festlegen aller Sortierparameter: Sowohl die Auftragsrichtung als auch die zu sortierenden Attribute können festgelegt werden. Es folgt die API der Methode:

  • orderBy ( CriteriaBuilder.asc ): Sortiert in aufsteigender Reihenfolge.
  • orderBy ( CriteriaBuilder.desc ): Sortiert in absteigender Reihenfolge.

Jeder Auftrag Beispiel wird mit dem C erstellt riteriaBuilder Objekt durch seine ASC oder DESC Methoden.

Hier ist ein kurzes Beispiel - Sortieren von Foos nach ihrem Namen :

CriteriaQuery criteriaQuery = criteriaBuilder.createQuery(Foo.class); Root from = criteriaQuery.from(Foo.class); CriteriaQuery select = criteriaQuery.select(from); criteriaQuery.orderBy(criteriaBuilder.asc(from.get("name")));

Das Argument für die ge t-Methode unterscheidet zwischen Groß- und Kleinschreibung, da es mit dem Namen des Attributs übereinstimmen muss.

Im Gegensatz zu einfachem JQL erzwingt die JPA Criteria Query Object API eine explizite Ordnungsrichtung in der Abfrage. Beachten Sie in der letzten Zeile dieses Codeausschnitts, dass das Kriterienkriterium- Objekt die aufsteigende Sortierreihenfolge durch Aufrufen seiner ASC- Methode angibt .

Wenn der obige Code ausgeführt wird, generiert JPA die unten gezeigte SQL-Abfrage. JPA Criteria Object generiert eine SQL-Anweisung mit einer expliziten ASC- Klausel:

Hibernate: select foo0_.id as id1_4_, foo0_.name as name2_4_ from Foo foo0_ order by foo0_.name asc

3.1. Sortieren nach mehr als einem Attribut

Um nach mehr als einem Attribut zu sortieren, übergeben Sie einfach eine Order- Instanz an die orderBy- Methode für jedes Attribut, nach dem sortiert werden soll.

Hier ein kurzes Beispiel: Sortieren nach Name und ID in aufsteigender bzw. absteigender Reihenfolge:

CriteriaQuery criteriaQuery = criteriaBuilder.createQuery(Foo.class); Root from = criteriaQuery.from(Foo.class); CriteriaQuery select = criteriaQuery.select(from); criteriaQuery.orderBy(criteriaBuilder.asc(from.get("name")), criteriaBuilder.desc(from.get("id")));

Die entsprechende SQL-Abfrage wird unten angezeigt:

Hibernate: select foo0_.id as id1_4_, foo0_.name as name2_4_ from Foo foo0_ order by foo0_.name asc, foo0_.id desc

4. Fazit

In diesem Artikel werden die Sortieralternativen in der Java-Persistenz-API für einfache Entitäten sowie für Entitäten in einer Eins-zu-Viele-Beziehung erläutert. Diese Ansätze delegieren die Last der Sortierarbeit an die Datenbankebene.

Die Implementierung dieses JPA-Sortier-Tutorials finden Sie im GitHub-Projekt - dies ist ein Maven-basiertes Projekt, daher sollte es einfach zu importieren und auszuführen sein.