Java-Backend-Entwicklung: Dynamische Abfrage mithilfe der JPA-Kriterien-API

In der Java-Backend-Entwicklung ist das Abfragen von Daten ein sehr häufiger Vorgang, und die Verwendung von JPA (Java Persistence API) ist eine sehr beliebte Methode. JPA bietet eine flexible, wiederverwendbare Möglichkeit, Daten in einer Datenbank abzurufen und zu bearbeiten. Bei dynamischen Abfragen (d. h. die Abfrage muss anhand verschiedener Parameter angepasst werden) ist die Verwendung herkömmlicher statischer Abfrageanweisungen oder von JPQL (Java Persistence Query Language) möglicherweise nicht praktisch. In diesem Fall kann die Verwendung der JPA Criteria API bequemer und flexibler sein.

JPA Criteria API ist eine objektorientierte Abfragemethode, die durch das Zusammenstellen von Abfragebedingungen und die Rückgabe von Ergebnissen durch Code implementiert wird. Im Vergleich zu herkömmlichen statischen Abfrageanweisungen oder JPQL besteht einer der Hauptvorteile darin, dass verschiedene Abfragebedingungen während des Abfragevorgangs dynamisch zusammengefügt werden können und besser auf Änderungen im Datenmodell reagiert werden kann. In diesem Artikel wird erläutert, wie Sie die JPA-Kriterien-API zum Durchführen dynamischer Abfragen verwenden.

1. Entitätsklasse

Zunächst benötigen wir eine Entitätsklasse. Angenommen, wir haben eine Benutzer-Entitätsklasse, die Felder wie ID, Name, Alter, Geschlecht usw. enthält. Bevor wir die JPA-Kriterien-API verwenden, müssen wir zunächst diese Entitätsklasse definieren.

@Entity
@Table(name = "user")
public class User {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;

    private Integer age;

    private Boolean gender;

    // 省略getter和setter方法
}

2. CriteriaBuilder

Bevor wir die JPA Criteria API verwenden, müssen wir zuerst den CriteriaBuilder herunterladen. CriteriaBuilder ist eine Factory-Klasse, die zum Erstellen verschiedener CriteriaQuery, Predicate und Expression verwendet wird. Normalerweise können wir CriteriaBuilder über EntityManager erhalten.

@PersistenceContext
private EntityManager entityManager;

public List<User> getUsers() {
    CriteriaBuilder cb = entityManager.getCriteriaBuilder();
    // ... 继续后续操作
}

3. CriteriaQuery

CriteriaQuery wird für Abfrageoperationen verwendet. Wir können damit die Bedingungen der Abfrage und die Art der zurückgegebenen Ergebnisse festlegen. Beim Festlegen von Abfragebedingungen können wir über Predicate, ein kleines Tool in der Criteria API zum Erstellen von Abfragebedingungen, mehrere Einschränkungen festlegen.

public List<User> getUsers(String name, Integer age, Boolean gender) {
    CriteriaBuilder cb = entityManager.getCriteriaBuilder();
    CriteriaQuery<User> cq = cb.createQuery(User.class);
    Root<User> root = cq.from(User.class);

    List<Predicate> predicates = new ArrayList<>();

    if (name != null) {
        Predicate namePredicate = cb.equal(root.get("name"), name);
        predicates.add(namePredicate);
    }

    if (age != null) {
        Predicate agePredicate = cb.greaterThanOrEqualTo(root.get("age"), age);
        predicates.add(agePredicate);
    }

    if (gender != null) {
        Predicate genderPredicate = cb.equal(root.get("gender"), gender);
        predicates.add(genderPredicate);
    }

    cq.where(predicates.toArray(new Predicate[0]));
    return entityManager.createQuery(cq).getResultList();
}

Der obige Code zeigt, wie CriteriaBuilder zum Erstellen einer CriteriaQuery verwendet wird. Zuerst verwenden wir EntityManager, um den CriteriaBuilder abzurufen. Anschließend erstellen wir ein Abfrageobjekt CriteriaQuery und geben an, dass der Ergebnistyp der Abfrage „Benutzer“ ist. Verwenden Sie Root root, um Abfragebedingungen zu erstellen, wobei root das Benutzerobjekt darstellt. Als nächstes können wir CriteriaBuilder verwenden, um Predicate-Objekte zu erstellen und sie der Liste hinzuzufügen. Legen Sie abschließend die Bedingungen in der CriteriaQuery fest und führen Sie die Abfrage aus, um die Ergebnisse zurückzugeben.

4. Ausdruck

Ausdruck ist ein weiteres sehr nützliches Konzept in der Kriterien-API. Es stellt einen Operationsausdruck dar, der zum Berechnen und Vergleichen einiger komplexer Datentypen verwendet werden kann. Wenn wir Expression verwenden, können wir unter den ursprünglichen Abfragebedingungen eine verfeinerte Filterung durchführen. Beispielsweise können wir die Methode „Zwischen“ verwenden, um Benutzer abzufragen, deren Alter innerhalb eines bestimmten Bereichs liegt.

public List<User> getUsersInRange(Integer minAge, Integer maxAge) {
    CriteriaBuilder cb = entityManager.getCriteriaBuilder();
    CriteriaQuery<User> cq = cb.createQuery(User.class);
    Root<User> root = cq.from(User.class);

    Expression<Integer> ageExpression = root.get("age");

    Predicate agePredicate = cb.between(ageExpression, minAge, maxAge);
    cq.where(agePredicate);

    return entityManager.createQuery(cq).getResultList();
}

Der obige Code fragt Benutzer ab, deren Alter zwischen minAge und maxAge liegt. Es ist zu beachten, dass wir hier Expression ageExpression verwenden, damit die JPA Criteria API versteht, dass das Altersfeld, das wir abfragen möchten, vom Typ Integer ist.

5. Abfrage mehrerer Tabellen

In einigen Szenarien müssen wir mehrere Tabellen abfragen. An dieser Stelle müssen wir Join verwenden, das Kernkonzept für Abfragen mit mehreren Tabellen. Angenommen, wir haben eine Task-Entitätsklasse, die über zwei Felder verfügt: id und userId. UserId ist mit dem ID-Feld in der User-Entitätsklasse verknüpft.

@Entity
@Table(name = "task")
public class Task {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private Long userId;

    // 省略getter和setter方法
}

Wir können zwei Entitätsklassen über Join verknüpfen und alle Aufgaben unter dem angegebenen Benutzer abfragen.

public List<Task> getUserTasks(Long userId) {
    CriteriaBuilder cb = entityManager.getCriteriaBuilder();
    CriteriaQuery<Task> cq = cb.createQuery(Task.class);
    Root<Task> taskRoot = cq.from(Task.class);
    Join<Task, User> userJoin = taskRoot.join("user");

    Predicate predicate = cb.equal(userJoin.get("id"), userId);
    cq.where(predicate);

    return entityManager.createQuery(cq).getResultList();
}

6. Seitenabfrage

Abschließend stellen wir vor, wie man eine Paging-Abfrage in der JPA Criteria API implementiert. Im Vergleich zu statischen Abfragen sind Paging-Abfragen ebenfalls sehr verbreitet und besonders wichtig für Szenarien mit relativ großen Datenmengen. In der JPA Criteria API können wir die Methoden setFirstResult und setMaxResults verwenden, um die Startposition der Abfrage und die maximale Anzahl zurückgegebener Ergebnisse anzugeben.

public List<User> getUsers(Integer pageNum, Integer pageSize) {
    CriteriaBuilder cb = entityManager.getCriteriaBuilder();
    CriteriaQuery<User> cq = cb.createQuery(User.class);
    Root<User> root = cq.from(User.class);

    int offset = (pageNum - 1) * pageSize;
    entityManager.createQuery(cq).setFirstResult(offset).setMaxResults(pageSize);

    return entityManager.createQuery(cq).getResultList();
}

Der obige Code zeigt, wie die Paging-Abfragebedingungen festgelegt werden. Zuerst berechnen wir den Offset über pageNum und pageSize, legen die Startposition fest und legen dann die maximale Anzahl zurückgegebener Ergebnisse über setMaxResults fest. In praktischen Anwendungen können wir Paging-Abfragen natürlich auch auf andere Weise durchführen.

Fazit

JPA Criteria API ist ein sehr flexibles und leistungsstarkes Tool, das gute Unterstützung bei dynamischen Abfragen bieten kann. Natürlich müssen wir in tatsächlichen Anwendungen auch Aspekte wie die Leistung berücksichtigen, aber dadurch kann unser Code lesbarer, wartbarer und skalierbarer werden. Ich hoffe, dass dieser Artikel für Leser hilfreich ist, die JPA verwenden oder die Verwendung von JPA in Betracht ziehen.

Das obige ist der detaillierte Inhalt vonJava-Backend-Entwicklung: Dynamische Abfrage mithilfe der JPA-Kriterien-API. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!