Pembangunan Bahagian Belakang Java: Pertanyaan Dinamik Menggunakan API Kriteria JPA

Dalam pembangunan back-end Java, pertanyaan data adalah operasi yang sangat biasa, dan menggunakan JPA (Java Persistence API) ialah kaedah yang sangat popular. JPA menyediakan cara yang fleksibel dan boleh digunakan semula untuk mendapatkan dan memanipulasi data dalam pangkalan data. Walau bagaimanapun, untuk pertanyaan dinamik (iaitu, pertanyaan perlu dilaraskan mengikut parameter yang berbeza), mungkin tidak sesuai untuk menggunakan pernyataan pertanyaan statik tradisional atau JPQL (Bahasa Pertanyaan Kegigihan Java). Dalam kes ini, menggunakan API Kriteria JPA boleh menjadi lebih mudah dan fleksibel.

API Kriteria JPA ialah kaedah pertanyaan berorientasikan objek, yang dilaksanakan dengan memasang syarat pertanyaan dan mengembalikan hasil melalui kod. Berbanding dengan pernyataan pertanyaan statik tradisional atau JPQL, salah satu kelebihan utamanya ialah ia boleh menggabungkan keadaan pertanyaan yang berbeza secara dinamik semasa proses pertanyaan, dan boleh bertindak balas dengan lebih baik kepada perubahan dalam model data. Artikel ini akan memperkenalkan cara menggunakan API Kriteria JPA untuk melaksanakan pertanyaan dinamik.

1. Kelas Entiti

Pertama, kita perlu mempunyai kelas entiti Katakan kita mempunyai kelas entiti Pengguna, yang mempunyai medan seperti id, nama, umur, jantina , dsb. Sebelum menggunakan API Kriteria JPA, kita perlu mentakrifkan kelas entiti ini terlebih dahulu.

@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

Sebelum menggunakan API Kriteria JPA, kita perlu mendapatkan CriteriaBuilder terlebih dahulu. CriteriaBuilder ialah kelas kilang yang digunakan untuk mencipta pelbagai CriteriaQuery, Predikat dan Ungkapan. Biasanya, kita boleh mendapatkan CriteriaBuilder melalui EntityManager.

@PersistenceContext
private EntityManager entityManager;

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

3. CriteriaQuery

CriteriaQuery digunakan untuk operasi pertanyaan Kami boleh menggunakannya untuk menetapkan syarat pertanyaan dan jenis hasil yang dikembalikan. Apabila menetapkan syarat pertanyaan, kami boleh menetapkan berbilang sekatan melalui Predikat ialah alat kecil dalam API Kriteria untuk membina syarat pertanyaan.

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();
}

Kod di atas menunjukkan cara menggunakan CriteriaBuilder untuk mencipta CriteriaQuery. Pertama, kami menggunakan EntityManager untuk mendapatkan CriteriaBuilder. Kemudian, kami mencipta objek pertanyaan CriteriaQuery4c8e0c17c3bd7e0081bb17cc795e1984 cq, menyatakan bahawa jenis hasil pertanyaan ialah Pengguna. Gunakan root4c8e0c17c3bd7e0081bb17cc795e1984 untuk membina keadaan pertanyaan, di mana akar mewakili objek Pengguna. Seterusnya, kita boleh menggunakan CriteriaBuilder untuk mencipta objek Predikat dan menambahkannya pada senarai. Akhir sekali, tetapkan syarat ke dalam CriteriaQuery dan laksanakan pertanyaan untuk mengembalikan keputusan.

4. Ekspresi

Ekspresi ialah satu lagi konsep yang sangat berguna dalam API Kriteria Ia mewakili ungkapan operasi yang boleh digunakan untuk mengira dan membandingkan beberapa jenis data yang kompleks. Apabila menggunakan Ungkapan, kami boleh melakukan penapisan yang lebih halus di bawah syarat pertanyaan asal. Sebagai contoh, kita boleh menggunakan kaedah antara untuk menanyakan pengguna yang umurnya berada dalam julat tertentu.

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();
}

Kod di atas menanyakan pengguna yang umurnya antara minAge dan maxAge. Perlu diingat bahawa di sini kami menggunakan Expressionc0f559cc8d56b43654fcbe4aa9df7b4a ageExpression, untuk membolehkan API Kriteria JPA memahami bahawa medan umur yang ingin kami tanyakan adalah daripada jenis integer.

5. Pertanyaan berbilang jadual

Dalam sesetengah senario, kita perlu menanyakan berbilang jadual. Pada ketika ini kita perlu menggunakan Sertai, iaitu konsep teras yang digunakan untuk pertanyaan berbilang jadual. Katakan kita mempunyai kelas entiti Tugas, yang mempunyai dua medan, id dan UserId dikaitkan dengan medan id dalam kelas entiti Pengguna.

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

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

    private Long userId;

    // 省略getter和setter方法
}

Kami boleh mengaitkan dua kelas entiti melalui Sertai dan tanya semua Tugas di bawah Pengguna tertentu.

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. Pertanyaan paging

Akhir sekali, kami memperkenalkan cara untuk melaksanakan pertanyaan paging dalam API Kriteria JPA. Berbanding dengan pertanyaan statik, pertanyaan paging juga sangat biasa, dan amat penting untuk senario dengan jumlah data yang agak besar. Dalam API Kriteria JPA, kita boleh menggunakan kaedah setFirstResult dan setMaxResults untuk menentukan kedudukan permulaan pertanyaan dan bilangan maksimum hasil yang dikembalikan.

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();
}

Kod di atas menunjukkan cara menetapkan syarat pertanyaan paging Mula-mula, kami mengira offset melalui pageNum dan pageSize, menetapkan kedudukan permulaan, dan kemudian menetapkan bilangan maksimum hasil yang dikembalikan melalui setMaxResults. Sudah tentu, dalam aplikasi praktikal, kami juga boleh melakukan pertanyaan paging dengan cara lain.

Kesimpulan

API Kriteria JPA ialah alat yang sangat fleksibel dan berkuasa yang boleh memberikan sokongan yang baik dalam pertanyaan dinamik. Sudah tentu, dalam aplikasi sebenar, kami juga perlu mempertimbangkan isu seperti prestasi, tetapi ia boleh menjadikan kod kami lebih mudah dibaca, diselenggara dan berskala. Saya harap artikel ini dapat membantu pembaca yang menggunakan JPA atau mempertimbangkan untuk menggunakan JPA.

Atas ialah kandungan terperinci Pembangunan Bahagian Belakang Java: Pertanyaan Dinamik Menggunakan API Kriteria JPA. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!