anotasi
Anotasi Hibernate adalah metode terbaru yang tidak menggunakan file XML untuk mendefinisikan pemetaan. Anotasi dapat digunakan dalam metadata pemetaan XML yang dipisahkan atau diganti.
Anotasi Hibernate adalah cara yang kuat untuk menyediakan pemetaan benda metadata dan tabel relasional. Semua metadata unggul bersama dengan file pojo java. Ini dapat membantu pengguna memahami struktur tabel dan pojo selama proses pengembangan.
Jika Anda bermaksud untuk mem-port aplikasi ke aplikasi ORM khusus EJB3 lainnya, Anda harus menggunakan anotasi untuk mewakili informasi pemetaan, tetapi jika Anda menginginkan fleksibilitas yang lebih besar, Anda harus menggunakan pemetaan berbasis XML.
Mengatur anotasi hibernasi di lingkungan terlebih dahulu, Anda harus memastikan bahwa Anda menggunakan JDK5.0, jika tidak, Anda perlu meningkatkan JDK ke JDK5.0 dukungan asli dengan anotasi.
Kedua, Anda perlu menginstal paket distribusi anotasi 3.x Hibernate, Anda dapat menggunakan SourceForge: (Unduh anotasi hibernate) dan salin hibernate-annotations.jar, lib/hibernate-comons-annotations.jar dan lib/ejb3-fersistence.jar untuk menugaskan dari hibernate annotation ke clask cockat.
Instance kelas berkomentar:
Seperti yang disebutkan, semua metadata yang bekerja dengan anotasi hibernate bekerja ke dalam file pojo java di atas ini dapat membantu pengguna memahami struktur tabel dan pojo selama pengembangan.
Pertimbangkan objek yang akan disimpan menggunakan tabel karyawan berikut:
Buat tabel karyawan (id int not null auto_increment, first_name varchar (20) default null, last_name varchar (20) default null, gaji int default null, kunci utama (id));
Berikut ini adalah pemetaan kelas karyawan objek dengan anotasi untuk dipetakan dengan tabel karyawan yang ditentukan:
impor javax.persistence.*; @entitas @table (name = "karyawan") Kelas publik {@id @generatedValue @column (name = "id") private int id; @Column (name = "first_name") private string firstName; @Column (name = "last_name") Private String LastName; @Column (name = "gaji") gaji int private; karyawan publik () {} int int getId () {return id; } public void setid (int id) {this.id = id; } public String getFirstName () {return firstName; } public void setFirstName (String first_name) {this.firstname = first_name; } public String getLastName () {return lastName; } public void setLastName (string last_name) {this.lastname = last_name; } public int getSalary () {return gaji; } public void setSalary (int gaji) {this.salary = gaji; }}Hibernate mendeteksi bahwa anotasi @ID bertentangan dengan bidang dan mengasumsikan bahwa ia harus mengakses properti objek secara langsung melalui domain runtime. Jika @ID dijelaskan dengan metode getId (), properti akan diakses secara default melalui metode Getter and Setter. Oleh karena itu, semua komentar lain juga ditempatkan di kedua bidang atau metode pengambil, seperti yang dipilih di bawah kebijakan. Bagian berikut menjelaskan komentar yang digunakan di kelas di atas.
Anotasi @entity:
Deskripsi spesifikasi EJB3 termasuk dalam paket javax.persistence, jadi kami mengimpor paket ini sebagai langkah pertama. Kedua, kami menggunakan anotasi @Entity untuk menandai kelas ini sebagai kelas karyawan entitas kacang, sehingga harus memiliki konstruktor tanpa parameter, yang akhirnya terlihat dengan perlindungan.
@Table Anotasi:
Anotasi @Table memungkinkan tabel yang ditentukan digunakan untuk menyimpan informasi terperinci tentang entitas dalam database.
Anotasi @Table menyediakan empat properti yang memungkinkan mengesampingkan nama tabel, direktori, skema, dan menjalankan kendala unik pada kolom dalam tabel. Sekarang, kami menggunakan nama tabel karyawan sekarang.
@Id dan @GeneratedValue Anotasi:
Setiap entitas kacang akan memiliki kunci utama yang dianotasi dalam anotasi @ID kelas. Kunci utama dapat berupa bidang tunggal atau kombinasi beberapa bidang sesuai dengan struktur tabel.
Secara default, anotasi @ID secara otomatis menentukan strategi pembuatan kunci utama yang paling tepat untuk digunakan, tetapi dapat digunakan dengan menerapkan anotasi @GeneratedValue, yang menerima dua parameter, strategi, dan generator, tidak untuk dibahas di sini, cukup gunakan strategi pembuatan kunci default default. Biarkan hibernate menentukan jenis generator yang akan digunakan untuk membuat portabilitas kode antara berbagai database.
@Column Anotasi:
Anotasi @Column digunakan untuk menentukan detail kolom ke bidang atau properti yang akan dipetakan. Properti yang paling umum digunakan berikut dapat dianotasi menggunakan kolom:
Atribut nama memungkinkan secara eksplisit menentukan nama kolom.
Properti panjang memungkinkan untuk memetakan ukuran kolom yang terutama untuk nilai string.
Properti nullable memungkinkan kolom ditandai bukan saat menghasilkan skema.
Properti unik memungkinkan kolom yang ditandai hanya berisi nilai unik.
Buat kelas aplikasi:
Akhirnya, kami akan membuat metode utama () dari kelas aplikasi untuk menjalankan aplikasi. Kami akan menggunakan aplikasi ini untuk menyimpan beberapa catatan karyawan dan kemudian kami akan mengajukan catatan tentang operasi CRUD.
impor java.util.list; impor java.util.date; import java.util.iterator; impor org.hibernate.hibernateException; impor org.hibernate.Session; Impor org.hibernate.transaction; impor org.hibernate.cfg.annotationconfiguration; impor org.hibernate.SessionFactory; impor org.hibernate.cfg.configuration; Public Class Management {Private Static Session Factory; public static void main (string [] args) {try {factory = new annotationConfiguration (). configure (). //addpackage("com.xyz ") // Tambahkan paket jika digunakan. AddannotatedClass (karyawan.class). BuildsessionFactory (); } catch (Throwable ex) {System.err.println ("Gagal membuat objek SesionFactory." + Ex); Lempar pengecualian baruinitializerError (EX); } Manajemen Me = Manajemen baru (); / * Tambahkan beberapa catatan karyawan dalam database */ integer empid1 = me.addemployee ("zara", "ali", 1000); Integer empid2 = me.addemployee ("daisy", "das", 5000); Integer empid3 = me.addemployee ("John", "Paul", 10000); / * Daftar semua karyawan */ me.listemployee (); / * Perbarui Catatan Karyawan */ Me.UpdateMir Kerja (Empid1, 5000); / * Hapus seorang karyawan dari database */ me.deleTeeMarder (empid2); / * Daftar daftar baru karyawan */ me.listemployee (); } / * Metode untuk membuat karyawan dalam database * / public integer addEmployee (string fname, string lname, int gaji) {session session = factory.opensession (); Transaksi tx = null; Integer Pegawai = NULL; coba {tx = session.begintransaction (); Karyawan Karyawan = Karyawan Baru (); karyawan.setFirstName (fname); karyawan.setLastName (lname); karyawan.setsalary (gaji); karyawan = (integer) session.save (karyawan); tx.commit (); } catch (hibernateException e) {if (tx! = null) tx.rollback (); e.printstacktrace (); } akhirnya {session.close (); } mengembalikan karyawan; } / * Metode untuk membaca semua karyawan * / public void listeMreees () {session session = factory.opensession (); Transaksi tx = null; coba {tx = session.begintransaction (); Daftar karyawan = session.createqueery ("dari karyawan"). Daftar (); untuk (iterator iterator = karyawan.iterator (); iterator.hasnext ();) {karyawan karyawan = (karyawan) iterator.next (); System.out.print ("Nama Depan:" + karyawan.getFirstName ()); System.out.print ("Nama Belakang:" + karyawan.getLastName ()); System.out.println ("Gaji:" + karyawan.getSalary ()); } tx.Commit (); } catch (hibernateException e) {if (tx! = null) tx.rollback (); e.printstacktrace (); } akhirnya {session.close (); }} / * Metode untuk memperbarui gaji untuk karyawan * / public void updateMireee (integer employeeid, int gaji) {session session = factory.opensession (); Transaksi tx = null; coba {tx = session.begintransaction (); Pegawai Karyawan = (karyawan) sesi. karyawan.setsalary (gaji); session.update (karyawan); tx.commit (); } catch (hibernateException e) {if (tx! = null) tx.rollback (); e.printstacktrace (); } akhirnya {session.close (); }} / * Metode untuk menghapus karyawan dari catatan * / public void deleteEmployee (integer usaha) {session session = factory.opensession (); Transaksi tx = null; coba {tx = session.begintransaction (); Pegawai Karyawan = (karyawan) sesi. session.delete (karyawan); tx.commit (); } catch (hibernateException e) {if (tx! = null) tx.rollback (); e.printstacktrace (); } akhirnya {session.close (); }}} Konfigurasi Basis Data:
Sekarang, mari kita buat file konfigurasi hibernate.cfg.xml untuk menentukan parameter database yang relevan.
<?xml version="1.0" encoding="utf-8"?><!DOCTYPE hibernate-configuration SYSTEM "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd"><hibernate-configuration> <session-factory> <property name="hibernate.dialect"> org.hibernate.dialect.MySQLDialect </property> <property name="hibernate.connection.driver_class"> com.mysql.jdbc.Driver </property> <!-- Assume students is the database name --> <property name="hibernate.connection.url"> jdbc:mysql://localhost/test </property> <property name = "hibernate.connection.userName"> root </pruptent> <properti nama = "hibernate.connection.password"> Cohondob </property> </sion-factory> </hibernate-configuration>
Kompilasi dan jalankan:
Berikut adalah langkah -langkah untuk mengkompilasi dan menjalankan aplikasi di atas. Pastikan jalur dan classpath diatur dengan tepat sebelum menyusun dan mengeksekusi.
Hapus file pemetaan karyawan.hbm.xml dari jalur.
Buat file sumber karyawan.java seperti yang ditunjukkan pada gambar di atas dan kompilasi.
Buat file Sumber Manajemen.java seperti yang ditunjukkan pada gambar di atas dan kompilasi.
Jalankan file biner manajemen kerja untuk menjalankan program.
Hasil berikut akan diperoleh dan catatan akan ada di tabel karyawan.
$java ManageEmployee.........VARIOUS LOG MESSAGES WILL DISPLAY HERE.........First Name: Zara Last Name: Ali Salary: 1000First Name: Daisy Last Name: Das Salary: 5000First Name: John Last Name: Paul Salary: 10000First Name: Zara Last Name: Ali Salary: 5000First Name: John Last Name: Paul Salary: 10000
Jika Anda memeriksa tabel karyawan, itu harus memiliki catatan berikut:
mysql> pilih * dari karyawan;+----+------------+-----------+--------+| ID | first_name | last_name | Gaji |+----+------------+-----------+--------+| 29 | Zara | Ali | 5000 || 31 | John | Paul | 10000 |+----+------------+-----------+--------+2 baris dalam set (0,00 secmysql>
cache
Caching adalah semua tentang optimalisasi kinerja aplikasi dan terletak di antara aplikasi dan database untuk menghindari beberapa akses database dan memungkinkan aplikasi kritis kinerja berkinerja lebih baik.
Caching penting untuk hibernasi, dan mengadopsi skema caching multi-level yang dijelaskan di bawah ini:
Cache Level 1:
Cache level pertama adalah cache sesi, yang merupakan cache wajib, dan semua permintaan melalui itu harus dilewati. Objek sesi terus -menerus ditenagai oleh objek sebelum mengirimkannya ke database.
Jika beberapa pembaruan dikeluarkan, Hibernate berupaya menunda pembaruan selama mungkin untuk mengurangi jumlah pembaruan yang dikeluarkan pernyataan SQL. Jika Anda menutup sesi, semua objek yang di -cache akan hilang, baik persisten, atau diperbarui dalam database.
Cache Level 2:
Cache Level 2 adalah opsional dan cache Level 1 yang akan selalu dicari sebelum upaya untuk menemukan cache Level 2 objek. Cache tingkat kedua dapat dikonfigurasi berdasarkan per-kelas dan per kategori, terutama bertanggung jawab atas objek yang di-cache dalam sesi.
Cache pihak ketiga mana pun dapat menggunakan hibernate. Antarmuka org.hibernate.cache.cacheprovider menyediakan, dan perlu untuk mengimplementasikan implementasi cache pegangan untuk menyediakan hibernate.
Cache Level Kueri:
Hibernate juga mengimplementasikan integrasi ketat dari hasil query set cache dan level 2 cache.
Ini adalah fitur opsional yang membutuhkan dua cache fisik tambahan untuk menyimpan hasil kueri yang di -cache dan daerah ketika tabel terakhir diperbarui. Ini hanya sangat berguna untuk kueri yang sering berjalan dengan parameter yang sama.
Cache Level 2:
Hibernate menggunakan cache Level 1, secara default, Anda tidak melakukan apa pun dengan cache Level 1. Mari kita langsung ke cache tingkat kedua opsional. Tidak semua kelas mendapat manfaat dari caching, jadi penting untuk menonaktifkan cache Level 2.
Hibernate level 2 cache diatur ke dua langkah. Pertama, Anda harus memutuskan strategi konkurensi mana yang akan digunakan. Setelah ini, Anda dapat mengonfigurasi cache kedaluwarsa dan menggunakan cache untuk memberikan atribut cache fisik.
Strategi konkurensi:
Kebijakan konkurensi adalah mediator yang bertanggung jawab untuk menyimpan item data dalam cache dan mengambilnya dari cache. Jika Anda ingin mengaktifkan caching Level 2, Anda harus memutuskan kebijakan konkurensi cache mana yang akan digunakan untuk setiap kelas dan koleksi yang persisten.
Transaksional: Menggunakan strategi ini untuk membaca data terutama untuk mencegah transaksi bersamaan dari data yang sudah ketinggalan zaman sangat penting dalam kasus pembaruan yang jarang terjadi.
Read-Write: Sekali lagi menggunakan strategi ini pembacaan utama data sangat penting untuk mencegah transaksi bersamaan dari data basi dalam kasus pembaruan yang jarang terjadi.
Nonstrict-Read-Write: Strategi ini tidak menjamin konsistensi antara cache dan database. Dengan strategi ini, kuncinya adalah tidak memperhatikan jika data jarang berubah dan kemungkinan data basi harus basi.
Baca-saja: Kebijakan konkurensi cocok untuk data dan tidak akan pernah berubah. Data yang digunakan hanya untuk referensi.
Jika kami ingin menggunakan cache tingkat kedua sebagai kelas karyawan kami, mari kita tambahkan elemen pemetaan yang diperlukan untuk memberi tahu Hibernate untuk menggunakan kebijakan cache yang dapat dibaca dan dapat ditulis untuk contoh karyawan.
<? XML Versi = "1.0" encoding = "utf-8"?> <! Doctype hibernate-mapping public "-// hibernate/hibernate pemetaan dtd // en" "http://www.hibernate.org/dtd/hibernate-papping-3.0 <meta attribute = "class-description"> Kelas ini berisi detail karyawan. </meta> <cache usage="read-write"/> <id name="id" type="int" column="id"> <generator/> </id> <property name="firstName" column="first_name" type="string"/> <property name="lastName" column="last_name" type="string"/> <property name="salary" column="salary" type="int"/> </belas> </hibernate-Mapping>
Properti penggunaan = "baca-tulis" memberi tahu Hibernate untuk menggunakan cache yang ditentukan oleh kebijakan konkurensi baca-tulis.
Penyedia cache:
Setelah mempertimbangkan kebijakan konkurensi kelas kandidat cache Anda, langkah selanjutnya adalah memilih penyedia cache. Pasukan Hibernate Memilih cache untuk melayani seluruh aplikasi.
Cache disediakan dalam file konfigurasi hibernate.cfg.xml yang ditentukan. Pilih Ehcache sebagai penyedia cache tingkat kedua:
<?xml version="1.0" encoding="utf-8"?><!DOCTYPE hibernate-configuration SYSTEM "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd"><hibernate-configuration> <session-factory> <property name="hibernate.dialect"> org.hibernate.dialect.MySQLDialect </property> <property name="hibernate.connection.driver_class"> com.mysql.jdbc.Driver </property> <!-- Assume students is the database name --> <property name="hibernate.connection.url"> jdbc:mysql://localhost/test </property> <property name = "hibernate.connection.userName"> root </propt> <properti name = "hibernate.connection.password"> root123 </property> <name properti = "hibernate.cache.provider_class"> org.hibernate.cache.ehcacheProvider </Property> <! resource = "emplinge.hbm.xml"/> </sion-factory> </hibernate-configuration>
Sekarang, Anda perlu menentukan sifat area cache. EHCACHE memiliki file konfigurasi sendiri ehcache.xml, di aplikasi di ClassPath. Di ehcache.xml, konfigurasi cache kelas karyawan mungkin terlihat seperti ini:
<diskstore path = "java.io.tmpdir"/> <defaultCachemaxElementsInmemory = "1000" abadi = "false" timeToidleseconds = "120" timetoliveseconds = "120" overflowTodisk = "true"/<cache name = "karyawan" maxElementsInmemory = "500" Eternal = "true" timeToidleseconds = "0" timeToliveseconds = "0" overflowTodisk = "false"/>
Itu saja, sekarang memungkinkan cache sekunder kelas karyawan dan hibernate sekarang memiliki cache sekunder, setiap kali menjelajah ke karyawan atau ketika karyawan dimuat oleh pengidentifikasi.
Anda harus menganalisis semua kelas Anda dan memilih strategi caching yang sesuai untuk setiap kelas. Terkadang, cache sekunder dapat menurunkan kinerja aplikasi. Jadi disarankan untuk aplikasi benchmark yang tidak memungkinkan caching untuk pertama kalinya, yang sangat cocok untuk caching dan memeriksa kinerja. Jika cache tidak meningkatkan kinerja sistem, tidak ada artinya untuk membuat jenis cache apa pun.
Cache Level Kueri:
Menggunakan cache kueri, itu harus diaktifkan terlebih dahulu di file konfigurasi properti hibernate.cache.use_query_cache = "true". Jika properti ini diatur ke true, biarkan hibernate membuat cache yang diperlukan dalam memori untuk menyimpan kueri dan set pengidentifikasi.
Selanjutnya, menggunakan Cache Query, Anda dapat menggunakan metode SetCacheable (Boolean) dari kelas kueri. Misalnya:
Hibernate juga mendukung dukungan cache berbutir yang sangat halus melalui konsep area cache. Cache adalah bagian dari cache yang diberi nama.
Kode ini menggunakan metode untuk memberi tahu Hibernate untuk menyimpan dan menemukan pertanyaan tentang karyawan di cache.