Cara menggunakan strategi pertanyaan dan strategi merangkak dalam Java Hibernate

Menggunakan kaedah berorientasikan objek untuk mengakses pangkalan data disediakan oleh Hibernate, rangka kerja ORM yang popular. Dalam Hibernate, kita boleh menggunakan pelbagai kaedah pertanyaan untuk mendapatkan data, termasuk pertanyaan OID, mendapatkan navigasi objek, mendapatkan HQL, mendapatkan QBC dan mendapatkan semula SQL.

Pertanyaan OID

OID (Pengecam Objek) ​​adalah pengecam unik bagi setiap objek berterusan dalam Hibernate. Anda boleh menggunakan pertanyaan OID untuk mendapatkan semula objek persisten tertentu. Apabila menggunakan pertanyaan OID, kita perlu menggunakan kaedah load() atau get(). Perbezaan antara kedua-dua kaedah ini ialah kaedah load() akan memuatkan objek apabila diperlukan, manakala kaedah get() akan memuatkan objek dengan serta-merta. Berikut ialah contoh menggunakan kaedah get():

Session session = HibernateUtil.getSessionFactory().getCurrentSession();
session.beginTransaction();
Student student = (Student) session.get(Student.class, 1);
session.getTransaction().commit();

Dalam contoh di atas, kami menggunakan kaedah get() untuk mendapatkan semula objek Pelajar dengan ID 1.

Pendapatan navigasi objek

Pencapaian navigasi objek membolehkan kami mendapatkan semula data melalui perhubungan antara objek. Sebagai contoh, jika kita mempunyai kelas Pelajar dan kelas Alamat, dan terdapat hubungan satu dengan satu antara mereka, kita boleh menggunakan perolehan navigasi objek untuk mendapatkan semula alamat objek Pelajar tertentu. Berikut ialah contoh mendapatkan semula menggunakan navigasi objek:

Session session = HibernateUtil.getSessionFactory().getCurrentSession();
session.beginTransaction();
Student student = (Student) session.get(Student.class, 1);
Address address = student.getAddress();
session.getTransaction().commit();

Dalam contoh di atas, kami mendapatkan semula objek Pelajar dan menggunakan kaedah getAddress() untuk mendapatkan alamat pelajar.

Pendapatan semula HQL

HQL (Hibernate Query Language) ialah bahasa pertanyaan berasaskan objek, yang serupa dengan SQL, tetapi lebih berorientasikan objek. HQL menggunakan kelas dan sifat daripada fail pemetaan Hibernate untuk membina pertanyaan. Berikut ialah contoh menanyakan semua objek Pelajar menggunakan HQL:

Session session = HibernateUtil.getSessionFactory().getCurrentSession();
session.beginTransaction();
Query query = session.createQuery("from Student");
List<Student> students = query.list();
session.getTransaction().commit();

Dalam contoh di atas, kami menggunakan kaedah createQuery() untuk mencipta pertanyaan HQL, dan kemudian menggunakan kaedah list() untuk mendapatkan hasilnya senarai.

Pendapatan QBC

QBC (Query By Criteria) ialah kaedah pertanyaan berasaskan objek yang menggunakan API Kriteria untuk membina pertanyaan. Menggunakan API Kriteria boleh mengelakkan beberapa ralat pertanyaan biasa kerana ia adalah cara pertanyaan selamat jenis. Berikut ialah contoh pertanyaan semua objek Pelajar menggunakan QBC:

Session session = HibernateUtil.getSessionFactory().getCurrentSession();
session.beginTransaction();
Criteria criteria = session.createCriteria(Student.class);
List<Student> students = criteria.list();
session.getTransaction().commit();

Dalam contoh di atas, kami menggunakan kaedah createCriteria() untuk mencipta objek Kriteria dan kaedah list() untuk mendapatkan senarai hasil.

Pendapatan semula SQL

Walaupun Hibernate menyokong pelbagai kaedah pertanyaan berasaskan objek, dalam beberapa kes kita mungkin perlu melakukan beberapa pertanyaan SQL yang kompleks. Dalam kes ini kita boleh menggunakan pertanyaan SQL untuk mendapatkan semula data. Berikut ialah contoh pertanyaan semua objek Pelajar menggunakan SQL:

Session session = HibernateUtil.getSessionFactory().getCurrentSession();
session.beginTransaction();
SQLQuery query = session.createSQLQuery("select * from Student");
query.addEntity(Student.class);
List<Student> students = query.list();
session.getTransaction().commit();

Dalam contoh di atas, kami mencipta pertanyaan SQL menggunakan kaedah createSQLQuery() dan memetakan hasilnya ke kelas Pelajar menggunakan kaedah addEntity() .

Strategi Ambil

Strategi pengambilan ialah mekanisme yang digunakan oleh Hibernate untuk mengendalikan perhubungan objek. Hibernate menyediakan tiga kaedah pengekstrakan data: pengekstrakan segera, pengekstrakan tertunda dan pengekstrakan kelompok.

Ambil serta-merta

Apabila mendapatkan semula objek, mengambil serta-merta bermakna Hibernate akan segera mendapatkan semula semua objek berkaitan objek itu. Strategi merangkak ini boleh menyebabkan masalah prestasi kerana ia boleh menyebabkan sejumlah besar data dipindahkan. Berikut ialah contoh menggunakan ambil serta-merta:

@ManyToOne(fetch = FetchType.EAGER)
private Address address;

Dalam contoh di atas, kami menetapkan atribut fetch kepada EAGER, menunjukkan penggunaan ambil serta-merta.

Pengambilan tertunda

Pengambilan tertunda Hibernate bermakna ia hanya mendapatkan semula entiti itu sendiri dan tidak mendapatkan semula entiti yang berkaitan. Apabila kita perlu mengakses objek berkaitan, Hibernate akan menanyakan objek ini sekali lagi. Strategi merangkak ini meningkatkan prestasi kerana ia mengelakkan pemindahan data yang tidak perlu. Berikut ialah contoh menggunakan pengambilan tertunda:

@ManyToOne(fetch = FetchType.LAZY)
private Address address;

Dalam contoh di atas, kami menetapkan atribut fetch kepada LAZY, yang bermaksud menggunakan pengambilan tertunda.

Merangkak kelompok

Merangkak kelompok ialah strategi merangkak yang membolehkan kami mendapatkan semula objek berbilang objek yang berkaitan sekali gus. Strategi merangkak ini meningkatkan prestasi kerana ia mengurangkan bilangan carian berbilang. Berikut ialah contoh menggunakan pengambilan kelompok:

@OneToMany(mappedBy = "student", fetch = FetchType.LAZY)
@BatchSize(size = 10)
private List<Grade> grades;

Dalam contoh di atas, kami menambah anotasi @BatchSize pada anotasi @OneToMany untuk menunjukkan penggunaan pengambilan kelompok.

Pemuatan malas

Pemuatan malas dalam Hibernate bermakna objek lain yang dikaitkan dengan objek dimuatkan hanya apabila diperlukan. Mekanisme ini boleh mengurangkan penghantaran data yang tidak diperlukan dan meningkatkan prestasi. Berikut ialah contoh penggunaan lazy loading:

Session session = HibernateUtil.getSessionFactory().getCurrentSession();
session.beginTransaction();
Student student = (Student) session.load(Student.class, 1);
Address address = student.getAddress();
session.getTransaction().commit();

Dalam contoh di atas, kami menggunakan kaedah load() untuk mendapatkan semula objek Pelajar dengan ID 1 dan kaedah getAddress() untuk mendapatkan alamat pelajar. Memandangkan kami menggunakan pemuatan malas, Hibernate hanya akan memuatkan objek alamat apabila diperlukan.

Atas ialah kandungan terperinci Cara menggunakan strategi pertanyaan dan strategi merangkak dalam Java Hibernate. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!