ORM Java apa yang Anda sukai, dan mengapa? [Tutup]

Itu pertanyaan berakhir yang cukup terbuka. Saya akan memulai proyek baru dan sedang melihat berbagai ORM untuk diintegrasikan dengan akses basis data.

Apakah Anda punya favorit? Apakah ada yang akan Anda sarankan untuk menjauh?

Saya sudah berhenti menggunakan ORM.

Alasannya bukan kesalahan besar dalam konsep. Hibernate berfungsi dengan baik. Sebagai gantinya, saya telah menemukan bahwa query memiliki overhead yang rendah dan saya dapat memasukkan banyak logika kompleks ke dalam query SQL yang besar, dan menggeser banyak pemrosesan saya ke dalam database.

Jadi pertimbangkan untuk hanya menggunakan paket JDBC.

Tidak ada, karena memiliki ORM mengambil terlalu banyak kendali dengan manfaat kecil. Penghematan waktu yang diperoleh dengan mudah terhapus ketika Anda harus men-debug kelainan yang dihasilkan dari penggunaan ORM. Selain itu, ORM tidak mendorong pengembang untuk belajar SQL dan bagaimana database relasional bekerja dan menggunakannya untuk keuntungan mereka.

Banyak ORM yang hebat, Anda perlu tahu mengapa Anda ingin menambahkan abstraksi di atas JDBC. Saya dapat merekomendasikan http://www.jooq.org kepada Anda (penafian: Saya pencipta jOOQ, jadi jawaban ini bias). JOOQ mencakup paradigma berikut:

• SQL adalah hal yang baik. Banyak hal yang dapat diekspresikan dengan cukup baik dalam SQL. Tidak perlu abstraksi lengkap dari SQL.
• Model data relasional adalah hal yang baik. Ini telah membuktikan model data terbaik selama 40 tahun terakhir. Tidak perlu untuk database XML atau model data yang benar-benar berorientasi objek. Sebagai gantinya, perusahaan Anda menjalankan beberapa contoh Oracle, MySQL, MSSQL, DB2 atau RDBMS lainnya.
• SQL memiliki struktur dan sintaksis. Seharusnya tidak diekspresikan dengan menggunakan rangkaian string "level rendah" di JDBC - atau rangkaian string "tingkat tinggi" di HQL - keduanya rentan terhadap kesalahan sintaks.
• Pengikatan variabel cenderung sangat kompleks ketika berhadapan dengan pertanyaan utama. ITULAH sesuatu yang harus diabstraksikan.
• POJO sangat bagus ketika menulis kode Java memanipulasi data database.
• POJO adalah rasa sakit untuk menulis dan memelihara secara manual. Pembuatan kode adalah caranya. Anda akan memiliki permintaan kompilasi-aman termasuk keamanan tipe data.
• Basis datanya didahulukan. Meskipun aplikasi di atas basis data Anda dapat berubah seiring waktu, basis data itu sendiri mungkin akan bertahan lebih lama.
• Ya, Anda memiliki prosedur tersimpan dan tipe yang ditentukan pengguna (UDT) di basis data lawas Anda. Alat basis data Anda harus mendukungnya.

Ada banyak ORM bagus lainnya. Terutama Hibernate atau iBATIS memiliki komunitas yang hebat. Tetapi jika Anda sedang mencari yang intuitif, sederhana, saya akan mengatakan mencoba JOOQ. Kamu akan menyukainya! :-)

Lihat contoh ini SQL:

  // Select authors with books that are sold out
  SELECT * 
    FROM T_AUTHOR a
   WHERE EXISTS (SELECT 1
                   FROM T_BOOK
                  WHERE T_BOOK.STATUS = 'SOLD OUT'
                    AND T_BOOK.AUTHOR_ID = a.ID);

Dan bagaimana hal itu bisa diungkapkan dalam jOOQ:

  // Alias the author table
  TAuthor a = T_AUTHOR.as("a");

  // Use the aliased table in the select statement
  create.selectFrom(a)
        .whereExists(create.selectOne()
                           .from(T_BOOK)
                           .where(T_BOOK.STATUS.equal(TBookStatus.SOLD_OUT)
                           .and(T_BOOK.AUTHOR_ID.equal(a.ID))))));

Hibernate, karena pada dasarnya standar de facto di Jawa dan merupakan salah satu kekuatan pendorong dalam penciptaan JPA. Itu mendapat dukungan yang sangat baik di Spring, dan hampir setiap kerangka kerja Java mendukungnya. Akhirnya, GORM adalah pembungkus yang sangat keren di sekitarnya melakukan pencari dinamis dan sebagainya menggunakan Groovy.

Itu bahkan telah porting ke .NET (NHibernate) sehingga Anda dapat menggunakannya di sana juga.

Hibernate, karena:

• stabil - berada di sekitar selama bertahun-tahun, tidak memiliki masalah besar
• menentukan standar di bidang ORM
• mengimplementasikan standar (JPA), selain mendikte itu.
• memiliki banyak informasi tentang itu di Internet. Ada banyak tutorial, solusi masalah umum, dll
• kuat - Anda dapat menerjemahkan model objek yang sangat kompleks menjadi model relasional.
• ia memiliki dukungan untuk RDBMS utama dan menengah
• mudah digunakan, setelah Anda mempelajarinya dengan baik

Beberapa poin mengapa (dan kapan) menggunakan ORM:

• Anda bekerja dengan objek di sistem Anda (jika sistem Anda telah dirancang dengan baik). Bahkan jika menggunakan JDBC, Anda akhirnya akan membuat beberapa layer terjemahan, sehingga Anda mentransfer data Anda ke objek Anda. Tapi taruhan saya adalah hibernate lebih baik dalam terjemahan daripada solusi custom-made.
• itu tidak membuat Anda kehilangan kendali. Anda dapat mengontrol berbagai hal dalam detail yang sangat kecil, dan jika API tidak memiliki beberapa fitur jarak jauh - jalankan kueri asli dan Anda memilikinya.
• sistem menengah atau lebih besar mana pun tidak mampu memiliki satu ton permintaan (baik itu di satu tempat atau tersebar di seluruh), jika itu bertujuan untuk dipertahankan
• jika kinerja tidak kritis. Hibernate menambahkan overhead kinerja, yang dalam beberapa kasus tidak dapat diabaikan.

Saya akan merekomendasikan menggunakan MyBatis . Ini adalah lapisan tipis di atas JDBC, sangat mudah untuk memetakan objek ke tabel dan masih menggunakan SQL biasa, semuanya ada di bawah kendali Anda.

Saya memiliki pengalaman yang sangat bagus dengan Avaje Ebean ketika saya sedang menulis aplikasi JavaSE berukuran sedang.

Ia menggunakan anotasi JPA standar untuk mendefinisikan entitas, tetapi memperlihatkan API yang jauh lebih sederhana (Tidak Ada EntityManager atau semua yang terlampir / terpisah entitas omong kosong). Ini juga memungkinkan Anda dengan mudah menggunakan kueri SQL atau memanggil panggilan JDBC saat diperlukan.

Ini juga memiliki API cairan dan tipe-aman yang sangat bagus untuk kueri. Anda dapat menulis hal-hal seperti:

List<Person> boys = Ebean.find(Person.class)
                                  .where()
                                       .eq("gender", "M")
                                       .le("age", 18)
                                  .orderBy("firstName")
                                  .findList();

SimpleORM , karena lurus dan tanpa sihir. Ini mendefinisikan semua struktur data meta dalam kode Java dan sangat fleksibel.

SimpleORM menyediakan fungsionalitas yang mirip dengan Hibernate dengan memetakan data dalam database relasional ke objek Java dalam memori. Kueri dapat ditentukan dalam hal objek Java, identitas objek disejajarkan dengan kunci basis data, hubungan antara objek dipertahankan dan objek yang dimodifikasi secara otomatis memerah ke database dengan kunci optimis.

Tetapi tidak seperti Hibernate, SimpleORM menggunakan struktur objek dan arsitektur yang sangat sederhana yang menghindari perlunya penguraian kompleks, pemrosesan kode byte, dll. SimpleORM kecil dan transparan, dikemas dalam dua botol dengan ukuran hanya 79K dan 52K, dengan hanya satu kecil dan opsional ketergantungan (Slf4j). (Hibernate lebih dari 2400K plus sekitar 2000K Jars dependen.) Ini membuat SimpleORM mudah dipahami dan sangat mengurangi risiko teknis.

Eclipse Link , untuk banyak alasan, tetapi terutama saya merasa seperti itu memiliki lebih sedikit mengasapi daripada solusi aliran utama lainnya (setidaknya lebih sedikit di-wajah Anda mengasapi).

Oh dan Eclipse Link telah dipilih untuk menjadi implementasi referensi untuk JPA 2.0

Sementara saya berbagi keprihatinan tentang penggantian Java untuk query SQL bentuk-bebas, saya benar-benar berpikir orang mengkritik ORM melakukannya karena desain aplikasi yang umumnya buruk.

OOD sejati didorong oleh kelas dan hubungan, dan ORM memberi Anda pemetaan yang konsisten dari berbagai jenis dan objek hubungan. Jika Anda menggunakan alat ORM dan mengakhiri pengkodean ekspresi kueri dalam bahasa apa pun yang didukung kerangka kerja ORM (termasuk, tetapi tidak terbatas pada pohon ekspresi Java, metode kueri, OQL dll.), Anda pasti melakukan sesuatu yang salah, yaitu model kelas Anda kemungkinan besar tidak mendukung persyaratan Anda seperti seharusnya. Desain aplikasi yang bersih tidak benar-benar membutuhkan pertanyaan pada level aplikasi. Saya telah refactoring banyak proyek orang mulai menggunakan kerangka kerja ORM dengan cara yang sama seperti mereka digunakan untuk menanamkan konstanta string SQL dalam kode mereka, dan pada akhirnya semua orang terkejut tentang betapa sederhananya dan terpeliharanya seluruh aplikasi setelah Anda mencocokkan tingkatkan model kelas Anda dengan model penggunaan. Memang, untuk hal-hal seperti fungsi pencarian dll. Anda memerlukan bahasa permintaan, tetapi meskipun begitu permintaan sangat dibatasi sehingga membuat VIEW dan pemetaan yang bahkan kompleks sehingga untuk kelas persisten baca-saja jauh lebih baik untuk dipertahankan dan dilihat daripada membangun ekspresi dalam beberapa bahasa permintaan dalam kode aplikasi Anda. Pendekatan VIEW juga memanfaatkan kemampuan basis data dan, melalui materialisasi, bisa jauh lebih baik dari segi kinerja daripada SQL yang ditulis tangan di sumber Java Anda. Jadi, saya tidak melihat alasan untuk aplikasi non-sepele TIDAK untuk menggunakan ORM. tetapi meskipun begitu pertanyaan sangat dibatasi sehingga membuat VIEW dan pemetaan yang lebih kompleks yang hanya untuk kelas persisten baca-jauh lebih baik untuk dipelihara dan dilihat daripada membangun ekspresi dalam beberapa bahasa permintaan dalam kode aplikasi Anda. Pendekatan VIEW juga memanfaatkan kemampuan basis data dan, melalui materialisasi, bisa jauh lebih baik dari segi kinerja daripada SQL yang ditulis tangan di sumber Java Anda. Jadi, saya tidak melihat alasan untuk aplikasi non-sepele TIDAK untuk menggunakan ORM. tetapi meskipun begitu pertanyaan sangat dibatasi sehingga membuat VIEW dan pemetaan yang lebih kompleks yang hanya untuk kelas persisten baca-jauh lebih baik untuk dipelihara dan dilihat daripada membangun ekspresi dalam beberapa bahasa permintaan dalam kode aplikasi Anda. Pendekatan VIEW juga memanfaatkan kemampuan basis data dan, melalui materialisasi, bisa jauh lebih baik dari segi kinerja daripada SQL yang ditulis tangan di sumber Java Anda. Jadi, saya tidak melihat alasan untuk aplikasi non-sepele TIDAK untuk menggunakan ORM.